public void ShouldUpdateProductProjection()
{
var rootId = Guid.NewGuid();
var resolver = new MemoryResolver();
var eventBus = new MemoryEventBus(resolver);
var appendOnly = new MemoryAppendOnlyStore(eventBus);
var eventStore = new EventStore(appendOnly, eventBus);
var view = new ProductView();
resolver.Register <ProductCreated>(view);
var factory = new AggregateFactory(eventStore);
var rootToSave = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(rootToSave.Id, 1, rootToSave.Changes, rootToSave.DomainEvents.ToArray());
var stream = eventStore.LoadEventStream(rootId);
var root = new ProductCatalogAggregate(stream);
root.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook", "Dell Inspiron 15000"));
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes, root.DomainEvents.ToArray());
Assert.True(1 == view.Products.Count);
Assert.Equal("Notebook", view.Products[0].Name);
}
public void ShouldUpdateProductProjection()
{
var rootId = Guid.NewGuid();
var queueService = new MemoryQueueService();
var appendOnly = new MemoryAppendOnlyStore(queueService);
var eventStore = new EventStore(appendOnly);
var view = new ProductView();
queueService.Subscribe <ProductCreated>(view);
var factory = new AggregateFactory(eventStore);
var rootToSave = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(rootToSave.Id, 1, rootToSave.Changes);
var stream = eventStore.LoadEventStream(rootId);
var root = new ProductCatalogAggregate(stream);
root.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook", "Dell Inspiron 15000"));
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes);
Assert.True(1 == view.Products.Count);
Assert.Equal("Notebook", view.Products[0].Name);
}
public void ShouldThrowExceptionConflictEvents()
{
var rootId = Guid.NewGuid();
var eventBus = new MemoryEventBus(new MemoryResolver());
var appendOnly = new MemoryAppendOnlyStore(eventBus);
var eventStore = new EventStore(appendOnly, eventBus);
var snapShotRepo = new SnapshotRepository();
var factory = new AggregateFactory(eventStore, snapShotRepo);
var productAggregate = factory.Create <ProductCatalogAggregate>(rootId);
productAggregate.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook Acer Aspire 3", "Notebook Acer Aspire 3 A315-53-348W Intel Core i3-6006U RAM de 4GB HD de 1TB Tela de 15.6” HD Windows 10"));
eventStore.AppendToStream <ProductCatalogAggregate>(productAggregate.Id, productAggregate.Version, productAggregate.Changes, productAggregate.DomainEvents.ToArray());
var user1 = factory.Load <ProductCatalogAggregate>(rootId);
var user2 = factory.Load <ProductCatalogAggregate>(rootId);
user1.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook Asus Vivobook", "Notebook Asus Vivobook X441B-CBA6A de 14 Con AMD A6-9225/4GB Ram/500GB HD/W10"));
eventStore.AppendToStream <ProductCatalogAggregate>(user1.Id, user1.Version, user1.Changes, user1.DomainEvents.ToArray());
user2.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook 2 em 1 Dell", "Notebook 2 em 1 Dell Inspiron i14-5481-M11F 8ª Geração Intel Core i3 4GB 128GB SSD 14' Touch Windows 10 Office 365 McAfe"));
Assert.Throws <EventStoreConcurrencyException>(()
=> eventStore.AppendToStream <ProductCatalogAggregate>(user2.Id, user2.Version, user2.Changes, user2.DomainEvents.ToArray())
);
}
public void ShouldCreateMultiplesSnapshots()
{
var rootId = Guid.NewGuid();
var eventBus = new MemoryEventBus();
var appendOnly = new MemoryAppendOnlyStore(eventBus);
var eventStore = new EventStore(appendOnly);
var snapShotRepo = new SnapshotRepository();
var factory = new AggregateFactory(eventStore, snapShotRepo);
var productAggregate = factory.Create <ProductCatalogAggregate>(rootId);
productAggregate.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook Acer Aspire 3", "Notebook Acer Aspire 3 A315-53-348W Intel Core i3-6006U RAM de 4GB HD de 1TB Tela de 15.6” HD Windows 10"));
eventStore.AppendToStream <ProductCatalogAggregate>(productAggregate.Id, productAggregate.Version, productAggregate.Changes);
var stream = eventStore.LoadEventStream(rootId);
snapShotRepo.SaveSnapshot(rootId, productAggregate, stream.Version);
productAggregate = factory.Load <ProductCatalogAggregate>(rootId);
productAggregate.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook Asus Vivobook", "Notebook Asus Vivobook X441B-CBA6A de 14 Con AMD A6-9225/4GB Ram/500GB HD/W10"));
eventStore.AppendToStream <ProductCatalogAggregate>(productAggregate.Id, productAggregate.Version, productAggregate.Changes);
stream = eventStore.LoadEventStream(rootId);
snapShotRepo.SaveSnapshot(rootId, productAggregate, stream.Version);
productAggregate = factory.Load <ProductCatalogAggregate>(rootId);
productAggregate.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook 2 em 1 Dell", "Notebook 2 em 1 Dell Inspiron i14-5481-M11F 8ª Geração Intel Core i3 4GB 128GB SSD 14' Touch Windows 10 Office 365 McAfe"));
eventStore.AppendToStream <ProductCatalogAggregate>(productAggregate.Id, productAggregate.Version, productAggregate.Changes);
stream = eventStore.LoadEventStream(rootId);
snapShotRepo.SaveSnapshot(rootId, productAggregate, stream.Version);
productAggregate = factory.Load <ProductCatalogAggregate>(rootId);
productAggregate.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook Gamer Dell", "Notebook Gamer Dell G3-3590-M60P 9ª Geração Intel Core i7 8GB 512GB SSD Placa Vídeo NVIDIA 1660Ti 15.6' Windows 10"));
eventStore.AppendToStream <ProductCatalogAggregate>(productAggregate.Id, productAggregate.Version, productAggregate.Changes);
stream = eventStore.LoadEventStream(rootId);
snapShotRepo.SaveSnapshot(rootId, productAggregate, stream.Version);
productAggregate = factory.Load <ProductCatalogAggregate>(rootId);
productAggregate.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook Lenovo 2 em 1 ideapad C340", "Notebook Lenovo 2 em 1 ideapad C340 i7-8565U 8GB 256GB SSD Win10 14' FHD IPS - 81RL0001BR"));
eventStore.AppendToStream <ProductCatalogAggregate>(productAggregate.Id, productAggregate.Version, productAggregate.Changes);
stream = eventStore.LoadEventStream(rootId);
snapShotRepo.SaveSnapshot(rootId, productAggregate, stream.Version);
var aggregateReloadedFromSnapshot = factory.Load <ProductCatalogAggregate>(rootId);
ProductCatalogAggregate root;
long snapshotVersion = 0;
var snap = snapShotRepo.TryGetSnapshotById(rootId, out root, out snapshotVersion);
stream = eventStore.LoadEventStreamAfterVersion(rootId, snapshotVersion);
Assert.True(snap);
Assert.True(root != null);
Assert.True(snapshotVersion == 6);
Assert.True(stream.Events.Count == 0);
Assert.True(aggregateReloadedFromSnapshot.Changes.Count == 0);
Assert.True(aggregateReloadedFromSnapshot.Id == rootId);
Assert.True(aggregateReloadedFromSnapshot.CountProducts() == 5);
}
public async Task Handler_BuildUnTracked_ReturnToTracked()
{
build.MarkAsUnTracked(DateTime.Now);
await eventStore.AppendToStream <Build>(build.Id, build.GetUncommitedChanges());
await markAsTrackedBuildHandler.Handle(fakeCommand, CancellationToken.None);
var editedBuild = await RestoreBuild();
Assert.Equal(fakeCommand.DistributionId, editedBuild.DistributionId);
Assert.Equal(ArtifactState.ReturnToTracked, editedBuild.ArtifactState);
Assert.False(editedBuild.IsUnTracked);
}
public void AppendOnlyShouldPublish()
{
var rootId = Guid.NewGuid();
var productId = Guid.NewGuid();
var resolver = new MemoryResolver();
var eventBus = new MemoryEventBus(resolver);
var appendOnly = new MemoryAppendOnlyStore(eventBus);
var eventStore = new EventStore(appendOnly, eventBus);
var productView = new ProductView();
resolver.Register <ProductCreated>(productView);
var events = new List <IEvent>
{
new ProductCreated(productId, "test", "")
};
var domainEvents = new List <IDomainEvent>
{
new ProductCreated(productId, "test", "")
};
eventStore.AppendToStream <Guid>(rootId, 0, events, domainEvents.ToArray());
Assert.True(productView.Products.Count == 1);
Assert.True(productView.Products.ElementAt(0).Id == productId);
}
public void REGISTER_PROJECTIONS()
{
var appendStore = new FileAppendOnlyStore(@"C:\Users\wydev\Documents\GitHub\Clones\lokad-iddd-sample\DomainTests\Store\");
var eventStore = new EventStore(appendStore);
var publisher = new DomainEventPublisher(eventStore, 0, 500);
var store = new FileDocumentReaderWriter <CustomerId, CustomerTransactions>(@"C:\Users\wydev\Documents\GitHub\Clones\lokad-iddd-sample\DomainTests\Store\",
new ViewStrategy(@"C:\Users\wydev\Documents\GitHub\Clones\lokad-iddd-sample\DomainTests\Views\"));
IDocumentWriter <CustomerId, CustomerTransactions> writer = store;
var projection = new CustomerTransactionsProjection(writer);
publisher.RegisterProjection(projection);
var id = new CustomerId(2);
var @event = new CustomerCreated
{
Id = id,
Name = "Microsoft",
Currency = Currency.Eur
};
IList <IEvent> Changes = new List <IEvent>();
Changes.Add(@event);
eventStore.AppendToStream(id, 0, Changes);
publisher.ProcessNewEvents();
}
public async Task when_document_ttl_is_configured_then_documents_have_that_ttl_set()
{
const string DatabaseName = "AppendingTestsCosmosOnly";
var client = DocumentClientFactory.Create(DatabaseName);
var collectionName = "TtlTests_" + Guid.NewGuid();
var storageEngine = await StorageEngineFactory.Create(DatabaseName,
o =>
{
o.CollectionName = collectionName;
o.DefaultTimeToLiveSeconds = -1;
o.DocumentTimeToLiveSeconds = 10;
});
await storageEngine.Initialise();
var streamId = Guid.NewGuid().ToString();
var store = new EventStore(storageEngine);
await store.AppendToStream(streamId, 0, new EventData(Guid.NewGuid(), new OrderCreated(streamId)));
var commitsLink = UriFactory.CreateDocumentCollectionUri(DatabaseName, collectionName);
var eventsQuery = client.CreateDocumentQuery <DocumentDbStorageEvent>(commitsLink)
.Where(x => x.StreamId == streamId)
.OrderBy(x => x.EventNumber)
.AsDocumentQuery();
var response = await eventsQuery.ExecuteNextAsync <DocumentDbStorageEvent>();
Assert.That(response.First().TimeToLiveSeconds, Is.EqualTo(10));
}
private static void Main(string[] args)
{
ObjectContainer.SetContainer(new AutofacContainerObject());
var applictionInitializer = new EventHandleProvider();
applictionInitializer.Initialize(Assembly.GetExecutingAssembly());
var commandInitializer = new CommandHandleProvider();
commandInitializer.Initialize(Assembly.GetExecutingAssembly());
ObjectContainer.RegisterInstance(applictionInitializer);
ObjectContainer.RegisterInstance(commandInitializer);
var dbConnection = new MySqlConnection(_mysqlConnection);
var persistence = new SnapshotPersistence(dbConnection);
var binarySerializer = new DefaultBinarySerializer();
var snapshotRepository = new SnapshotRepository(persistence, new SnapshotFactory(binarySerializer));
var eventPersistence = new EventStorePersistence(dbConnection);
var eventFactory = new EventStreamFactory(binarySerializer);
var eventStore = new EventStore(eventPersistence, eventFactory);
IRepository repository = new EventSouringRepository(eventStore, snapshotRepository);
var comamndHandler = ObjectContainer.Resolve<CommandHandleProvider>();
var changePasswordCommand = new ChangePasswordCommand("90ca0d59-65e6-403b-82c5-8df967cc8e22", "2222222", "11111");
var commandContext = new CommandContext(repository);
var commandHanldeAction = comamndHandler.GetInternalCommandHandle(typeof(ChangePasswordCommand));
commandHanldeAction(commandContext, changePasswordCommand);
var aggregateRoots = commandContext.AggregateRoots;
IList<IEvent> unCommitEvents = null;
foreach (var item in aggregateRoots)
{
unCommitEvents = item.Value.Commit();
}
var aggregateRoot = aggregateRoots.FirstOrDefault().Value;
eventStore.AppendToStream(aggregateRoot.AggregateRootId, new EventStream(aggregateRoot.Version, unCommitEvents));
snapshotRepository.Create(aggregateRoot);
Console.WriteLine("改方法执行完毕...");
}
public async Task Handler_RemoveTag_BuildTagRemoved()
{
build.AddTag("new_Tag");
build.AddTag("new_Tag_2");
await eventStore.AppendToStream <Build>(build.Id, build.GetUncommitedChanges());
var command = new UpdateBuildTags()
{
BuildId = build.Id,
Tags = Array.Empty <string>()
};
await updateBuildTagsHandler.Handle(command, CancellationToken.None);
var editedBuild = await RestoreBuild();
Assert.Equal(command.Tags, editedBuild.Tags);
Assert.Equal(ArtifactState.Updated, editedBuild.ArtifactState);
}
/// <summary>
/// Конструктор.
/// </summary>
public UpdateBuildTagsCommandHandlerTests()
{
eventStore = new EventStore(new MemoryChangesetRepository(), new Mock <IMediator>().Object);
updateBuildTagsHandler = new UpdateBuildTagsHandler(
new AggregateRepository(eventStore, new Mock <ILogger <AggregateRepository> >().Object),
new Mock <ILogger <UpdateBuildTagsHandler> >().Object,
new CollectionsComparer()
);
build = CreateBuild();
eventStore.AppendToStream <Build>(build.Id, build.GetUncommitedChanges()).GetAwaiter().GetResult();
}
public IActionResult Post([FromBody] PaymentIntent intent, string paymentReference)
{
if (!ModelState.IsValid)
{
return(new ValidationErrorResult(ModelState));
}
eventStore.AppendToStream(paymentReference, 0, new EventData(Guid.NewGuid(), new PaymentIntentAdded()));
return(Ok());
}
public void ShouldIncreaseVersionCorrectly()
{
var eventBus = new MemoryEventBus(new MemoryResolver());
var appendOnly = new MemoryAppendOnlyStore(eventBus);
var eventStore = new EventStore(appendOnly, eventBus);
var rootId = Guid.NewGuid();
var factory = new AggregateFactory(eventStore);
var root = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes, root.DomainEvents.ToArray());
root = factory.Load <ProductCatalogAggregate>(rootId);
root.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook", "Dell Inspiron 15000"));
root.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook Asus Vivobook", "Notebook Asus Vivobook X441B-CBA6A de 14 Con AMD A6-9225/4GB Ram/500GB HD/W10"));
root.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook 2 em 1 Dell", "Notebook 2 em 1 Dell Inspiron i14-5481-M11F 8ª Geração Intel Core i3 4GB 128GB SSD 14' Touch Windows 10 Office 365 McAfe"));
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes, root.DomainEvents.ToArray());
root = factory.Load <ProductCatalogAggregate>(rootId);
Assert.True(4 == root.Version);
}
public async Task when_a_read_operation_is_successful_the_log_callback_is_called()
{
var logCount = 0;
var sut = new EventStore(await CreateStorageEngine(t => logCount++));
var streamId = Guid.NewGuid().ToString();
await sut.AppendToStream(streamId, 0, new EventData(Guid.NewGuid(), new OrderCreated("TEST-ORDER")));
await sut.ReadStreamForwards(streamId);
Assert.That(logCount, Is.EqualTo(2));
}
public async Task when_a_write_operation_is_successful_the_log_callback_is_called()
{
ResponseInformation response = null;
var sut = new EventStore(await CreateStorageEngine(t => response = t));
var streamId = Guid.NewGuid().ToString();
await sut.AppendToStream(streamId, 0, new EventData(Guid.NewGuid(), new OrderCreated("TEST-ORDER")));
Assert.NotNull(response);
TestContext.Out.WriteLine($"Charge: {response.RequestCharge}");
TestContext.Out.WriteLine($"Quota Usage: {response.CurrentResourceQuotaUsage}");
TestContext.Out.WriteLine($"Max Resource Quote: {response.MaxResourceQuota}");
TestContext.Out.WriteLine($"Response headers: {response.ResponseHeaders}");
}
public async Task Handler_CanChange_CreatedEventLifeCycleStateChanged()
{
SetupInit(true, true);
await eventStore.AppendToStream <Build>(build.Id, build.GetUncommitedChanges());
await changeBuildStateHandler.Handle(FakeCommand, CancellationToken.None);
var editedBuild = await RestoreBuild();
Assert.Equal(FakeCommand.NewState, editedBuild.LifeCycleState);
Assert.Equal(ArtifactState.Updated, editedBuild.ArtifactState);
Assert.Equal(FakeCommand.BuildId, editedBuild.Id);
VerifyChangeSuffixMethod();
}
public async Task Handler_UpdateBuild_BuildUpdated()
{
SetupInit(LifeCycleState.Release);
fakeCommand.Location = Location + "_R";
fakeCommand.Number = new VersionNumber("1.0.0.1");
fakeCommand.ReleaseNumber = new VersionNumber("1.0.0");
fakeCommand.Suffixes = new List <string>()
{
"R"
};
await eventStore.AppendToStream <Build>(build.Id, build.GetUncommitedChanges());
await updateBuildHandler.Handle(fakeCommand, CancellationToken.None);
var updatedBuild = await RestoreBuild();
Assert.Equal(fakeCommand.Location, updatedBuild.Location);
Assert.Equal(fakeCommand.Suffixes, updatedBuild.Suffixes);
Assert.Equal(fakeCommand.Number, updatedBuild.Number);
Assert.Equal(fakeCommand.ReleaseNumber, updatedBuild.ReleaseNumber);
Assert.Equal(fakeCommand.BuildId, updatedBuild.Id);
Assert.Equal(LifeCycleState.Release, updatedBuild.LifeCycleState);
}
public void ShouldIncrementVersionCorrectly()
{
var rootId = Guid.NewGuid();
var queueService = new MemoryQueueService();
var appendOnly = new MemoryAppendOnlyStore(queueService);
var eventStore = new EventStore(appendOnly);
var factory = new AggregateFactory(eventStore);
var rootToSave = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(rootToSave.Id, rootToSave.Version, rootToSave.Changes);
var stream = eventStore.LoadEventStream(rootId);
var root = new ProductCatalogAggregate(stream);
root.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook", "Dell Inspiron 15000"));
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes);
stream = eventStore.LoadEventStream(rootId);
root = new ProductCatalogAggregate(stream);
Assert.Equal(2, stream.Version);
Assert.Equal(1, root.CountProducts());
}
/// <summary>
/// Конструктор.
/// </summary>
public ChangeBuildStateHandlerTests()
{
eventStore = new EventStore(new MemoryChangesetRepository(), new Mock <IMediator>().Object);
changeBuildStateHandler = new ChangeBuildStateHandler(
new AggregateRepository(eventStore, new Mock <ILogger <AggregateRepository> >().Object),
new Mock <ILogger <ChangeBuildStateHandler> >().Object,
buildStateChangeCheckerMock.Object,
buildLifeCycleStateMapperMock.Object,
buildSyncServiceMock.Object
);
build = CreateBuild();
eventStore.AppendToStream <Build>(build.Id, build.GetUncommitedChanges()).GetAwaiter().GetResult();
}
public void ShouldNotAllowCreateAggregatesWithSameId()
{
var eventBus = new MemoryEventBus(new MemoryResolver());
var appendOnly = new MemoryAppendOnlyStore(eventBus);
var eventStore = new EventStore(appendOnly, eventBus);
var rootId = Guid.NewGuid();
var factory = new AggregateFactory(eventStore);
var root = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes, root.DomainEvents.ToArray());
Assert.Throws <DuplicatedRootException>(()
=> factory.Create <ProductCatalogAggregate>(rootId)
);
}
public void ShouldSaveStream()
{
var rootId = Guid.NewGuid();
var queueService = new MemoryQueueService();
var appendOnly = new MemoryAppendOnlyStore(queueService);
var eventStore = new EventStore(appendOnly);
var factory = new AggregateFactory(eventStore);
var root = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes);
var stream = eventStore.LoadEventStream(rootId);
Assert.Equal(1, stream.Version);
Assert.Equal(typeof(AggregateCreated <Guid>), stream.Events.ElementAt(0).GetType());
}
public void ShouldSaveStream()
{
var rootId = Guid.NewGuid();
var eventBus = new MemoryEventBus(new MemoryResolver());
var appendOnly = new MemoryAppendOnlyStore(eventBus);
var eventStore = new EventStore(appendOnly, eventBus);
var factory = new AggregateFactory(eventStore);
var root = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes, root.DomainEvents.ToArray());
var stream = eventStore.LoadEventStream(rootId);
Assert.Equal(1, stream.Version);
Assert.Equal(typeof(AggregateCreated <Guid>), stream.Events.ElementAt(0).GetType());
}
public void ShouldNotAllowCreateAggregatesWithSameId()
{
var queueService = new MemoryQueueService();
var appendOnly = new MemoryAppendOnlyStore(queueService);
var eventStore = new EventStore(appendOnly);
var rootId = Guid.NewGuid();
var factory = new AggregateFactory(eventStore);
var root = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(root.Id, root.Version, root.Changes);
Assert.Throws <DuplicatedRootException>(()
=> factory.Create <ProductCatalogAggregate>(rootId)
);
}
public void ShouldAggregateLoadStream()
{
var rootId = Guid.NewGuid();
var eventBus = new MemoryEventBus(new MemoryResolver());
var appendOnly = new MemoryAppendOnlyStore(eventBus);
var eventStore = new EventStore(appendOnly, eventBus);
var factory = new AggregateFactory(eventStore);
var rootToSave = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(rootToSave.Id, 1, rootToSave.Changes, rootToSave.DomainEvents.ToArray());
var root = factory.Load <ProductCatalogAggregate>(rootId);
Assert.True(0 == root.Changes.Count);
Assert.Equal(rootId, root.Id);
}
public void ShouldAggregateLoadStream()
{
var rootId = Guid.NewGuid();
var queueService = new MemoryQueueService();
var appendOnly = new MemoryAppendOnlyStore(queueService);
var eventStore = new EventStore(appendOnly);
var factory = new AggregateFactory(eventStore);
var rootToSave = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(rootToSave.Id, 1, rootToSave.Changes);
var root = factory.Load <ProductCatalogAggregate>(rootId);
Assert.True(0 == root.Changes.Count);
Assert.Equal(rootId, root.Id);
}
public void ShouldAddProductToProductCatalog()
{
var rootId = Guid.NewGuid();
var queueService = new MemoryQueueService();
var appendOnly = new MemoryAppendOnlyStore(queueService);
var eventStore = new EventStore(appendOnly);
var factory = new AggregateFactory(eventStore);
var rootToSave = factory.Create <ProductCatalogAggregate>(rootId);
eventStore.AppendToStream <ProductCatalogAggregate>(rootToSave.Id, rootToSave.Version, rootToSave.Changes);
var root = factory.Load <ProductCatalogAggregate>(rootId);
root.CreateProduct(new CreateProductCommand(rootId, Guid.NewGuid(), "Notebook", "Dell Inspiron 15000"));
Assert.True(root.Changes.Count == 1);
Assert.True(root.Changes.ElementAt(0).GetType() == typeof(ProductCreated));
}
public async Task when_reading_a_stream_that_has_deleted_events_the_stream_can_still_be_read()
{
const string databaseName = "ReadingPartialStreamTests";
const string collectionName = "Commits";
var client = DocumentClientFactory.Create(databaseName);
var storageEngine = await StorageEngineFactory.Create(databaseName, o => o.CollectionName = collectionName);
var eventStore = new EventStore(storageEngine);
var streamId = Guid.NewGuid().ToString();
await eventStore.AppendToStream(streamId, 0, new EventData(Guid.NewGuid(), new OrderCreated(streamId)), new EventData(Guid.NewGuid(), new OrderDispatched(streamId)));
await SimulateTimeToLiveExpiration(databaseName, collectionName, client, streamId);
var stream = await eventStore.ReadStreamForwards(streamId);
Assert.That(stream.Count, Is.EqualTo(1));
Assert.That(stream.First().EventBody, Is.InstanceOf <OrderDispatched>());
Assert.That(stream.First().EventNumber, Is.EqualTo(2));
}