public void SetHeaders_AddValueToHeadersDictionary(
JournaledEvent journaledEvent,
string headerName,
string headerValue)
{
journaledEvent.SetHeader(headerName, headerValue);
Assert.Equal(journaledEvent.Headers[headerName], headerValue);
}
private static Fixture PrepareFixture()
{
var fixture = new Fixture();
fixture.Customize <JournaledEvent>(
composer => composer.FromFactory((object stub) => JournaledEvent.Create(stub, Serialize)));
return(fixture);
}
public async Task PublishAsync_AppendsEventsToStreamUsingStreamWriter(
[Frozen] Mock<IEventStreamWriter> writerMock,
JournaledEvent[] events,
EventStreamProducer producer)
{
await producer.PublishAsync(events);
writerMock.Verify(self => self.AppendEventsAsync(events));
}
protected override Task ProcessEventAsync(JournaledEvent journaledEvent)
{
if (Exception != null)
{
throw Exception;
}
return(TaskDone.Done);
}
public void Customize(IFixture fixture)
{
fixture.Customize <JournaledEvent>(composer => composer
.FromFactory(() => JournaledEvent.Create(
new object(),
(_, type, writer) => writer.WriteLine(fixture.Create("EventPayload")))));
fixture.Customize <IReadOnlyList <JournaledEvent> >(composer => composer
.FromFactory((JournaledEvent[] events) => events));
}
public void GetEventPayload_ReturnsStreamWithPayloadContent(string payload)
{
var journaledEvent = JournaledEvent.Create(new object(), (evt, type, writer) => writer.Write(payload));
using (var payloadStream = journaledEvent.GetEventPayload())
using (var reader = new StreamReader(payloadStream))
{
Assert.Equal(payload, reader.ReadToEnd());
}
}
public void SetHeaders_WhenValueIsNull_RemovesHeader(
JournaledEvent journaledEvent,
string headerName,
string headerValue)
{
journaledEvent.SetHeader(headerName, headerValue);
journaledEvent.SetHeader(headerName, null);
Assert.False(journaledEvent.Headers.ContainsKey(headerName));
}
public async Task AppendEvents_AppendEventsToJournal(
[Frozen] EventStreamPosition position,
[Frozen] Mock<IEventJournal> journalMock,
EventStreamWriter writer,
JournaledEvent[] events)
{
await writer.AppendEventsAsync(events);
journalMock.Verify(journal => journal.AppendEventsAsync(
writer.StreamName,
position,
It.Is<IReadOnlyCollection<JournaledEvent>>(e => e.Count == events.Length)));
}
public void GetEventPayload_ForRestoredEvents_ReturnsStreamWithPayloadContent(string payload)
{
var journaledEvent = JournaledEvent.Create(new object(), (evt, type, writer) => writer.Write(payload));
var eventProperties = journaledEvent.ToDictionary();
var restoredEvent = JournaledEvent.Create(eventProperties);
using (var payloadStream = restoredEvent.GetEventPayload())
using (var reader = new StreamReader(payloadStream))
{
Assert.Equal(payload, reader.ReadToEnd());
}
}
public void RestoredEvent_ShouldRestoreHeaders(string payload)
{
var journaledEvent = JournaledEvent.Create(new object(), (evt, type, writer) => writer.Write(payload));
journaledEvent.SetHeader("A", "A");
journaledEvent.SetHeader("B", "B");
var eventProperties = journaledEvent.ToDictionary();
var restoredEvent = JournaledEvent.Create(eventProperties);
Assert.Equal("A", restoredEvent.Headers["A"]);
Assert.Equal("B", restoredEvent.Headers["B"]);
}
public void Customize(IFixture fixture)
{
fixture.Customize <JournaledEvent>(composer => composer
.FromFactory((Guid headerName, string headerValue) =>
{
var result = JournaledEvent.Create(
new object(),
(_, type, writer) => writer.WriteLine(fixture.Create("EventPayload")));
result.SetHeader(headerName.ToString("N"), headerValue);
return(result);
}));
}
protected override Task ProcessEventAsync(JournaledEvent journaledEvent)
{
if (m_throwException)
{
m_throwException = false;
throw new Exception();
}
Events.Add(journaledEvent);
if (++m_eventCount == ExpectedEventCount)
{
Events.CompleteAdding();
}
return(TaskDone.Done);
}
public async Task StreamPosition_AfterWriteAsyncCall_UpdatedStreamVersionValue(
[Frozen] Mock<IEventJournal> journalMock,
EventStreamPosition position,
EventStreamWriter writer,
JournaledEvent[] events)
{
journalMock
.Setup(self => self.AppendEventsAsync(
It.IsAny<string>(),
It.IsAny<EventStreamPosition>(),
It.IsAny<IReadOnlyCollection<JournaledEvent>>()))
.Returns(position.YieldTask());
await writer.AppendEventsAsync(events);
Assert.Equal(position.Version, writer.StreamVersion);
}
public async Task PublishAsync_WhenWriterThrows_MovesItToTheEndOfStreamAndTriesAppendAgain(
[Frozen] Mock<IEventStreamWriter> writerMock,
[Frozen] RetryPolicyStub retryPolicy,
JournaledEvent[] events,
EventStreamProducer producer)
{
var expectedAttemptsCount = 5;
retryPolicy.ConfigureMaxAttemptNumber(expectedAttemptsCount);
writerMock
.Setup(self => self.AppendEventsAsync(events))
.Throws<EventStreamConcurrencyException>();
await Assert.ThrowsAsync<EventStreamConcurrencyException>(() => producer.PublishAsync(events));
writerMock.Verify(self => self.MoveToEndOfStreamAsync());
writerMock.Verify(self => self.AppendEventsAsync(events), Times.Exactly(expectedAttemptsCount));
}
public JournaledEvent Mutate(JournaledEvent journaledEvent)
{
Require.NotNull(journaledEvent, "journaledEvent");
return(m_mutators.Aggregate(journaledEvent, (current, mutator) => mutator.Mutate(current)));
}
protected abstract Task ProcessEventAsync(JournaledEvent journaledEvent);
public async Task <FetchEventsResult> FetchStreamEvents(string stream, EventStreamHeader header, StreamVersion fromVersion, int sliceSize)
{
// fromVersion already in slice
var isFetchingCompleted = false;
var nextSliceVersion = fromVersion.Increment(sliceSize - 1);
if (nextSliceVersion >= header.Version)
{
nextSliceVersion = header.Version;
isFetchingCompleted = true;
}
const string queryTemplate =
"((PartitionKey eq '{0}') and (RowKey eq 'HEAD')) or " +
"((PartitionKey eq '{0}') and (RowKey ge '{1}' and RowKey le '{2}'))";
var query = m_table.PrepareEntityFilterRangeQuery(
queryTemplate.FormatString(
stream,
fromVersion.ToString(),
nextSliceVersion.ToString()));
var queryResult = await query.ExecuteAsync();
var events = new SortedList <StreamVersion, JournaledEvent>(sliceSize);
foreach (var properties in queryResult)
{
var rowKey = (string)properties[KnownProperties.RowKey];
if (!rowKey.EqualsCi("HEAD"))
{
events.Add(StreamVersion.Parse((string)properties[KnownProperties.RowKey]), JournaledEvent.Create(properties));
}
}
return(new FetchEventsResult(isFetchingCompleted, events));
}
public JournaledEvent Mutate(JournaledEvent journaledEvent)
{
journaledEvent.SetHeader(m_headerName, "A");
return(journaledEvent);
}
