public void Handle_logs_exception_before_throwing_it()
{
// Arrange
var newEvent = new NewResultIntegrationEvent();
var anyException = new Exception($"Failed to process {nameof(NewResultIntegrationEvent)}: {newEvent.Id}");
var logger = new Mock <ILogger <NewResultIntegrationEventHandler> >();
var uow = new Mock <IUnitOfWork>();
uow.Setup(s => s.DiffResultsRepository)
.Throws(anyException);
var handler = GetHandler(logger, uow: uow);
// Act
Assert.ThrowsAsync <Exception>(() => handler.Handle(newEvent));
// Assert
logger.Verify(l =>
l.Log(
LogLevel.Error,
0,
It.Is <FormattedLogValues>(v => v.ToString() == anyException.Message),
It.Is <Exception>(e => e == anyException),
It.IsAny <Func <object, Exception, string> >())
);
}
public void Handle_should_return_expected_differences_for_different_inputs(
InputData input,
InputData opposingInput,
DiffResult expectedResult
)
{
// Arrange
var resultEvent = new NewResultIntegrationEvent(input, string.Empty, expectedResult);
var newInputEvent = new NewInputIntegrationEvent()
{
Position = input.Position
};
var eventBus = new Mock <IRabbitMQEventBus>();
var repository = new Mock <IInputRepository>();
repository
.Setup(s => s.FindAsync(It.IsAny <string>()))
.ReturnsAsync(() => input);
repository
.Setup(s => s.GetLastInputBeforeAsync(It.IsAny <Guid>(), It.IsAny <InputPosition>(), It.IsAny <DateTime>()))
.ReturnsAsync(() => opposingInput);
var handler = GetHandler(
eventBus: eventBus,
repository: repository,
logic: new DiffLogic()
);
// Act
handler.Handle(newInputEvent);
// Assert
eventBus.Verify(
eb => eb.Publish(
It.Is <NewResultIntegrationEvent>(e =>
e.Result == ResultType.Different &&
e.Differences.Count == expectedResult.Differences.Count &&
e.Differences.All(_ => expectedResult.Differences.Contains(_))
)
)
);
}
public async Task Handle_doesnt_save_result_if_already_exists()
{
// Arrange
var newEvent = new NewResultIntegrationEvent {
InputId = Guid.NewGuid().ToString()
};
var mapper = new Mock <IMapper>();
mapper.Setup(s => s.Map <DiffResult>(It.IsAny <NewResultIntegrationEvent>()))
.Returns(new DiffResult());
var mockRepo = new Mock <IDiffResultsRepository>();
mockRepo.Setup(s => s.Get(It.IsAny <Expression <Func <DiffResult, bool> > >()))
.Returns(() =>
new DiffResult[] {
new DiffResult {
TriggerInputId = newEvent.InputId
}
}
.AsQueryable()
);
var uow = new Mock <IUnitOfWork>();
uow.Setup(s => s.DiffResultsRepository)
.Returns(mockRepo.Object);
var handler = GetHandler(mapper: mapper, uow: uow);
// Act
await handler.Handle(newEvent);
// Assert
mockRepo.Verify(r =>
r.Add(It.IsAny <DiffResult>()),
Times.Never
);
uow.Verify(u =>
u.SaveChangesAsync(),
Times.Never
);
}
public void Handle_consider_input_larger_if_no_opposing_input_found(InputPosition position, ResultType expectedResultType)
{
// Arrange
var input = new InputData(position, "test");
var expectedResult = new DiffResult(expectedResultType, null);
var resultEvent = new NewResultIntegrationEvent(input, string.Empty, expectedResult);
var newInputEvent = new NewInputIntegrationEvent()
{
Position = input.Position
};
var eventBus = new Mock <IRabbitMQEventBus>();
var logic = new Mock <IDiffLogic>();
logic.Setup(s => s.CompareData(It.IsAny <InputData>(), It.IsAny <InputData>()))
.Returns(expectedResult);
var repository = new Mock <IInputRepository>();
repository
.Setup(s => s.FindAsync(It.IsAny <string>()))
.ReturnsAsync(() => input);
repository
.Setup(s => s.GetLastInputBeforeAsync(It.IsAny <Guid>(), It.IsAny <InputPosition>(), It.IsAny <DateTime>()))
.ReturnsAsync(() => null);
var handler = GetHandler(
eventBus: eventBus,
repository: repository,
logic: logic.Object
);
// Act
handler.Handle(newInputEvent);
// Assert
eventBus.Verify(
eb => eb.Publish(
It.Is <NewResultIntegrationEvent>(e => e.Result == expectedResult.Result)
)
);
}
private void PublishNewResult(InputData input, string oppsingInputId, DiffResult diffResult)
{
var newResult = new NewResultIntegrationEvent(input, oppsingInputId, diffResult);
_eventBus.Publish(newResult);
}
