public async Task return_false_when_concurrency_conflict_when_commit_events()
{
var mockEvent = new Mock <IBusinessEvent>();
var events = new List <IBusinessEvent>()
{
mockEvent.Object
}.ToImmutableList();
var eventType = mockEvent.Object.GetType().Name;
var dataText = "{}";
var dataBytes = Encoding.Unicode.GetBytes(dataText);
var unresolvedEvent = new UnresolvedBusinessEvent(eventType, dataBytes);
var mockResolver = new Mock <IBusinessEventResolver>();
var mockState = new Mock <IAggregateRootState>();
var mockStreamClientFactory = new Mock <IStreamClientFactory>();
var mockStreamClient = new Mock <IStreamClient>();
var ar = new TestAggregateRoot(new AggregateRootDependencies <IAggregateRootState>(null, null, null, mockStreamClientFactory.Object, mockResolver.Object), null, null);
mockResolver.Setup(x => x.CanUnresolve(mockEvent.Object)).Returns(true);
mockResolver.Setup(x => x.Unresolve(mockEvent.Object)).Returns(unresolvedEvent);
mockStreamClientFactory.Setup(x => x.Create(It.IsAny <string>())).Returns(mockStreamClient.Object);
mockStreamClient.Setup(x => x.CommitEventsToStreamAsync(It.IsAny <string>(), It.IsAny <long?>(), It.IsAny <IEnumerable <CommitEvent> >())).ReturnsAsync(CommitResult.ConcurrencyConflict);
var result = await ar.TestCommitEventsAsync(events, null, null, null);
Assert.False(result);
}
public void construct()
{
var eventType = "a";
var data = Encoding.UTF8.GetBytes("{}");
var e = new UnresolvedBusinessEvent(eventType, data);
Assert.Equal(eventType, e.EventType);
Assert.Equal(data, e.Data); // Reference equality, not value eq.
}
public async Task commit_and_return_true_when_commit_events()
{
var regionId = "x";
var streamId = "s";
var streamPositionCheckpoint = 0;
var mockEvent = new Mock <IBusinessEvent>();
var events = new List <IBusinessEvent>()
{
mockEvent.Object
}.ToImmutableList();
var eventType = mockEvent.Object.GetType().Name;
var dataText = "{}";
var dataBytes = Encoding.Unicode.GetBytes(dataText);
var unresolvedEvent = new UnresolvedBusinessEvent(eventType, dataBytes);
var mockResolver = new Mock <IBusinessEventResolver>();
var mockStreamClientFactory = new Mock <IStreamClientFactory>();
var mockStreamClient = new Mock <IStreamClient>();
var ar = new TestAggregateRoot(new AggregateRootDependencies <IAggregateRootState>(null, null, null, mockStreamClientFactory.Object, mockResolver.Object), null, null);
mockResolver.Setup(x => x.CanUnresolve(mockEvent.Object)).Returns(true);
mockResolver.Setup(x => x.Unresolve(mockEvent.Object)).Returns(unresolvedEvent);
mockStreamClientFactory.Setup(x => x.Create(regionId)).Returns(mockStreamClient.Object);
mockStreamClient.Setup(x => x.CommitEventsToStreamAsync(It.IsAny <string>(), It.IsAny <long?>(), It.IsAny <IEnumerable <CommitEvent> >())).ReturnsAsync(CommitResult.Success);
var result = await ar.TestCommitEventsAsync(events, regionId, streamId, streamPositionCheckpoint);
Assert.True(result);
mockStreamClient.Verify(x =>
x.CommitEventsToStreamAsync(
streamId, streamPositionCheckpoint,
It.Is <IEnumerable <CommitEvent> >(ces => ces.FirstOrDefault(ce => ce.EventType == eventType && Encoding.Unicode.GetString(ce.Data) == dataText) != null)
)
);
}
public async Task process_command_to_committed_events_and_return_success_handler_result_when_handle_generic_command()
{
var regionId = "x";
var aggregateRootName = "ar";
var aggregateRootId = "1";
var streamId = "sId";
var commandId = "cId";
var mockEvent = new Mock <IBusinessEvent>();
var events = new List <IBusinessEvent>()
{
mockEvent.Object
}.ToImmutableList();
var eventType = mockEvent.Object.GetType().Name;
var eventDataText = "{}";
var eventDataBytes = Encoding.Unicode.GetBytes(eventDataText);
var unresolvedEvent = new UnresolvedBusinessEvent(eventType, eventDataBytes);
var firstPositionInStream = 1;
var hydratedStreamEvent = new StreamEvent(streamId, firstPositionInStream, null, "whatever", new byte[] { });
var commitResult = CommitResult.Success;
var mockCommand = new Mock <ICommand>();
var mockCommandValidationResult = new Mock <ICommandValidationResult>();
var mockStreamIdBuilder = new Mock <IStreamIdBuilder>();
var mockStreamClientFactory = new Mock <IStreamClientFactory>();
var mockStreamClient = new Mock <IStreamClient>();
var mockStateRepo = new Mock <IAggregateRootStateRepo <IAggregateRootState> >();
var mockState = new Mock <IAggregateRootState>();
var mockCommandResult = new Mock <ICommandResult>();
var mockResolver = new Mock <IBusinessEventResolver>();
var cancelSource = new CancellationTokenSource();
var dependencies = new AggregateRootDependencies <IAggregateRootState>(NullStandardLogger.Instance, mockStateRepo.Object, mockStreamIdBuilder.Object, mockStreamClientFactory.Object, mockResolver.Object);
var ar = new TestAggregateRoot(dependencies, null, aggregateRootName);
mockCommandValidationResult.Setup(x => x.IsValid).Returns(true);
mockCommand.Setup(x => x.ValidateSemantics()).Returns(mockCommandValidationResult.Object);
mockCommand.Setup(x => x.GetRegionId()).Returns(regionId);
mockCommand.Setup(x => x.GetAggregateRootId()).Returns(aggregateRootId);
mockCommand.Setup(x => x.GetCommandId()).Returns(commandId);
mockStreamIdBuilder.Setup(x => x.Build(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(streamId);
mockStateRepo.Setup(x => x.LoadAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(mockState.Object);
mockState.Setup(x => x.IsCausalIdInHistoryAsync(commandId)).ReturnsAsync(false);
mockState.Setup(x => x.StreamPositionCheckpoint).Returns(firstPositionInStream);
mockCommandResult.Setup(x => x.IsSuccess).Returns(true);
mockCommandResult.Setup(x => x.Events).Returns(events);
mockResolver.Setup(x => x.CanUnresolve(mockEvent.Object)).Returns(true);
mockResolver.Setup(x => x.Unresolve(mockEvent.Object)).Returns(unresolvedEvent);
mockStreamClientFactory.Setup(x => x.Create(regionId)).Returns(mockStreamClient.Object);
mockStreamClient.Setup(x => x.CommitEventsToStreamAsync(It.IsAny <string>(), It.IsAny <long?>(), It.IsAny <IEnumerable <CommitEvent> >())).ReturnsAsync(commitResult);
ar.HandleDelegate = (pState, pCommand, pToken) =>
{
if (pState != mockState.Object || pCommand != mockCommand.Object || pToken != cancelSource.Token)
{
throw new Exception();
}
return(Task.FromResult <ICommandResult>(mockCommandResult.Object));
};
var result = await ar.HandleGenericCommandAsync(mockCommand.Object, cancelSource.Token);
mockStreamClient.Verify(x => x.CommitEventsToStreamAsync(streamId, firstPositionInStream, It.IsAny <IEnumerable <CommitEvent> >()));
Assert.True(result.IsSuccess);
Assert.Contains(mockEvent.Object, result.Events);
}
