public void It_should_enforce_uniqueness()
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga1);
factory.SaveChanges();
factory.ReleaseSession();
Assert.Throws<ConcurrencyException>(() =>
{
var saga2 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga2);
factory.SaveChanges();
});
}
public async Task SetUp()
{
var cfg = new Configuration()
.DataBaseIntegration(x =>
{
x.Dialect <MsSql2012Dialect>();
x.ConnectionString = Consts.SqlConnectionString;
});
var metaModel = new SagaMetadataCollection();
metaModel.Initialize(SagaTypes);
var sagaDataTypes = new List <Type>();
using (var enumerator = metaModel.GetEnumerator())
{
while (enumerator.MoveNext())
{
sagaDataTypes.Add(enumerator.Current.SagaEntityType);
}
}
sagaDataTypes.Add(typeof(ContainSagaData));
SagaModelMapper.AddMappings(cfg, metaModel, sagaDataTypes);
SessionFactory = cfg.BuildSessionFactory();
schema = new SchemaExport(cfg);
await schema.CreateAsync(false, true);
SagaPersister = new SagaPersister();
}
public async Task Should_delete_the_unique_doc_properly()
{
var sagaId = Guid.NewGuid();
IAsyncDocumentSession session;
var options = this.CreateContextWithAsyncSessionPresent(out session);
var persister = new SagaPersister();
var sagaEntity = new SagaData
{
Id = sagaId,
SomeId = Guid.NewGuid()
};
var synchronizedSession = new RavenDBSynchronizedStorageSession(session);
await persister.Save(sagaEntity, this.CreateMetadata <SomeSaga>(sagaEntity), synchronizedSession, options);
//session.Advanced.GetMetadataFor(sagaEntity).Remove("NServiceBus-UniqueDocId");
await session.SaveChangesAsync().ConfigureAwait(false);
var saga = await persister.Get <SagaData>(sagaId, synchronizedSession, options);
await persister.Complete(saga, synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
Assert.Null(await session.Query <SagaUniqueIdentity>().Customize(c => c.WaitForNonStaleResults()).SingleOrDefaultAsync(u => u.SagaId == sagaId));
}
protected override void Setup(FeatureConfigurationContext context)
{
context.Settings.EnableFeature<StorageType.Sagas>();
var settings = context.Settings;
var endpointName = settings.GetTablePrefix<StorageType.Sagas>();
var sqlVarient = settings.GetSqlVarient();
var commandBuilder = new SagaCommandBuilder(sqlVarient,endpointName);
var jsonSerializerSettings = SagaSettings.GetJsonSerializerSettings(settings);
var jsonSerializer = BuildJsonSerializer(jsonSerializerSettings);
var readerCreator = SagaSettings.GetReaderCreator(settings);
if (readerCreator == null)
{
readerCreator = reader => new JsonTextReader(reader);
}
var writerCreator = SagaSettings.GetWriterCreator(settings);
if (writerCreator == null)
{
writerCreator = writer => new JsonTextWriter(writer);
}
var versionDeserializeBuilder = SagaSettings.GetVersionSettings(settings);
var infoCache = new SagaInfoCache(versionDeserializeBuilder, jsonSerializer, readerCreator, writerCreator, commandBuilder);
var sagaPersister = new SagaPersister(infoCache);
context.Container.ConfigureComponent<ISagaPersister>(() => sagaPersister, DependencyLifecycle.SingleInstance);
}
public async Task The_database_should_enforce_the_uniqueness()
{
var failed = false;
using (var session = SessionFactory.OpenSession())
using (var transaction = session.BeginTransaction())
{
var correlationProperty = new SagaCorrelationProperty("UniqueString", "whatever");
var storageSession = new TestingNHibernateSynchronizedStorageSession(session);
await SagaPersister.Save(new SagaWithUniqueProperty
{
Id = Guid.NewGuid(),
UniqueString = "whatever"
}, correlationProperty, storageSession, new ContextBag()).ConfigureAwait(false);
await SagaPersister.Save(new SagaWithUniqueProperty
{
Id = Guid.NewGuid(),
UniqueString = "whatever"
}, correlationProperty, storageSession, new ContextBag()).ConfigureAwait(false);
try
{
transaction.Commit();
}
catch (Exception)
{
failed = true;
}
}
Assert.IsTrue(failed);
}
public void SetUp()
{
ConnectionString = $"Data Source={Path.GetTempFileName()};New=True;";
var configuration = new Configuration()
.AddProperties(new Dictionary <string, string>
{
{ "dialect", dialect },
{ Environment.ConnectionString, ConnectionString }
});
var metaModel = new SagaMetadataCollection();
metaModel.Initialize(SagaTypes);
var sagaDataTypes = new List <Type>();
using (var enumerator = metaModel.GetEnumerator())
{
while (enumerator.MoveNext())
{
sagaDataTypes.Add(enumerator.Current.SagaEntityType);
}
}
sagaDataTypes.Add(typeof(ContainSagaData));
SagaModelMapper.AddMappings(configuration, metaModel, sagaDataTypes);
SessionFactory = configuration.BuildSessionFactory();
new SchemaUpdate(configuration).Execute(true, true);
SagaPersister = new SagaPersister();
}
private SagaPersister GetPersister()
{
SagaPersister.Initialize(_connectionFactoryHolder.ConnectionFactory, new[] {typeof (FakeSagaData), typeof(BiggerSagaData)});
SagaPersister.Initialize(_connectionFactoryHolder.ConnectionFactory, new[] { typeof(FakeSagaData), typeof(BiggerSagaData) });
var persister = new SagaPersister(_connectionFactoryHolder);
return persister;
}
public async Task TestMarkingAsComplete(ConventionType seedType)
{
using (var db = new ReusableDB())
{
List <TestSagaData> sagas;
using (var store = db.NewStore())
{
ApplyPrefillConventions(store, seedType);
store.Initialize();
sagas = await Prefill(store, seedType);
}
using (var store = db.NewStore())
{
Console.WriteLine($"Testing saga lookups with DocumentStore initially configured for {seedType} conventions.");
ApplyTestConventions(store, seedType);
store.Initialize();
// Update each saga, once by id and once by correlation property
foreach (var saga in sagas)
{
var persister = new SagaPersister();
using (var session = store.OpenAsyncSession())
{
Console.WriteLine($"Retrieving SagaId {saga.Id} by Correlation Property OrderId={saga.OrderId} and completing.");
var ravenDBSynchronizedStorageSession = new RavenDBSynchronizedStorageSession(session, false);
var contextBag = new ContextBag();
var byOrderId = await persister.Get <TestSagaData>("OrderId", saga.OrderId, ravenDBSynchronizedStorageSession, contextBag);
Assert.IsNotNull(byOrderId);
await persister.Complete(byOrderId, ravenDBSynchronizedStorageSession, contextBag);
await session.SaveChangesAsync();
}
}
db.WaitForIndexing(store);
// Ensure terms are still the saga type and unique identity type
var terms = store.DatabaseCommands.GetTerms("Raven/DocumentsByEntityName", "Tag", null, 1024).ToList();
Assert.AreEqual(2, terms.Count);
foreach (var term in terms)
{
var query = new IndexQuery
{
Query = "Tag:" + term,
PageSize = 0
};
// Ensure there are none left
var queryResult = store.DatabaseCommands.Query("Raven/DocumentsByEntityName", query);
Assert.AreEqual(0, queryResult.TotalResults);
}
}
}
}
private async Task RunTestUsing(GetSagaDelegate getSaga)
{
var sagaId = StoreSagaDocuments();
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency())
{
var persister = new SagaPersister();
var context = new ContextBag();
context.Set(session);
var synchronizedSession = new RavenDBSynchronizedStorageSession(session);
var sagaData = await getSaga(persister, sagaId, synchronizedSession, context);
Assert.IsNotNull(sagaData);
Assert.AreEqual(42, sagaData.Counter);
Assert.AreEqual("Alpha", sagaData.Name);
await persister.Complete(sagaData, synchronizedSession, context);
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency())
{
var dataDocs = await session.Advanced.LoadStartingWithAsync <SagaDataContainer>("CountingSagaDatas/");
var uniqueDocs = await session.Advanced.LoadStartingWithAsync <SagaUniqueIdentity>("Raven3Sagas-");
Assert.IsEmpty(dataDocs);
Assert.IsEmpty(uniqueDocs);
}
}
public void It_should_allow_the_update()
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga1);
factory.SaveChanges();
factory.ReleaseSession();
var saga = persister.Get<SagaData>(saga1.Id);
saga.UniqueString = Guid.NewGuid().ToString();
persister.Update(saga);
factory.SaveChanges();
factory.ReleaseSession();
var saga2 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
//this should not blow since we changed the unique value in the previous saga
persister.Save(saga2);
factory.SaveChanges();
}
public void It_should_persist_successfully()
{
using (var store = DocumentStoreBuilder.Build())
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga1);
factory.SaveChanges();
factory.ReleaseSession();
var saga = persister.Get <SagaData>(saga1.Id);
persister.Complete(saga);
factory.SaveChanges();
factory.ReleaseSession();
var saga2 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga2);
factory.SaveChanges();
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
ValidateSagaOutboxCombo(settings);
var sqlDialect = settings.GetSqlDialect();
var container = context.Container;
var connectionBuilder = settings.GetConnectionBuilder();
var isSagasEnabledForSqlPersistence = settings.IsFeatureActive(typeof(SqlSagaFeature));
var isOutboxEnabledForSqlPersistence = settings.IsFeatureActive(typeof(SqlOutboxFeature));
SagaInfoCache infoCache = null;
if (isSagasEnabledForSqlPersistence)
{
infoCache = BuildSagaInfoCache(sqlDialect, settings);
}
if (isOutboxEnabledForSqlPersistence || isSagasEnabledForSqlPersistence)
{
//Info cache can be null if Outbox is enabled but Sagas are disabled.
container.ConfigureComponent(() => new SynchronizedStorage(connectionBuilder, infoCache), DependencyLifecycle.SingleInstance);
container.ConfigureComponent(() => new StorageAdapter(connectionBuilder, infoCache, sqlDialect), DependencyLifecycle.SingleInstance);
}
if (isSagasEnabledForSqlPersistence)
{
var sagaPersister = new SagaPersister(infoCache, sqlDialect);
container.ConfigureComponent <ISagaPersister>(() => sagaPersister, DependencyLifecycle.SingleInstance);
}
}
public async Task Schema_version_should_be_persisted()
{
// arrange
var entity = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = "SomeUniqueString",
};
var persister = new SagaPersister();
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency().InContext(out var context))
{
var synchronizedSession = new RavenDBSynchronizedStorageSession(session);
// act
await persister.Save(entity, this.CreateMetadata <SomeSaga>(entity), synchronizedSession, context);
await session.SaveChangesAsync();
// assert
var sagaDataContainerId = SagaPersister.DocumentIdForSagaData(session, entity);
var sagaDataContainer = await session.LoadAsync <SagaDataContainer>(sagaDataContainerId);
var sagaDataContainerMetadata = session.Advanced.GetMetadataFor(sagaDataContainer);
var sagaUniqueIdentityId = sagaDataContainer.IdentityDocId;
var sagaUniqueIdentity = await session.LoadAsync <SagaUniqueIdentity>(sagaUniqueIdentityId);
var sagaUniqueIdentityMetadata = session.Advanced.GetMetadataFor(sagaUniqueIdentity);
Assert.AreEqual(SagaDataContainer.SchemaVersion, sagaDataContainerMetadata[SchemaVersionExtensions.SagaDataContainerSchemaVersionMetadataKey]);
Assert.AreEqual(SagaUniqueIdentity.SchemaVersion, sagaUniqueIdentityMetadata[SchemaVersionExtensions.SagaUniqueIdentitySchemaVersionMetadataKey]);
}
}
public async Task Should_delete_the_saga_and_the_unique_doc()
{
var sagaId = Guid.NewGuid();
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency().InContext(out var options))
{
var persister = new SagaPersister();
var entity = new SagaData
{
Id = sagaId
};
var synchronizedSession = new RavenDBSynchronizedStorageSession(session);
await persister.Save(entity, this.CreateMetadata <SomeSaga>(entity), synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
var saga = await persister.Get <SagaData>(sagaId, synchronizedSession, options);
await persister.Complete(saga, synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
Assert.Null(await persister.Get <SagaData>(sagaId, synchronizedSession, options));
Assert.Null(await session.Query <SagaUniqueIdentity>().Customize(c => c.WaitForNonStaleResults()).SingleOrDefaultAsync(u => u.SagaId == sagaId).ConfigureAwait(false));
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
ValidateSagaOutboxCombo(settings);
var sqlDialect = settings.GetSqlDialect();
var services = context.Services;
var connectionManager = settings.GetConnectionBuilder <StorageType.Sagas>();
var sqlSagaPersistenceActivated = settings.IsFeatureActive(typeof(SqlSagaFeature));
SagaInfoCache infoCache = null;
if (sqlSagaPersistenceActivated)
{
infoCache = BuildSagaInfoCache(sqlDialect, settings);
}
var sessionHolder = new CurrentSessionHolder();
//Info cache can be null if Outbox is enabled but Sagas are disabled.
services.AddSingleton <ISynchronizedStorage>(new SynchronizedStorage(connectionManager, infoCache, sessionHolder));
services.AddSingleton <ISynchronizedStorageAdapter>(new StorageAdapter(connectionManager, infoCache, sqlDialect, sessionHolder));
services.AddTransient(_ => sessionHolder.Current);
context.Pipeline.Register(new CurrentSessionBehavior(sessionHolder), "Manages the lifecycle of the current session holder.");
if (sqlSagaPersistenceActivated)
{
var sagaPersister = new SagaPersister(infoCache, sqlDialect);
services.AddSingleton <ISagaPersister>(sagaPersister);
}
}
public async Task Inherited_property_classes_should_be_persisted()
{
IAsyncDocumentSession session;
var options = this.CreateContextWithAsyncSessionPresent(out session);
var persister = new SagaPersister();
var entity = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = "SomeUniqueString",
PolymorphicRelatedProperty = new PolymorphicProperty
{
SomeInt = 9
}
};
var synchronizedSession = new RavenDBSynchronizedStorageSession(session, true);
await persister.Save(entity, this.CreateMetadata <SomeSaga>(entity), synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
var savedEntity = await persister.Get <SagaData>(entity.Id, synchronizedSession, options);
var expected = (PolymorphicProperty)entity.PolymorphicRelatedProperty;
var actual = (PolymorphicProperty)savedEntity.PolymorphicRelatedProperty;
Assert.AreEqual(expected.SomeInt, actual.SomeInt);
}
public async Task It_should_persist_successfully()
{
IAsyncDocumentSession session;
var options = this.CreateContextWithAsyncSessionPresent(out session);
var persister = new SagaPersister();
var uniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString,
NonUniqueString = "notUnique"
};
var synchronizedSession = new RavenDBSynchronizedStorageSession(session, true);
await persister.Save(saga1, this.CreateMetadata <SomeSaga>(saga1), synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
var saga = await persister.Get <SagaData>(saga1.Id, synchronizedSession, options);
saga.NonUniqueString = "notUnique2";
await persister.Update(saga, synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
}
public void It_should_persist_successfully()
{
using (var store = DocumentStoreBuilder.Build())
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var anotherUniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString,
NonUniqueString = "notUnique"
};
persister.Save(saga1);
factory.SaveChanges();
var saga = persister.Get <SagaData>(saga1.Id);
saga.NonUniqueString = "notUnique2";
saga.UniqueString = anotherUniqueString;
persister.Update(saga);
factory.SaveChanges();
}
}
public void It_should_persist_successfully()
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga1);
factory.SaveChanges();
factory.ReleaseSession();
var saga = persister.Get<SagaData>(saga1.Id);
persister.Complete(saga);
factory.SaveChanges();
factory.ReleaseSession();
var saga2 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga2);
factory.SaveChanges();
}
public async Task It_should_persist_successfully()
{
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency().InContext(out var options))
{
var persister = new SagaPersister();
var uniqueString = Guid.NewGuid().ToString();
var anotherUniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString,
NonUniqueString = "notUnique"
};
var synchronizedSession = new RavenDBSynchronizedStorageSession(session);
await persister.Save(saga1, this.CreateMetadata <SomeSaga>(saga1), synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
var saga = await persister.Get <SagaData>(saga1.Id, synchronizedSession, options);
saga.NonUniqueString = "notUnique2";
saga.UniqueString = anotherUniqueString;
await persister.Update(saga, synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var settings = context.Settings;
ValidateSagaOutboxCombo(settings);
var sqlDialect = settings.GetSqlDialect();
var container = context.Container;
var connectionManager = settings.GetConnectionBuilder <StorageType.Sagas>();
var sqlSagaPersistenceActivated = settings.IsFeatureActive(typeof(SqlSagaFeature));
SagaInfoCache infoCache = null;
if (sqlSagaPersistenceActivated)
{
infoCache = BuildSagaInfoCache(sqlDialect, settings);
}
var sessionHolder = new CurrentSessionHolder();
//Info cache can be null if Outbox is enabled but Sagas are disabled.
container.ConfigureComponent(() => new SynchronizedStorage(connectionManager, infoCache, sessionHolder), DependencyLifecycle.SingleInstance);
container.ConfigureComponent(() => new StorageAdapter(connectionManager, infoCache, sqlDialect, sessionHolder), DependencyLifecycle.SingleInstance);
container.ConfigureComponent(() => sessionHolder.Current, DependencyLifecycle.InstancePerCall);
context.Pipeline.Register(new CurrentSessionBehavior(sessionHolder), "Manages the lifecycle of the current session holder.");
if (sqlSagaPersistenceActivated)
{
var sagaPersister = new SagaPersister(infoCache, sqlDialect);
container.ConfigureComponent <ISagaPersister>(() => sagaPersister, DependencyLifecycle.SingleInstance);
}
}
public async Task Public_setters_and_getters_of_concrete_classes_should_be_persisted()
{
var entity = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = "SomeUniqueString",
TestComponent = new TestComponent
{
Property = "Prop"
}
};
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency().InContext(out var options))
{
var persister = new SagaPersister(new SagaPersistenceConfiguration());
var synchronizedSession = new RavenDBSynchronizedStorageSession(session, options);
await persister.Save(entity, this.CreateMetadata <SomeSaga>(entity), synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
var savedEntity = await persister.Get <SagaData>(entity.Id, synchronizedSession, options);
Assert.AreEqual(entity.TestComponent.Property, savedEntity.TestComponent.Property);
Assert.AreEqual(entity.TestComponent.AnotherProperty, savedEntity.TestComponent.AnotherProperty);
}
}
public void Connect()
{
connection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113));
connection.ConnectAsync().GetAwaiter().GetResult();
persister = new SagaPersister();
}
public async Task Public_setters_and_getters_of_concrete_classes_should_be_persisted()
{
var entity = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = "SomeUniqueString",
TestComponent = new TestComponent
{
Property = "Prop"
}
};
IAsyncDocumentSession session;
var options = this.CreateContextWithAsyncSessionPresent(out session);
var persister = new SagaPersister();
var synchronizedSession = new RavenDBSynchronizedStorageSession(session, true);
await persister.Save(entity, this.CreateMetadata <SomeSaga>(entity), synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
var savedEntity = await persister.Get <SagaData>(entity.Id, synchronizedSession, options);
Assert.AreEqual(entity.TestComponent.Property, savedEntity.TestComponent.Property);
Assert.AreEqual(entity.TestComponent.AnotherProperty, savedEntity.TestComponent.AnotherProperty);
}
public async Task Saga_should_be_persisted()
{
var saga = new SagaData
{
Id = Guid.NewGuid(),
SomeId = "test-id",
SomeName = "Test Name"
};
IDocumentSession session;
var context = this.CreateContextWithSessionPresent(out session);
var sagaPersister = new SagaPersister();
var synchronizedStorageSession = new MartenSynchronizedStorageSession(session, true);
await sagaPersister.Save(saga, new SagaCorrelationProperty("SomeId", saga.SomeId), synchronizedStorageSession, context);
await session.SaveChangesAsync().ConfigureAwait(false);
var savedSaga = await sagaPersister.Get <SagaData>(saga.Id, synchronizedStorageSession, context);
savedSaga.Id.Should().Be(saga.Id);
savedSaga.SomeId.Should().Be(saga.SomeId);
savedSaga.SomeName.Should().Be(saga.SomeName);
}
public void It_should_allow_the_update()
{
using (var store = DocumentStoreBuilder.Build())
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga1);
factory.SaveChanges();
factory.ReleaseSession();
var saga = persister.Get <SagaData>(saga1.Id);
saga.UniqueString = Guid.NewGuid().ToString();
persister.Update(saga);
factory.SaveChanges();
factory.ReleaseSession();
var saga2 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
//this should not blow since we changed the unique value in the previous saga
persister.Save(saga2);
factory.SaveChanges();
}
}
public async Task Inherited_property_classes_should_be_persisted()
{
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency().InContext(out var options))
{
var persister = new SagaPersister(new SagaPersistenceConfiguration());
var entity = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = "SomeUniqueString",
PolymorphicRelatedProperty = new PolymorphicProperty
{
SomeInt = 9
}
};
var synchronizedSession = new RavenDBSynchronizedStorageSession(session, options);
await persister.Save(entity, this.CreateMetadata <SomeSaga>(entity), synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
var savedEntity = await persister.Get <SagaData>(entity.Id, synchronizedSession, options);
var expected = (PolymorphicProperty)entity.PolymorphicRelatedProperty;
var actual = (PolymorphicProperty)savedEntity.PolymorphicRelatedProperty;
Assert.AreEqual(expected.SomeInt, actual.SomeInt);
}
}
public void SetUp()
{
connectionString = String.Format(@"Data Source={0};New=True;", Path.GetTempFileName());
var configuration = new global::NHibernate.Cfg.Configuration()
.AddProperties(new Dictionary <string, string>
{
{ "dialect", dialect },
{ global::NHibernate.Cfg.Environment.ConnectionString, connectionString }
});
var modelMapper = new SagaModelMapper(new[] { typeof(T) });
configuration.AddMapping(modelMapper.Compile());
SessionFactory = configuration.BuildSessionFactory();
new SchemaUpdate(configuration).Execute(false, true);
session = SessionFactory.OpenSession();
SagaPersister = new SagaPersister(new FakeSessionProvider(SessionFactory, session));
new Installer().Install(WindowsIdentity.GetCurrent().Name, null);
}
public void It_should_enforce_uniqueness()
{
using (var store = DocumentStoreBuilder.Build())
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga1);
factory.SaveChanges();
factory.ReleaseSession();
Assert.Throws <ConcurrencyException>(() =>
{
var saga2 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga2);
factory.SaveChanges();
});
}
}
public void SetUp()
{
ConnectionString = $@"Data Source={Path.GetTempFileName()};New=True;";
var configuration = new global::NHibernate.Cfg.Configuration()
.AddProperties(new Dictionary <string, string>
{
{ "dialect", dialect },
{ global::NHibernate.Cfg.Environment.ConnectionString, ConnectionString }
});
var metaModel = new SagaMetadataCollection();
metaModel.Initialize(new[] { typeof(T) });
var metadata = metaModel.Find(typeof(T));
var modelMapper = new SagaModelMapper(metaModel, new[] { metadata.SagaEntityType });
configuration.AddMapping(modelMapper.Compile());
SessionFactory = configuration.BuildSessionFactory();
new SchemaUpdate(configuration).Execute(false, true);
SagaPersister = new SagaPersister();
}
public void SetUp()
{
_sagaEntityA = new SagaEntityA {
Id = Guid.NewGuid(), SomeIdentifier = IDENTIFIER
};
SagaPersister.Save(_sagaEntityA);
SagaPersister.DocumentSessionFactory.Current.SaveChanges();
}
public void an_sagaEntity_by_property_value()
{
var loadedSagaA = SagaPersister.Get <SagaEntityA>("SomeIdentifier", IDENTIFIER);
var loadedSagaB = SagaPersister.Get <SagaEntityB>("SomeIdentifier", IDENTIFIER);
Assert.That(loadedSagaA.Id, Is.EqualTo(_sagaEntityA.Id));
Assert.That(loadedSagaB.Id, Is.EqualTo(_sagaEntityB.Id));
}
public SagaPersisterIntegrationTests()
{
_dbContext = new TestDbContext();
_mockDbContextProvider = new Mock <IDbContextProvider>();
_mockDbContextProvider.Setup(m => m.GetSagaDbContext()).Returns(_dbContext);
_persister = new SagaPersister(_mockDbContextProvider.Object);
}
public async Task It_should_return_null()
{
IAsyncDocumentSession session;
var options = this.CreateContextWithAsyncSessionPresent(out session);
var persister = new SagaPersister();
var synchronizedSession = new RavenDBSynchronizedStorageSession(session, true);
Assert.Null(await persister.Get <SagaData>("UniqueString", Guid.NewGuid().ToString(), synchronizedSession, options));
}
public SagaTestsConfiguration(string versionElementName, Func <Type, string> collectionNamingConvention, TimeSpan?transactionTimeout = null)
{
DatabaseName = "Test_" + DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture);
CollectionNamingConvention = collectionNamingConvention;
SynchronizedStorage = new StorageSessionFactory(ClientProvider.Client, true, DatabaseName, collectionNamingConvention, transactionTimeout ?? MongoPersistence.DefaultTransactionTimeout);
SagaStorage = new SagaPersister(versionElementName);
}
public async Task TestRetrievingSagas(ConventionType seedType)
{
using (var db = new ReusableDB())
{
List<TestSagaData> sagas;
using (var store = db.NewStore())
{
ApplyPrefillConventions(store, seedType);
store.Initialize();
sagas = await Prefill(store, seedType);
}
// Need to ensure multiple runs will work, after conventions document is stored
for (var i = 0; i < 3; i++)
{
using (var store = db.NewStore())
{
Console.WriteLine($"Testing saga lookups with DocumentStore initially configured for {seedType} conventions.");
ApplyTestConventions(store, seedType);
store.Initialize();
foreach (var saga in sagas)
{
var persister = new SagaPersister();
Console.WriteLine($"Retrieving SagaId {saga.Id} by SagaId");
TestSagaData byId;
using (var session = store.OpenAsyncSession())
{
byId = await persister.Get<TestSagaData>(saga.Id, new RavenDBSynchronizedStorageSession(session, false), null);
}
Assert.IsNotNull(byId);
Assert.AreEqual(byId.Id, saga.Id);
Assert.AreEqual(byId.OrderId, saga.OrderId);
Assert.AreEqual(byId.OriginalMessageId, saga.OriginalMessageId);
Assert.AreEqual(byId.Originator, saga.Originator);
Assert.AreEqual(1, saga.Counter);
Console.WriteLine($"Retrieving SagaId {saga.Id} by Correlation Property OrderId={saga.OrderId}");
using (var session = store.OpenAsyncSession())
{
byId = await persister.Get<TestSagaData>("OrderId", saga.OrderId, new RavenDBSynchronizedStorageSession(session, false), new ContextBag());
}
Assert.IsNotNull(byId);
Assert.AreEqual(byId.Id, saga.Id);
Assert.AreEqual(byId.OrderId, saga.OrderId);
Assert.AreEqual(byId.OriginalMessageId, saga.OriginalMessageId);
Assert.AreEqual(byId.Originator, saga.Originator);
Assert.AreEqual(1, saga.Counter);
}
}
}
}
}
public void SetUp()
{
var nhibernateProperties = SQLiteConfiguration.UsingFile(Path.GetTempFileName());
SessionFactory = new SessionFactoryBuilder(typeof(TestSaga).Assembly.GetTypes())
.Build(nhibernateProperties, true);
SagaPersister = new SagaPersister { SessionFactory = SessionFactory };
UnitOfWork = new UnitOfWorkManager { SessionFactory = SessionFactory };
}
public void Should_not_generate_a_to_long_unique_property_id()
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var saga = new SagaWithUniquePropertyAndALongNamespace
{
Id = Guid.NewGuid(),
UniqueString = uniqueString
};
persister.Save(saga);
factory.SaveChanges();
}
public void SetUp()
{
var nhibernateProperties = SQLiteConfiguration.Standard
.UsingFile(Path.GetTempFileName())
.ProxyFactoryFactory(typeof(ProxyFactoryFactory).AssemblyQualifiedName)
.ToProperties();
SessionFactory = new SessionFactoryBuilder(typeof(TestSaga).Assembly.GetTypes())
.Build(nhibernateProperties, true);
MessageModule = new NHibernateMessageModule { SessionFactory = SessionFactory };
SagaPersister = new SagaPersister { SessionFactory = SessionFactory };
}
public RavenDbSagaPersisterTests()
{
var documentStore = new Raven.Client.Client.EmbeddableDocumentStore { RunInMemory = true };
documentStore.Initialize();
//var documentStore = new Raven.Client.Document.DocumentStore {Url = "http://localhost:8080"};
//documentStore.Initialize();
//IDocumentSessionFactory documentSessionFactory = new DocumentSessionFactory(embeddableDocumentStore);
IDocumentSessionFactory documentSessionFactory = new DocumentSessionFactory(documentStore);
SagaPersister = new SagaPersister
{
DocumentSessionFactory = documentSessionFactory
};
}
public void Enums_should_be_persisted()
{
var entity = new SagaData
{
Id = Guid.NewGuid(),
Status = StatusEnum.AnotherStatus
};
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
persister.Save(entity);
factory.SaveChanges();
var savedEntity = persister.Get<SagaData>(entity.Id);
Assert.AreEqual(entity.Status, savedEntity.Status);
}
public void Public_setters_and_getters_of_concrete_classes_should_be_persisted()
{
var entity = new SagaData
{
Id = Guid.NewGuid(),
TestComponent = new TestComponent
{
Property = "Prop"
}
};
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
persister.Save(entity);
factory.SaveChanges();
var savedEntity = persister.Get<SagaData>(entity.Id);
Assert.AreEqual(entity.TestComponent.Property, savedEntity.TestComponent.Property);
Assert.AreEqual(entity.TestComponent.AnotherProperty, savedEntity.TestComponent.AnotherProperty);
}
public void Should_delete_the_saga()
{
var sagaId = Guid.NewGuid();
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
persister.Save(new SagaData
{
Id = sagaId
});
factory.SaveChanges();
var saga = persister.Get<SagaData>(sagaId);
persister.Complete(saga);
factory.SaveChanges();
Assert.Null(persister.Get<SagaData>(sagaId));
}
public async Task It_should_load_successfully()
{
var unique = Guid.NewGuid().ToString();
CreateLegacySagaDocuments(store, unique);
IAsyncDocumentSession session;
var options = this.CreateContextWithAsyncSessionPresent(out session);
var persister = new SagaPersister();
var synchronizedSession = new RavenDBSynchronizedStorageSession(session, true);
var saga = await persister.Get<SagaWithUniqueProperty>("UniqueString", unique, synchronizedSession, options);
Assert.IsNotNull(saga, "Saga is null");
await persister.Complete(saga, synchronizedSession, options);
await session.SaveChangesAsync().ConfigureAwait(false);
Assert.IsNull(await persister.Get<SagaWithUniqueProperty>("UniqueString", unique, synchronizedSession, options), "Saga was not completed");
}
public void Inherited_property_classes_should_be_persisted()
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var entity = new SagaData
{
Id = Guid.NewGuid(),
PolymorphicRelatedProperty = new PolymorphicProperty
{
SomeInt = 9
}
};
persister.Save(entity);
factory.SaveChanges();
var savedEntity = persister.Get<SagaData>(entity.Id);
var expected = (PolymorphicProperty)entity.PolymorphicRelatedProperty;
var actual = (PolymorphicProperty)savedEntity.PolymorphicRelatedProperty;
Assert.AreEqual(expected.SomeInt, actual.SomeInt);
}
public void It_should_set_the_attribute_and_allow_the_update()
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var anotherUniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString,
NonUniqueString = "notUnique"
};
persister.Save(saga1);
factory.SaveChanges();
factory.ReleaseSession();
using (var session = store.OpenSession())
{
//fake that the attribute was just added by removing the metadata
session.Advanced.GetMetadataFor(saga1).Remove(SagaPersister.UniqueValueMetadataKey);
session.SaveChanges();
}
var saga = persister.Get<SagaData>(saga1.Id);
saga.UniqueString = anotherUniqueString;
persister.Update(saga);
factory.SaveChanges();
factory.ReleaseSession();
using (var session = store.OpenSession())
{
var value = session.Advanced.GetMetadataFor(saga1)[SagaPersister.UniqueValueMetadataKey].ToString();
Assert.AreEqual(anotherUniqueString, value);
}
}
public void SetUp()
{
string connectionString = String.Format(@"Data Source={0};Version=3;New=True;", Path.GetTempFileName());
Configure.ConfigurationSource = new FakeConfigurationSource();
NHibernateSettingRetriever.AppSettings = () => new NameValueCollection
{
{"NServiceBus/Persistence/NHibernate/dialect", dialect}
};
NHibernateSettingRetriever.ConnectionStrings = () => new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("NServiceBus/Persistence/NHibernate/Saga", connectionString)
};
ConfigureNHibernate.Init();
Configure.Features.Enable<Features.Sagas>();
var types = typeof(TestSaga).Assembly.GetTypes().ToList();
types.Add(typeof(ContainSagaData));
Configure.With(types)
.DefineEndpointName("Foo")
.DefaultBuilder()
.UseNHibernateSagaPersister();
var builder = new SessionFactoryBuilder(Configure.TypesToScan);
var properties = ConfigureNHibernate.SagaPersisterProperties;
SessionFactory = builder.Build(ConfigureNHibernate.CreateConfigurationWith(properties));
UnitOfWork = new UnitOfWorkManager { SessionFactory = SessionFactory };
SagaPersister = new SagaPersister { UnitOfWorkManager = (UnitOfWorkManager)UnitOfWork };
new Installer().Install(WindowsIdentity.GetCurrent().Name);
}
public void It_should_persist_successfully()
{
var factory = new RavenSessionFactory(store);
factory.ReleaseSession();
var persister = new SagaPersister(factory);
var uniqueString = Guid.NewGuid().ToString();
var anotherUniqueString = Guid.NewGuid().ToString();
var saga1 = new SagaData
{
Id = Guid.NewGuid(),
UniqueString = uniqueString,
NonUniqueString = "notUnique"
};
persister.Save(saga1);
factory.SaveChanges();
var saga = persister.Get<SagaData>(saga1.Id);
saga.NonUniqueString = "notUnique2";
saga.UniqueString = anotherUniqueString;
persister.Update(saga);
factory.SaveChanges();
}
public async Task TestStoringSagas(ConventionType seedType)
{
using (var db = new ReusableDB())
{
List<TestSagaData> sagas;
using (var store = db.NewStore())
{
ApplyPrefillConventions(store, seedType);
store.Initialize();
sagas = await Prefill(store, seedType);
}
using (var store = db.NewStore())
{
Console.WriteLine($"Testing saga updates with DocumentStore initially configured for {seedType} conventions.");
ApplyTestConventions(store, seedType);
store.Initialize();
// Update each saga, once by id and once by correlation property
foreach (var saga in sagas)
{
var persister = new SagaPersister();
Console.WriteLine($"Retrieving SagaId {saga.Id} by SagaId");
using (var session = store.OpenAsyncSession())
{
var ravenDBSynchronizedStorageSession = new RavenDBSynchronizedStorageSession(session, false);
var byId = await persister.Get<TestSagaData>(saga.Id, ravenDBSynchronizedStorageSession, null);
Assert.IsNotNull(byId);
byId.Counter++;
await persister.Update(byId, ravenDBSynchronizedStorageSession, null);
await session.SaveChangesAsync();
Console.WriteLine($"Retrieving SagaId {saga.Id} by Correlation Property OrderId={saga.OrderId}");
var byOrderId = await persister.Get<TestSagaData>("OrderId", saga.OrderId, ravenDBSynchronizedStorageSession, new ContextBag());
Assert.IsNotNull(byOrderId);
byOrderId.Counter++;
await persister.Update(byOrderId, ravenDBSynchronizedStorageSession, null);
await session.SaveChangesAsync();
}
}
Console.WriteLine("Retrieving each saga again by SagaId and making sure Counter == 3");
foreach (var saga in sagas)
{
var persister = new SagaPersister();
using (var session = store.OpenAsyncSession())
{
Console.WriteLine($"Retrieving SagaId {saga.Id} by SagaId");
var byId = await persister.Get<TestSagaData>(saga.Id, new RavenDBSynchronizedStorageSession(session, false), null);
Assert.IsNotNull(byId);
Assert.AreEqual(3, byId.Counter);
}
}
}
}
}
private async Task<List<TestSagaData>> Prefill(IDocumentStore store, ConventionType seedType)
{
var snooper = StoreSnooper.Install(store);
Console.WriteLine($"Filling database with saga data, using {seedType} conventions");
var names = new Dictionary<ConventionType, string>
{
{ConventionType.RavenDefault, "TestSagaDatas"},
{ConventionType.NSBDefault, "TestSaga"},
{ConventionType.Customer, "ataDagaStseT"}
};
var name = names[seedType];
var sagas = Enumerable.Range(1001, 10)
.Select(orderId => new TestSagaData
{
Id = Guid.NewGuid(),
OrderId = orderId,
OriginalMessageId = Guid.NewGuid().ToString(),
Originator = "SomeSaga",
Counter = 1
})
.ToList();
foreach (var saga in sagas)
{
snooper.Clear();
var persister = new SagaPersister();
Console.WriteLine($"Storing SagaId {saga.Id}");
using (var session = store.OpenAsyncSession())
{
await persister.Save(saga, new SagaCorrelationProperty("OrderId", saga.OrderId), new RavenDBSynchronizedStorageSession(session, false), null);
await session.SaveChangesAsync();
}
var keysStored = snooper.KeysStored.ToList();
foreach (var key in keysStored)
{
Console.WriteLine($" * Document created: {key}");
}
Assert.AreEqual(2, snooper.KeyCount);
Assert.Contains($"{name}/{saga.Id}", keysStored);
}
return sagas;
}
public async Task TestMarkingAsComplete(ConventionType seedType)
{
using (var db = new ReusableDB())
{
List<TestSagaData> sagas;
using (var store = db.NewStore())
{
ApplyPrefillConventions(store, seedType);
store.Initialize();
sagas = await Prefill(store, seedType);
}
using (var store = db.NewStore())
{
Console.WriteLine($"Testing saga lookups with DocumentStore initially configured for {seedType} conventions.");
ApplyTestConventions(store, seedType);
store.Initialize();
// Update each saga, once by id and once by correlation property
foreach (var saga in sagas)
{
var persister = new SagaPersister();
using (var session = store.OpenAsyncSession())
{
Console.WriteLine($"Retrieving SagaId {saga.Id} by Correlation Property OrderId={saga.OrderId} and completing.");
var ravenDBSynchronizedStorageSession = new RavenDBSynchronizedStorageSession(session, false);
var contextBag = new ContextBag();
var byOrderId = await persister.Get<TestSagaData>("OrderId", saga.OrderId, ravenDBSynchronizedStorageSession, contextBag);
Assert.IsNotNull(byOrderId);
await persister.Complete(byOrderId, ravenDBSynchronizedStorageSession, contextBag);
await session.SaveChangesAsync();
}
}
db.WaitForIndexing(store);
// Ensure terms are still the saga type and unique identity type
var terms = store.DatabaseCommands.GetTerms("Raven/DocumentsByEntityName", "Tag", null, 1024).ToList();
Assert.AreEqual(2, terms.Count);
foreach (var term in terms)
{
var query = new IndexQuery
{
Query = "Tag:" + term,
PageSize = 0
};
// Ensure there are none left
var queryResult = store.DatabaseCommands.Query("Raven/DocumentsByEntityName", query);
Assert.AreEqual(0, queryResult.TotalResults);
}
}
}
}
