public async Task GivenOneMessageInQueue_WhenReceivedAndProcessingStopped_ThenExpectExceptionLogged()
{
//arrange
string testMessageId = "1";
string expectedExceptionMessage = $"Processing of message: 1, UOWId: has been cancelled.";
var testBatch = new MessageBatchResult <RingbaUOW>
{
Messages = new List <MessageWrapper <RingbaUOW> > {
new MessageWrapper <RingbaUOW> {
Id = testMessageId, Body = new RingbaUOW()
}
}
};
ImplementMeService service = null;
var logService = Substitute.For <ILogService>();
logService.LogAsync(Arg.Any <string>(),
Arg.Any <string>(),
Arg.Any <LOG_LEVEL>(),
Arg.Any <object[]>())
.Returns(Task.CompletedTask);
var subMessageQueService = Substitute.For <IMessageQueService>();
subMessageQueService.GetMessagesFromQueAsync <RingbaUOW>(
Arg.Any <int>(),
Arg.Any <int>(),
Arg.Any <int>())
.Returns(Task.FromResult(testBatch))
.AndDoes(p => service.Stop());
subMessageQueService.UpdateMessagesAsync(Arg.Any <IEnumerable <UpdateBatchRequest> >())
.Returns(Task.FromResult(new ActionResult()));
var subMessageProcessingService = Substitute.For <IMessageProcessService>();
subMessageProcessingService.ProccessMessageAsync(Arg.Any <RingbaUOW>())
.Returns(new ActionResult());
service = new ImplementMeService(
Substitute.For <IUOWStatusService>(),
logService,
subMessageProcessingService,
subMessageQueService);
//act
await service.DoWork();
//assert
await logService.Received().LogAsync(
Arg.Any <string>(),
Arg.Is <string>(exceptionMessage => exceptionMessage.Contains(expectedExceptionMessage)),
Arg.Is <LOG_LEVEL>(logLevel => logLevel == LOG_LEVEL.WARNING),
Arg.Any <object[]>());
await subMessageProcessingService.DidNotReceive().ProccessMessageAsync(Arg.Any <RingbaUOW>());
}
public async Task GivenOneMessageInQueue_WhenReceivedAndProcessingAndCancellationRequested_ThenExpect10LoggedMessages()
{
//arrange
var updateFinishedEvent = new ManualResetEventSlim();
var testBatch = new MessageBatchResult <RingbaUOW>
{
Messages = new List <MessageWrapper <RingbaUOW> > {
new MessageWrapper <RingbaUOW> {
Id = "1", Body = new RingbaUOW()
}
}
};
ImplementMeService service = null;
var logService = Substitute.For <ILogService>();
logService.LogAsync(
Arg.Any <string>(),
Arg.Any <string>(),
Arg.Any <LOG_LEVEL>(),
Arg.Any <object[]>())
.Returns(Task.CompletedTask);
var subMessageQueService = Substitute.For <IMessageQueService>();
subMessageQueService.GetMessagesFromQueAsync <RingbaUOW>(
Arg.Any <int>(),
Arg.Any <int>(),
Arg.Any <int>())
.Returns(Task.FromResult(testBatch))
.AndDoes(p => { service.Stop(); });
subMessageQueService.UpdateMessagesAsync(Arg.Any <IEnumerable <UpdateBatchRequest> >())
.Returns(Task.FromResult(new ActionResult()));
var subMessageProcessingService = Substitute.For <IMessageProcessService>();
subMessageProcessingService.ProccessMessageAsync(Arg.Any <RingbaUOW>())
.Returns(new ActionResult {
IsSuccessfull = true
});
//act
service = new ImplementMeService(
Substitute.For <IUOWStatusService>(),
logService,
subMessageProcessingService,
subMessageQueService);
await service.DoWork();
//assert
await logService.Received(11).LogAsync(
Arg.Any <string>(),
Arg.Any <string>(),
Arg.Any <LOG_LEVEL>(),
Arg.Any <object[]>());
}
public void SampleTestOk()
{
//this is a fake test to show some general usage
var service = new ImplementMeService(Substitute.For <IKVRepository>(),
_logService,
Substitute.For <IMessageProcessService>(),
Substitute.For <IMessageQueService>());
;
Assert.Throws(typeof(NotImplementedException), () => service.Stop());
}
public async Task GivenOneMessageInQueue_WhenReceivedAndProcessingFails_ThenExpectExceptionLogged()
{
//arrange
string expectedExceptionMessage = "exceptionMessage";
var updateFinishedEvent = new ManualResetEventSlim();
var testBatch = new MessageBatchResult <RingbaUOW>
{
Messages = new List <MessageWrapper <RingbaUOW> > {
new MessageWrapper <RingbaUOW> {
Id = "1", Body = new RingbaUOW()
}
}
};
ImplementMeService service = null;
var subMessageQueService = Substitute.For <IMessageQueService>();
subMessageQueService.GetMessagesFromQueAsync <RingbaUOW>(
Arg.Any <int>(),
Arg.Any <int>(),
Arg.Any <int>())
.Returns(Task.FromResult(testBatch));
subMessageQueService.UpdateMessagesAsync(Arg.Any <IEnumerable <UpdateBatchRequest> >())
.Returns(Task.FromResult(new ActionResult()))
.AndDoes(p => service.Stop());
var subMessageProcessingService = Substitute.For <IMessageProcessService>();
subMessageProcessingService.ProccessMessageAsync(Arg.Any <RingbaUOW>())
.Returns <ActionResult>(x => throw new ArgumentNullException("someParam", expectedExceptionMessage));
var subUOWStatusService = Substitute.For <IUOWStatusService>();
subUOWStatusService.TrySetInProcessing(Arg.Any <string>())
.Returns(Task.FromResult(true));
service = new ImplementMeService(
subUOWStatusService,
_logService,
subMessageProcessingService,
subMessageQueService);
//act
await service.DoWork();
//assert
await _logService.Received().LogAsync(
Arg.Any <string>(),
Arg.Is <string>(exceptionMessage => exceptionMessage.Contains(expectedExceptionMessage)),
Arg.Is <LOG_LEVEL>(logLevel => logLevel == LOG_LEVEL.EXCEPTION),
Arg.Any <object[]>());
}
public async Task GivenOneMessageInQueue_WhenReceivedAndProcessingFails_ThenExpectOneMessageUpdated()
{
//arrange
var updateFinishedEvent = new ManualResetEventSlim();
var testBatch = new MessageBatchResult <RingbaUOW>
{
Messages = new List <MessageWrapper <RingbaUOW> > {
new MessageWrapper <RingbaUOW> {
Id = "1", Body = new RingbaUOW()
}
}
};
ImplementMeService service = null;
var subMessageQueService = Substitute.For <IMessageQueService>();
subMessageQueService.GetMessagesFromQueAsync <RingbaUOW>(
Arg.Any <int>(),
Arg.Any <int>(),
Arg.Any <int>())
.Returns(Task.FromResult(testBatch));
subMessageQueService.UpdateMessagesAsync(Arg.Any <IEnumerable <UpdateBatchRequest> >())
.Returns(Task.FromResult(new ActionResult()))
.AndDoes(p => service.Stop());
var subMessageProcessingService = Substitute.For <IMessageProcessService>();
subMessageProcessingService.ProccessMessageAsync(Arg.Any <RingbaUOW>())
.Returns <ActionResult>(x => throw new ArgumentNullException());
var subUOWStatusService = Substitute.For <IUOWStatusService>();
subUOWStatusService.TrySetInProcessing(Arg.Any <string>())
.Returns(Task.FromResult(true));
//act
service = new ImplementMeService(
subUOWStatusService,
_logService,
subMessageProcessingService,
subMessageQueService);
await service.DoWork();
//assert
await subMessageQueService.Received().UpdateMessagesAsync(Arg.Is <IEnumerable <UpdateBatchRequest> >(p =>
p.Count() == 1 &&
p.First().Id == "1" &&
p.First().MessageCompleted == false));
}
public async Task GivenOneMessageInQueue_WhenOneRingbaUOWWithSameIdInProcessing_ThenExpectMessageNotProcessed()
{
//arrange
var updateFinishedEvent = new ManualResetEventSlim();
var testBatch = new MessageBatchResult <RingbaUOW>
{
Messages = new List <MessageWrapper <RingbaUOW> > {
new MessageWrapper <RingbaUOW> {
Id = "1", Body = new RingbaUOW()
}
}
};
ImplementMeService service = null;
var subMessageQueService = Substitute.For <IMessageQueService>();
subMessageQueService.GetMessagesFromQueAsync <RingbaUOW>(
Arg.Any <int>(),
Arg.Any <int>(),
Arg.Any <int>())
.Returns(Task.FromResult(testBatch));
subMessageQueService.UpdateMessagesAsync(Arg.Is <IEnumerable <UpdateBatchRequest> >(p => p.Count() == 0))
.Returns(Task.FromResult(new ActionResult()));
var subUOWStatusService = Substitute.For <IUOWStatusService>();
subUOWStatusService.TrySetInProcessing(Arg.Any <string>())
.Returns(Task.FromResult(false))
.AndDoes(p => service.Stop());
var subMessageProcessingService = Substitute.For <IMessageProcessService>();
subMessageProcessingService.ProccessMessageAsync(Arg.Any <RingbaUOW>())
.Returns(Task.FromResult(new ActionResult {
IsSuccessfull = true
}));
//act
service = new ImplementMeService(
subUOWStatusService,
_logService,
subMessageProcessingService,
subMessageQueService);
await service.DoWork();
//assert
await subMessageQueService.Received().UpdateMessagesAsync(Arg.Is <IEnumerable <UpdateBatchRequest> >(p => p.Count() == 0));
}
public async Task GivenOneMessageInQueue_WhenExpirySet_ThenSetMessageCompletedAccordingly(
bool hasExpiredAge,
bool hasExpiredRetries,
bool expectedMessageCompleted)
{
//arrange
var updateFinishedEvent = new ManualResetEventSlim();
var testBatch = new MessageBatchResult <RingbaUOW>
{
Messages = new List <MessageWrapper <RingbaUOW> > {
new MessageWrapper <RingbaUOW> {
Id = "1", Body = new RingbaUOW()
}
}
};
ImplementMeService service = null;
var subMessageQueService = Substitute.For <IMessageQueService>();
subMessageQueService.GetMessagesFromQueAsync <RingbaUOW>(
Arg.Any <int>(),
Arg.Any <int>(),
Arg.Any <int>())
.Returns(Task.FromResult(testBatch));
subMessageQueService.UpdateMessagesAsync(Arg.Is <IEnumerable <UpdateBatchRequest> >(p => p.First().MessageCompleted == true))
.Returns(Task.FromResult(new ActionResult()));
var subUOWStatusService = Substitute.For <IUOWStatusService>();
subUOWStatusService.TrySetInProcessing(Arg.Any <string>())
.Returns(Task.FromResult(true));
subUOWStatusService.HasExpiredAge(
Arg.Any <string>(),
Arg.Any <long>(),
Arg.Any <int>())
.Returns(Task.FromResult(hasExpiredAge))
.AndDoes(p => service.Stop());
subUOWStatusService.HasExpiredRetries(
Arg.Any <string>(),
Arg.Any <int>())
.Returns(Task.FromResult(hasExpiredRetries))
.AndDoes(p => service.Stop());
var subMessageProcessingService = Substitute.For <IMessageProcessService>();
subMessageProcessingService.ProccessMessageAsync(Arg.Any <RingbaUOW>())
.Returns(Task.FromResult(new ActionResult {
IsSuccessfull = true
}));
//act
service = new ImplementMeService(
subUOWStatusService,
_logService,
subMessageProcessingService,
subMessageQueService);
await service.DoWork();
//assert
await subMessageQueService.Received().UpdateMessagesAsync(Arg.Is <IEnumerable <UpdateBatchRequest> >(p => p.First().MessageCompleted == expectedMessageCompleted));
}
public async Task GivenOneMessageInQueue_WhenProcessed_ThenExpectOneMessageUpdated(bool isActionResultSuccessful)
{
//arrange
var testBatch = new MessageBatchResult <RingbaUOW>
{
Messages = new List <MessageWrapper <RingbaUOW> > {
new MessageWrapper <RingbaUOW> {
Id = "1", Body = new RingbaUOW()
}
}
};
ImplementMeService service = null;
var subMessageQueService = Substitute.For <IMessageQueService>();
subMessageQueService.GetMessagesFromQueAsync <RingbaUOW>(
Arg.Any <int>(),
Arg.Any <int>(),
Arg.Any <int>())
.Returns(Task.FromResult(testBatch));
subMessageQueService.UpdateMessagesAsync(Arg.Any <IEnumerable <UpdateBatchRequest> >())
.Returns(Task.FromResult(new ActionResult()))
.AndDoes(p => service.Stop());
var subUOWStatusService = Substitute.For <IUOWStatusService>();
subUOWStatusService.TrySetInProcessing(Arg.Any <string>())
.Returns(Task.FromResult(true));
subUOWStatusService.ClearStatusMetadata(
Arg.Any <string>())
.Returns(Task.CompletedTask);
subUOWStatusService.ResetInProcessing(
Arg.Any <string>())
.Returns(Task.CompletedTask);
var subMessageProcessingService = Substitute.For <IMessageProcessService>();
subMessageProcessingService.ProccessMessageAsync(Arg.Any <RingbaUOW>())
.Returns(Task.FromResult(new ActionResult {
IsSuccessfull = isActionResultSuccessful
}));
//act
service = new ImplementMeService(
subUOWStatusService,
_logService,
subMessageProcessingService,
subMessageQueService);
await service.DoWork();
//assert
await subMessageQueService.Received().UpdateMessagesAsync(Arg.Is <IEnumerable <UpdateBatchRequest> >(p =>
p.Count() == 1 &&
p.First().Id == "1" &&
p.First().MessageCompleted == isActionResultSuccessful));
await subUOWStatusService.Received(isActionResultSuccessful? 1 : 0).ClearStatusMetadata(Arg.Any <string>());
await subUOWStatusService.Received(isActionResultSuccessful? 0 : 1).ResetInProcessing(Arg.Any <string>());
}
