public void UnknownUser()
{
// Arrange
IEnumerable <User> users = new[]
{
new User {
Id = 1, FirstName = "User1", LastName = "User1", Email = "*****@*****.**", IsActive = true
},
new User {
Id = 2, FirstName = "User2", LastName = "User2", Email = "*****@*****.**", IsActive = true
},
new User {
Id = 3, FirstName = "User3", LastName = "User3", Email = "*****@*****.**", IsActive = true
}
};
ApplicationDbContext dbContext = new Mock <ApplicationDbContext>("Test")
.SetupDbContextData(x => x.Users, users)
.Build();
// Act
UserByEmailQuery query = new UserByEmailQuery(dbContext);
User result = query.Execute("*****@*****.**");
// Assert
Assert.IsNull(result);
}
public void ExistingUser()
{
// Arrange
IEnumerable<User> users = new[]
{
new User {Id = 1, FirstName = "User1", LastName = "User1", Email = "*****@*****.**", IsActive = true},
new User {Id = 2, FirstName = "User2", LastName = "User2", Email = "*****@*****.**", IsActive = true},
new User {Id = 3, FirstName = "User3", LastName = "User3", Email = "*****@*****.**", IsActive = true}
};
ApplicationDbContext dbContext = new Mock<ApplicationDbContext>("Test")
.SetupDbContextData(x => x.Users, users)
.Build();
// Act
User userToSearch = users.Skip(1).First();
UserByEmailQuery query = new UserByEmailQuery(dbContext);
User result = query.Execute(userToSearch.Email);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(userToSearch.Id, result.Id);
Assert.AreEqual(userToSearch.FirstName, result.FirstName);
Assert.AreEqual(userToSearch.LastName, result.LastName);
Assert.AreEqual(userToSearch.Email, result.Email);
Assert.AreEqual(userToSearch.IsActive, result.IsActive);
}
public UserProcesses(UserByCredentialsQuery userCredentialsQuery,
UserByEmailQuery userEmailQuery,
IValidator <EditUserDetailsParams> editUserDetailsValidator,
IUnitOfWork unitOfWork)
{
_userCredentialsQuery = userCredentialsQuery;
_editUserDetailsValidator = editUserDetailsValidator;
_unitOfWork = unitOfWork;
_userEmailQuery = userEmailQuery;
}
public async Task <ActionResult <UserDetailView> > Get(string email)
{
UserByEmailQuery query = new UserByEmailQuery()
{
EmailAddress = email
};
UserDetailView result = await mediator.Send(query, CancellationToken.None);
return(result ?? (ActionResult <UserDetailView>)NotFound());
}
public void Execute_Returns_Null_User_When_No_User_Found()
{
// Setup
InitializeTestEntities();
string email = "*****@*****.**";
// Act
User result = new UserByEmailQuery(_unitOfWork).WithEmail(email).Execute();
// Verify
Assert.IsNull(result, "Execute returned a non-null user");
}
public void Email_Query_Is_CaseInsensitive_And_Trimmed()
{
// Setup
InitializeTestEntities();
// Act
User result = new UserByEmailQuery(_unitOfWork).WithEmail(" [email protected] ").Execute();
// Verify
Assert.IsNotNull(result, "Query returned a null user");
Assert.AreEqual(_user2, result, "Query returned the incorrect user");
}
public void Can_Retrieve_User_By_Email()
{
// Setup
InitializeTestEntities();
// Act
User result = new UserByEmailQuery(_unitOfWork).WithEmail(_user2.Email).Execute();
// Verify
Assert.IsNotNull(result, "Query returned a null user");
Assert.AreEqual(_user2, result, "Query returned the incorrect user");
}
public void TestHandle_EntityDoesNotExist_ShouldThrowEntityNotFoundExceptionWithCorrectErrors(string email)
{
// Arrange
var command = new UserByEmailQuery {
Email = email
};
var sut = new UserByEmailQuery.Handler(Context, Mapper);
// Act
var action = new Func <Task <UserWithProfileDto> >(async() => await sut.Handle(command, CancellationToken.None));
// Assert
action.Should().Throw <EntityNotFoundException <UserProfile> >().And.Message.Should().Contain(email);
}
public async Task <RequestResult <UserResponse> > Handle(UserByEmailQuery request, CancellationToken cancellationToken)
{
try
{
var user = await _ctx.Users.FirstOrDefaultAsync(x => x.Email == request.Email);
if (user == null)
{
return(RequestResult.Error <UserResponse>());
}
var response = _mapper.Map <UserResponse>(user);
return(RequestResult.Success(response));
}
catch (Exception ex)
{
_logger.LogError("Error getting user", ex);
return(RequestResult.Error <UserResponse>());
}
}
public override MembershipUser GetUser(string email, bool userIsOnline)
{
var unitOfWork = GetUnitOfWork();
try
{
var user = new UserByEmailQuery(unitOfWork).WithEmail(email).Execute();
if (user == null)
{
return(null);
}
return(new MyJobLeadsMembershipUser(user));
}
catch (MJLUserNotFoundException)
{
return(null);
}
}
public void UnknownUser()
{
// Arrange
IEnumerable<User> users = new[]
{
new User {Id = 1, FirstName = "User1", LastName = "User1", Email = "*****@*****.**", IsActive = true},
new User {Id = 2, FirstName = "User2", LastName = "User2", Email = "*****@*****.**", IsActive = true},
new User {Id = 3, FirstName = "User3", LastName = "User3", Email = "*****@*****.**", IsActive = true}
};
ApplicationDbContext dbContext = new Mock<ApplicationDbContext>("Test")
.SetupDbContextData(x => x.Users, users)
.Build();
// Act
UserByEmailQuery query = new UserByEmailQuery(dbContext);
User result = query.Execute("*****@*****.**");
// Assert
Assert.IsNull(result);
}
public async Task TestHandle_EntityExists_ShouldReturnCorrectly(string email)
{
// Arrange
var userProfile = new UserProfile(Guid.NewGuid().ToString(), email, "username");
Context.UserProfiles.Add(userProfile);
await Context.SaveChangesAsync();
var command = new UserByEmailQuery {
Email = email
};
var sut = new UserByEmailQuery.Handler(Context, Mapper);
var expectedResult = Mapper.Map <UserWithProfileDto>(userProfile);
// Act
var actualResult = await sut.Handle(command, CancellationToken.None);
// Assert
actualResult.Should().BeEquivalentTo(expectedResult);
}
/// <summary>
/// Executes the command
/// </summary>
/// <returns>Returns the generated password for the user</returns>
/// <exception cref="MJLEntityNotFoundException">Thrown when the specified user is not found</exception>
public virtual string Execute()
{
// Retrieve the user
var user = new UserByEmailQuery(_unitOfWork).WithEmail(_email).Execute();
if (user == null)
{
throw new MJLUserNotFoundException(MJLUserNotFoundException.SearchPropertyType.Email, _email);
}
// Generate a new password for the user
string newPassword = PasswordUtils.GenerateRandomPassword();
user.Password = PasswordUtils.CreatePasswordHash(user.Email, newPassword);
_unitOfWork.Commit();
// Send out an email
EmailProvider.Send(user.Email, "Password Recovery", "Your new MyJobLeads password is: " + newPassword);
return(newPassword);
}
public void ExistingUser()
{
// Arrange
IEnumerable <User> users = new[]
{
new User {
Id = 1, FirstName = "User1", LastName = "User1", Email = "*****@*****.**", IsActive = true
},
new User {
Id = 2, FirstName = "User2", LastName = "User2", Email = "*****@*****.**", IsActive = true
},
new User {
Id = 3, FirstName = "User3", LastName = "User3", Email = "*****@*****.**", IsActive = true
}
};
ApplicationDbContext dbContext = new Mock <ApplicationDbContext>("Test")
.SetupDbContextData(x => x.Users, users)
.Build();
// Act
User userToSearch = users.Skip(1).First();
UserByEmailQuery query = new UserByEmailQuery(dbContext);
User result = query.Execute(userToSearch.Email);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(userToSearch.Id, result.Id);
Assert.AreEqual(userToSearch.FirstName, result.FirstName);
Assert.AreEqual(userToSearch.LastName, result.LastName);
Assert.AreEqual(userToSearch.Email, result.Email);
Assert.AreEqual(userToSearch.IsActive, result.IsActive);
}
public override bool ChangePassword(string email, string oldPassword, string newPassword)
{
var unitOfWork = GetUnitOfWork();
// Retrieve the user with the specified email
var user = new UserByEmailQuery(unitOfWork).WithEmail(email).Execute();
if (user == null)
{
return(false);
}
// Update the password
try
{
new EditUserCommand(unitOfWork).WithUserId(user.Id)
.WithExistingPassword(oldPassword)
.SetPassword(newPassword)
.Execute();
}
catch (MJLIncorrectPasswordException) { return(false); }
return(true);
}
