UserSignInResult GetUserResult(SignInResult result)
{
SignInResultConverter converter = new SignInResultConverter();
UserSignInResult userResult = converter.Convert(result);
return(userResult);
}
public void Convert_WhenSuccess_ReturnsSuccess()
{
//Given, When
UserSignInResult userResult = GetUserResult(SignInResult.Success);
//Then
Assert.Equal(UserSignInResult.Success, userResult);
}
public void Create_WhenInvalidOrSuccessfulResult_ThrowsException(UserSignInResult signInResult)
{
//Given
SignInErrorCreator creator = new SignInErrorCreator(new FailedSignInMessageConverter());
//When, Then
Assert.Throws <ArgumentException>(() => creator.Create(signInResult));
}
public void Convert_WhenLockedOut_ReturnsLockedOut()
{
//Given, When
UserSignInResult userResult = GetUserResult(SignInResult.LockedOut);
//Then
Assert.Equal(UserSignInResult.LockedOut, userResult);
}
public void Convert_WhenNotAllowed_ReturnsFailed()
{
//Given, When
UserSignInResult userResult = GetUserResult(SignInResult.NotAllowed);
//Then
Assert.Equal(UserSignInResult.NotAllowed, userResult);
}
public void Convert_WhenTwoFactorRequired_ReturnsRequiredTwoFactor()
{
//Given, When
UserSignInResult userResult = GetUserResult(SignInResult.TwoFactorRequired);
//Then
Assert.Equal(UserSignInResult.RequiresTwoFactor, userResult);
}
private IdentityController GetController(UserSignInResult desiredResult)
{
ILogger <IdentityController> logger = new Mock <ILogger <IdentityController> >().Object;
Mock <IUserSignInManager> signInMock = new Mock <IUserSignInManager>();
signInMock.Setup(mgr => mgr.CheckSignInAsync(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(desiredResult));
IdentityController controller = new IdentityController(logger, signInMock.Object);
return(controller);
}
public async Task CheckSignIn_WhenFailureFromClient_ReturnsFailure(UserSignInResult desiredClientResult)
{
//Given
IdentityProvider provider = GetProvider(desiredClientResult);
//When
UserSignInResult result = await provider.CheckSignInAsync("myUserName", "myPassword");
//Then
Assert.Equal(desiredClientResult, result);
}
public async Task CheckSignIn_WhenSuccessFromClient_ReturnsSuccess()
{
//Given
IdentityProvider provider = GetProvider(UserSignInResult.Success);
//When
UserSignInResult result = await provider.CheckSignInAsync("myUserName", "myPassword");
//Then
Assert.Equal(UserSignInResult.Success, result);
}
public void Create_WhenFailedResult_ReturnsError(UserSignInResult signInResult)
{
//Given
SignInErrorCreator creator = new SignInErrorCreator(new FailedSignInMessageConverter());
//When
ValidationError error = creator.Create(signInResult);
//Then
Assert.NotNull(error);
Assert.Empty(error.PropertyName);
Assert.NotEmpty(error.Message);
}
public async Task <IActionResult> CheckSignIn(string userName, string password)
{
UserSignInResult result = await signInManager.CheckSignInAsync(userName, password);
if (result == UserSignInResult.Success)
{
return(Ok(result));
}
else
{
return(BadRequest(result));
}
}
public async Task SignIn_WhenCredentialsAreIncorrect_ReturnsBadRequest(UserSignInResult desiredClientResult)
{
//Given
IdentityController controller = GetController(desiredClientResult);
//When
IActionResult result = await controller.CheckSignIn("userName", "password");
BadRequestObjectResult badResult = result as BadRequestObjectResult;
UserSignInResult returnedSignInResult = (UserSignInResult)badResult.Value;
//Then
Assert.NotNull(badResult);
Assert.Equal(400, badResult.StatusCode);
Assert.Equal(desiredClientResult, returnedSignInResult);
}
IdentityProvider GetProvider(UserSignInResult desiredResult)
{
Mock <IHttpClientProvider> providerMock = new Mock <IHttpClientProvider>();
providerMock.Setup(prv => prv.SendAsync(It.IsAny <HttpRequestMessage>())).Returns(Task.FromResult(new HttpResponseMessage()
{
Content = new StringContent(desiredResult.ToString())
}));
Mock <IConfiguration> configMock = new Mock <IConfiguration>();
configMock.SetupGet(mock => mock["Services:DataSource:Uri"]).Returns("https://localhost:1234");
IdentityProvider provider = new IdentityProvider(providerMock.Object, configMock.Object);
return(provider);
}
public async Task SignIn_WhenCredentialsAreCorrect_ReturnsOK()
{
//Given
UserSignInResult desiredSignInResult = UserSignInResult.Success;
IdentityController controller = GetController(desiredSignInResult);
//When
IActionResult result = await controller.CheckSignIn("userName", "password");
OkObjectResult okResult = result as OkObjectResult;
UserSignInResult returnedResult = (UserSignInResult)okResult.Value;
//Then
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
Assert.Equal(desiredSignInResult, returnedResult);
}
public async Task SignIn_WhenSignInCheckFails_RedirectsToCurrent(UserSignInResult desiredResult)
{
//Given, When
SignInUseCaseConfig config = new SignInUseCaseConfig()
{
ValidationResult = new ValidationResult()
{
IsValid = true
},
DesiredSignInResult = desiredResult
};
await GetUseCase(config).SignInAsync(new UserLoginModel());
//Then
Assert.Equal(NavigationLocation.Current, navigatedLocation);
}
async Task SignInIfCredentialsOK(UserLoginModel model)
{
UserSignInResult result = await identityProvider.CheckSignInAsync(model.Username, model.Password);
if (result == UserSignInResult.Success)
{
await SignInUserAsync(model);
}
else if (result == UserSignInResult.Invalid)
{
throw new InvalidOperationException($"Invalid result received form {nameof(identityProvider)}.");
}
else
{
errorCollector.AddError(errorCreator.Create(result));
errorCollector.Save();
NavigateTo(NavigationLocation.Current);
}
}
public async Task <UserSignInResult> CheckSignInAsync(string userName, string password)
{
string serviceUri = $"{config["Services:DataSource:Uri"]}{config["Services:DataSource:CheckSignInPath"]}";
UriBuilder builder = new UriBuilder(serviceUri);
builder.Query = $"userName={userName}&password={password}";
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, builder.Uri);
HttpResponseMessage response = await provider.SendAsync(request);
if (response.IsSuccessStatusCode)
{
string res = await response.Content.ReadAsStringAsync();
UserSignInResult content = JsonConvert.DeserializeObject <UserSignInResult>($"'{res}'");
return(content);
}
else
{
return(UserSignInResult.Failed);
}
}
internal string Convert(UserSignInResult signInResult) =>
signInResult switch
{
internal ValidationError Create(UserSignInResult signInResult) => new ValidationError()
{
PropertyName = string.Empty,
Message = converter.Convert(signInResult)
};
