public async Task CreateStateAsync_Should_Return_CreatedAtRouteResult_With_StateResponse()
{
var createStateRequest = new CreateStateRequest {
Name = "Name", PolishName = "PolishName"
};
var createStateCommand = new CreateStateCommand(Guid.NewGuid(), createStateRequest.Name, createStateRequest.PolishName);
var stateOutputQuery = new StateOutputQuery(createStateCommand.StateId, Array.Empty <byte>(), createStateCommand.Name,
createStateCommand.PolishName);
var stateResponse = new StateResponse(stateOutputQuery.Id, stateOutputQuery.RowVersion, stateOutputQuery.Name, stateOutputQuery.PolishName);
_mapperMock.Setup(x => x.Map <CreateStateRequest, CreateStateCommand>(It.IsAny <CreateStateRequest>())).Returns(createStateCommand);
_communicationBusMock.Setup(x => x.SendCommandAsync(It.IsAny <CreateStateCommand>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
_getStateQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetStateInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(stateOutputQuery);
_mapperMock.Setup(x => x.Map <StateOutputQuery, StateResponse>(It.IsAny <StateOutputQuery>())).Returns(stateResponse);
var result = await _controller.CreateStateAsync(createStateRequest);
var createdAtRouteResult = result.As <CreatedAtRouteResult>();
createdAtRouteResult.Value.Should().BeEquivalentTo(stateResponse);
createdAtRouteResult.RouteName.Should().BeEquivalentTo("GetState");
createdAtRouteResult.RouteValues.Should().BeEquivalentTo(new RouteValueDictionary(new { id = stateResponse.Id }));
}
public async Task HandleAsync_Should_Throw_ConflictException_When_Name_And_PolishName_Are_Already_Used()
{
var command = new CreateStateCommand(Guid.NewGuid(), "Name", "PolishName");
var duplicateNameError = new Error(StateErrorCodeEnumeration.NameAlreadyInUse, StateErrorMessage.NameAlreadyInUse);
var duplicatePolishNameError = new Error(StateErrorCodeEnumeration.PolishNameAlreadyInUse, StateErrorMessage.PolishNameAlreadyInUse);
var nameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
duplicateNameError
});
var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
duplicatePolishNameError
});
var errors = new Collection <IError> {
duplicateNameError, duplicatePolishNameError
};
_stateVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_stateVerificationServiceMock.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ConflictException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
/// <inheritdoc cref="ICommandHandler" />
bool ICommandHandler.CreateState(string stateId, string desc, string defaultValue)
{
if (string.IsNullOrWhiteSpace(stateId) ||
string.IsNullOrWhiteSpace(desc))
{
return(false);
}
var command = new CreateStateCommand(stateId, desc, defaultValue);
return(SendCommand(command));
}
public async Task HandleAsync_Should_Create_State()
{
var command = new CreateStateCommand(Guid.NewGuid(), "Name", "PolishName");
var state = State.Builder()
.SetId(command.StateId)
.SetRowVersion(Array.Empty <byte>())
.SetName(command.Name)
.SetPolishName(command.PolishName)
.Build();
var nameIsNotTakenVerificationResult = VerificationResult.Ok();
var polishNameIsNotTakenVerificationResult = VerificationResult.Ok();
_stateVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_stateVerificationServiceMock.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
_mapperMock.Setup(x => x.Map <CreateStateCommand, State>(It.IsAny <CreateStateCommand>())).Returns(state);
_stateRepositoryMock.Setup(x => x.AddAsync(It.IsAny <State>())).Returns(Task.CompletedTask);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
await result.Should().NotThrowAsync <Exception>();
}
