public async Task PublishPendingEvents_deletes_pending_events(
FakeUserCreated created,
FakeUsernameChanged usernameChanged)
{
// Arrange
var sourceId = Guid.NewGuid();
var events = new DomainEvent[] { created, usernameChanged };
RaiseEvents(sourceId, events);
using (var db = new DataContext())
{
foreach (DomainEvent e in events)
{
var envelope = new Envelope(e);
db.PendingEvents.Add(PendingEvent.FromEnvelope(envelope, serializer));
}
await db.SaveChangesAsync();
}
// Act
await sut.PublishPendingEvents(sourceId, CancellationToken.None);
// Assert
using (var db = new DataContext())
{
bool actual = await db
.PendingEvents
.Where(e => e.AggregateId == sourceId)
.AnyAsync();
actual.Should().BeFalse();
}
}
public void FromEnvelope_has_guard_clause_for_invalid_message()
{
var envelope = new Envelope(new object());
Action action = () => PendingEvent.FromEnvelope(envelope, serializer);
action.ShouldThrow <ArgumentException>().Where(x => x.ParamName == "envelope");
}
public async Task PublishPendingEvents_commits_once(
FakeUserCreated created,
FakeUsernameChanged usernameChanged)
{
// Arrange
var sourceId = Guid.NewGuid();
var events = new DomainEvent[] { created, usernameChanged };
RaiseEvents(sourceId, events);
Mock.Get(mockDbContext.PendingEvents)
.SetupData(events
.Select(e => new Envelope(e))
.Select(e => PendingEvent.FromEnvelope(e, serializer))
.ToList());
var sut = new SqlEventPublisher(
() => mockDbContext, serializer, messageBus);
// Act
await sut.PublishPendingEvents(sourceId, CancellationToken.None);
// Assert
Mock.Get(mockDbContext).Verify(
x => x.SaveChangesAsync(CancellationToken.None),
Times.Once());
}
private Envelope RestoreEnvelope(PendingEvent pendingEvent) =>
new Envelope(
pendingEvent.MessageId,
_serializer.Deserialize(pendingEvent.EventJson),
pendingEvent.OperationId,
pendingEvent.CorrelationId,
pendingEvent.Contributor);
public void FromEnvelope_sets_Version_correctly()
{
FakeUserCreated domainEvent = _fixture.Create <FakeUserCreated>();
var envelope = new Envelope(domainEvent);
var actual = PendingEvent.FromEnvelope(envelope, _serializer);
actual.Version.Should().Be(domainEvent.Version);
}
public void FromEnvelope_sets_AggregateId_correctly()
{
FakeUserCreated domainEvent = _fixture.Create <FakeUserCreated>();
var envelope = new Envelope(domainEvent);
var actual = PendingEvent.FromEnvelope(envelope, _serializer);
actual.AggregateId.Should().Be(domainEvent.SourceId);
}
public void FromEnvelope_sets_MessageId_correctly()
{
var domainEvent = fixture.Create <FakeUserCreated>();
var envelope = new Envelope(domainEvent);
var actual = PendingEvent.FromEnvelope(envelope, serializer);
actual.MessageId.Should().Be(envelope.MessageId);
}
public void FromEnvelope_sets_OperationId_correctly()
{
FakeUserCreated domainEvent = _fixture.Create <FakeUserCreated>();
string operationId = $"{Guid.NewGuid()}";
var envelope = new Envelope(Guid.NewGuid(), domainEvent, operationId);
var actual = PendingEvent.FromEnvelope(envelope, _serializer);
actual.OperationId.Should().Be(operationId);
}
public void FromEnvelope_sets_Contributor_correctly()
{
FakeUserCreated domainEvent = _fixture.Create <FakeUserCreated>();
string contributor = _fixture.Create <string>();
var envelope = new Envelope(Guid.NewGuid(), domainEvent, contributor: contributor);
var actual = PendingEvent.FromEnvelope(envelope, _serializer);
actual.Contributor.Should().Be(contributor);
}
public void FromEnvelope_sets_CorrelationId_correctly()
{
var domainEvent = fixture.Create <FakeUserCreated>();
var correlationId = Guid.NewGuid();
var envelope = new Envelope(correlationId, domainEvent);
var actual = PendingEvent.FromEnvelope(envelope, serializer);
actual.CorrelationId.Should().Be(correlationId);
}
public void FromEnvelope_sets_EventJson_correctly()
{
var domainEvent = fixture.Create <FakeUserCreated>();
var envelope = new Envelope(domainEvent);
var actual = PendingEvent.FromEnvelope(envelope, serializer);
object message = serializer.Deserialize(actual.EventJson);
message.Should().BeOfType <FakeUserCreated>();
message.ShouldBeEquivalentTo(domainEvent);
}
private void InsertEvent(
EventStoreDbContext context,
IDomainEvent domainEvent,
string operationId,
Guid?correlationId,
string contributor)
{
var envelope = new Envelope(Guid.NewGuid(), domainEvent, operationId, correlationId, contributor);
context.PersistentEvents.Add(PersistentEvent.FromEnvelope(envelope, _serializer));
context.PendingEvents.Add(PendingEvent.FromEnvelope(envelope, _serializer));
}
public async Task FlushPendingEvents_sends_events_correctly()
{
// Arrange
FakeUserCreated created = _fixture.Create <FakeUserCreated>();
FakeUsernameChanged usernameChanged = _fixture.Create <FakeUsernameChanged>();
var sourceId = Guid.NewGuid();
string operationId = _fixture.Create <string>();
var correlationId = Guid.NewGuid();
string contributor = _fixture.Create <string>();
var domainEvents = new DomainEvent[] { created, usernameChanged };
RaiseEvents(sourceId, domainEvents);
var envelopes = new List <Envelope>();
using (var db = new DataContext())
{
foreach (DomainEvent domainEvent in domainEvents)
{
var envelope = new Envelope(Guid.NewGuid(), domainEvent, operationId, correlationId, contributor);
envelopes.Add(envelope);
db.PendingEvents.Add(PendingEvent.FromEnvelope(envelope, _serializer));
}
await db.SaveChangesAsync();
}
List <Envelope> batch = null;
Mock.Get(_messageBus)
.Setup(
x =>
x.Send(
It.IsAny <IEnumerable <Envelope> >(),
It.IsAny <CancellationToken>()))
.Callback <IEnumerable <Envelope>, CancellationToken>((b, t) => batch = b.ToList())
.Returns(Task.FromResult(true));
// Act
await _sut.FlushPendingEvents(sourceId, CancellationToken.None);
// Assert
Mock.Get(_messageBus).Verify(
x =>
x.Send(
It.IsAny <IEnumerable <Envelope> >(),
CancellationToken.None),
Times.Once());
batch.ShouldAllBeEquivalentTo(envelopes, opts => opts.RespectingRuntimeTypes());
}
private void InsertEvents(
EventStoreDbContext context,
List <IDomainEvent> events,
Guid?correlationId)
{
foreach (IDomainEvent domainEvent in events)
{
var envelope =
correlationId == null
? new Envelope(domainEvent)
: new Envelope(correlationId.Value, domainEvent);
context.PersistentEvents.Add(PersistentEvent.FromEnvelope(envelope, _serializer));
context.PendingEvents.Add(PendingEvent.FromEnvelope(envelope, _serializer));
}
}
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 async Task PublishPendingEvents_sends_events(
FakeUserCreated created,
FakeUsernameChanged usernameChanged)
{
// Arrange
var sourceId = Guid.NewGuid();
var events = new DomainEvent[] { created, usernameChanged };
RaiseEvents(sourceId, events);
var envelopes = new List <Envelope>();
using (var db = new DataContext())
{
foreach (DomainEvent e in events)
{
var envelope = new Envelope(e);
envelopes.Add(envelope);
db.PendingEvents.Add(PendingEvent.FromEnvelope(envelope, serializer));
}
await db.SaveChangesAsync();
}
List <Envelope> batch = null;
Mock.Get(messageBus)
.Setup(
x =>
x.SendBatch(
It.IsAny <IEnumerable <Envelope> >(),
It.IsAny <CancellationToken>()))
.Callback <IEnumerable <Envelope>, CancellationToken>((b, t) => batch = b.ToList())
.Returns(Task.FromResult(true));
// Act
await sut.PublishPendingEvents(sourceId, CancellationToken.None);
// Assert
Mock.Get(messageBus).Verify(
x =>
x.SendBatch(
It.IsAny <IEnumerable <Envelope> >(),
CancellationToken.None),
Times.Once());
batch.ShouldAllBeEquivalentTo(envelopes, opts => opts.RespectingRuntimeTypes());
}
public async Task FlushPendingEvents_sends_events_correctly()
{
// Arrange
var created = new FakeUserCreated();
var usernameChanged = new FakeUsernameChanged();
var sourceId = Guid.NewGuid();
var events = new DomainEvent[] { created, usernameChanged };
events.Raise(sourceId);
var envelopes = new List <Envelope>();
using (var db = new FakeEventStoreDbContext(_dbContextOptions))
{
var serializer = new JsonMessageSerializer();
foreach (DomainEvent e in events)
{
var envelope = new Envelope(
messageId: Guid.NewGuid(),
correlationId: Guid.NewGuid(),
contributor: Guid.NewGuid().ToString(),
message: e);
envelopes.Add(envelope);
db.PendingEvents.Add(PendingEvent.FromEnvelope <FakeUser>(envelope, serializer));
}
await db.SaveChangesAsync();
}
var messageBus = new MessageBus();
var sut = new SqlEventPublisher(
() => new FakeEventStoreDbContext(_dbContextOptions),
new JsonMessageSerializer(),
messageBus);
// Act
await sut.FlushPendingEvents <FakeUser>(sourceId, CancellationToken.None);
// Assert
messageBus.Sent.ShouldAllBeEquivalentTo(envelopes, opts => opts.RespectingRuntimeTypes());
}
public async Task FlushPendingEvents_deletes_pending_events()
{
// Arrange
var sourceId = Guid.NewGuid();
var created = new FakeUserCreated();
var usernameChanged = new FakeUsernameChanged();
var events = new DomainEvent[] { created, usernameChanged };
events.Raise(sourceId);
using (var db = new FakeEventStoreDbContext(_dbContextOptions))
{
var serializer = new JsonMessageSerializer();
foreach (DomainEvent e in events)
{
var envelope = new Envelope(e);
db.PendingEvents.Add(PendingEvent.FromEnvelope <FakeUser>(envelope, serializer));
}
await db.SaveChangesAsync();
}
var sut = new SqlEventPublisher(
() => new FakeEventStoreDbContext(_dbContextOptions),
new JsonMessageSerializer(),
Mock.Of <IMessageBus>());
// Act
await sut.FlushPendingEvents <FakeUser>(sourceId);
// Assert
using (var db = new FakeEventStoreDbContext(_dbContextOptions))
{
bool actual = await db
.PendingEvents
.Where(e => e.AggregateId == sourceId)
.AnyAsync();
actual.Should().BeFalse();
}
}
