public async Task Given_ThereIsAnInvoiceInTheDatabase_When_HandlerIsCalled_Then_TheInvoiceIsReturnedAndTheStatusCodeIs200()
{
//arrange
var setupInvoice = new Invoice {
Amount = 100, Identifier = "TEST-100"
};
await _applicationDbContext.Invoices.AddAsync(setupInvoice);
await _applicationDbContext.SaveChangesAsync();
var getInvoiceQuery = new GetInvoiceQuery(setupInvoice.InvoiceId);
//act
var response = await _systemUnderTest.Handle(getInvoiceQuery, default);
//assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
response.Error.Should().BeNull();
response.HasError.Should().BeFalse();
response.Content.Should().NotBeNull();
response.Content.Identifier.Should().Be(setupInvoice.Identifier);
response.Content.Amount.Should().Be(setupInvoice.Amount);
response.Content.CreatedBy.Should().Be(_testUserId);
response.Content.InvoiceId.Should().Be(setupInvoice.InvoiceId);
}
public async Task <DeleteInvoiceByIdResponse> Handle(DeleteInvoiceByIdRequest request, CancellationToken cancellationToken)
{
var query = new GetInvoiceQuery()
{
Id = request.Id
};
var getInvoice = await this.queryExecutor.Execute(query);
if (getInvoice == null)
{
return(new DeleteInvoiceByIdResponse()
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var mappedCommand = this.mapper.Map <DataAccess.Entities.Invoice>(request);
var command = new DeleteInvoiceCommand()
{
Parameter = mappedCommand
};
var created = await this.commandExecutor.Execute(command);
var response = new DeleteInvoiceByIdResponse()
{
Data = created
};
return(response);
}
public HttpResponseMessage Get(int id)
{
var query = new GetInvoiceQuery(id);
var queryResult = _queryDispatcher.Handle <GetInvoiceQueryResult>(query);
return(Request.CreateResponse(HttpStatusCode.OK, queryResult.InvoiceModel));
}
public async Task <ActionResult <InvoiceResult> > GetInvoice(int id)
{
var invoiceCommand = new GetInvoiceQuery(id);
var invoiceResult = await _mediator.Send(invoiceCommand);
if (invoiceResult == null)
{
return(NotFound());
}
return(invoiceResult);
}
public void Given_TheCallIsCancelledByUser_When_HandlerIsCalled_Then_TheHandlerShouldThrowOperationCancelledException()
{
using (var cancellationTokenSource = new CancellationTokenSource())
{
var cancellationToken = cancellationTokenSource.Token;
cancellationTokenSource.Cancel();
var getInvoiceQuery = new GetInvoiceQuery(100);
Func <Task <GetInvoiceQueryResponse> > func = async() => await _systemUnderTest.Handle(getInvoiceQuery, cancellationToken);
func.Should().ThrowAsync <OperationCanceledException>();
}
}
public async Task Given_TheInvoiceIsNotInTheDatabase_When_HandlerIsCalled_Then_NotFoundResponseIsReturned()
{
//arrange
var getInvoiceQuery = new GetInvoiceQuery(100);
//act
var response = await _systemUnderTest.Handle(getInvoiceQuery, default);
//assert
response.StatusCode.Should().Be(HttpStatusCode.NotFound);
response.Error.Should().NotBeNull();
response.HasError.Should().BeTrue();
response.Content.Should().BeNull();
response.Error.ErrorCode.Should().Be(ApplicationConstants.ErrorCodes.BusinessValidationError);
response.Error.ErrorMessage.Should().Be(string.Format(ApplicationConstants.ErrorMessages.InvoiceWithIdDoesNotExist, 100));
}
public async Task <CreateInvoiceResponse> Handle(CreateInvoiceRequest request, CancellationToken cancellationToken)
{
if (request.AuthenticationRole == "UserHotel" || request.AuthenticationRole == "UserAdmin")
{
return(new CreateInvoiceResponse
{
Error = new ErrorModel(ErrorType.Forbidden)
});
}
var query = new GetInvoiceQuery()
{
Number = request.Number,
CompanyId = request.CompanyId,
LaundryId = request.LaundryId,
WouldLikeToCreate = true
};
var getInvoice = await this.queryExecutor.Execute(query);
if (getInvoice != null)
{
lastDocNumber = getInvoice.Number;
}
else
{
lastDocNumber = "0/0/0";
}
request.Number = docNumCreator.DocumentNumberCreator(lastDocNumber);
var mappedCommand = this.mapper.Map <DataAccess.Entities.Invoice>(request);
var command = new CreateInvoiceCommand()
{
Parameter = mappedCommand
};
var created = await this.commandExecutor.Execute(command);
var response = new CreateInvoiceResponse()
{
Data = this.mapper.Map <API.Domain.Models.Invoice>(created)
};
return(response);
}
public async Task <GetInvoiceByIdResponse> Handle(GetInvoiceByIdRequest request, CancellationToken cancellationToken)
{
var query = new GetInvoiceQuery()
{
Id = request.Id
};
var invoice = await this.queryExecutor.Execute(query);
if (invoice == null)
{
return(new GetInvoiceByIdResponse
{
Error = new ErrorModel(ErrorType.NotFound)
});
}
var mappedInvoices = this.mapper.Map <Invoice>(invoice);
return(new GetInvoiceByIdResponse()
{
Data = mappedInvoices
});
}
public async Task GetInvoiceTest()
{
var query = new GetInvoiceQuery()
{
};
}
