void ThrowIfStreamWasDeleted(string stream, EventReadResult result)
{
if (result.Status == EventReadStatus.StreamDeleted)
{
throw new CorruptedEventStore($"Stream '{stream}' was deleted");
}
}
private void Repeat(int position)
{
EventReadResult result = EventStoreLoader.Connection.ReadEventAsync(
_streamName,
position,
false).Result;
if (result.Status != EventReadStatus.Success || result.Event == null)
{
_view.ErrorMsg = "Event not found to repeat";
return;
}
var evt = result.Event.Value.Event;
EventStoreLoader.Connection.AppendToStreamAsync(
evt.EventStreamId,
ExpectedVersion.Any,
new EventData(
Guid.NewGuid(),
evt.EventType,
evt.IsJson,
evt.Data,
evt.Metadata));
}
async Task <TResult> ReadQueryCheckpoint <TResult>(FlowKey key, Func <TResult> getDefault, Func <ResolvedEvent, TResult> getCheckpoint)
{
var stream = key.GetCheckpointStream();
EventReadResult result = default(EventReadResult);
try
{
result = await _context.Connection.ReadEventAsync(stream, StreamPosition.End, resolveLinkTos : false);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
switch (result.Status)
{
case EventReadStatus.NoStream:
case EventReadStatus.NotFound:
return(getDefault());
case EventReadStatus.Success:
return(getCheckpoint(result.Event.Value));
default:
throw new Exception($"Unexpected result when reading {stream}: {result.Status}");
}
}
public async Task AdHocInvokeAsync_IfEventCannotBeRead_ReturnAppropriateResult()
{
var result = new EventReadResult(EventReadStatus.NotFound, null);
_eventStoreHttpConnectionMock.Setup(x => x.ReadEventAsync(It.IsAny <string>(), It.IsAny <int>())).Returns(async() => result);
var invocationResult = await _subscriber.AdHocInvokeAsync(StreamName, 123);
invocationResult.ResultCode.Should().Be(AdHocInvocationResult.AdHocInvocationResultCode.CouldNotFindEvent);
}
public async Task AdHocInvokeAsync_ShouldAttemptToRetrieveCorrectEvent()
{
var result = new EventReadResult(EventReadStatus.NotFound, null);
_eventStoreHttpConnectionMock.Setup(x => x.ReadEventAsync(It.IsAny <string>(), It.IsAny <int>())).Returns(async() => result);
await _subscriber.AdHocInvokeAsync(StreamName, 123);
_eventStoreHttpConnectionMock.Verify(x => x.ReadEventAsync(It.Is <string>(s => s == StreamName), It.Is <int>(i => i == 123)));
}
public async Task AdHocInvokeAsync_IfEventHasNoHandlers_ReturnAppropriateResult()
{
var result = new EventReadResult(EventReadStatus.Success, new EventInfo
{
EventType = typeof(SomeHandlerForACustomSubscriberId).FullName
});
_eventStoreHttpConnectionMock.Setup(x => x.ReadEventAsync(It.IsAny <string>(), It.IsAny <int>())).Returns(async() => result);
var invocationResult = await _subscriber.AdHocInvokeAsync(StreamName, 123);
invocationResult.ResultCode.Should().Be(AdHocInvocationResult.AdHocInvocationResultCode.NoHandlersFound);
}
public async Task AdHocInvokeAsync_IfEventHasHandlers_AndHandlerThrowsAnException_Return_AppropriateResult()
{
_eventTypeResolverMock.Setup(x => x.Resolve(It.IsAny <string>())).Returns(typeof(EventANoBaseOrInterface));
_eventHandlerResolverMock.Setup(x => x.GetHandlersOf(It.IsAny <Type>())).Returns(new[] { new HandlerThatThrowsAnException() });
var result = new EventReadResult(EventReadStatus.Success, new EventInfo
{
EventType = typeof(EventANoBaseOrInterface).FullName
});
_eventStoreHttpConnectionMock.Setup(x => x.ReadEventAsync(It.IsAny <string>(), It.IsAny <int>())).Returns(async() => result);
var invocationResult = await _subscriber.AdHocInvokeAsync(StreamName, 123);
invocationResult.ResultCode.Should().Be(AdHocInvocationResult.AdHocInvocationResultCode.HandlerThrewException);
}
public async Task AdHocInvokeAsync_IfEventHasHandlers_AndHandlerThrowsAnException_ExceptionShouldBeRecorded()
{
_eventTypeResolverMock.Setup(x => x.Resolve(It.IsAny <string>())).Returns(typeof(EventANoBaseOrInterface));
_eventHandlerResolverMock.Setup(x => x.GetHandlersOf(It.IsAny <Type>())).Returns(new[] { new HandlerThatThrowsAnException() });
var result = new EventReadResult(EventReadStatus.Success, new EventInfo
{
EventType = typeof(EventANoBaseOrInterface).FullName
});
_eventStoreHttpConnectionMock.Setup(x => x.ReadEventAsync(It.IsAny <string>(), It.IsAny <int>())).Returns(async() => result);
var invocationResult = await _subscriber.AdHocInvokeAsync(StreamName, 123);
invocationResult.Errors.Should().NotBeNull();
invocationResult.Errors.Should().NotBeEmpty();
invocationResult.Errors[typeof(HandlerThatThrowsAnException)].Message.Should().Be(HandlerThatThrowsAnException.SomeException.Message);
}
private Maybe <StoredEvent> GetEventFrom(EventReadResult result)
{
switch (result.Status)
{
case ReadStatus.Success:
return(ToStoredEvent(result.Event));
case ReadStatus.NotFound:
case ReadStatus.NoStream:
return(new Maybe <StoredEvent>());
case ReadStatus.StreamDeleted:
throw new InvalidOperationException($"Stream {Id} has been deleted.");
default:
throw new NotSupportedException(result.Status.ToString());
}
}
protected override async Task When()
{
_read = await _conn.ReadEventAsync(LinkedStreamName, 0, true);
}
private static bool ResultHasNoEvent(EventReadResult result)
{
return(!result.Event.HasValue);
}
protected override void When()
{
_read = _conn.ReadEventAsync(LinkedStreamName, 0, true).Result;
}
private static bool AnySnapshotExists(EventReadResult lastSnapshot)
{
return(lastSnapshot.Event.HasValue);
}
public async void Retrieve()
{
EventReadResult event1 = await Connection.ReadEventAsync(OrderCreatedStreamName, 4);
EventReadResult event2 = await Connection.ReadEventAsync(OrderCreatedStreamName, 6);
}
private static bool NotAnySnapshotExists(EventReadResult snapshot)
{
return(!snapshot.Event.HasValue);
}
