public async Task Auto_reload_on_multiple_obsolete_reamodels() { SimpleTestAtomicReadModel rm1 = GenerateChangesetWithTwoEvents(); SimpleTestAtomicReadModel rm2 = GenerateChangesetWithTwoEvents(); Assert.That(rm1.TouchCount, Is.EqualTo(1)); Assert.That(rm2.TouchCount, Is.EqualTo(1)); await _sut.UpsertAsync(rm1).ConfigureAwait(false); await _sut.UpsertAsync(rm2).ConfigureAwait(false); //ok now in db we have an older version, lets update version SimpleTestAtomicReadModel.FakeSignature = 2; //I want to reload and autocorrect, reprojecting again everything. GenerateSut(); var reloaded = await _sut.FindManyAsync(_ => _.Id == rm1.Id || _.Id == rm2.Id, true).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); var rmList = reloaded.ToList(); Assert.That(rmList.Count, Is.EqualTo(2)); Assert.That(rmList[0].TouchCount, Is.EqualTo(2)); Assert.That(rmList[1].TouchCount, Is.EqualTo(2)); Assert.That(rmList[0].ReadModelVersion, Is.EqualTo(2)); Assert.That(rmList[1].ReadModelVersion, Is.EqualTo(2)); }
public async Task Ability_to_catchup_events() { //Arrange create the readmodel, and process some events, then persist those events. var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); //do not forget to persist the readmodel await _sut.UpsertAsync(rm).ConfigureAwait(false); //now generate another event that is not projected var extraTouchEvent = GenerateTouchedEvent(false); //Check //first of all verify that standard read does not read last event. var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.AggregateVersion, Is.EqualTo(evtTouch.AggregateVersion)); var actualTouchCount = reloaded.TouchCount; //now we need to load with catchup var reloadedWithCatchup = await _sut.FindOneByIdAndCatchupAsync(rm.Id).ConfigureAwait(false); //Assert Assert.That(reloadedWithCatchup, Is.Not.Null); Assert.That(reloadedWithCatchup.AggregateVersion, Is.EqualTo(extraTouchEvent.AggregateVersion)); Assert.That(reloadedWithCatchup.TouchCount, Is.EqualTo(actualTouchCount + 1)); }
public async Task Process_extra_changeset_make_readmodel_not_persistable() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //check var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(1)); //now generate another touch event but process with extra events var changesetTouch2 = GenerateTouchedEvent(false); rm.ProcessExtraStreamChangeset(changesetTouch2); Assert.That(rm.TouchCount, Is.EqualTo(2)); await _sut.UpsertAsync(rm).ConfigureAwait(false); //we expect two things. Assert.That(rm.ModifiedWithExtraStreamEvents, Is.True, "After process extra stream changeset the aggregate is not persistable"); //saving should not have persisted reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(1)); Assert.That(reloaded.ProjectedPosition, Is.EqualTo(evtTouch.GetChunkPosition())); }
public async Task Not_persistale_is_honored_in_update() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //check var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(1)); //forcing not persistable rm.SetPropertyValue(_ => _.ModifiedWithExtraStreamEvents, true); //saving should not have persisted reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(1)); Assert.That(reloaded.ProjectedPosition, Is.EqualTo(evtTouch.GetChunkPosition())); }
public async Task Auto_reload_from_obsolete_reader_can_still_unwind() { SimpleTestAtomicReadModel.FakeSignature = 2; var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //go backward SimpleTestAtomicReadModel.FakeSignature = 1; //I want to reload and autocorrect, reprojecting again everything. GenerateSut(); var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded.TouchCount, Is.EqualTo(1)); Assert.That(reloaded.ReadModelVersion, Is.EqualTo(1)); //signature change //no update should be done to the DB var record = _collection.AsQueryable().Single(_ => _.Id == rm.Id); Assert.That(record.TouchCount, Is.EqualTo(2)); Assert.That(record.ReadModelVersion, Is.EqualTo(2)); }
public async Task Verify_new_signature_overwrite_readmodel_even_with_same_version() { SimpleTestAtomicReadModel.FakeSignature = 1; var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var changesetTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(changesetTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //Retry saving without checking with same version but higher signature. SimpleTestAtomicReadModel.FakeSignature = 2; var rm2 = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm2.ProcessChangeset(evt); rm2.ProcessChangeset(changesetTouch); Assert.That(rm2.TouchCount, Is.EqualTo(2)); await _sut.UpdateAsync(rm2).ConfigureAwait(false); //reload the readmdoel, the version should be overwritten because signature is new var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(2)); Assert.That(reloaded.ReadModelVersion, Is.EqualTo(2)); var evtTouch = changesetTouch.Events[0] as DomainEvent; Assert.That(reloaded.ProjectedPosition, Is.EqualTo(evtTouch.CheckpointToken)); }
public async Task Verify_force_insert_bypass_equal_version() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //saved at version 2, manually alter data on database. var rmLoaded = await _collection.FindOneByIdAsync(rm.Id).ConfigureAwait(false); rmLoaded.SetPropertyValue(_ => _.TouchCount, 10000); _collection.Save(rmLoaded, rm.Id); //now try to resave with insert true, but without any change, no exception, no data changed await _sut.UpsertAsync(rm).ConfigureAwait(false); rmLoaded = await _collection.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(rmLoaded.TouchCount, Is.EqualTo(10000)); //now upsert with force true, this will update data in database no matter what. await _sut.UpsertForceAsync(rm).ConfigureAwait(false); rmLoaded = await _collection.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(rmLoaded.TouchCount, Is.EqualTo(1)); }
public async Task Auto_reload_on_serialization_error() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var changeset = GenerateCreatedEvent(false); rm.ProcessChangeset(changeset); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); Assert.That(rm.TouchCount, Is.EqualTo(1)); await _sut.UpsertAsync(rm).ConfigureAwait(false); //ok now go to the database and alter the document var doc = _mongoBsonCollection.FindOneById(rm.Id); doc ["ExtraProperty"] = 42; _mongoBsonCollection.ReplaceOne( Builders <BsonDocument> .Filter.Eq("_id", rm.Id), doc); //I want to reload and autocorrect, reprojecting again everything. GenerateSut(); var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded.TouchCount, Is.EqualTo(1)); Assert.That(reloaded.ReadModelVersion, Is.EqualTo(1)); }
public async Task Verify_correctly_return_false_of_Unhandled_event() { var cs = await GenerateSampleAggregateDerived1().ConfigureAwait(false); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); Assert.IsFalse(rm.ProcessChangeset(cs)); }
public async Task Verify_basic_dispatch_of_changeset() { var cs = await GenerateCreatedEvent().ConfigureAwait(false); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm.ProcessChangeset(cs); Assert.That(rm.ProjectedPosition, Is.EqualTo(cs.GetChunkPosition())); }
public async Task Verify_correctly_return_of_handled_event() { var cs = await GenerateCreatedEvent().ConfigureAwait(false); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm.ProcessChangeset(cs); Assert.IsTrue(rm.Created); }
private SimpleTestAtomicReadModel GenerateChangesetWithTwoEvents() { _aggregateIdSeed++; var id = new SampleAggregateId(_aggregateIdSeed); var rm1 = new SimpleTestAtomicReadModel(id); rm1.ProcessChangeset(GenerateCreatedEvent(false)); rm1.ProcessChangeset(GenerateTouchedEvent(false)); return(rm1); }
public void Before_and_after_called() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var firstEvt = evt.Events[0] as DomainEvent; Assert.That(rm.ExtraString, Is.EqualTo($"B-{firstEvt.MessageId}IN-{firstEvt.MessageId}A-{firstEvt.MessageId}")); }
public async Task Verify_correctly_return_of_handled_event_even_if_a_single_Event_is_handled() { var cs = await GenerateCreatedEvent().ConfigureAwait(false); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm.ProcessChangeset(cs); var evta = new SampleAggregateDerived1(); var evtb = new SampleAggregateTouched(); var cs2 = await ProcessEvents(new DomainEvent[] { evta, evtb }, p => new AtomicAggregateId(p)).ConfigureAwait(false); Assert.IsTrue(rm.ProcessChangeset(cs2)); }
public void Before_and_after_not_called_for_events_not_handled() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var commit1 = GenerateCreatedEvent(false); rm.ProcessChangeset(commit1); var firstEvt = commit1.Events[0] as DomainEvent; var commit2 = GenerateInvalidatedEvent(false); rm.ProcessChangeset(commit2); Assert.That(rm.ExtraString, Is.EqualTo($"B-{firstEvt.MessageId}IN-{firstEvt.MessageId}A-{firstEvt.MessageId}")); }
public async Task Verify_idempotency_on_save_older_model() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //now generate another touch and save var changesetTouch2 = GenerateTouchedEvent(false); rm.ProcessChangeset(changesetTouch2); await _sut.UpsertAsync(rm).ConfigureAwait(false); //check var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(2)); //ok create a readmodel with less event var rm2 = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm2.ProcessChangeset(evt); rm2.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm2).ConfigureAwait(false); //reload the readmdoel, the version should never be overwritten with old version reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(2)); var evtTouch2 = changesetTouch2.Events[0] as DomainEvent; Assert.That(reloaded.ProjectedPosition, Is.EqualTo(evtTouch2.CheckpointToken)); //redo again without the insert mode await _sut.UpdateAsync(rm2).ConfigureAwait(false); //reload the readmdoel, the version should never be overwritten with old version reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(2)); Assert.That(reloaded.ProjectedPosition, Is.EqualTo(evtTouch2.CheckpointToken)); }
public async Task Verify_idempotency_insert() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //now try to resave with insert true, but without any change, no exception //should be raised. await _sut.UpsertAsync(rm).ConfigureAwait(false); }
public async Task Verify_cache_does_not_dispatch_wrong_event() { //ok process a created event var cs = await GenerateCreatedEvent().ConfigureAwait(false); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm.ProcessChangeset(cs); //then take a different readmodel that does not consume that element ++_aggregateIdSeed; var rm2 = new SimpleAtomicAggregateReadModel(new AtomicAggregateId(_aggregateIdSeed)); var processed = rm2.ProcessChangeset(cs); Assert.IsFalse(processed); }
public async Task Verify_basic_insert_of_readmodel() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var changeset = GenerateCreatedEvent(false); rm.ProcessChangeset(changeset); await _sut.UpsertAsync(rm).ConfigureAwait(false); //We need to check that the readmodel was saved correctly var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); var evt = changeset.Events[0] as DomainEvent; Assert.That(reloaded.Id, Is.EqualTo(evt.AggregateId.AsString())); }
public async Task Can_be_resolved_with_factory() { using (WindsorContainer container = new WindsorContainer()) { container.AddFacility <JarvisTypedFactoryFacility>(); container.Register( Component .For <IMongoDatabase>() .Instance(_db), Component .For <IPersistence>() .Instance(_persistence), Component .For <IIdentityManager, IIdentityConverter>() .Instance(_identityManager), Component .For <ICommitEnhancer>() .ImplementedBy <CommitEnhancer>(), Component .For <ILiveAtomicReadModelProcessor>() .ImplementedBy <LiveAtomicReadModelProcessor>(), Component .For <IAtomicReadModelFactory>() .ImplementedBy <AtomicReadModelFactory>(), Component .For(new Type[] { typeof(IAtomicMongoCollectionWrapper <>), typeof(IAtomicCollectionWrapper <>), typeof(IAtomicCollectionReader <>), }) .ImplementedBy(typeof(AtomicMongoCollectionWrapper <>)) .Named("AtomicMongoCollectionWrapper"), Component .For <IAtomicCollectionWrapperFactory>() .AsFactory() ); var factory = container.Resolve <IAtomicCollectionWrapperFactory>(); var cw = factory.CreateCollectionWrappper <SimpleTestAtomicReadModel>(); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); await cw.UpsertAsync(rm).ConfigureAwait(false); } }
public async Task Verify_idempotence_of_changeest_processing() { var cs = await GenerateAtomicAggregateCreatedEvent().ConfigureAwait(false); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm.ProcessChangeset(cs); var touch = await GenerateTouchedEvent().ConfigureAwait(false); rm.ProcessChangeset(touch); Assert.That(rm.TouchCount, Is.EqualTo(1)); rm.ProcessChangeset(touch); Assert.That(rm.TouchCount, Is.EqualTo(1)); }
public async Task Verify_processing_event_with_holes() { var cs = await GenerateAtomicAggregateCreatedEvent().ConfigureAwait(false); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm.ProcessChangeset(cs); var touch1 = await GenerateTouchedEvent().ConfigureAwait(false); var touch2 = await GenerateTouchedEvent().ConfigureAwait(false); rm.ProcessChangeset(touch2); Assert.That(rm.TouchCount, Is.EqualTo(1), "We can process event even if there are holes."); rm.ProcessChangeset(touch1); Assert.That(rm.TouchCount, Is.EqualTo(1), "Past events should not be processed"); }
public async Task Verify_idempotency_on_old_version() { SimpleTestAtomicReadModel.FakeSignature = 2; var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //now try to save another RM but with a version that is lower //it should not happen, but we need to keep this 100% foolproof. SimpleTestAtomicReadModel.FakeSignature = 1; var rm2 = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm2.ProcessChangeset(evt); rm2.ProcessChangeset(evtTouch); var evtTouch2 = GenerateTouchedEvent(false); rm2.ProcessChangeset(evtTouch2); //now the versino of the aggregate is greater await _sut.UpdateAsync(rm2).ConfigureAwait(false); //reload the readmdoel, the version should never be overwritten with old version var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(2)); var evt2 = evtTouch2.Events[0] as DomainEvent; Assert.That(reloaded.ProjectedPosition, Is.EqualTo(evt2.CheckpointToken)); //Same test, but with insert mode true await _sut.UpsertAsync(rm2).ConfigureAwait(false); //reload the readmdoel, the version should never be overwritten with old version reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Not.Null); Assert.That(reloaded.TouchCount, Is.EqualTo(2)); Assert.That(reloaded.ProjectedPosition, Is.EqualTo(evt2.CheckpointToken)); }
public async Task Capability_of_catchup_to_project_everything() { await GenerateSomeChangesetsAndReturnLatestsChangeset().ConfigureAwait(false); await GenerateSomeChangesetsAndReturnLatestsChangeset().ConfigureAwait(false); var c3 = await GenerateTouchedEvent().ConfigureAwait(false); //Arrange: manually process some events in readmodel var firstEvent = (DomainEvent)c3.Events[0]; var sut = _container.Resolve <ILiveAtomicReadModelProcessor>(); var rm = new SimpleTestAtomicReadModel(firstEvent.AggregateId); //Act, ask to catchup events. await sut.CatchupAsync(rm).ConfigureAwait(false); Assert.That(rm.AggregateVersion, Is.EqualTo(c3.AggregateVersion)); Assert.That(rm.TouchCount, Is.EqualTo(3)); //we have 3 touch events. }
public async Task Not_persistable_is_honored_in_insert() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); //forcing not persistable rm.SetPropertyValue(_ => _.ModifiedWithExtraStreamEvents, true); await _sut.UpsertAsync(rm).ConfigureAwait(false); //check var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Null); }
public async Task Auto_reload_on_obsolete_reamodel() { var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); var changeset = GenerateCreatedEvent(false); rm.ProcessChangeset(changeset); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); Assert.That(rm.TouchCount, Is.EqualTo(1)); await _sut.UpsertAsync(rm).ConfigureAwait(false); //ok now in db we have an older version, lets update version SimpleTestAtomicReadModel.FakeSignature = 2; //I want to reload and autocorrect, reprojecting again everything. GenerateSut(); var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded.TouchCount, Is.EqualTo(2)); Assert.That(reloaded.ReadModelVersion, Is.EqualTo(2)); }
public async Task Verify_basic_properties() { var cs = await GenerateCreatedEvent(issuedBy : "admin").ConfigureAwait(false); var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); rm.ProcessChangeset(cs); Assert.That(rm.CreationUser, Is.EqualTo("admin")); Assert.That(rm.LastModificationUser, Is.EqualTo("admin")); Assert.That(rm.LastModify, Is.EqualTo(((DomainEvent)cs.Events[0]).CommitStamp)); Assert.That(rm.AggregateVersion, Is.EqualTo(cs.AggregateVersion)); cs = await GenerateTouchedEvent(issuedBy : "admin2").ConfigureAwait(false); rm.ProcessChangeset(cs); Assert.That(rm.CreationUser, Is.EqualTo("admin")); Assert.That(rm.LastModificationUser, Is.EqualTo("admin2")); Assert.That(rm.LastModify, Is.EqualTo(((DomainEvent)cs.Events[0]).CommitStamp)); Assert.That(rm.AggregateVersion, Is.EqualTo(cs.AggregateVersion)); }
public async Task Ability_to_catchup_events_when_nothing_was_still_projected() { //Arrange create the readmodel, and process some events, then persist those events. var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); GenerateCreatedEvent(false); var lastEvent = GenerateTouchedEvent(false); //Check //first of all verify that standard read does not read last event. var reloaded = await _sut.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(reloaded, Is.Null); //now we need to load with catchup var reloadedWithCatchup = await _sut.FindOneByIdAndCatchupAsync(rm.Id).ConfigureAwait(false); //Assert Assert.That(reloadedWithCatchup, Is.Not.Null); Assert.That(reloadedWithCatchup.AggregateVersion, Is.EqualTo(lastEvent.AggregateVersion)); Assert.That(reloadedWithCatchup.TouchCount, Is.EqualTo(1)); }
public async Task Verify_force_insert_honors_readmodel_version() { //Create a readmodel with signature equalto 2. var rm = new SimpleTestAtomicReadModel(new SampleAggregateId(_aggregateIdSeed)); SimpleTestAtomicReadModel.FakeSignature = 2; var evt = GenerateCreatedEvent(false); rm.ProcessChangeset(evt); var evtTouch = GenerateTouchedEvent(false); rm.ProcessChangeset(evtTouch); await _sut.UpsertAsync(rm).ConfigureAwait(false); //Now alter data on database var rmLoaded = await _collection.FindOneByIdAsync(rm.Id).ConfigureAwait(false); rmLoaded.SetPropertyValue(_ => _.TouchCount, 10000); _collection.Save(rmLoaded, rm.Id); //Act: change the signature, downgrade the model rm.SetPropertyValue(_ => _.ReadModelVersion, 1); //now try to resave with insert true, but without any change, no exception, no data changed await _sut.UpsertAsync(rm).ConfigureAwait(false); rmLoaded = await _collection.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(rmLoaded.TouchCount, Is.EqualTo(10000)); //now upsert with force true, this should NOT update the reamodel because the version is lower. await _sut.UpsertForceAsync(rm).ConfigureAwait(false); rmLoaded = await _collection.FindOneByIdAsync(rm.Id).ConfigureAwait(false); Assert.That(rmLoaded.TouchCount, Is.EqualTo(10000)); }