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; }