private async Task <IEnumerable <IDomainEvent> > Load <T>(
Guid sourceId,
int afterVersion,
CancellationToken cancellationToken)
where T : class, IEventSourced
{
string filter = CombineFilters(
GenerateFilterCondition(
nameof(ITableEntity.PartitionKey),
Equal,
EventTableEntity.GetPartitionKey(typeof(T), sourceId)),
And,
GenerateFilterCondition(
nameof(ITableEntity.RowKey),
GreaterThan,
EventTableEntity.GetRowKey(afterVersion)));
var query = new TableQuery <EventTableEntity>().Where(filter);
IEnumerable <EventTableEntity> events = await _eventTable
.ExecuteQuery(query, cancellationToken)
.ConfigureAwait(false);
return(new List <IDomainEvent>(events
.Select(e => e.EventJson)
.Select(_serializer.Deserialize)
.Cast <IDomainEvent>()));
}
public void GetPartitionKey_returns_the_same_as_EventTableEntity()
{
var sourceType = typeof(FakeUser);
var sourceId = Guid.NewGuid();
string actual = CorrelationTableEntity.GetPartitionKey(sourceType, sourceId);
actual.Should().Be(EventTableEntity.GetPartitionKey(sourceType, sourceId));
}
public void FromEnvelope_sets_PersistentPartition_correctly()
{
var domainEvent = fixture.Create <FakeUserCreated>();
var envelope = new Envelope(domainEvent);
PendingEventTableEntity actual =
FromEnvelope <FakeUser>(envelope, serializer);
actual.PersistentPartition.Should().Be(
EventTableEntity.GetPartitionKey(
typeof(FakeUser), domainEvent.SourceId));
}
public async Task SaveEvents_inserts_event_entities_correctly()
{
// Arrange
var created = fixture.Create <FakeUserCreated>();
var usernameChanged = fixture.Create <FakeUsernameChanged>();
var events = new DomainEvent[] { created, usernameChanged };
var correlationId = Guid.NewGuid();
RaiseEvents(userId, events);
// Act
await sut.SaveEvents <FakeUser>(events, correlationId);
// Assert
string partitionKey = EventTableEntity.GetPartitionKey(typeof(FakeUser), userId);
var query = new TableQuery <EventTableEntity>().Where($"PartitionKey eq '{partitionKey}'");
IEnumerable <EventTableEntity> persistentEvents = s_eventTable.ExecuteQuery(query);
foreach (var t in persistentEvents.Zip(events, (persistent, source)
=> new { Persistent = persistent, Source = source }))
{
var actual = new
{
t.Persistent.RowKey,
t.Persistent.Version,
t.Persistent.EventType,
t.Persistent.CorrelationId,
Event = (DomainEvent)serializer.Deserialize(t.Persistent.EventJson),
t.Persistent.RaisedAt
};
actual.ShouldBeEquivalentTo(new
{
RowKey = EventTableEntity.GetRowKey(t.Source.Version),
t.Source.Version,
EventType = t.Source.GetType().FullName,
CorrelationId = correlationId,
Event = t.Source,
t.Source.RaisedAt
});
}
}
public async Task SaveEvents_inserts_pending_event_entities_correctly()
{
// Arrange
var created = fixture.Create <FakeUserCreated>();
var usernameChanged = fixture.Create <FakeUsernameChanged>();
var events = new DomainEvent[] { created, usernameChanged };
var correlationId = Guid.NewGuid();
RaiseEvents(userId, events);
// Act
await sut.SaveEvents <FakeUser>(events, correlationId);
// Assert
string partitionKey = PendingEventTableEntity.GetPartitionKey(typeof(FakeUser), userId);
var query = new TableQuery <PendingEventTableEntity>().Where($"PartitionKey eq '{partitionKey}'");
IEnumerable <PendingEventTableEntity> pendingEvents = s_eventTable.ExecuteQuery(query);
foreach (var t in pendingEvents.Zip(events, (pending, source) =>
new { Pending = pending, Source = source }))
{
var actual = new
{
t.Pending.RowKey,
t.Pending.PersistentPartition,
t.Pending.Version,
t.Pending.CorrelationId,
Message = serializer.Deserialize(t.Pending.EventJson)
};
actual.ShouldBeEquivalentTo(new
{
RowKey = PendingEventTableEntity.GetRowKey(t.Source.Version),
PersistentPartition = EventTableEntity.GetPartitionKey(typeof(FakeUser), userId),
t.Source.Version,
CorrelationId = correlationId,
Message = t.Source
},
opts => opts.RespectingRuntimeTypes());
}
}
public static PendingEventTableEntity FromEnvelope <T>(
Envelope envelope,
IMessageSerializer serializer)
where T : class, IEventSourced
{
if (envelope == null)
{
throw new ArgumentNullException(nameof(envelope));
}
if (serializer == null)
{
throw new ArgumentNullException(nameof(serializer));
}
var domainEvent = envelope.Message as IDomainEvent;
if (domainEvent == null)
{
throw new ArgumentException(
$"{nameof(envelope)}.{nameof(envelope.Message)} must be an {nameof(IDomainEvent)}.",
nameof(envelope));
}
string persistentPartition = EventTableEntity.GetPartitionKey(
typeof(T), domainEvent.SourceId);
return(new PendingEventTableEntity
{
PartitionKey = GetPartitionKey(typeof(T), domainEvent.SourceId),
RowKey = GetRowKey(domainEvent.Version),
PersistentPartition = persistentPartition,
Version = domainEvent.Version,
MessageId = envelope.MessageId,
CorrelationId = envelope.CorrelationId,
EventJson = serializer.Serialize(domainEvent)
});
}
public static string GetPartitionKey(Type sourceType, Guid sourceId) => EventTableEntity.GetPartitionKey(sourceType, sourceId);
