public async Task Activate_User_Should_Activate_User() { var idUserTest = _jimmyUser.Id; User myUserDesactivated = null; using (var context = new DaOAuthContext(_dbContextOptions)) { myUserDesactivated = context.Users.FirstOrDefault(u => u.Id.Equals(idUserTest)); myUserDesactivated.IsValid = false; context.Update(myUserDesactivated); context.Commit(); } Assert.IsNotNull(myUserDesactivated); Assert.IsFalse(myUserDesactivated.IsValid); var activateOrDesactivateUserDto = new ActivateOrDesactivateUserDto() { UserName = _jimmyUser.UserName }; var httpResponseMessage = await _client.PutAsJsonAsync("users/activate", activateOrDesactivateUserDto); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); User myUserActivated = null; using (var context = new DaOAuthContext(_dbContextOptions)) { myUserActivated = context.Users.FirstOrDefault(u => u.Id.Equals(idUserTest)); } Assert.IsNotNull(myUserActivated); Assert.IsTrue(myUserActivated.IsValid); }
private static void CompareUserDtoAndDbUser(UserDto myUser, User dbUser) { Assert.IsNotNull(myUser); Assert.AreEqual(dbUser.BirthDate, myUser.BirthDate); Assert.AreEqual(dbUser.CreationDate, myUser.CreationDate); Assert.AreEqual(dbUser.EMail, myUser.EMail); Assert.AreEqual(dbUser.FullName, myUser.FullName); Assert.AreEqual(dbUser.UserName, myUser.UserName); IList <Role> sammysRoles = null; using (var context = new DaOAuthContext(_dbContextOptions)) { sammysRoles = context.UsersRoles .Where(u => u.UserId.Equals(dbUser.Id)) .Select(u => u.Role) .ToList(); } Assert.IsNotNull(sammysRoles); Assert.IsTrue(sammysRoles.Count() > 0); Assert.AreEqual(sammysRoles.Count(), myUser.Roles.Count()); foreach (var fromDbRole in sammysRoles) { Assert.IsTrue(myUser.Roles.Any(r => r.Equals(fromDbRole.Wording))); } }
public async Task Change_Password_Should_Change_Password_For_Logged_User() { var newPassword = "******"; var changePasswordDto = new ChangePasswordDto() { NewPassword = newPassword, NewPasswordRepeat = newPassword, OldPassword = _sammyPassword }; var httpResponseMessage = await _client.PutAsJsonAsync("users/password", changePasswordDto); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); var encryptionService = new EncryptionService(); var encodedNewPassword = encryptionService.Sha256Hash( String.Concat(GuiApiTestStartup.Configuration.PasswordSalt, newPassword)); User myUser = null; using (var context = new DaOAuthContext(_dbContextOptions)) { myUser = context.Users.FirstOrDefault(u => u.UserName.Equals(GuiApiTestStartup.LoggedUserName)); } Assert.IsNotNull(myUser); Assert.IsTrue(encodedNewPassword.SequenceEqual(myUser.Password)); }
protected void CleanDataBase() { using (var context = new DaOAuthContext(_dbContextOptions)) { context.Database.EnsureDeleted(); } }
public async Task Put_Should_Update_Return_Url() { ClientReturnUrl toUpdateReturnUrl = null; using (var context = new DaOAuthContext(_dbContextOptions)) { toUpdateReturnUrl = context.ClientReturnUrls.Where(c => c.ClientId.Equals(_sammyClient.Id)).FirstOrDefault(); } Assert.IsNotNull(toUpdateReturnUrl); var toUpdateReturnUrlDto = new UpdateReturnUrlDto() { IdReturnUrl = toUpdateReturnUrl.Id, ReturnUrl = "http://updated.return.url" }; var httpResponseMessage = await _client.PutAsJsonAsync("returnUrl", toUpdateReturnUrlDto); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); ClientReturnUrl updatedReturnUrl = null; using (var context = new DaOAuthContext(_dbContextOptions)) { updatedReturnUrl = context.ClientReturnUrls.Where(c => c.Id.Equals(toUpdateReturnUrl.Id)).SingleOrDefault(); } Assert.IsNotNull(updatedReturnUrl); Assert.AreNotEqual(toUpdateReturnUrl.ReturnUrl, updatedReturnUrl.ReturnUrl); Assert.AreEqual(toUpdateReturnUrlDto.ReturnUrl, updatedReturnUrl.ReturnUrl); }
public async Task Get_Should_Return_All_Ressources_Servers() { var totalRessourcesServers = 0; IList <Scope> scopesFromDbs = null; using (var context = new DaOAuthContext(_dbContextOptions)) { totalRessourcesServers = context.RessourceServers.Count(); scopesFromDbs = context.Scopes.Where(s => s.RessourceServerId.Equals(_validRessourceServer.Id)).ToList(); } Assert.IsNotNull(scopesFromDbs); var httpResponseMessage = await _client.GetAsync("ressourcesServers?skip=0&limit=50"); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); var ressourcesServers = JsonConvert.DeserializeObject <SearchResult <RessourceServerDto> >( await httpResponseMessage.Content.ReadAsStringAsync()); Assert.AreEqual(ressourcesServers.Count, totalRessourcesServers); Assert.IsTrue(ressourcesServers.Count > 0); Assert.AreEqual(ressourcesServers.Datas.Count(), totalRessourcesServers); var validRessourceServer = ressourcesServers.Datas.Where(rs => rs.Id.Equals(_validRessourceServer.Id)).SingleOrDefault(); CompareRessouceServerAndRessourceServerDto(scopesFromDbs, _validRessourceServer, validRessourceServer); }
public void Add_Should_Add_Entity() { var actualClientCount = 0; using (var context = new DaOAuthContext(_dbContextOptions)) { actualClientCount = context.Clients.Count(); var clientRepository = _repoFactory.GetClientRepository(context); clientRepository.Add(new Client() { ClientSecret = "6", ClientTypeId = 1, CreationDate = DateTime.Now, Description = "Test 2", IsValid = true, Name = "testeur2", PublicId = "test" }); context.Commit(); } // Use a separate instance of the context to verify correct datas were saved to database using (var context = new DaOAuthContext(_dbContextOptions)) { Assert.AreEqual(actualClientCount + 1, context.Clients.Count()); } }
public async Task Get_Administration_Should_Return_All_Users() { var totalUsers = 0; using (var context = new DaOAuthContext(_dbContextOptions)) { totalUsers = context.Users.Count(); } var httpResponseMessage = await _client.GetAsync("administration?skip=0&limit=50"); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); var users = JsonConvert.DeserializeObject <SearchResult <AdminUsrDto> >( await httpResponseMessage.Content.ReadAsStringAsync()); Assert.AreEqual(users.Count, totalUsers); Assert.IsTrue(users.Count > 0); Assert.AreEqual(users.Datas.Count(), totalUsers); var sammy = users.Datas.Where(u => u.Id.Equals(_sammyUser.Id)).FirstOrDefault(); Assert.IsNotNull(sammy); Assert.AreEqual(sammy.Email, _sammyUser.EMail); Assert.AreEqual(sammy.Id, _sammyUser.Id); Assert.AreEqual(sammy.IsValid, _sammyUser.IsValid); Assert.AreEqual(sammy.UserName, _sammyUser.UserName); }
public async Task Get_All_Should_Return_All_Users_Clients() { IList <UserClient> usersClientsFromDb = null; using (var context = new DaOAuthContext(_dbContextOptions)) { usersClientsFromDb = context.UsersClients.Where(uc => uc.UserId.Equals(_sammyUser.Id)).ToList(); } Assert.IsNotNull(usersClientsFromDb); Assert.IsTrue(usersClientsFromDb.Any()); var httpResponseMessage = await _client.GetAsync("usersClients?skip=0&limit=50"); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); var usersClients = JsonConvert.DeserializeObject <SearchResult <UserClientListDto> >( await httpResponseMessage.Content.ReadAsStringAsync()); Assert.AreEqual(usersClients.Count, usersClientsFromDb.Count()); Assert.IsTrue(usersClients.Count > 0); Assert.AreEqual(usersClients.Datas.Count(), usersClientsFromDb.Count()); foreach (var userClientFromDb in usersClientsFromDb) { var myUserClient = usersClients.Datas.Where(uc => uc.Id.Equals(userClientFromDb.Id)).FirstOrDefault(); Assert.IsNotNull(myUserClient); Assert.AreEqual(userClientFromDb.Id, myUserClient.Id); Assert.AreEqual(userClientFromDb.ClientId, myUserClient.ClientId); Client clientFromDb = null; using (var context = new DaOAuthContext(_dbContextOptions)) { clientFromDb = context.Clients.SingleOrDefault(c => c.Id.Equals(myUserClient.ClientId)); } Assert.IsNotNull(clientFromDb); Assert.AreEqual(clientFromDb.Name, myUserClient.ClientName); Assert.AreEqual(clientFromDb.PublicId, myUserClient.ClientPublicId); ClientType clientTypeFromDb = null; using (var context = new DaOAuthContext(_dbContextOptions)) { clientTypeFromDb = context.ClientsTypes.SingleOrDefault(c => c.Id.Equals(clientFromDb.ClientTypeId)); } Assert.IsNotNull(clientTypeFromDb); Assert.AreEqual(clientTypeFromDb.Wording, myUserClient.ClientType); IList <ClientReturnUrl> returnsUrlsFromDb = null; using (var context = new DaOAuthContext(_dbContextOptions)) { returnsUrlsFromDb = context.ClientReturnUrls.Where(c => c.ClientId.Equals(clientFromDb.Id)).ToList(); } Assert.IsNotNull(returnsUrlsFromDb); Assert.IsTrue(returnsUrlsFromDb.Where(ru => ru.ReturnUrl.Equals(myUserClient.DefaultReturnUri)).Any()); Assert.AreEqual(userClientFromDb.IsActif, myUserClient.IsActif); Assert.IsTrue(myUserClient.IsCreator); } }
public async Task Post_Should_Create_Return_Url() { var toCreateReturnUrl = new CreateReturnUrlDto() { ClientPublicId = _sammyClient.PublicId, ReturnUrl = "http://back.to.test" }; var httpResponseMessage = await _client.PostAsJsonAsync("returnUrl", toCreateReturnUrl); Assert.AreEqual(HttpStatusCode.Created, httpResponseMessage.StatusCode); Assert.IsTrue(httpResponseMessage.Headers.Contains("location")); var location = httpResponseMessage.Headers.GetValues("location").Single(); Assert.IsTrue(location.Length > 0); var returnUrlId = Int32.Parse(location.Split('/', StringSplitOptions.RemoveEmptyEntries).Last()); ClientReturnUrl myReturnUrl = null; Client myClient = null; using (var context = new DaOAuthContext(_dbContextOptions)) { myReturnUrl = context.ClientReturnUrls.Where(c => c.Id.Equals(returnUrlId)).SingleOrDefault(); myClient = context.Clients.Where(c => c.PublicId.Equals(toCreateReturnUrl.ClientPublicId)).SingleOrDefault(); } Assert.IsNotNull(myReturnUrl); Assert.IsNotNull(myClient); Assert.AreEqual(toCreateReturnUrl.ClientPublicId, myClient.PublicId); Assert.AreEqual(toCreateReturnUrl.ReturnUrl, myReturnUrl.ReturnUrl); }
public async Task Post_Should_Add_User_Client() { var createUserClientDto = new CreateUserClientDto() { ClientPublicId = _jimmyClient.PublicId, IsActif = true }; var httpResponseMessage = await _client.PostAsJsonAsync("usersClients", createUserClientDto); Assert.AreEqual(HttpStatusCode.Created, httpResponseMessage.StatusCode); Assert.IsTrue(httpResponseMessage.Headers.Contains("location")); var location = httpResponseMessage.Headers.GetValues("location").Single(); Assert.IsTrue(location.Length > 0); var userClientId = Int32.Parse(location.Split('/', StringSplitOptions.RemoveEmptyEntries).Last()); using (var context = new DaOAuthContext(_dbContextOptions)) { var myCreatedUserClient = context.UsersClients.SingleOrDefault(uc => uc.Id.Equals(userClientId)); Assert.IsNotNull(myCreatedUserClient); Assert.AreEqual(myCreatedUserClient.ClientId, _jimmyClient.Id); } }
public async Task Put_Should_Update_User_Client() { UserClient userClientToUpdate; using (var context = new DaOAuthContext(_dbContextOptions)) { userClientToUpdate = context.UsersClients.Include(uc => uc.Client).FirstOrDefault(uc => uc.IsActif && uc.User.UserName.Equals(GuiApiTestStartup.LoggedUserName)); Assert.IsNotNull(userClientToUpdate); } var updateUserClientDto = new UpdateUserClientDto() { ClientPublicId = userClientToUpdate.Client.PublicId, IsActif = false, UserName = GuiApiTestStartup.LoggedUserName }; var httpResponseMessage = await _client.PutAsJsonAsync("usersClients", updateUserClientDto); Assert.AreEqual(204, (int)httpResponseMessage.StatusCode); using (var context = new DaOAuthContext(_dbContextOptions)) { var userClientFromDb = context.UsersClients.SingleOrDefault(uc => uc.IsActif.Equals(false) && uc.Client.PublicId.Equals(userClientToUpdate.Client.PublicId) && uc.User.UserName.Equals(GuiApiTestStartup.LoggedUserName)); Assert.IsNotNull(userClientFromDb); } }
private static async Task CheckResponseContentIsValid(HttpResponseMessage httpResponseMessage, bool checkRefreshToken = true) { var jsonResult = new { access_token = "", token_type = "", expires_in = 0, refresh_token = "", scope = "" }; var myTokenInfos = JsonConvert.DeserializeAnonymousType(await httpResponseMessage.Content.ReadAsStringAsync(), jsonResult); Assert.IsNotNull(myTokenInfos); Assert.AreEqual(_sammyScopeWording, myTokenInfos.scope); CheckTokenValid(myTokenInfos.access_token, OAuthConvention.AccessToken); Assert.AreEqual(OAuthApiTestStartup.Configuration.AccesTokenLifeTimeInSeconds, myTokenInfos.expires_in); if (checkRefreshToken) { CheckTokenValid(myTokenInfos.refresh_token, OAuthConvention.RefreshToken); string refreshTokenFromDb; using (var context = new DaOAuthContext(_dbContextOptions)) { var userClient = context.UsersClients.Where(uc => uc.Id.Equals(_sammyUserClientIdConfidential)).FirstOrDefault(); Assert.IsNotNull(userClient); refreshTokenFromDb = userClient.RefreshToken; } Assert.AreEqual(refreshTokenFromDb, myTokenInfos.refresh_token); } }
public async Task Get_By_Id_Should_Return_Client() { var httpResponseMessage = await _client.GetAsync($"clients/{_sammyClient.Id}"); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); var myClient = JsonConvert.DeserializeObject <ClientDto>(await httpResponseMessage.Content.ReadAsStringAsync()); Assert.IsNotNull(myClient); Client clientFromDb = null; ClientType clientType = null; IList <ClientReturnUrl> clientReturnUrls = null; IList <ClientScope> clientScopes = null; using (var context = new DaOAuthContext(_dbContextOptions)) { clientFromDb = context.Clients.Where(c => c.Id.Equals(_sammyClient.Id)).SingleOrDefault(); clientType = context.ClientsTypes.Where(ct => ct.Id.Equals(_sammyClient.ClientTypeId)).SingleOrDefault(); clientReturnUrls = context.ClientReturnUrls.Where(c => c.ClientId.Equals(_sammyClient.Id)).ToList(); clientScopes = context.ClientsScopes.Where(c => c.ClientId.Equals(_sammyClient.Id)).ToList(); } Assert.IsNotNull(clientType); Assert.IsNotNull(clientFromDb); Assert.IsNotNull(clientReturnUrls); Assert.IsNotNull(clientScopes); Assert.AreEqual(clientFromDb.CreationDate, myClient.CreationDate); Assert.AreEqual(clientType.Wording, myClient.ClientType); Assert.AreEqual(clientFromDb.Name, myClient.Name); Assert.AreEqual(clientFromDb.PublicId, myClient.PublicId); Assert.AreEqual(clientFromDb.Description, myClient.Description); Assert.AreEqual(clientFromDb.ClientSecret, myClient.ClientSecret); Assert.IsTrue(myClient.ReturnUrls.Count() > 0); Assert.AreEqual(clientReturnUrls.Count(), myClient.ReturnUrls.Count()); foreach (var ru in clientReturnUrls) { Assert.IsTrue(myClient.ReturnUrls.ContainsKey(ru.Id)); Assert.IsTrue(myClient.ReturnUrls[ru.Id].Equals(ru.ReturnUrl)); } Assert.IsTrue(myClient.Scopes.Count() > 0); Assert.AreEqual(clientScopes.Count(), myClient.Scopes.Count()); foreach (var cs in clientScopes) { Scope scopeFromDb = null; using (var context = new DaOAuthContext(_dbContextOptions)) { scopeFromDb = context.Scopes.Where(s => s.Id.Equals(cs.ScopeId)).FirstOrDefault(); } Assert.IsNotNull(scopeFromDb); var scope = myClient.Scopes.Where(s => s.Id.Equals(cs.ScopeId)).SingleOrDefault(); Assert.IsNotNull(scope); Assert.AreEqual(scopeFromDb.NiceWording, scope.NiceWording); Assert.AreEqual(scopeFromDb.Wording, scope.Wording); Assert.AreEqual(scopeFromDb.Id, scope.Id); } }
public async Task Put_Should_Update_User() { User toUpdateUser = null; using (var context = new DaOAuthContext(_dbContextOptions)) { toUpdateUser = context.Users.Where(c => c.Id.Equals(_sammyUser.Id)).FirstOrDefault(); } Assert.IsNotNull(toUpdateUser); var updateUserDto = new UpdateUserDto() { BirthDate = new DateTime(1978, 09, 16), EMail = "*****@*****.**", FullName = "New Name" }; var httpResponseMessage = await _client.PutAsJsonAsync("users", updateUserDto); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); User updatedUser = null; using (var context = new DaOAuthContext(_dbContextOptions)) { updatedUser = context.Users.Where(c => c.Id.Equals(_sammyUser.Id)).FirstOrDefault(); } Assert.IsNotNull(updatedUser); Assert.AreEqual(updateUserDto.BirthDate, updatedUser.BirthDate); Assert.AreEqual(updateUserDto.EMail, updatedUser.EMail); Assert.AreEqual(updateUserDto.FullName, updatedUser.FullName); }
public async Task Post_Should_Create_Client() { var toCreateClient = new CreateClientDto() { ClientType = _confidentialClientType.Wording, Description = "a new client for logged user !", Name = "logged user's client", ReturnUrls = new List <string>() { "http://return.com" }, ScopesIds = new List <int>() { _scope1.Id, _scope2.Id } }; var httpResponseMessage = await _client.PostAsJsonAsync("clients", toCreateClient); Assert.AreEqual(HttpStatusCode.Created, httpResponseMessage.StatusCode); Assert.IsTrue(httpResponseMessage.Headers.Contains("location")); var location = httpResponseMessage.Headers.GetValues("location").Single(); Assert.IsTrue(location.Length > 0); var clientId = Int32.Parse(location.Split('/', StringSplitOptions.RemoveEmptyEntries).Last()); Client myNewClient = null; ClientReturnUrl myClientReturnUrl = null; IList <ClientScope> myClientScopes = null; using (var context = new DaOAuthContext(_dbContextOptions)) { myNewClient = context.Clients.Where(c => c.Id.Equals(clientId)).SingleOrDefault(); myClientReturnUrl = context.ClientReturnUrls.Where(c => c.ClientId.Equals(clientId)).SingleOrDefault(); myClientScopes = context.ClientsScopes.Where(c => c.ClientId.Equals(clientId)).ToList(); } Assert.IsNotNull(myNewClient); Assert.AreEqual(toCreateClient.Description, myNewClient.Description); Assert.AreEqual(toCreateClient.Name, myNewClient.Name); Assert.IsTrue(myNewClient.IsValid); Assert.IsTrue(myNewClient.PublicId.Length > 0); Assert.IsTrue(myNewClient.ClientSecret.Length > 0); Assert.AreEqual(DateTime.Now.Date, myNewClient.CreationDate.Date); Assert.IsNotNull(myClientReturnUrl); Assert.AreEqual(toCreateClient.ReturnUrls.First(), myClientReturnUrl.ReturnUrl); Assert.IsNotNull(myClientScopes); Assert.IsTrue(toCreateClient.ScopesIds.Count() > 0); Assert.AreEqual(toCreateClient.ScopesIds.Count(), myClientScopes.Count()); foreach (var scopeId in toCreateClient.ScopesIds) { Assert.IsTrue(myClientScopes.Select(cs => cs.ScopeId).Contains(scopeId)); } }
public async Task Post_Should_Create_User() { var userName = "******"; var password = "******"; var encryptionService = new EncryptionService(); var hashPassword = encryptionService.Sha256Hash($"{GuiApiTestStartup.Configuration.PasswordSalt}{password}"); SendEmailDto mailSentInfos = null; _fakeMailService.SendMailCalled += delegate(object sender, SendEmailDto e) { mailSentInfos = e; }; var createUserDto = new CreateUserDto() { BirthDate = DateTime.Now.AddYears(-41), EMail = "*****@*****.**", FullName = "johnny lecrabe", Password = password, RepeatPassword = password, UserName = userName }; var httpResponseMessage = await _client.PostAsJsonAsync("users", createUserDto); Assert.AreEqual(HttpStatusCode.Created, httpResponseMessage.StatusCode); Assert.IsNotNull(mailSentInfos); Assert.IsNotNull(mailSentInfos.Receviers.FirstOrDefault()); Assert.AreEqual(createUserDto.EMail, mailSentInfos.Receviers.First().Key); User userFromDb = null; using (var context = new DaOAuthContext(_dbContextOptions)) { userFromDb = context.Users.FirstOrDefault(u => u.UserName.Equals(userName)); } Assert.IsNotNull(userFromDb); Assert.AreEqual(createUserDto.BirthDate, userFromDb.BirthDate); Assert.AreEqual(createUserDto.EMail, userFromDb.EMail); Assert.AreEqual(DateTime.Now.Date, userFromDb.CreationDate.Date); Assert.AreEqual(createUserDto.FullName, userFromDb.FullName); Assert.IsTrue(hashPassword.SequenceEqual <byte>(userFromDb.Password)); Assert.IsFalse(userFromDb.IsValid); IList <UserRole> userRolesFromDb = null; using (var context = new DaOAuthContext(_dbContextOptions)) { userRolesFromDb = context.UsersRoles.Where(ur => ur.UserId.Equals(userFromDb.Id)).ToList(); } Assert.IsNotNull(userRolesFromDb); Assert.IsTrue(userRolesFromDb.Count() > 0); Assert.IsNotNull(userRolesFromDb.FirstOrDefault(ur => ur.Id.Equals((int)ERole.USER))); Assert.IsNull(userRolesFromDb.FirstOrDefault(ur => ur.Id.Equals((int)ERole.ADMIN))); }
public async Task Token_For_Grant_Type_Refresh_Token_Should_Return_Valid_Token() { var jwtService = new JwtService() { Configuration = OAuthApiTestStartup.Configuration, Logger = new FakeLogger(), RepositoriesFactory = null, StringLocalizerFactory = new FakeStringLocalizerFactory() }; var jwtTokenDto = jwtService.GenerateToken(new CreateTokenDto() { ClientPublicId = _sammyClientPublicIdConfidential, Scope = _sammyScopeWording, SecondsLifeTime = OAuthApiTestStartup.Configuration.RefreshTokenLifeTimeInSeconds, TokenName = OAuthConvention.RefreshToken, UserName = _sammyUserName }); using (var context = new DaOAuthContext(_dbContextOptions)) { var userClient = context.UsersClients. FirstOrDefault(uc => uc.User.UserName.Equals(_sammyUserName) && uc.Client.PublicId.Equals(_sammyClientPublicIdConfidential)); Assert.IsNotNull(userClient); userClient.RefreshToken = jwtTokenDto.Token; context.Update(userClient); context.Commit(); } var formContent = BuildFormContent( _sammyClientPublicIdConfidential, String.Empty, OAuthConvention.GrantTypeRefreshToken, jwtTokenDto.Token, String.Empty, _sammyReturnUrlConfidential, _sammyScopeWording, _sammyUserName); _client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); _client.DefaultRequestHeaders.Authorization = BuildAuthenticationHeaderValue(_sammyClientPublicIdConfidential, _sammyClientSecretConfidential); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/token"); request.Content = formContent; var httpResponseMessage = await _client.SendAsync(request); Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode); await CheckResponseContentIsValid(httpResponseMessage); }
public void Get_By_Public_Id_Should_Return_Client() { using (var context = new DaOAuthContext(_dbContextOptions)) { var clientRepository = _repoFactory.GetClientRepository(context); var client = clientRepository.GetByPublicId(_clientConfidential1.PublicId); Assert.IsNotNull(client); } }
public void Get_User_Client_By_Corrects_UserName_And_Client_Public_Id_Should_Return_User_Client() { using (var context = new DaOAuthContext(_dbContextOptions)) { var userClientRepository = _repoFactory.GetUserClientRepository(context); var userClient = userClientRepository.GetUserClientByClientPublicIdAndUserName(_clientConfidential1.PublicId, _user1.UserName); Assert.IsNotNull(userClient); } }
public void Get_User_Client_By_Incorrects_UserName_And_Client_Public_Id_Should_Return_Null() { using (var context = new DaOAuthContext(_dbContextOptions)) { var userClientRepository = _repoFactory.GetUserClientRepository(context); var userClient = userClientRepository.GetUserClientByClientPublicIdAndUserName(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()); Assert.IsNull(userClient); } }
public void Get_By_Existing_Email_Should_Return_User() { using (var context = new DaOAuthContext(_dbContextOptions)) { var userRepository = _repoFactory.GetUserRepository(context); var user = userRepository.GetByEmail(_user1.EMail); Assert.IsNotNull(user); } }
public void Get_By_Non_Existing_Login_Should_Return_Null() { using (var context = new DaOAuthContext(_dbContextOptions)) { var ressourceServerRepository = _repoFactory.GetRessourceServerRepository(context); var ressourceServer = ressourceServerRepository.GetByLogin(Guid.NewGuid().ToString()); Assert.IsNull(ressourceServer); } }
public void Get_All_By_Criterias_Count_Should_Return_0_With_Unknow_Ressource_Server() { using (var context = new DaOAuthContext(_dbContextOptions)) { var ressourceServerRepository = _repoFactory.GetRessourceServerRepository(context); var ressourceServerCount = ressourceServerRepository.GetAllByCriteriasCount(null, Guid.NewGuid().ToString(), true); Assert.AreEqual(0, ressourceServerCount); } }
public void Get_By_Non_Existing_Email_Should_Return_Null() { using (var context = new DaOAuthContext(_dbContextOptions)) { var userRepository = _repoFactory.GetUserRepository(context); var user = userRepository.GetByUserName($"{Guid.NewGuid().ToString()}@rab.com"); Assert.IsNull(user); } }
public void Get_By_Id_Should_Return_Return_Url_With_Client() { using (var context = new DaOAuthContext(_dbContextOptions)) { var ruRepo = _repoFactory.GetClientReturnUrlRepository(context); var returnUrl = ruRepo.GetById(_clientReturnUrl1ForClient1.Id); Assert.IsNotNull(returnUrl); Assert.IsNotNull(returnUrl.Client); } }
public void Get_By_Code_Should_Return_Code() { using (var context = new DaOAuthContext(_dbContextOptions)) { var codeRepo = _repoFactory.GetCodeRepository(context); var c = codeRepo.GetByCode(_code1.CodeValue); Assert.IsNotNull(c); } }
public void Get_By_Wording_Should_Return_Scope() { using (var context = new DaOAuthContext(_dbContextOptions)) { var scopeRepository = _repoFactory.GetScopeRepository(context); var scope = scopeRepository.GetByWording(_scope2.Wording); Assert.IsNotNull(scope); } }
public void Get_All_Should_Return_All_Entities() { using (var context = new DaOAuthContext(_dbContextOptions)) { var clientRepository = _repoFactory.GetClientRepository(context); var clients = clientRepository.GetAll(); Assert.IsNotNull(clients); Assert.IsTrue(clients.Count() > 0); Assert.AreEqual(context.Clients.Count(), clients.Count()); } }
public void Get_By_Existing_UserName_With_Different_Case_Should_Return_User() { using (var context = new DaOAuthContext(_dbContextOptions)) { var userRepository = _repoFactory.GetUserRepository(context); var user = userRepository.GetByUserName(_user1.UserName.ToUpper()); Assert.IsNotNull(user); Assert.AreNotEqual(_user1.UserName, _user1.UserName.ToUpper()); } }