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); } } } }