/*******************************************************************************/
public virtual void ReleaseListeners(object view)
{
if (Loaded != null)
{
foreach (Delegate d in Loaded.GetInvocationList())
{
if (view == null || d.Target == view)
{
Loaded -= (LoadFinishedEventHandler)d;
}
}
}
if (Changed != null)
{
foreach (Delegate d in Changed.GetInvocationList())
{
if (view == null || d.Target == view)
{
Changed -= (ChangedEventHandler)d;
}
}
}
if (Persisted != null)
{
foreach (Delegate d in Persisted.GetInvocationList())
{
if (view == null || d.Target == view)
{
Persisted -= (PersistFinishedEventHandler)d;
}
}
}
}
public void Entity_should_persist_successfully(Sprint sprint,
Ticket ticket1,
Ticket ticket2,
[FromDi] Lazy <ISessionFactory> sessionFactory,
[FromDi] Lazy <IResetsDatabase> dbResetter)
{
sprint.Tickets.Add(ticket1);
sprint.Tickets.Add(ticket2);
using (var provider = new CachingDataConnectionFactoryAdapter(new CSF.ORM.NHibernate.SessionFactoryAdapter(sessionFactory.Value)))
{
var result = TestPersistence.UsingConnectionProvider(provider)
.WithSetup(s => dbResetter.Value.ResetDatabase(), false)
.WithEntity(sprint)
.WithEqualityRule(builder => {
return(builder
.ForProperty(x => x.CreationDate, c => c.UsingComparer(ComparerFactory.GetDateTimeAccurateToSecondsComparer()))
.ForProperty(x => x.StartDate, c => c.UsingComparer(ComparerFactory.GetNullableDateTimeAccurateToSecondsComparer()))
.ForProperty(x => x.EndDate, c => c.UsingComparer(ComparerFactory.GetNullableDateTimeAccurateToSecondsComparer()))
.ForProperty(x => x.Tickets, c => c.UsingComparer(new SetEqualityComparer <Ticket>(new EntityIdentityEqualityComparer())))
.ForAllOtherProperties());
});
Assert.That(result, Persisted.Successfully());
}
}
public void Entity_should_persist_successfully(Label label,
Ticket ticket1,
Ticket ticket2,
[FromDi] Lazy <ISessionFactory> sessionFactory,
[FromDi] Lazy <IResetsDatabase> dbResetter)
{
label.Tickets.Add(ticket1);
label.Tickets.Add(ticket2);
using (var provider = new CachingDataConnectionFactoryAdapter(new CSF.ORM.NHibernate.SessionFactoryAdapter(sessionFactory.Value)))
{
var result = TestPersistence.UsingConnectionProvider(provider)
.WithSetup(s => {
dbResetter.Value.ResetDatabase();
// The many-to-many from Label to Ticket doesn't cascade from the Label side,
// so the tickets must be saved independently.
using (var tran = s.GetTransactionFactory().GetTransaction())
{
var persister = s.GetPersister();
persister.Add(ticket1);
persister.Add(ticket2);
tran.Commit();
}
}, false)
.WithEntity(label)
.WithEqualityRule(builder => {
return(builder
.ForProperty(x => x.Tickets, c => c.UsingComparer(new SetEqualityComparer <Ticket>(new EntityIdentityEqualityComparer())))
.ForAllOtherProperties());
});
Assert.That(result, Persisted.Successfully());
}
}
public void Entity_should_persist_successfully(User user,
Project contrib1,
Project contrib2,
Project admin1,
Project admin2,
[FromDi] Lazy <ISessionFactory> sessionFactory,
[FromDi] Lazy <IResetsDatabase> dbResetter)
{
user.ContributorTo.Add(contrib1);
user.ContributorTo.Add(contrib2);
user.AdministratorOf.Add(admin1);
user.AdministratorOf.Add(admin2);
using (var provider = new CachingDataConnectionFactoryAdapter(new CSF.ORM.NHibernate.SessionFactoryAdapter(sessionFactory.Value)))
{
var result = TestPersistence.UsingConnectionProvider(provider)
.WithSetup(s => dbResetter.Value.ResetDatabase(), false)
.WithEntity(user)
.WithEqualityRule(builder => {
return(builder
.ForProperty(x => x.ContributorTo, c => c.UsingComparer(new SetEqualityComparer <Project>(new EntityIdentityEqualityComparer())))
.ForProperty(x => x.AdministratorOf, c => c.UsingComparer(new SetEqualityComparer <Project>(new EntityIdentityEqualityComparer())))
.ForAllOtherProperties());
});
Assert.That(result, Persisted.Successfully());
}
}
public IEnumerable <IConceptInfo> CreateNewConcepts(IEnumerable <IConceptInfo> existingConcepts)
{
return(new[]
{
new ComputedFromKeyPropertiesInfo
{
ComputedFrom = Persisted.CreateEntityComputedFrom(),
KeyProperties = KeyProperties
}
});
}
public void Given_system_with_sql_persistence()
{
var actor = Sys.ActorOf(Props.Create <PersistencePingActor>(TestActor));
_sqlJournalPing = new SqlJournalPing()
{
Payload = "testPayload"
};
actor.Ask(_sqlJournalPing);
OnPersistMessage = ExpectMsg <Persisted>(TimeSpan.FromSeconds(3));
_journalName = Persistence.Instance.Apply(Sys).JournalFor(null).Path.Name;
}
public void Entity_should_persist_successfully(Ticket ticket,
Comment comment1,
Comment comment2,
Label label1,
Label label2,
DirectionalRelationship rel1,
DirectionalRelationship rel2,
NonDirectionalRelationship rel3,
Ticket otherTicket,
TicketWorkLog log1,
TicketWorkLog log2,
[FromDi] Lazy <ISessionFactory> sessionFactory,
[FromDi] Lazy <IResetsDatabase> dbResetter)
{
ticket.Comments.Add(comment1);
ticket.Comments.Add(comment2);
ticket.Labels.Add(label1);
ticket.Labels.Add(label2);
ticket.PrimaryRelationships.Add(new TicketRelationship {
Relationship = rel1, SecondaryTicket = otherTicket
});
ticket.PrimaryRelationships.Add(new TicketRelationship {
Relationship = rel3, SecondaryTicket = otherTicket
});
ticket.SecondaryRelationships.Add(new TicketRelationship {
Relationship = rel2, PrimaryTicket = otherTicket
});
ticket.WorkLogs.Add(log1);
ticket.WorkLogs.Add(log2);
using (var provider = new CachingDataConnectionFactoryAdapter(new CSF.ORM.NHibernate.SessionFactoryAdapter(sessionFactory.Value)))
{
var result = TestPersistence.UsingConnectionProvider(provider)
.WithSetup(s => dbResetter.Value.ResetDatabase(), false)
.WithEntity(ticket)
.WithEqualityRule(builder => {
return(builder
.ForProperty(x => x.CreationTimestamp, c => c.UsingComparer(ComparerFactory.GetDateTimeAccurateToSecondsComparer()))
.ForProperty(x => x.Comments, c => c.UsingComparer(new SetEqualityComparer <Comment>(new EntityIdentityEqualityComparer())))
.ForProperty(x => x.Labels, c => c.UsingComparer(new SetEqualityComparer <Label>(new EntityIdentityEqualityComparer())))
.ForProperty(x => x.PrimaryRelationships, c => c.UsingComparer(new SetEqualityComparer <TicketRelationship>(new EntityIdentityEqualityComparer())))
.ForProperty(x => x.SecondaryRelationships, c => c.UsingComparer(new SetEqualityComparer <TicketRelationship>(new EntityIdentityEqualityComparer())))
.ForProperty(x => x.WorkLogs, c => c.UsingComparer(new SetEqualityComparer <TicketWorkLog>(new EntityIdentityEqualityComparer())))
.ForAllOtherProperties());
});
Assert.That(result, Persisted.Successfully());
}
}
public void Load(Persisted state)
{
state.DoUpgrades();
// BEGIN_GAME_BUILDER_CODE_GEN STAGE_LOAD_PERSISTED
SetGroundSizeXLocal(state.groundSizeX); // GENERATED
SetGroundSizeZLocal(state.groundSizeZ); // GENERATED
SetSkyTypeLocal(state.skyType.IsNullOrEmpty() ? DefaultSkyType : Util.ParseEnum <SkyType>(state.skyType)); // GENERATED
SetSkyColorLocal(state.skyColor); // GENERATED
SetGroundTypeLocal(state.groundType.IsNullOrEmpty() ? DefaultGroundType : Util.ParseEnum <GroundType>(state.groundType)); // GENERATED
SetGroundColorLocal(state.groundColor); // GENERATED
SetInitialCameraModeLocal(state.initialCameraMode.IsNullOrEmpty() ? DefaultInitialCameraMode : Util.ParseEnum <CameraMode>(state.initialCameraMode)); // GENERATED
SetIsoCamRotationIndexLocal(state.isoCamRotationIndex); // GENERATED
SetSceneLightingModeLocal(state.sceneLightingMode.IsNullOrEmpty() ? DefaultSceneLightingMode : Util.ParseEnum <SceneLightingMode>(state.sceneLightingMode)); // GENERATED
// END_GAME_BUILDER_CODE_GEN
}
public void Entity_should_persist_successfully(Project project,
Ticket ticket1,
Ticket ticket2,
Sprint sprint1,
Sprint sprint2,
User contrib1,
User contrib2,
User admin1,
User admin2,
[FromDi] Lazy <ISessionFactory> sessionFactory,
[FromDi] Lazy <IResetsDatabase> dbResetter)
{
project.Tickets.Add(ticket1);
project.Tickets.Add(ticket2);
project.Sprints.Add(sprint1);
project.Sprints.Add(sprint2);
project.Contributors.Add(contrib1);
project.Contributors.Add(contrib2);
project.Administrators.Add(admin1);
project.Administrators.Add(admin2);
using (var provider = new CachingDataConnectionFactoryAdapter(new CSF.ORM.NHibernate.SessionFactoryAdapter(sessionFactory.Value)))
{
var result = TestPersistence.UsingConnectionProvider(provider)
.WithSetup(s => {
dbResetter.Value.ResetDatabase();
using (var tran = s.GetTransactionFactory().GetTransaction())
{
var p = s.GetPersister();
p.Add(contrib1);
p.Add(contrib2);
p.Add(admin1);
p.Add(admin2);
tran.Commit();
}
}, false)
.WithEntity(project)
.WithEqualityRule(builder => {
return(builder
.ForProperty(x => x.Tickets, c => c.UsingComparer(new SetEqualityComparer <Ticket>(new EntityIdentityEqualityComparer())))
.ForProperty(x => x.Sprints, c => c.UsingComparer(new SetEqualityComparer <Sprint>(new EntityIdentityEqualityComparer())))
.ForProperty(x => x.Contributors, c => c.UsingComparer(new SetEqualityComparer <User>(new EntityIdentityEqualityComparer())))
.ForProperty(x => x.Administrators, c => c.UsingComparer(new SetEqualityComparer <User>(new EntityIdentityEqualityComparer())))
.ForAllOtherProperties());
});
Assert.That(result, Persisted.Successfully());
}
}
public void Entity_should_persist_successfully(NonDirectionalRelationship relationship,
[FromDi] Lazy <ISessionFactory> sessionFactory,
[FromDi] Lazy <IResetsDatabase> dbResetter)
{
using (var provider = new CachingDataConnectionFactoryAdapter(new CSF.ORM.NHibernate.SessionFactoryAdapter(sessionFactory.Value)))
{
var result = TestPersistence.UsingConnectionProvider(provider)
.WithSetup(s => dbResetter.Value.ResetDatabase(), false)
.WithEntity(relationship)
.WithEqualityRule(builder => {
return(builder
.ForAllOtherProperties());
});
Assert.That(result, Persisted.Successfully());
}
}
public void Persistence_test_fails_for_an_entity_which_cannot_be_saved(EntityWithBadlyNamedProperty entity,
ConnectionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetConnectionFactory();
var result = TestPersistence.UsingConnectionProvider(factory)
.WithSetup(s => CreateSchema(s, schemaCreator))
.WithEntity(entity)
.WithEqualityRule(r => r.ForAllOtherProperties());
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.InstanceOf <AssertionException>());
Assert.That(result?.SaveException, Is.Not.Null);
}
public void Persistence_test_fails_for_an_incorrectly_mapped_entity(EntityWithUnmappedProperty entity,
ConnectionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetConnectionFactory();
var result = TestPersistence.UsingConnectionProvider(factory)
.WithSetup(s => CreateSchema(s, schemaCreator))
.WithEntity(entity)
.WithEqualityRule(r => r.ForAllOtherProperties());
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.InstanceOf <AssertionException>());
Assert.That(result?.EqualityResult?.RuleResults?.Where(x => !x.Passed).Count(), Is.EqualTo(1));
}
public void Entity_should_persist_successfully(TicketWorkLog log,
[FromDi] Lazy <ISessionFactory> sessionFactory,
[FromDi] Lazy <IResetsDatabase> dbResetter)
{
using (var provider = new CachingDataConnectionFactoryAdapter(new CSF.ORM.NHibernate.SessionFactoryAdapter(sessionFactory.Value)))
{
var result = TestPersistence.UsingConnectionProvider(provider)
.WithSetup(s => dbResetter.Value.ResetDatabase(), false)
.WithEntity(log)
.WithEqualityRule(builder => {
return(builder
.ForProperty(x => x.TimeStarted, c => c.UsingComparer(ComparerFactory.GetDateTimeAccurateToSecondsComparer()))
.ForAllOtherProperties());
});
Assert.That(result, Persisted.Successfully());
}
}
public void Persistence_test_passes_for_a_correctly_mapped_entity(SampleEntity entity,
SessionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetSessionFactory();
var result = TestPersistence.UsingSessionFactory(factory)
.WithSetup(s =>
{
schemaCreator.CreateSchema(s.Connection);
})
.WithEntity(entity)
.WithEqualityRule(r => r.ForAllOtherProperties());
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.Nothing);
}
public void Persistence_test_fails_when_the_setup_throws_an_exception(SampleEntity entity,
SessionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetSessionFactory();
var result = TestPersistence.UsingSessionFactory(factory)
.WithSetup(s =>
{
schemaCreator.CreateSchema(s.Connection);
throw new InvalidOperationException("Sample exception");
})
.WithEntity(entity)
.WithEqualityRule(r => r.ForAllOtherProperties());
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.InstanceOf <AssertionException>());
Assert.That(result?.SetupException, Is.Not.Null);
}
public void Persistence_test_passes_for_a_correctly_mapped_entity([NoRecursion] SampleEntity entity,
ConnectionFactoryProvider factoryProvider,
SchemaCreator schemaCreator)
{
var factory = factoryProvider.GetConnectionFactory();
var result = TestPersistence.UsingConnectionProvider(factory)
.WithSetup(s => CreateSchema(s, schemaCreator))
.WithEntity(entity)
.WithEqualityRule((EqualityBuilder <SampleEntity> r) =>
{
return(r
.ForProperty(x => x.RelatedEntity,
c => c.UsingComparer(new EqualityBuilder <EntityWithRelationship>()
.ForProperty(x => x.Identity)
.ForAllOtherProperties(p => p.Ignore())
.Build()))
.ForAllOtherProperties());
});
Assert.That(() =>
{
Assert.That(result, Persisted.Successfully());
}, Throws.Nothing);
}
public void AddHandlersWithLoad(ChangedEventHandler changedEventHandler,
LoadFinishedEventHandler loadFinishedEventHandler,
PersistFinishedEventHandler persistFinishedEventHandler)
{
#if (CHATTY_DEBUG)
string msg = "*** HRA OBJECT AddHandlersWithLoad on : " + this.ToString() + System.Environment.NewLine;
if (changedEventHandler != null)
{
msg += "By: " + changedEventHandler.Target.ToString();
}
else if (loadFinishedEventHandler != null)
{
msg += "By: " + loadFinishedEventHandler.Target.ToString();
}
else if (persistFinishedEventHandler != null)
{
msg += "By: " + persistFinishedEventHandler.Target.ToString();
}
Logger.Instance.DebugToLog(msg);
#endif
if (changedEventHandler != null)
{
if (Changed == null)
{
Changed += changedEventHandler;
}
else
{
bool ok = true;
foreach (Delegate d in Changed.GetInvocationList())
{
if (d.Target == changedEventHandler.Target)
{
ok = false;
}
}
if (ok)
{
Changed += changedEventHandler;
}
}
}
if (loadFinishedEventHandler != null)
{
if (Loaded == null)
{
Loaded += loadFinishedEventHandler;
}
else
{
bool ok = true;
foreach (Delegate d in Loaded.GetInvocationList())
{
if (d.Target == loadFinishedEventHandler.Target)
{
ok = false;
}
}
if (ok)
{
Loaded += loadFinishedEventHandler;
}
}
}
if (persistFinishedEventHandler != null)
{
if (Persisted == null)
{
Persisted += persistFinishedEventHandler;
}
else
{
bool ok = true;
foreach (Delegate d in Persisted.GetInvocationList())
{
if (d.Target == persistFinishedEventHandler.Target)
{
ok = false;
}
}
if (ok)
{
Persisted += persistFinishedEventHandler;
}
}
}
switch (HraState)
{
case States.Null:
LoadObject();
break;
case States.Loading:
break;
case States.Ready:
if (loadFinishedEventHandler != null)
{
RunWorkerCompletedEventArgs dummy = new RunWorkerCompletedEventArgs(this, null, false);
#if (CHATTY_DEBUG)
string msg2 = "*** HRA OBJECT loadFinishedEventHandler Firing on : " + this.ToString() + System.Environment.NewLine;
msg2 += "FOR " + loadFinishedEventHandler.Target.ToString();
Logger.Instance.DebugToLog(msg2);
#endif
loadFinishedEventHandler.Invoke(null, dummy);
}
break;
}
}
