public void Authenticate_WithCorrectInput_ReturnsOk()
{
IMicroserviceSettings microserviceSettings = new MicroserviceSettings
{
JwtIssuer = $"{Guid.NewGuid()}",
JwtKey = $"{Guid.NewGuid()}"
};
var dto = new ApiCredentialsDto
{
ApiKey = $"{Guid.NewGuid()}",
ApiSecret = $"{Guid.NewGuid()}"
};
var controller = new AuthenticateController(microserviceSettings);
var actionResult = controller.Authenticate(dto);
Assert.NotNull(actionResult);
var okObjectResult = Assert.IsAssignableFrom <OkObjectResult>(actionResult);
var response = Assert.IsAssignableFrom <AuthenticateResponseDto>(okObjectResult?.Value);
Assert.NotNull(response);
Assert.NotNull(response.Token);
}
public async Task Post_WithValidCredentials_ShouldReturnOk()
{
var expectedToken = "Test_Token";
var key = new Key {
JWT = "Test_JWT_Parent_Key"
};
var mockService = new Mock <IStudentService>();
mockService.Setup(service => service.AuthenticateBasicAsync(It.IsAny <string>()))
.ReturnsAsync(new Student())
.Verifiable();
mockService.Setup(service => service.GenerateToken(It.IsAny <Student>(), It.IsAny <string>()))
.Returns(expectedToken)
.Verifiable();
var mockMapper = new Mock <IMapper>();
mockMapper.Setup(mapper => mapper.Map <UserDto>(It.IsAny <Student>()))
.Returns(new UserDto())
.Verifiable();
var controller = new AuthenticateController(mockService.Object, mockMapper.Object, key);
var response = await controller.Post();
var responseResult = Assert.IsType <OkObjectResult>(response.Result);
var model = Assert.IsAssignableFrom <AuthorizeDto>(responseResult.Value);
Assert.Equal(expectedToken, model.Token);
mockService.Verify();
mockMapper.Verify();
}
public UnitTest1(IServiceProvider provider, UserManager <User> userManager, RoleManager <IdentityRole> roleManager, IConfiguration configuration)
{
_repo = new PersonManagement(provider);
_service = new PersonService(_repo);
_authController = new AuthenticateController(userManager, roleManager, configuration);
_personController = new PeopleController(_service);
}
public void SetUp()
{
_authenticateBusinessMock = new Mock <IAuthenticateBusiness>();
_mapperMock = new Mock <IMapper>();
_controller = new AuthenticateController(_authenticateBusinessMock.Object, _mapperMock.Object);
}
public void Setup()
{
userName = "******";
password = "******";
email = "*****@*****.**";
mockAuthenticateService = new MockAuthenticateService();
mockUserManagementService = new MockUserManagementService();
mockUserManagementInvalidUserNameService = new MockUserManagementService();
mockUserManagementInvalidPasswordService = new MockUserManagementService();
tokenRequest = new TokenRequest()
{
UserName = userName,
Password = password
};
sut = new AuthenticateController(
mockAuthenticateService.AuthenticateServiceSuccessfulRequest.Object,
mockUserManagementService.UserManagementServiceSuccssfulRequest.Object);
sutInvalid = new AuthenticateController(
mockAuthenticateService.AuthenticateServiceFailedRequest.Object,
mockUserManagementService.UserManagementServiceFailedRequest.Object);
sutInvalidUserName = new AuthenticateController(
mockAuthenticateService.AuthenticateServiceFailedRequest.Object,
mockUserManagementInvalidUserNameService.UserManagementServiceUserNameFailedRequest.Object);
sutInvalidPassword = new AuthenticateController(
mockAuthenticateService.AuthenticateServiceFailedRequest.Object,
mockUserManagementInvalidPasswordService.UserManagementServicePasswordFailedRequest.Object);
sutUserNameNotFound = new AuthenticateController(
mockAuthenticateService.AuthenticateServiceFailedRequest.Object,
mockUserManagementService.UserManagementServiceFailedRequest.Object);
}
public async Task RegisterCrossVerifingEmailToCreateUser()
{
var store = new Mock <IUserStore <AppUser> >();
var _mockUserMgr = new Mock <UserManager <AppUser> >(store.Object, null, null, null, null, null, null, null, null);
var appUser = new AppUser {
Email = "*****@*****.**"
};
var registrationDTO = new RegistrationDTO {
Email = "*****@*****.**", Password = "******"
};
//Set up findByEmail
_mockUserMgr.Setup(userMgr => userMgr.FindByEmailAsync(null))
.Returns(Task.FromResult <AppUser>(null));
//Set up create and assert user enterered email is same as set in AppUser obj
_mockUserMgr.Setup(userMgr => userMgr.CreateAsync(appUser, It.IsAny <string>()))
.Returns(Task.FromResult(It.IsAny <IdentityResult>()))
.Callback(() => Assert.AreEqual(appUser.Email, registrationDTO.Email));
var authenticateController = new AuthenticateController(_mockUserMgr.Object, null);
//Called Register method
var result = await authenticateController.Register(registrationDTO);
// if result is null or not succedded
var badResult = result as BadRequestObjectResult;
Assert.AreEqual(Convert.ToString(badResult.StatusCode), "400");
}
public async Task Post_WithoutException_ReturnToken()
{
var mocks = GetMocks();
RoleDataUtil roleDataUtil = new RoleDataUtil();
AccountDataUtil accountDataUtil = new AccountDataUtil();
var roleModel = roleDataUtil.GetNewData();
var accountModel = accountDataUtil.GetNewData();
accountModel.AccountRoles.Add(new AccountRole()
{
Role = roleModel,
RoleUId = "RoleUId",
UId = "UId"
});
mocks.Secret.Setup(s => s.SecretString).Returns("secretsecretsecret");
mocks.Service.Setup(s => s.Authenticate(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(accountModel);
var roleVM = roleDataUtil.GetNewViewModel();
var accountVM = accountDataUtil.GetNewViewModel();
accountVM.roles.Add(roleVM);
mocks.Mapper.Setup(s => s.Map <AccountViewModel>(It.IsAny <Account>())).Returns(accountVM);
AuthenticateController controller = GetController(mocks);
var result = await controller.Post(new LoginViewModel()
{
Password = "******",
Username = "******"
});
Assert.Equal((int)HttpStatusCode.OK, GetStatusCode(result));
}
public void GetAuthTokenSuccessTest()
{
// Arrange
AuthenticateUserResource resource = new AuthenticateUserResource();
User user = new User();
mapper.Map <AuthenticateUserResource, User>(Arg.Any <AuthenticateUserResource>()).Returns(user);
IAuthenticateService authenticateService = Substitute.For <IAuthenticateService>();
string token;
authenticateService.IsAuthenticated(user, out token)
.Returns(x => {
x[1] = "token";
return(true);
});
AuthenticateController controller = new AuthenticateController(authenticateService, mapper);
// Act
IActionResult result = controller.GetAuthToken(resource);
// Assert
result.Should().BeOfType <OkObjectResult>();
OkObjectResult okResult = result as OkObjectResult;
okResult.Value.Should().Be("token");
}
public Resources()
{
MockApiCaller = new MockApiCaller();
MockCookieHelper = new MockCookieHelper();
MockUserAgentHelper = new MockUserAgentHelper();
Controller = new AuthenticateController(MockApiCaller, MockCookieHelper, MockUserAgentHelper);
}
public void Initialize()
{
httpContext = new MockHttpContextWrapper();
controllerToTest = new AuthenticateController();
controllerToTest.ControllerContext = new ControllerContext(httpContext.Context.Object, new RouteData(), controllerToTest);
dbContext = new DAL.SchoolContext(this.ConnectionString);
controllerToTest.DbContext = dbContext;
}
public void TestAuthenticateUserValid()
{
var controller = new AuthenticateController(_repository);
var result = controller.Get("*****@*****.**", "pwd1") as OkNegotiatedContentResult <Boolean>;
Assert.IsNotNull(result);
Assert.IsTrue(result.Content);
}
public void name()
{
AuthenticateController DC = new AuthenticateController();
//Act
string result = DC.logon2("sivaravula", "Bahubali");
//Assert
Assert.AreEqual(result, result);
}
public void Init_BeforeTest()
{
controllerToTest = new AuthenticateController();
IDatabaseInitializer <SchoolContext> db = new DropCreateDatabaseAlways <SchoolContext>();
Database.SetInitializer(db);
db.InitializeDatabase(new SchoolContext());
}
public void ShouldReturnFalse4()
{
var controller = new AuthenticateController();
var user = new Users()
{
UserEmail = "*****@*****.**"
};
var result = controller.Authenticate(user);
Assert.AreEqual(false, result);
}
public void ShouldReturnFalse3()
{
var controller = new AuthenticateController();
var user = new Users()
{
UserPassword = "******"
};
var result = controller.Authenticate(user);
Assert.AreEqual(false, result);
}
public void ShouldReturnTrue1()
{
var controller = new AuthenticateController();
var user = new Users()
{
UserEmail = "*****@*****.**", UserPassword = "******"
};
var result = controller.Authenticate(user);
Assert.AreEqual(true, result);
}
public void SetUp()
{
_fakeCreateUserRequestUseCase = new Mock <ICreateUserRequestUseCase>();
_fakeConfirmUserUseCase = new Mock <IConfirmUserUseCase>();
_fakeAuthenticateUseCase = new Mock <IAuthenticateUseCase>();
_fakeGetUserUseCase = new Mock <IGetUserUseCase>();
_classUnderTest = new AuthenticateController(_fakeAuthenticateUseCase.Object,
_fakeCreateUserRequestUseCase.Object,
_fakeConfirmUserUseCase.Object,
_fakeGetUserUseCase.Object);
}
public Resources()
{
Configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
MemoryCache = new MemoryCache(new MemoryCacheOptions());
SecurityHelper = new Mock <ISecurityHelper>();
CommunicationsHelper = new Mock <ICommunicationsHelper>();
Context = TestHelper.CreateDbContext(Configuration);
Controller = new AuthenticateController(Context, MemoryCache, Configuration, SecurityHelper.Object, CommunicationsHelper.Object);
}
public void LoggInn_Feil_Validering()
{
//Arrange
var controller = new AuthenticateController();
var innBruker = new LogInn();
controller.ModelState.AddModelError("Brukernavn", "Brukernavn må oppgis");
//Act
var result = controller.Post(innBruker);
//Assert
Assert.AreEqual(HttpStatusCode.NotFound, result.StatusCode);
}
public void Authenticate_WithIncorrectInput_ReturnsBadRequest()
{
IMicroserviceSettings microserviceSettings = new MicroserviceSettings
{
JwtIssuer = $"{Guid.NewGuid()}",
JwtKey = $"{Guid.NewGuid()}"
};
var controller = new AuthenticateController(microserviceSettings);
var actionResult = controller.Authenticate(null);
Assert.NotNull(actionResult);
Assert.IsAssignableFrom <BadRequestResult>(actionResult);
}
public async Task Post_WithoutException_ReturnNotFound()
{
var mocks = GetMocks();
mocks.Service.Setup(s => s.Authenticate(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(default(Account));
AuthenticateController controller = GetController(mocks);
var result = await controller.Post(new LoginViewModel()
{
Password = "******",
Username = "******"
});
Assert.Equal((int)HttpStatusCode.NotFound, GetStatusCode(result));
}
public async Task Post_WithException_ReturnBadRequest()
{
var mocks = GetMocks();
mocks.Service.Setup(s => s.Authenticate(It.IsAny <string>(), It.IsAny <string>())).ThrowsAsync(new Exception("error"));
AuthenticateController controller = GetController(mocks);
var result = await controller.Post(new LoginViewModel()
{
Password = "******",
Username = "******"
});
Assert.Equal((int)HttpStatusCode.BadRequest, GetStatusCode(result));
}
public async Task RegisterForExistingUserReturnsConflict()
{
var store = new Mock <IUserStore <AppUser> >();
var _mockUserMgr = new Mock <UserManager <AppUser> >(store.Object, null, null, null, null, null, null, null, null);
_mockUserMgr.Setup(userMgr => userMgr.FindByEmailAsync(It.IsAny <string>()))
.Returns(Task.FromResult(new AppUser()));
var authenticateController = new AuthenticateController(_mockUserMgr.Object, null);
var result = await authenticateController.Register(new RegistrationDTO());
var conflitResult = result as ConflictObjectResult;
Assert.AreEqual(Convert.ToString(conflitResult.StatusCode), "409");
}
public void Should_Call_Authenticate_With_Post_And_Receive_Ok_False()
{
var authenticationParameters = new AuthenticationParameters()
{
Email = "*****@*****.**",
Password = "******"
};
var controller = new AuthenticateController(credentialsRepository);
IHttpActionResult actionResult = controller.Authenticate(authenticationParameters);
var contentResult = actionResult as OkNegotiatedContentResult <bool>;
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(false, contentResult.Content);
}
public void ShouldNotAuthenticateWhenUserIsInvalid()
{
var invalidLogin = _authFixture.getInvalidUserLogin();
var authService = new Mock <IAuthenticationService>();
authService
.Setup(auth => auth.AuthenticateBy(invalidLogin.Email, invalidLogin.Password))
.Returns((AuthenticatedUser)null);
var tokenService = new Mock <ITokenService>();
var expectedStatusCode = (int)HttpStatusCode.BadRequest;
var authController = new AuthenticateController(authService.Object, tokenService.Object);
var response = authController.Authenticate(invalidLogin);
response.As <BadRequestObjectResult>().StatusCode.Should().Be(expectedStatusCode);
}
private void button1_Click(object sender, EventArgs e)
{
string username = usernameTB.Text.Trim();
string password = passwordTB.Text.Trim();
string role = comboBox.Text.ToString().Trim();
if (username.Length == 0 || password.Length == 0)
{
MessageBox.Show("Fill all the required field", "Message", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (role.ToLower().Equals("admin") || role.ToLower().Equals("managers") || role.ToLower().Equals("salesman"))
{
var result = AuthenticateController.AuthController(username, password, role);
if (result == null)
{
MessageBox.Show("Invalid Credentials", "Message", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
Author.Name = result.Name;
Author.Username = result.Username;
Author.Role = role;
if (role.ToLower().Equals("admin"))
{
this.Hide();
new AdminDashboard().Show();
}
else if (role.ToLower().Equals("salesman"))
{
this.Hide();
new SalesmanDashboard().Show();
}
else if (role.ToLower().Equals("managers"))
{
this.Hide();
new ManagerDashboard().Show();
}
}
else
{
MessageBox.Show("Choose a Valid Role", "Message", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private void ShouldAuthenticateValidUser()
{
var userLogin = _authFixture.getValidUserLogin();
var authenticatedUser = _authFixture.getAuthenticatedUser();
var authService = new Mock <IAuthenticationService>();
authService
.Setup(auth => auth.AuthenticateBy(userLogin.Email, userLogin.Password))
.Returns(authenticatedUser);
var tokenService = new Mock <ITokenService>();
var expectedStatusCode = (int)HttpStatusCode.OK;
var authController = new AuthenticateController(authService.Object, tokenService.Object);
var response = authController.Authenticate(userLogin);
var result = response.As <OkObjectResult>();
result.StatusCode.Should().Be(expectedStatusCode);
}
public void Authenticate_WithMissingApiKey_ReturnsUnauthorized()
{
IMicroserviceSettings microserviceSettings = new MicroserviceSettings
{
JwtIssuer = $"{Guid.NewGuid()}",
JwtKey = $"{Guid.NewGuid()}"
};
var dto = new ApiCredentialsDto
{
ApiKey = string.Empty,
ApiSecret = $"{Guid.NewGuid()}"
};
var controller = new AuthenticateController(microserviceSettings);
var actionResult = controller.Authenticate(dto);
Assert.NotNull(actionResult);
Assert.IsAssignableFrom <UnauthorizedResult>(actionResult);
}
public void GetAuthTokenFailureTest()
{
// Arrange
AuthenticateUserResource resource = new AuthenticateUserResource();
User user = new User();
mapper.Map <AuthenticateUserResource, User>(Arg.Any <AuthenticateUserResource>()).Returns(user);
IAuthenticateService authenticateService = Substitute.For <IAuthenticateService>();
string token;
authenticateService.IsAuthenticated(user, out token).Returns(false);
AuthenticateController controller = new AuthenticateController(authenticateService, mapper);
// Act
IActionResult result = controller.GetAuthToken(resource);
// Assert
result.Should().BeOfType <BadRequestObjectResult>();
BadRequestObjectResult badRequestResult = result as BadRequestObjectResult;
badRequestResult.Value.Should().Be("Invalid authentication request.");
}
public void Post_Logginn_NOT_Found_I_DB()
{
LogInn bruker = new LogInn();
bruker.Brukernavn = "*****@*****.**";
bruker.Passord = "passord123";
var commandBus = new Mock <IBrukerLogikk>();
commandBus.Setup(c => c.BrukerIdb(bruker)).Returns(true);
// Mapper.CreateMap<CategoryFormModel, CreateOrUpdateCategoryCommand>();
var httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"],
new HttpRouteValueDictionary {
{ "controller", "Authenticate" }
});
var controller = new AuthenticateController(commandBus.Object)
{
Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/Authenticate/")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
LogInn nyBruker = new LogInn();
nyBruker.Brukernavn = "*****@*****.**";
nyBruker.Passord = "yolo1231";
var response = controller.Post(nyBruker);
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
// Act
}
