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