public void Accept_ShouldCreateAudit()
{
// Arrrange
var dummyAudit = new ServiceModel.Audit();
var mockLogger = Mock.Of <ILoggerAdapter <AuditServiceFireForget> >(MockBehavior.Strict);
Mock.Get(mockLogger)
.Setup(l => l.LogError(string.Empty))
.Verifiable();
var mockFireForgetEventHandler = Mock.Of <IFireForgetEventHandler>(MockBehavior.Strict);
Mock.Get(mockFireForgetEventHandler)
.Setup(m => m.Execute(It.IsAny <Func <IAuditService, Task> >()))
.Verifiable();
// Act
var auditService = new AuditServiceFireForget(mockFireForgetEventHandler, mockLogger);
auditService.Accept(dummyAudit);
//Assert
Mock.Get(mockFireForgetEventHandler)
.Verify(m => m.Execute(It.IsAny <Func <IAuditService, Task> >()), Times.Once);
Mock.Get(mockLogger).Verify(m => m.LogError(string.Empty), Times.Never);
}
/// <summary>
/// Create async helper.
/// </summary>
/// <param name="expectedStatusCode">Status code to mock test.</param>
private async Task EndpointHelper(ServiceModels.Audit audit, int expectedStatusCode)
{
// Arrange
// Act
var result = await CreatePostAsync("/api/audit", GetStringContent(audit));
// Assert
result.Should().BeOfType <HttpResponseMessage>().Which.StatusCode.Should().Be(expectedStatusCode);
}
/// <summary>
/// Set service Audit model.
/// </summary>
private void SetServiceAuditHelper(string textMessage)
{
_serviceAudit = new ServiceModel.Audit()
{
Action = 0,
Message = textMessage,
Severity = 1,
Ukprn = 12345,
User = "******"
};
}
public void CreateAsync_WhenArgumentNull_ThrowsArgumentNullException()
{
// Arrange
ServiceModel.Audit smAudit = null;
IAuditService sut = GetAuditServiceHelper();
// Act
Func <Task> func = () => sut.CreateAsync(smAudit);
// Assert
func.Should().Throw <ArgumentNullException>();
}
/// <summary>
/// Create new Audit repository model and pass on to the repository.
/// </summary>
/// <param name="request">Audit entity.</param>
/// <returns>Returns void.</returns>
public async Task CreateAsync(ServiceModel.Audit request)
{
It.IsNull(request)
.AsGuard <ArgumentNullException>();
var dmAudit = _mapper.Map <ServiceModel.Audit, DataModel.Audit>(request);
dmAudit.CreatedAt = DateTime.UtcNow;
dmAudit.User = dmAudit.User ?? "AuditUser";
await _unitOfWork.AuditRepository.AddAsync(dmAudit);
await _unitOfWork.CommitAsync();
}
/// <summary>
/// Accept a fire and forget audit message.
/// </summary>
/// <param name="message">Audit.</param>
public void Accept(ServiceModel.Audit message)
{
_fireForgetEventHandler.Execute(async a =>
{
try
{
await a.CreateAsync(message);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Unexpected error during fire and forget audit creation of audit message : {message.Message}.");
}
});
}
public async Task Execute_ShouldCreateAuditAsync()
{
// Arrrange
var dummyAudit = new ServiceModel.Audit();
var mockAuditService = Mock.Of <IAuditService>(MockBehavior.Strict);
var serviceProvider = Mock.Of <IServiceProvider>(MockBehavior.Strict);
var serviceScope = Mock.Of <IServiceScope>(MockBehavior.Strict);
var serviceScopeFactory = Mock.Of <IServiceScopeFactory>(MockBehavior.Strict);
Mock.Get(mockAuditService)
.Setup(x => x.CreateAsync(dummyAudit))
.Returns(Task.CompletedTask);
Mock.Get(serviceScope).SetupGet(x => x.ServiceProvider).Returns(serviceProvider);
Mock.Get(serviceScopeFactory)
.Setup(x => x.CreateScope())
.Returns(serviceScope);
Mock.Get(serviceProvider)
.Setup(x => x.GetService(typeof(IAuditService)))
.Returns(mockAuditService);
Mock.Get(serviceProvider)
.Setup(x => x.GetService(typeof(IServiceScopeFactory)))
.Returns(serviceScopeFactory);
// Act
var fireForgetEventHandler = new FireForgetEventHandler(serviceScopeFactory);
fireForgetEventHandler.Execute(async auditService => await auditService.CreateAsync(dummyAudit));
// We execute run in a separate thread then the current one so we need to delay to assert.
await Task.Delay(100);
//Assert
Mock.Get(serviceScopeFactory).Verify(x => x.CreateScope(), Times.Once);
Mock.Get(serviceScope).VerifyGet(x => x.ServiceProvider, Times.Once);
Mock.Get(serviceProvider).Verify(x => x.GetService(typeof(IAuditService)), Times.Once);
Mock.Get(mockAuditService).Verify(x => x.CreateAsync(dummyAudit), Times.Once);
}
public async Task CreateAsync_ShouldCreateAudit()
{
// Arrrange
_auditRepositoryMock.Setup(m => m.AddAsync(_dmAudit)).Returns(Task.CompletedTask);
_unitOfWorkMock.Setup(m => m.AuditRepository).Returns(_auditRepositoryMock.Object);
_unitOfWorkMock.Setup(m => m.CommitAsync()).Returns(Task.CompletedTask);
var smAudit = new ServiceModel.Audit()
{
Action = 5, Message = "Test", Severity = 1, Ukprn = 12345
};
IAuditService sut = GetAuditServiceHelper();
// Act
await sut.CreateAsync(smAudit);
//Assert
_auditRepositoryMock.Verify();
_auditRepositoryMock.Verify(x => x.AddAsync(_dmAudit), Times.Once);
_unitOfWorkMock.Verify(x => x.CommitAsync(), Times.Once);
Mock.VerifyAll(_mockMapper);
}
public async Task <IActionResult> CreateAsync(ServiceModels.Audit request)
{
await _auditService.CreateAsync(request);
return(StatusCode(StatusCodes.Status201Created));
}
public IActionResult Accept(ServiceModels.Audit request)
{
_auditServiceFireForget.Accept(request);
return(StatusCode(StatusCodes.Status202Accepted));
}