public AuthControllerTests()
{
mailClient = Substitute.For<IMailClient>();
service = Substitute.For<IAccountService>();
validator = Substitute.For<IAccountValidator>();
controller = Substitute.ForPartsOf<AuthController>(validator, service, mailClient);
controller.ControllerContext.HttpContext = Substitute.For<HttpContext>();
controller.TempData = Substitute.For<ITempDataDictionary>();
controller.ControllerContext.RouteData = new RouteData();
controller.Url = Substitute.For<IUrlHelper>();
accountRegister = ObjectFactory.CreateAccountRegisterView();
accountRecovery = ObjectFactory.CreateAccountRecoveryView();
accountReset = ObjectFactory.CreateAccountResetView();
accountLogin = ObjectFactory.CreateAccountLoginView();
}
public AuthControllerTests()
{
mailClient = Substitute.For<IMailClient>();
service = Substitute.For<IAccountService>();
validator = Substitute.For<IAccountValidator>();
controller = Substitute.ForPartsOf<AuthController>(validator, service, mailClient);
accountRegister = ObjectFactory.CreateAccountRegisterView();
accountRecovery = ObjectFactory.CreateAccountRecoveryView();
accountReset = ObjectFactory.CreateAccountResetView();
accountLogin = ObjectFactory.CreateAccountLoginView();
HttpContextBase httpContext = HttpContextFactory.CreateHttpContextBase();
controller.Url = new UrlHelper(httpContext.Request.RequestContext);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = httpContext;
}
public async Task Post()
{
// Arrange
AuthController controller = new AuthController();
var authPost = new AuthPost()
{
Password = "******",
AuthIdentity = "Admin"
};
// Act
var httpRequest = new HttpRequestMessage(HttpMethod.Post, "http://example.com");
httpRequest.SetConfiguration(new HttpConfiguration());
authPost.Request = httpRequest;
await authPost.ExecuteAsync(CancellationToken.None);
// Assert
}
public async Task Login_Failure_ReponseUnAuthorized(string username, string password)
{
//Arrage: Create injection
Mock <IAuthRepository> mockIAuthRepository = new Mock <IAuthRepository>();
Mock <IConfiguration> mockIConfig = new Mock <IConfiguration>();
//Created a user for login
var userForLogin = new UserForLoginDto()
{
UserName = username,
PassWord = password
};
// Login fail => return null as no users in the system matches the input username
mockIAuthRepository.Setup(repo => repo.Login(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult((User)null));
var authController = new AuthController(mockIAuthRepository.Object, mockIConfig.Object);
//Action : Call the login method and expecte to get a UnAuthorized Request
var response = await authController.Login(userForLogin);
//Assert: expect an Unauthorized response
Assert.IsInstanceOf <Microsoft.AspNetCore.Mvc.UnauthorizedResult>(response);
}
public void Auth_should_return_userinfo_when_user_exist()
{
// arrange
var authController = new AuthController(_hashHelper.Object, _userRepository.Object, _authenticationService.Object);
var authRequest = new AuthRequest();
authRequest.UserName = "******";
authRequest.Password = "******";
var hashedPassword = Guid.NewGuid().ToString();
_hashHelper.Setup(x => x.Hash(authRequest.Password)).Returns(hashedPassword);
_userRepository.Setup(x => x.GetUserInfo(authRequest.UserName, hashedPassword)).Returns(new UserInfo());
// act
IActionResult result = authController.Auth(authRequest);
// assert
((OkObjectResult)result).StatusCode.Should().Be(HttpStatusCode.OK.GetHashCode());
_userRepository.Verify(x => x.GetUserInfo(authRequest.UserName, hashedPassword), Times.Once);
}
public async Task SignUp_ReturnConflictObjectResult_WhenUsernameIsTaken()
{
//Arrange
var userSignUpResource = new UserSignUpResource();
var expectedErrorMessage = "Username has already been taken";
_mockService.Setup(service => service.FindUserByEmail(It.IsAny <string>()))
.ReturnsAsync((User)null);
_mockService.Setup(service => service.FindUserByUsername(It.IsAny <string>()))
.ReturnsAsync(new User());
var controller = new AuthController(_mapper, _mockService.Object);
//Act
var actionResult = await controller.SignUp(userSignUpResource);
var objectResult = actionResult as ConflictObjectResult;
var errorMessage = objectResult.Value;
//Assert
Assert.IsType <ConflictObjectResult>(actionResult);
Assert.Equal(expectedErrorMessage, errorMessage);
}
public async void ShouldNotResetPasswordIfUserNotFound()
{
string email = "test";
var repo = new Mock <IRepository <User> >();
User user = null;
repo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <User, bool> > >())).Returns(Task.FromResult(user));
var configuration = new Mock <IConfiguration>();
var authService = new AuthService(repo.Object, configuration.Object);
var authController = new AuthController(authService, configuration.Object);
var result = await authController.ResetPassword(email);
var badRequest = Assert.IsType <BadRequestObjectResult>(result);
var errorResult = Assert.IsAssignableFrom <ResultDto <BaseDto> >(badRequest.Value);
string error = "Nie znaleziono wybranego u¿ytkownika";
Assert.Contains(error, errorResult.Error);
}
public void SetUp()
{
_userRegisterRequest = new UserRegisterRequest
{
Email = "*****@*****.**",
FullName = "Test User",
Password = "******"
};
_userLoginRequest = new UserLoginRequest
{
Email = "*****@*****.**",
Password = "******"
};
_service = new Mock <IAuthService>();
_jwtTokenService = new Mock <IJwtTokenService>();
_jwtTokenService
.Setup(j => j.GenerateToken(new UserLoginResponse()))
.Returns(() => "jwt.token.example");
_authController = new AuthController(_service.Object, _jwtTokenService.Object);
}
protected void delProductType(object sender, EventArgs e)
{
int id = Int32.Parse(productTypeId.Value);
Boolean productType = AuthController.checkProductType(id);
Boolean product = AuthController.checkProductTypeOnProduct(id);
if (productType && !product)
{
CrudController.removeProductType(id);
viewProductType.DataSource = CrudController.getProductType();
viewProductType.DataBind();
errorMsg.Text = "";
errorMsg.Style.Add("visibility", "hidden");
}
else
{
errorMsg.Text = "Gagal delete";
errorMsg.Style.Add("visibility", "visible");
}
}
public void Get_Access_Token_Valid_But_Wrong_User()
{
var controller = new AuthController(_dbCtx);
var creds = new LoginCredentials()
{
Username = "******",
Password = "******"
};
var result = controller.LoginUser(creds) as ObjectResult;
var token = ((AuthResponse)result.Value).ResponseToken;
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers[_config.authHeader] = $"Bearer {token}";
var controllerContext = new ControllerContext()
{
HttpContext = httpContext
};
var canvasController = new CanvasAccessTokenController(_dbCtx);
canvasController.ControllerContext = controllerContext;
var tokenToGet = _dbCtx.PersonalAccessTokens.Where(x => x.TokenName.Equals("FirstToken")).FirstOrDefault();
var response = canvasController.GetUserAccessTokenById(tokenToGet.Id);
var objResult = response as ObjectResult;
var objValue = (ObjectResponse <CanvasPersonalAccessToken>)objResult.Value;
var tokenRetreived = objValue.Value;
var outcome = tokenRetreived == null;
Assert.True(outcome);
}
public async Task ShouldResponse400_WhenConflictEmail()
{
var userRepoMock = new Mock <IUserRepository>();
var controller = new AuthController(AutoMapperConfig.Instance, null, userRepoMock.Object);
userRepoMock.Setup(x =>
x.IsExistEmail(It.IsAny <string>()))
.Returns(true);
var model = new RegisterRequest
{
Name = "test",
Email = "*****@*****.**",
Password = "******"
};
var result = await controller.Register(model);
var response = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(ErrorResponse.EmailConflict, response.Value);
}
public async Task AuthenticateUser_without_cookie_consent_returns_message()
{
//Arrange
var controller = new AuthController(_bosAuthClient, _bosIAClient, _bosEmailClient, _configuration)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
}
};
AuthModel authModel = new AuthModel();
//Act
var result = await controller.AuthenticateUser(authModel);
//Assert
var viewResult = Assert.IsType <ViewResult>(result); //Asserting that the return is a View
Assert.Equal("Index", viewResult.ViewName); //Asseting that the returned Controller is "Home"
Assert.True(controller.ViewData.ModelState.Count == 1);
}
public async Task TestExternalLoginCallBackRemoteErrorNotNull()
{
//Arrange
var(mockAuthService, mockUserService, mockMapper, mockStringLocalizer, AuthController) = CreateAuthController();
mockAuthService
.Setup(s => s.GetAuthSchemesAsync())
.Returns(Task.FromResult <IEnumerable <AuthenticationScheme> >(GetTestAuthenticationSchemes()));
mockStringLocalizer
.Setup(s => s["Error-ExternalLoginProvider"])
.Returns(GetTestError());
//Act
var result = await AuthController.ExternalLoginCallBack(GetTestReturnUrl(), GetTestRemoteError());
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <LoginViewModel>(viewResult.ViewData.Model);
Assert.Equal(GetTestLoginViewModel().ReturnUrl, model.ReturnUrl);
Assert.NotNull(viewResult);
}
public async Task AuthenticateUser_without_cookie_consent_returns_message()
{
//Arrange
var controller = new AuthController(_configuration, _contextAccessor, multitenantService)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
}
};
AuthModel authModel = new AuthModel();
//Act
var result = await controller.AuthenticateUser(authModel);
//Assert
var viewResult = Assert.IsType <ViewResult>(result); //Asserting that the return is a View
Assert.Equal("Index", viewResult.ViewName); //Asserting that the returned Controller is "Index"
Assert.True(controller.ViewData.ModelState.Count == 1); //Asserts that there is a ModelStateError object
}
public void HasSessionExpired_returns_true_when_session_not_found()
{
//Arrange
var controller = new AuthController(_configuration, _contextAccessor, multitenantService)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
Session = null
}
}
};
//Act
var result = controller.HasSessionExpired();
//Assert
var viewResult = Assert.IsType <bool>(result);
Assert.True(viewResult);
}
public UserDialogView(User u)
{
InitializeComponent();
if (u == null)
{
Close();
}
else
{
if (u.Login == "Admin")
{
Login.IsReadOnly = true;
RestrictionCheck.IsEnabled = false;
BlockCheck.IsEnabled = false;
Delete.Visibility = Visibility.Hidden;
}
selectedUser = AuthController.LoadByLogin(u.Login);
Login.Text = selectedUser.Login;
RestrictionCheck.IsChecked = selectedUser.isRestricted;
BlockCheck.IsChecked = selectedUser.isBlocked;
}
}
public async Task Register_Successful_ResponseStatusCode201(string email, string password)
{
Mock <IAuthRepository> mockIAuthRepository = new Mock <IAuthRepository>();
Mock <IOptions <ApplicationSettings> > mockIOptions_ApllicationSettings = new Mock <IOptions <ApplicationSettings> >();
var customerToRegister = new CustomerToRegister()
{
Email = email,
Password = password
};
// Set up default return from repo
mockIAuthRepository.Setup(repo => repo.UserExists(It.IsAny <String>()))
.Returns(Task.FromResult(false)); // false -> email not existed in system -> user able to register
mockIAuthRepository.Setup(repo => repo.Register(It.IsAny <CustomerToRegister>()))
.ReturnsAsync(new Customer()); // return new user when register successfully
var authController = new AuthController(mockIAuthRepository.Object, mockIOptions_ApllicationSettings.Object);
// Get a status code reponse back from call register method in auth controller
var statusCode = await authController.Register(customerToRegister);
// Expect 201
Assert.IsInstanceOf <Microsoft.AspNetCore.Mvc.StatusCodeResult>(statusCode);
}
public void IndexTest()
{
var UserName = Utils.NewGuidString();
string Token = Utils.NewGuidString();
string ResultToken = string.Empty;
using (HttpSimulator simulator = new HttpSimulator())
{
simulator.SimulateRequest(new Uri("http://localhost:8080"));
HttpContext.Current.ApplicationInstance = new HttpApplication();
Utils.Users = new ConcurrentDictionary <string, UserData>();
Utils.Users.TryAdd(UserName, new UserData {
Token = Token
});
var principal = new GenericPrincipal(new GenericIdentity(UserName), null);
Thread.CurrentPrincipal = principal;
HttpContext.Current.User = principal;
var result = new AuthController().Index() as OkNegotiatedContentResult <AuthSuccessResult>;
ResultToken = result.Content.access_token;
}
Assert.IsTrue(ResultToken == Token);
}
public void Register_Successful()
{
// Arrange
User user = new User {
UserEmail = "*****@*****.**",
Password = "******",
FirstName = "X",
LastName = "Unit",
};
var expectedValue = "successfull";
authServiceMoq.Setup(c => c.RegisterUser(user, out expectedValue)).Returns(It.IsAny <IEnumerable <InviteUsers> >());
// Act
var controller = new AuthController(authServiceMoq.Object, logger.Object, mailService.Object);
var response = controller.RegisterUser(user) as OkObjectResult;
// Assert
Assert.IsType <OkObjectResult>(response);
Assert.Equal(200, response.StatusCode);
authServiceMoq.Verify(c => c.RegisterUser(user, out expectedValue), Times.Once);
}
public async Task GivenAValidUser_WhenIRegisterANewUserWithExistingName_ThenItReturnsbadRequest()
{
_mockAuthRepository = new Mock <IAuthRepository>();
_mockAuthMapper = new Mock <IMapper>();
_mockConfig = new Mock <IConfiguration>();
_mockAuthMapper.Setup(mapper => mapper.Map <TblUser>(It.IsAny <UserForRegisterDto>()))
.Returns(new TblUser());
_mockAuthMapper.Setup(mapper => mapper.Map <UserForDetailedDto>(It.IsAny <TblUser>()))
.Returns(new UserForDetailedDto());
_mockAuthRepository.Setup(r => r.UserExists(It.IsAny <string>())).ReturnsAsync(true);
_authController = new AuthController(_mockAuthRepository.Object, _mockConfig.Object, _mockAuthMapper.Object);
var tblUser = await _authController.Register(new UserForRegisterDto
{
Aname = "John",
AUsername = "******",
AEmail = "*****@*****.**",
Password = "******",
ADob = new DateTime(2000, 12, 12)
});
Assert.IsInstanceOf <BadRequestObjectResult>(tblUser);
}
public async Task SignIn_ReturnBadRequestObjectResult_WhenPasswordIsIncorrect()
{
//Arrange
var userSignInResource = new UserSignInResource();
var expectedValue = "Email or password is incorrect";
_mockService.Setup(service => service.FindUserByEmail(It.IsAny <string>()))
.ReturnsAsync(new User());
_mockService.Setup(service => service.IsUserPasswordCorrect(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(false);
var controller = new AuthController(_mapper, _mockService.Object);
//Act
var actionResult = await controller.SignIn(userSignInResource);
var objectResult = actionResult as BadRequestObjectResult;
var value = objectResult.Value;
//Assert
Assert.IsType <BadRequestObjectResult>(actionResult);
Assert.Equal(expectedValue, value);
}
public async Task ResendEmailForRegistering_Invalid_FindByIdAsyncReturnsNull_Test()
{
// Arrange
var(_,
_,
_,
_,
_,
AuthController) = CreateAuthController();
string userId = "userId";
// Act
var expected = StatusCodes.Status400BadRequest;
var result = await AuthController.ResendEmailForRegistering(userId);
var actual = (result as BadRequestResult).StatusCode;
// Assert
Assert.IsInstanceOf <BadRequestResult>(result);
Assert.AreEqual(expected, actual);
Assert.NotNull(result);
}
public async Task ForcePasswordChange_returns_error_string_when_userid_is_invalid()
{
//Arrange
var controller = new AuthController(_configuration, _contextAccessor, multitenantService);
dynamic passwordInfo = new ExpandoObject();
StringConversion stringConversion = new StringConversion();
string userId = stringConversion.EncryptString(Guid.NewGuid().ToString());
passwordInfo.userId = userId;
passwordInfo.password = "******";
JObject data = JObject.FromObject(passwordInfo);
//Act
var result = await controller.ForcePasswordChange(data);
//Assert
var errorMessage = Assert.IsType <string>(result); //Asserting that the return is a string
Assert.Contains("Something went wrong.", errorMessage.ToString()); //Asserting that the returned message matches to the one mentioned
}
private void btnRegister_Click(object sender, EventArgs e)
{
string errors = ValidateInputs();
if (errors != "")
{
MessageBox.Show(errors, "Sorry", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
User user = GetInputs();
if (AuthController.Register(user))
{
MessageBox.Show("Registration completed!.", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Close();
}
else
{
MessageBox.Show("Registration failed!.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void CreateToken_Throws()
{
// Arrange
IdentityModelEventSource.ShowPII = true;
var options = Substitute.For <IOptions <TokenData> >();
options.Value.Returns <TokenData>(new TokenData
{
Web = "Web",
Mobile = "Mobile",
Key = "ToShort",
Issuer = "Issuer",
Audience = "Audience"
});
var logger = Substitute.For <ILogger <AuthController> >();
var model = new CredentialModel
{
UserAgent = "Web"
};
using (var target = new AuthController(logger, options))
{
// Act
var result = target.CreateToken(model);
// Assert
// Just test that the error was logged
logger.Received().Log(
LogLevel.Error,
Arg.Any <EventId>(),
Arg.Any <object>(),
null,
Arg.Any <Func <object, Exception, string> >());
Assert.IsType <BadRequestResult>(result);
}
}
public async Task LoginUser_ShouldLogingTheUser(CommandResult <UserLoginResponse> commandResultExpected)
{
//Arrange
var request = new UserLoginView();
request.Email = "*****@*****.**";
request.Password = "******";
_mediatorHandler.Setup(s => s.SendCommand <UserLoginCommand, UserLoginResponse>(It.IsAny <UserLoginCommand>())).ReturnsAsync(commandResultExpected);
_sut = new AuthController(_mediatorHandler.Object);
//Act
var response = await _sut.Login(request);
var result = new CommandResultObjectMap <UserLoginResponse>(response);
//Assert
result.ErrorCode.Should().Be(200);
result.CommandResult.Should().NotBeNull();
result.CommandResult.Should().BeEquivalentTo(commandResultExpected.Payload);
}
public void HasSessionExpired_returns_true_when_session_not_found()
{
//Arrange
var controller = new AuthController(_bosAuthClient, _bosIAClient, _bosEmailClient, _configuration)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
Session = null
}
}
};
//Act
var result = controller.HasSessionExpired();
//Assert
var viewResult = Assert.IsType <bool>(result);
Assert.True(viewResult);
}
public void HasSessionExpired_throws_expection_when_session_is_null()
{
//Arrange
//Mocking a session
MockHttpSession mockSession = new MockHttpSession();
mockSession["Key"] = "KeySession";
var controller = new AuthController(_bosAuthClient, _bosIAClient, _bosEmailClient, _configuration)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
Session = mockSession
}
}
};
//Act and Assert
Assert.Throws <KeyNotFoundException>(() => controller.HasSessionExpired()); //Asserting that the expection thrown is KeyNotFound
}
public async Task ForcePasswordChange_returns_error_message_when_password_is_null()
{
//Arrange
var controller = new AuthController(_bosAuthClient, _bosIAClient, _bosEmailClient, _configuration);
dynamic passwordInfo = new ExpandoObject();
StringConversion stringConversion = new StringConversion();
string userId = stringConversion.EncryptString(Guid.NewGuid().ToString());
passwordInfo.userId = userId;
passwordInfo.password = null;
JObject data = JObject.FromObject(passwordInfo);
//Act
var result = await controller.ForcePasswordChange(data);
//Assert
var errorMessage = Assert.IsType <string>(result); //Asserting that the return is a string
Assert.Contains("Something went wrong", errorMessage.ToString()); //Asserting that the returned message matches to the one mentioned
}
public async Task AuthenticateUser_null_authobj_returns_index_view_with_modelstate_error()
{
//Arrange
var controller = new AuthController(_configuration, _contextAccessor, null)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
}
};
controller.ControllerContext.HttpContext.Request.Headers.Add("Cookie", new CookieHeaderValue(".AspNet.Consent", "true").ToString());
AuthModel authModel = null;
//Act
var result = await controller.AuthenticateUser(authModel);
//Assert
Assert.Equal("RedirectToActionResult", result.GetType().Name);
Assert.True(controller.ViewData.ModelState.Count == 0); //Asserting that there is a ModelError object
}
public async Task TestLoginPostReturnsViewPasswordInCorrect()
{
//Arrange
var(mockAuthService, mockUserService, mockMapper, mockStringLocalizer, AuthController) = CreateAuthController();
mockAuthService
.Setup(s => s.GetAuthSchemesAsync())
.Returns(Task.FromResult <IEnumerable <AuthenticationScheme> >(GetTestAuthenticationSchemes()));
mockMapper
.Setup(m => m.Map <LoginDto>(It.IsAny <LoginViewModel>()))
.Returns(GetTestLoginDto());
mockAuthService
.Setup(s => s.FindByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(GetTestUserDtoWithAllFields());
mockAuthService
.Setup(s => s.IsEmailConfirmedAsync(It.IsAny <UserDTO>()))
.ReturnsAsync(true);
mockAuthService
.Setup(s => s.SignInAsync(It.IsAny <LoginDto>()))
.ReturnsAsync(Microsoft.AspNetCore.Identity.SignInResult.Failed);
mockStringLocalizer
.Setup(s => s["Login-InCorrectPassword"])
.Returns(GetTestError());
//Act
var result = await AuthController.Login(GetTestLoginViewModel(), GetTestReturnUrl());
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <LoginViewModel>(viewResult.ViewData.Model);
Assert.Equal(GetTestLoginViewModel().ReturnUrl, model.ReturnUrl);
Assert.NotNull(viewResult);
}
public AuthControllerTests()
{
// (MockBehavior.Strict)
_recipeRepoMock = new Mock <IRecipeRepository>();
_configMock = new Mock <IConfiguration>();
_mockEmailService = new Mock <IEmailService>();
var userStoreMock = new Mock <IUserStore <User> >();
_mockUserManager = new Mock <FakeUserManager>();
_mockSignInManager = new Mock <FakeSignInManager>();
var contextAccessor = new Mock <IHttpContextAccessor>();
var userPrincipalFactory = new Mock <IUserClaimsPrincipalFactory <User> >();
var mockMapper = new MapperConfiguration(cfg => { cfg.AddProfile(new AutoMapperProfiles()); });
var mapper = mockMapper.CreateMapper();
_configMock.Setup(x => x.GetSection("AppSettings:Token").Value).Returns("some random value");
_authController = new AuthController(_recipeRepoMock.Object, _configMock.Object, mapper, _mockUserManager.Object, _mockSignInManager.Object, _mockEmailService.Object);
// Mock claim types
_userClaims = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "josh"),
new Claim(ClaimTypes.NameIdentifier, "2"),
}, "mock"));
_authController.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = _userClaims
}
};
}
public void Login_ValidUser_ReturnToken()
{
var authServiceMock = new Mock <IAuthService>();
Guid userId = Guid.NewGuid();
var userToLogin = new UserForLoginDto {
Username = "******", Password = "******"
};
var user = new UserResponseDto()
{
Username = userToLogin.Username, Id = userId
};
var tokenToReturn = "D4569KRTeKj_kqdAVrAiPbpRloAfE1fqp0eVAJ-IChQcV-kv3gW-gBAzWztBEdGGY";
var loginResponseDto = new LoginResponseDto()
{
token = tokenToReturn, user = user
};
authServiceMock.Setup(u => u.Login(userToLogin.Username, userToLogin.Password)).Returns(loginResponseDto);
var controller = new AuthController(authServiceMock.Object);
var result = controller.Login(userToLogin);
var statusCode = ((OkObjectResult)result).StatusCode;
var jsonValue = JsonConvert.SerializeObject(((OkObjectResult)result).Value);
var dictionary = JsonConvert.DeserializeObject <Dictionary <object, object> >(jsonValue);
Assert.True(statusCode == 200);
Assert.Equal("D4569KRTeKj_kqdAVrAiPbpRloAfE1fqp0eVAJ-IChQcV-kv3gW-gBAzWztBEdGGY", dictionary["token"]);
authServiceMock.VerifyAll();
}
public NominateHandler(ElectroController electroController, AuthController authController, string prefix)
: base(authController, prefix)
{
this.electroController = electroController;
}
public LoginHandler(AuthController authController, string prefix)
: base(prefix)
{
this.authController = authController;
}
protected AuthorizedBaseHandler(AuthController authController, string prefix)
: base(prefix)
{
this.authController = authController;
}
public void Setup()
{
Users = Builder<User>.CreateListOfSize(50)
.WhereAll()
.Have(u => u.Password = u.Password.ConvertToHash())
.And(u => u.Role = Role.Member)
.And(u => u.Email = String.Format("{0}@domain.com", u.Email))
.WhereTheFirst(5)
.Have(u => u.Role = Role.Admin)
.WhereTheLast(5)
.Have(u => u.Role = Role.Guest)
.Build();
DataRepository = MockRepository.GenerateStub<IDataRepository<User>>();
AuthService = MockRepository.GenerateStub<IAuthService>();
Sut = new AuthController(DataRepository, AuthService);
}
public RegisterHandler(AuthController authController, string prefix)
: base(prefix)
{
this.authController = authController;
}
public StartElectionHandler(ElectroController electroController, AuthController authController, string prefix)
: base(authController, prefix)
{
this.electroController = electroController;
}
