public async Task AndUserDoesNotExist_NullIsReturnedAsync()
{
var loggerMock = Mock.Of <ILogger <AccountManagerService> >();
var clientFactoryMock = new Mock <IClientFactory>();
var clientMock = new Moq.Mock <ResourceAccess.ResourceAccessClient>();
var expectedResponse = new GetUserOnUserNameResponse
{
User = null
};
var fakeCall = TestCalls.AsyncUnaryCall <GetUserOnUserNameResponse>(Task.FromResult(new GetUserOnUserNameResponse()), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
clientMock.Setup(m => m.GetUserOnUserNameAsync(Moq.It.IsAny <GetUserOnUserNameRequest>(), null, null, CancellationToken.None)).Returns(fakeCall);
clientFactoryMock.Setup(c => c.AccountResourceAccessClient()).Returns(clientMock.Object);
var appConfig = Mock.Of <IOptions <AppSettings> >();
var service = new AccountManagerService(loggerMock, clientFactoryMock.Object, appConfig);
AuthenticateResponse authResponse = await service.Authenticate(new AuthenticateRequest { HashedPassword = "******", IpAddress = "123", UserName = "******" }, null);
Assert.True(string.IsNullOrEmpty(authResponse.JwtToken));
Assert.True(string.IsNullOrEmpty(authResponse.RefreshToken));
Assert.True(string.IsNullOrEmpty(authResponse.Role));
Assert.True(string.IsNullOrEmpty(authResponse.UserId));
Assert.True(string.IsNullOrEmpty(authResponse.UserName));
}
public async Task ToAuthenticateAndUserExist_TokenIsReturnedAsync()
{
var loggerMock = Mock.Of <ILogger <AccountManagerService> >();
var clientFactoryMock = new Mock <IClientFactory>();
var clientMock = new Moq.Mock <ResourceAccess.ResourceAccessClient>();
var expectedResponse = new GetUserOnUserNameResponse
{
User = new UserMessage
{
Firstname = "Firstname",
Lastname = "Lastname",
UserId = Guid.NewGuid().ToString(),
Role = "User",
UserName = "******",
}
};
var fakeCall = TestCalls.AsyncUnaryCall <GetUserOnUserNameResponse>(Task.FromResult(expectedResponse), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
clientMock.Setup(m => m.GetUserOnUserNameAsync(Moq.It.IsAny <GetUserOnUserNameRequest>(), null, null, CancellationToken.None)).Returns(fakeCall);
var expectedUpdateResponse = new UpdateUserResponse
{
User = new UserMessage
{
Firstname = "Firstname",
Lastname = "Lastname",
UserId = Guid.NewGuid().ToString(),
Role = "User",
UserName = "******"
}
};
expectedUpdateResponse.User.RefreshTokens.Add(new RefreshTokenMessage
{
CreatedByIp = "123",
Token = "123123",
});
var fakeUIpdateCall = TestCalls.AsyncUnaryCall <UpdateUserResponse>(Task.FromResult(expectedUpdateResponse), Task.FromResult(new Metadata()), () => Status.DefaultSuccess, () => new Metadata(), () => { });
clientMock.Setup(m => m.UpdateUserAsync(Moq.It.IsAny <UpdateUserRequest>(), null, null, CancellationToken.None)).Returns(fakeUIpdateCall);
clientFactoryMock.Setup(c => c.AccountResourceAccessClient()).Returns(clientMock.Object);
var testoption = Options.Create(new AppSettings {
SecretString = "secretStuff!ddddddddddddddddddddddddddddddddddddddddddddddddddddddgggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg"
});
var service = new AccountManagerService(loggerMock, clientFactoryMock.Object, testoption);
AuthenticateResponse authResponse = await service.Authenticate(new AuthenticateRequest { HashedPassword = "******", IpAddress = "123", UserName = "******" }, null);
Assert.False(string.IsNullOrEmpty(authResponse.JwtToken));
Assert.False(string.IsNullOrEmpty(authResponse.RefreshToken));
Assert.False(string.IsNullOrEmpty(authResponse.Role));
Assert.False(string.IsNullOrEmpty(authResponse.UserId));
Assert.False(string.IsNullOrEmpty(authResponse.UserName));
}
public async Task <PagedResult <UserSchema> > ListAsync(int?accountManagerId = null, bool isExternalUser = true, int page = 0, int pageSize = 0)
{
IQueryable <User> query = Context.Users;
if (accountManagerId.HasValue)
{
var accManager = AccountManagerService.GetAccountManagerById(accountManagerId.Value);
if (accManager != null)
{
var userNames = AccountManagerService.GetUserAccountManagersByAccountManager(accManager.Id)
.Select(x => x.UserIdentifier);
if (userNames != null)
{
query = query.Where(x => userNames.Contains(x.UserName));
}
}
}
else
{
if (!isExternalUser)
{
query = query.Where(x => AccountManagerService.IsInternalUser(x.UserName));
}
else
{
query = query.Where(x => !AccountManagerService.IsInternalUser(x.UserName));
}
}
var pagedResult = query.GetPaged(page, pageSize);
var listUsers = pagedResult.Results
.Select(user =>
{
var mapped = MapResult(user);
return(mapped);
})
.ToList();
PagedResult <UserSchema> result = new PagedResult <UserSchema>()
{
Results = listUsers,
PageCount = pagedResult != null ? pagedResult.PageCount : 0,
RowCount = pagedResult != null ? pagedResult.RowCount : 0,
PageSize = pagedResult != null ? pagedResult.PageSize : 0,
CurrentPage = pagedResult != null ? pagedResult.CurrentPage : 0,
FirstRowOnPage = pagedResult != null ? pagedResult.FirstRowOnPage : 0,
LastRowOnPage = pagedResult != null ? pagedResult.LastRowOnPage : 0
};
return(await Task.FromResult(result));
}
private static Task <ResultDTO> CreateControllerAndMakeChangePassword(string oldPassword, string newPassword, string confirmPassword, string userEmail)
{
var fakeContext = new FakeContext("AccountManagerServiceTests");
var fakeService = fakeContext.FakeUserManager().Object;
var controller = new AccountManagerService(fakeService);
var changePasswordDTO = new ChangePasswordDTO {
OldPassword = oldPassword, NewPassword = newPassword, ConfirmPassword = confirmPassword
};
var userExistis = fakeContext.Get <RegisterCreateDTO>().Where(x => x.Email == userEmail).FirstOrDefault();
var identity = new[] { new Claim("Name", userEmail) };
var result = controller.ChangePassword(changePasswordDTO, new ClaimsPrincipal(new ClaimsIdentity(identity)));
return(result);
}
private UserSchema MapResult(User user)
{
var userGroups = GetUserGroupsByUserIdAsync(user.Id).Result.Select(x => x.GroupId);
var accManager = AccountManagerService.GetAccountManager(user.UserName);
if (accManager == null)
{
accManager = new AccountManager();
}
var userSchema = Mapper.Map <UserSchema>(user);
userSchema.AccountManagerId = accManager.Id;
userSchema.IsExternalUser = !AccountManagerService.IsInternalUser(user.UserName);
userSchema.IsMaster = AccountManagerService.IsMaster(user.UserName);
userSchema.Groups = userGroups;
return(userSchema);
}
private void TratarUserAccountManagerAsync(bool isMaster, string formerUsername, string username, string userAction, int accountManagerId)
{
// Deletar os UserAccountManager existentes
var userAccManagers = AccountManagerService.GetUserAccountManagersByUser(formerUsername);
if (userAccManagers != null)
{
this.AccountManagerService.DeleteUserAccountManagers(userAccManagers);
}
var userAccountManager = new UserAccountManager()
{
IsMaster = isMaster,
UserIdentifier = username,
CreationDate = DateTimeOffset.Now,
CreationUser = userAction,
AccountManagerId = accountManagerId
};
this.AccountManagerService.AddUserAccountManager(userAccountManager);
}
public AccountManagerController(AccountManagerService accountManagerService)
{
_accountManagerService = accountManagerService;
}