public void Throws_exception_when_applying_unknown_event_on_aggregate_root()
{
var entity = new SomeDomainEntity();
var domainEvent = new SomeDomainEvent();
entity.Apply(domainEvent);
}
public void Event_handler_invoked_when_applying_domain_event_to_aggregate_root()
{
var entity = new SomeDomainEntityWithEvents();
var domainEvent = new SomeDomainEvent();
entity.Apply(domainEvent);
entity.DomainEventHandlerInvoked.ShouldBeTrue("the eventhandler for the event was not invoked");
}
public void Other_handlers_not_invoked_when_publishing_event()
{
SomeOtherDomainEvent handledEvent = null;
Action<SomeOtherDomainEvent> handler = e => { handledEvent = e; };
var domainEvent = new SomeDomainEvent();
_kernel.Bind<IDomainEventHandler<SomeOtherDomainEvent>>().ToConstant(new ActionEventHandler<SomeOtherDomainEvent>(handler));
_bus.Publish(domainEvent);
handledEvent.ShouldBeNull("The event handler was unexpectedly invoked");
}
public void Can_apply_domain_events_to_entity()
{
var entity = new SomeDomainEntityWithEvents();
var domainEvent = new SomeDomainEvent();
entity.Apply(domainEvent);
var changes = entity.GetChanges();
changes.ShouldNotBeNull();
changes.Count().ShouldBeEqualTo(1, "Only one event should have been applied to aggregate");
changes.First().ShouldBeSameAs(domainEvent, "The event applied to aggregate was not the one expected");
}
public void Create_sets_EventType_correctly()
{
IFixture fixture = new Fixture();
SomeDomainEvent domainEvent = fixture.Create <SomeDomainEvent>();
fixture.Inject <IDomainEvent>(domainEvent);
var actual = PersistentEvent.Create(
fixture.Create <Type>(),
fixture.Create <Envelope <IDomainEvent> >(),
new JsonMessageSerializer());
actual.EventType.Should().Be(typeof(SomeDomainEvent).FullName);
}
public void Create_sets_RowKey_correctly()
{
IFixture fixture = new Fixture();
SomeDomainEvent domainEvent = fixture.Create <SomeDomainEvent>();
TestContext.WriteLine($"Version: {domainEvent.Version}");
fixture.Inject <IDomainEvent>(domainEvent);
var actual = PersistentEvent.Create(
fixture.Create <Type>(),
fixture.Create <Envelope <IDomainEvent> >(),
new JsonMessageSerializer());
actual.RowKey.Should().Be(PersistentEvent.GetRowKey(domainEvent.Version));
}
public void Handler_invoked_when_publishing_event()
{
SomeDomainEvent handledEvent = null;
Action<SomeDomainEvent> actionHandler = e => { handledEvent = e; };
_kernel.Bind<IDomainEventHandler<SomeDomainEvent>>().ToConstant(new ActionEventHandler<SomeDomainEvent>(actionHandler));
var domainEvent = new SomeDomainEvent();
_bus.Publish(domainEvent);
handledEvent.ShouldNotBeNull("The event handler was not invoked");
handledEvent.ShouldBeSameAs(domainEvent, "The event passed to the event handler was not the one expected");
}
public TextReader GetReader(Guid aId)
{
var ev = new SomeDomainEvent();
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write(DomainEventSerializer.Serialize(ev));
writer.Flush();
stream.Position = 0;
return new StreamReader(stream);
}
public void Events_are_published_to_bus_on_commit()
{
var session = new Session(this, this);
var aggregate = new SomeDomainEntityWithEvents();
session.Track(aggregate);
var domainEvent = new SomeDomainEvent();
aggregate.Apply(domainEvent);
session.CommitChanges();
PublishedEvents.Count().ShouldBeEqualTo(1);
PublishedEvents.Pop().ShouldBeSameAs(domainEvent);
}
public void Can_commit_changes()
{
var session = new Session(this, this);
var aggregate = new SomeDomainEntityWithEvents();
session.Track(aggregate);
var domainEvent = new SomeDomainEvent();
aggregate.Apply(domainEvent);
session.CommitChanges();
_savedId.ShouldBeEqualTo(aggregate.Id);
_savedEvents.Count().ShouldBeEqualTo(1);
_savedEvents.First().ShouldBeSameAs(domainEvent);
}
public void FromEnvelope_generates_PendingEvent_correctly()
{
var domainEvent = new SomeDomainEvent();
var messageId = Guid.NewGuid();
var correlationId = Guid.NewGuid();
var envelope = new Envelope(messageId, domainEvent, correlationId: correlationId);
IMessageSerializer serializer = new JsonMessageSerializer();
var actual = PendingEvent.FromEnvelope(envelope, serializer);
actual.AggregateId.Should().Be(domainEvent.SourceId);
actual.Version.Should().Be(domainEvent.Version);
actual.MessageId.Should().Be(messageId);
actual.CorrelationId.Should().Be(correlationId);
actual.EventJson.Should().Be(serializer.Serialize(domainEvent));
}
public void Create_sets_PartitionKey_correctly()
{
IFixture fixture = new Fixture();
Type sourceType = fixture.Create <Type>();
SomeDomainEvent domainEvent = fixture.Create <SomeDomainEvent>();
TestContext.WriteLine($"SourceId: {domainEvent.SourceId}");
fixture.Inject <IDomainEvent>(domainEvent);
var actual = PersistentEvent.Create(
sourceType,
fixture.Create <Envelope <IDomainEvent> >(),
new JsonMessageSerializer());
actual.PartitionKey.Should().Be(AggregateEntity.GetPartitionKey(sourceType, domainEvent.SourceId));
}
public void Create_sets_Contributor_correctly()
{
IFixture fixture = new Fixture();
SomeDomainEvent domainEvent = fixture.Create <SomeDomainEvent>();
fixture.Inject <IDomainEvent>(domainEvent);
Envelope <IDomainEvent> envelope = fixture.Create <Envelope <IDomainEvent> >();
TestContext.WriteLine($"Contributor: {envelope.Contributor}");
var actual = PersistentEvent.Create(
fixture.Create <Type>(),
envelope,
new JsonMessageSerializer());
actual.Contributor.Should().Be(envelope.Contributor);
}
public void Create_sets_OperationId_correctly()
{
IFixture fixture = new Fixture();
SomeDomainEvent domainEvent = fixture.Create <SomeDomainEvent>();
fixture.Inject <IDomainEvent>(domainEvent);
Envelope <IDomainEvent> envelope = fixture.Create <Envelope <IDomainEvent> >();
TestContext.WriteLine($"OperationId: {envelope.OperationId}");
var actual = PendingEvent.Create(
fixture.Create <Type>(),
envelope,
new JsonMessageSerializer());
actual.OperationId.Should().Be(envelope.OperationId);
}
public void ReadSetup()
{
using (var stream = _eventStore.OpenStream(StreamId, 0, int.MaxValue))
{
// add XXX commits to the stream
for (int i = 0; i < 500; i++)
{
var @event = new SomeDomainEvent {
Value = i.ToString()
};
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
}
}
public void Create_sets_EventJson_correctly()
{
IFixture fixture = new Fixture();
SomeDomainEvent domainEvent = fixture.Create <SomeDomainEvent>();
fixture.Inject <IDomainEvent>(domainEvent);
var serializer = new JsonMessageSerializer();
var actual = PersistentEvent.Create(
fixture.Create <Type>(),
fixture.Create <Envelope <IDomainEvent> >(),
serializer);
object restored = serializer.Deserialize(actual.EventJson);
restored.Should().BeOfType <SomeDomainEvent>();
restored.ShouldBeEquivalentTo(domainEvent);
}
public void ReadSetup()
{
_eventStore.Advanced.Purge();
using (var stream = _eventStore.CreateStream(StreamId))
{
// add XXX commits to the stream
for (int i = 0; i < CommitsToWrite; i++)
{
var @event = new SomeDomainEvent {
Value = i.ToString()
};
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
}
}
public void WriteToStream()
{
// we can call CreateStream(StreamId) if we know there isn't going to be any data.
// or we can call OpenStream(StreamId, 0, int.MaxValue) to read all commits,
// if no commits exist then it creates a new stream for us.
using (var stream = _eventStore.OpenStream(StreamId, 0, int.MaxValue))
{
// add XXX commits to the stream
for (int i = 0; i < CommitsToWrite; i++)
{
var @event = new SomeDomainEvent {
Value = i.ToString()
};
stream.Add(new EventMessage {
Body = @event
});
stream.CommitChanges(Guid.NewGuid());
}
}
}
public void Multiple_handlers_invoked_when_publishing_event()
{
SomeDomainEvent handledEvent = null;
SomeDomainEvent secondHandledEvent = null;
Action<SomeDomainEvent> handler = e => { handledEvent = e; };
Action<SomeDomainEvent> secondHandler = e => { secondHandledEvent = e; };
var domainEvent = new SomeDomainEvent();
_kernel.Bind<IDomainEventHandler<SomeDomainEvent>>().ToConstant(new ActionEventHandler<SomeDomainEvent>(handler));
_kernel.Bind<IDomainEventHandler<SomeDomainEvent>>().ToConstant(new ActionEventHandler<SomeDomainEvent>(secondHandler));
_bus.Publish(domainEvent);
handledEvent.ShouldNotBeNull("The first event handler was not invoked");
secondHandledEvent.ShouldNotBeNull("The second event handler was not invoked");
handledEvent.ShouldBeSameAs(domainEvent, "The event passed to the first event handler was not the one expected");
secondHandledEvent.ShouldBeSameAs(domainEvent, "The event passed to the second event handler was not the one expected");
}
private void Handle(SomeDomainEvent domainEvent)
{
Property = domainEvent.Property;
}
