public async Task ReadModelFeed()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("http://localost:5000/api/DomainEvents/?lastVersion=0")
.Respond("application/json", "[{ \"domainEventType\": \"UNKNOWN_TYPE\",\"entityStreamVersion\": 12, \"overallVersion\": \"1\", \"domainEvent\": {\"EntityId\" : \"5a8b63c8-0f7f-4de7-a9e5-b6b377aa2180\"}}, { \"domainEventType\": \"TestEv\",\"entityStreamVersion\": 12, \"overallVersion\": \"2\", \"domainEvent\": {\"EntityId\" : \"5a8b63c8-0f7f-4de7-a9e5-b6b377aa2180\" }}]");
var domainOverallEventClient = new HttpClient(mockHttp);
domainOverallEventClient.BaseAddress = new Uri("http://localost:5000/api/DomainEvents/");
var factoryMock = new Mock <IDomainEventClientFactory>();
factoryMock.Setup(m => m.GetClient <ReadModelEventHandler <TestReadModel> >()).ReturnsAsync(domainOverallEventClient);
var domainEventFactory = new DomainEventFactory(_eventTypeRegistration);
var readModelFeed = new EventFeed <ReadModelEventHandler <TestReadModel> >(
domainEventFactory,
factoryMock.Object, new MicrowaveLogger <EventFeed <ReadModelEventHandler <TestReadModel> > >());
var domainEvents = await readModelFeed.GetEventsAsync();
var domainEventWrappers = domainEvents.ToList();
Assert.AreEqual(1, domainEventWrappers.Count);
Assert.AreEqual(new Guid("5a8b63c8-0f7f-4de7-a9e5-b6b377aa2180").ToString(), domainEventWrappers[0].DomainEvent
.EntityId);
}
public void SetUp()
{
var factory = new DomainEventFactory();
var definitionService = new EventDefinitionService(new NullLog());
definitionService.Load(typeof(ThingyPingEvent));
_serializer = new EventJsonSerializer(new JsonSerializer(), definitionService, factory);
}
public async Task <TEntity> GetByIdAsync(TKey id)
{
var streamId = GenerateStreamId(id);
var streamEvents = await EventStreamReader.Read(_connection, streamId, StreamPosition.Start, 200);
var domainEvents = DomainEventFactory.Create(streamEvents, _eventTypeResolver);
return(AggregateFactory.Create <TEntity>(domainEvents));
}
public void SetUp()
{
var factory = new DomainEventFactory();
var definitionService = new EventDefinitionService(
Mock <ILogger <EventDefinitionService> >(),
Mock <ILoadedVersionedTypes>());
definitionService.Load(typeof(ThingyPingEvent));
_serializer = new EventJsonSerializer(new JsonSerializer(), definitionService, factory);
}
public void ParseDomainEventWrapper_NoKeyInRegistration()
{
var domainEventWrapper = new [] { new DomainEventWrapper
{
EntityStreamVersion = 12,
OverallVersion = 0,
DomainEvent = new Event1(Guid.NewGuid(), "Name")
} };
var serializeObject = JsonConvert.SerializeObject(domainEventWrapper);
var eventTypeRegistration = new EventRegistration();
var domainEventFactory = new DomainEventFactory(eventTypeRegistration);
var ev = domainEventFactory.Deserialize(serializeObject);
var domainEventWrappers = ev.ToList();
Assert.AreEqual(0, domainEventWrappers.Count);
}
public void ParseDomainEventWrapper_StringKey()
{
var domainEventWrapper = new [] { new DomainEventWrapper
{
EntityStreamVersion = 12,
OverallVersion = 0,
DomainEvent = new Event2("luls", "Name")
} };
var serializeObject = JsonConvert.SerializeObject(domainEventWrapper);
var eventTypeRegistration = new EventRegistration {
{ nameof(Event2), typeof(Event2) }
};
var domainEventFactory = new DomainEventFactory(eventTypeRegistration);
var domainEventWrappers = domainEventFactory.Deserialize(serializeObject).ToList();
var wrapperActual = domainEventWrappers.Single();
Assert.AreEqual("luls", wrapperActual.DomainEvent.EntityId);
}
private EventStoreBase CreateStore()
{
var aggregateFactory = Mock.Of <IAggregateFactory>();
var resolver = Mock.Of <IResolver>();
var metadataProviders = Enumerable.Empty <IMetadataProvider>();
var snapshotStore = Mock.Of <ISnapshotStore>();
var log = new NullLog();
var factory = new DomainEventFactory();
var persistence = new InMemoryEventPersistence(log);
var upgradeManager = new EventUpgradeManager(log, resolver);
var definitionService = new EventDefinitionService(log);
definitionService.Load(typeof(ThingyPingEvent));
var serializer = new EventJsonSerializer(new JsonSerializer(), definitionService, factory);
var store = new EventStoreBase(log, aggregateFactory,
serializer, upgradeManager, metadataProviders,
persistence, snapshotStore);
return(store);
}
public async Task UpdateMultiple(
bool pingFirst,
bool injectPing)
{
// Arrange
var readStoreManager = Resolver.Resolve <IReadStoreManager>();
var thingyId = ThingyId.New;
var thingyMessage = Fixture.Create <ThingyMessage>();
var pingId = PingId.New;
var command = new ThingyAddMessageAndPingCommand(
thingyId,
thingyMessage,
pingId,
pingFirst);
var metadata = new Metadata
{
Timestamp = DateTimeOffset.Now,
AggregateSequenceNumber = 1,
AggregateName = typeof(ThingyAggregate).GetAggregateName().Value,
AggregateId = thingyId.Value,
EventId = EventId.New,
};
var domainEvent = injectPing
? DomainEventFactory.Create(new ThingyPingEvent(pingId), metadata, thingyId.Value, 1)
: DomainEventFactory.Create(new ThingyMessageAddedEvent(thingyMessage), metadata, thingyId.Value, 1);
await readStoreManager.UpdateReadStoresAsync(
new[] { domainEvent },
CancellationToken.None);
// Act
await CommandBus.PublishAsync(command, CancellationToken.None);
// Assert
var returnedThingyMessages = await QueryProcessor.ProcessAsync(new ThingyGetMessagesQuery(thingyId)).ConfigureAwait(false);
returnedThingyMessages.Should().HaveCount(1);
var readModel = await QueryProcessor.ProcessAsync(new ThingyGetQuery(thingyId)).ConfigureAwait(false);
readModel.PingsReceived.Should().Be(1);
}
private EventStoreBase CreateStore()
{
var aggregateFactory = Mock <IAggregateFactory>();
var serviceProvider = Mock <IServiceProvider>();
var metadataProviders = Enumerable.Empty <IMetadataProvider>();
var snapshotStore = Mock <ISnapshotStore>();
var factory = new DomainEventFactory();
var persistence = new InMemoryEventPersistence(Logger <InMemoryEventPersistence>());
var upgradeManager = new EventUpgradeManager(Logger <EventUpgradeManager>(), serviceProvider);
var definitionService = new EventDefinitionService(Logger <EventDefinitionService>(), Mock <ILoadedVersionedTypes>());
definitionService.Load(typeof(ThingyPingEvent));
var serializer = new EventJsonSerializer(new JsonSerializer(), definitionService, factory);
var store = new EventStoreBase(
Logger <EventStoreBase>(),
aggregateFactory,
serializer, upgradeManager, metadataProviders,
persistence, snapshotStore);
return(store);
}
public async Task ReadModelFeed_Unauthorized()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("http://localost:5000/api/DomainEvents/?timeStamp=0001-01-01T00:00:00.0000000+00:00")
.Respond(HttpStatusCode.Unauthorized);
var domainOverallEventClient = new HttpClient(mockHttp);
domainOverallEventClient.BaseAddress = new Uri("http://localost:5000/api/DomainEvents/");
var factoryMock = new Mock <IDomainEventClientFactory>();
factoryMock.Setup(m => m.GetClient <ReadModelEventHandler <TestReadModel> >()).ReturnsAsync(domainOverallEventClient);
var domainEventFactory = new DomainEventFactory(_eventTypeRegistration);
var readModelFeed = new EventFeed <ReadModelEventHandler <TestReadModel> >(domainEventFactory, factoryMock
.Object, new MicrowaveLogger <EventFeed <ReadModelEventHandler <TestReadModel> > >());
var domainEvents = await readModelFeed.GetEventsAsync();
var domainEventWrappers = domainEvents.ToList();
Assert.AreEqual(0, domainEventWrappers.Count);
}
public async Task ReadModelFeed_Exception()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.When("http://localost:5000/api/DomainEvents/?lastVersion=0")
.Throw(new HttpRequestException());
var domainOverallEventClient = new HttpClient(mockHttp);
domainOverallEventClient.BaseAddress = new Uri("http://localost:5000/api/DomainEvents/");
var factoryMock = new Mock <IDomainEventClientFactory>();
factoryMock.Setup(m => m.GetClient <ReadModelEventHandler <TestReadModel> >()).ReturnsAsync(domainOverallEventClient);
var domainEventFactory = new DomainEventFactory(_eventTypeRegistration);
var readModelFeed = new EventFeed <ReadModelEventHandler <TestReadModel> >(domainEventFactory, factoryMock
.Object, new MicrowaveLogger <EventFeed <ReadModelEventHandler <TestReadModel> > >());
var domainEvents = await readModelFeed.GetEventsAsync();
var domainEventWrappers = domainEvents.ToList();
Assert.AreEqual(0, domainEventWrappers.Count);
}
public void ParseDomainEventWrapper()
{
var domainEventWrapper = new [] { new DomainEventWrapper
{
EntityStreamVersion = 12,
OverallVersion = 1,
DomainEvent = new Event1(Guid.NewGuid(), "Name")
} };
var serializeObject = JsonConvert.SerializeObject(domainEventWrapper);
var eventTypeRegistration = new EventRegistration {
{ nameof(Event1), typeof(Event1) }
};
var domainEventFactory = new DomainEventFactory(eventTypeRegistration);
var ev = domainEventFactory.Deserialize(serializeObject);
var domainEventWrappers = ev.ToList();
var wrapperActual = domainEventWrappers.Single();
var wrapperExpected = domainEventWrapper.Single();
Assert.AreEqual(wrapperExpected.DomainEvent.EntityId, wrapperActual.DomainEvent.EntityId);
Assert.AreEqual(wrapperExpected.EntityStreamVersion, wrapperActual.EntityStreamVersion);
Assert.AreEqual(wrapperExpected.OverallVersion, wrapperActual.OverallVersion);
Assert.AreEqual(((Event1)wrapperExpected.DomainEvent).Name, ((Event1)wrapperActual.DomainEvent).Name);
}
