public async Task ShouldHashRequest()
{
//arrange
HashRequestModel model = new HashRequestModel {
Login = "******", Password = "******"
};
var json = JsonConvert.SerializeObject(model);
var byteArray = Encoding.ASCII.GetBytes(json);
MemoryStream _memoryStream = new MemoryStream(byteArray);
_memoryStream.Flush();
_memoryStream.Position = 0;
_httpRequest.Setup(x => x.Body).Returns(_memoryStream);
//act
var response = await HashFunction.Run(_httpRequest.Object, _logger.Object);
//assert
var result = Assert.IsType <OkObjectResult>(response);
Assert.Equal(200, result.StatusCode);
Assert.IsType <HashResponseModel>(result.Value);
Assert.Equal("DB0E8B62C29CEAB7298679CB28E5D6E8", ((HashResponseModel)result.Value).hash_value);
}
public async Task ShouldReturnHasValue()
{
//arrange
_hashManager.Setup(u => u.HashAsync(It.IsAny <HashRequestModel>()))
.Returns(() => Task.FromResult(new HashResponseModel
{
hash_value = "D4B767CBA7637E855F5278ACC53D434D",
}));
HashRequestModel model = new HashRequestModel {
Login = "******", Password = "******"
};
//act
var response = await _hashController.Hash(model);
//assert
var result = Assert.IsType <OkObjectResult>(response);
Assert.Equal(200, result.StatusCode);
Assert.IsType <HashResponseModel>(result.Value);
Assert.Equal("D4B767CBA7637E855F5278ACC53D434D", (( HashResponseModel)result.Value).hash_value);
}
public async Task <HashResponseModel> Hash(HashRequestModel model)
{
var requestString = JsonConvert.SerializeObject(model);
HttpContent httpContent = new StringContent(requestString, Encoding.UTF8, "application/json");
var result = await _httpClient.PostAsync("api/hash", httpContent);
var response = JsonConvert.DeserializeObject <HashResponseModel>(await result.Content.ReadAsStringAsync());
return(response);
}
public void ShouldFailRequestValidationWhenPasswordIsNotProvided()
{
//arrange
HashRequestModel model = new HashRequestModel
{
Login = "******",
Password = ""
};
//act
var success = _requestValidation.ValidateLoginRequest(model, out string message);
//assert
Assert.False(success, message);
}
public async Task ShouldPassRequestValidation()
{
//arrange
HashRequestModel model = new HashRequestModel
{
Login = "******",
Password = "******"
};
//act
var success = _requestValidation.ValidateLoginRequest(model, out string message);
//assert
Assert.True(success, message);
}
public async Task <HashResponseModel> HashAsync(HashRequestModel model)
{
var success = _requestValidation.ValidateLoginRequest(model, out string message);
if (success)
{
var response = await _funcService.Hash(model);
return(response);
}
else
{
throw new ProcessException($"Invalid request: {message}");
}
}
public bool ValidateLoginRequest(HashRequestModel model, out string message)
{
bool success = false;
if (string.IsNullOrEmpty(model.Login))
{
message = "Provide log";
}
else if (string.IsNullOrEmpty(model.Password))
{
message = "Provide password";
}
else
{
message = "Validation successful";
success = true;
}
return(success);
}
public async Task ShouldReturnHashedValue()
{
//arrange
HashRequestModel model = new HashRequestModel {
Login = "******", Password = "******"
};
HashResponseModel responseModel = new HashResponseModel {
hash_value = "otee"
};
var handlerMock = new Mock <HttpMessageHandler>();
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(responseModel)),
};
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(httpResponse);
var httpClient = new HttpClient(handlerMock.Object);
httpClient.BaseAddress = new Uri("http://localhost:7071");
FunctionService service = new FunctionService(httpClient);
//act
var serviceResponse = await service.Hash(model);
//assert
Assert.NotNull(service);
Assert.NotNull(serviceResponse.hash_value);
}
public async Task ShouldHashRequest(HashRequestModel requestModel)
{
//arrange
string validationMessage = "Validation Successful";
_reqValidation.Setup(u => u.ValidateLoginRequest(requestModel, out validationMessage))
.Returns(true);
_funcService.Setup(u => u.Hash(It.IsAny <HashRequestModel>()))
.Returns(() => Task.FromResult(responseModel));
//act
var response = await _hashManager.HashAsync(requestModel);
//assert
_reqValidation.Verify(u => u.ValidateLoginRequest(It.IsAny <HashRequestModel>(), out validationMessage), Times.Once);
_funcService.Verify(u => u.Hash(It.IsAny <HashRequestModel>()), Times.Once);
Assert.NotNull(response);
Assert.NotNull(response.hash_value);
}
public async Task ShouldThrowProcessException()
{
//arrange
string validationMessage = "Provide Login";
HashRequestModel requestModel = new HashRequestModel {
Login = "", Password = "******"
};
_reqValidation.Setup(u => u.ValidateLoginRequest(requestModel, out validationMessage))
.Returns(false);
_funcService.Setup(u => u.Hash(It.IsAny <HashRequestModel>()))
.Returns(() => Task.FromResult(responseModel));
//act
await Assert.ThrowsAsync <ProcessException>(() => _hashManager.HashAsync(requestModel));
//assert
_reqValidation.Verify(u => u.ValidateLoginRequest(It.IsAny <HashRequestModel>(), out validationMessage), Times.Once);
_funcService.Verify(u => u.Hash(It.IsAny <HashRequestModel>()), Times.Never);
}
public async Task <IActionResult> Hash(HashRequestModel model)
{
var responseModel = await _hashManager.HashAsync(model);
return(Ok(responseModel));
}
