public async Task AddAgentClaim_ClaimNotAdded(string email, string key, string value)
{
// Arrange
var agent = new NARE.Domain.Entities.Agent()
{
Email = email
};
UserManager.Setup(u => u.AddClaimAsync(It.IsAny <NARE.Domain.Entities.Agent>(), It.IsAny <Claim>())).ReturnsAsync(IdentityResult.Failed());
// Act / Assert
await Assert.ThrowsAsync <ArgumentNullException>(() => Handler.Handle(new AddAgentClaimCommand(agent, key, value), CancellationToken.None));
}
public async Task NewAgent_ThrowsAccountAlreadyExistsException(string name, string email, string password)
{
// Arrange
var requestedUser = new NARE.Domain.Entities.Agent()
{
Email = email
};
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByEmailQuery>(), default(CancellationToken))).ReturnsAsync(requestedUser);
// Act / Assert
await Assert.ThrowsAsync <AccountAlreadyExistsException>(() => Handler.Handle(new NewAgentCommand(name, email, password), CancellationToken.None));
}
public void UpdateAgentInformation_AgentIsValid(string agentId)
{
// Arrange
var agent = new NARE.Domain.Entities.Agent()
{
Id = agentId
};
// Act
var result = Validator.Validate(new UpdateAgentInformationCommand(agent));
// Assert
Assert.True(result.IsValid);
}
public async Task ResetPassword_ThrowsFailedToResetPasswordException(string email, string token, string newPassword)
{
// Arrange
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Email = email
};
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByEmailQuery>(), default(CancellationToken))).ReturnsAsync(requestedAgent);
UserManager.Setup(u => u.ResetPasswordAsync(It.IsAny <NARE.Domain.Entities.Agent>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed());
// Act / Assert
await Assert.ThrowsAsync <FailedToResetPassword>(() => Handler.Handle(new ResetPasswordCommand(token, email, newPassword), CancellationToken.None));
}
public void AddAgentClaim_ValueIsValid(string key, string value)
{
// Arrange
var agent = new NARE.Domain.Entities.Agent()
{
UserName = "******",
Id = "123"
};
// Act
var result = Validator.Validate(new AddAgentClaimCommand(agent, key, value));
// Assert
Assert.True(result.IsValid);
}
public void RemoveAgentClaim_KeyIsValid(string key)
{
// Arrange
var agent = new NARE.Domain.Entities.Agent()
{
Email = "*****@*****.**",
Id = "123"
};
// Act
var result = Validator.Validate(new RemoveAgentClaimCommand(agent, key));
// Assert
Assert.True(result.IsValid);
}
public void AddAgentClaim_AgentIsValid(string agentName)
{
// Arrange
var agent = new NARE.Domain.Entities.Agent()
{
UserName = agentName,
Id = "123"
};
// Act
var result = Validator.Validate(new AddAgentClaimCommand(agent, "key", "value"));
// Assert
Assert.True(result.IsValid);
}
public async Task AddAgentClaim_ClaimAdded(string email, string key, string value)
{
// Arrange
var agent = new NARE.Domain.Entities.Agent()
{
Email = email
};
UserManager.Setup(u => u.AddClaimAsync(It.IsAny <NARE.Domain.Entities.Agent>(), It.IsAny <Claim>())).ReturnsAsync(IdentityResult.Success);
// Act
var result = await Handler.Handle(new AddAgentClaimCommand(agent, key, value), CancellationToken.None);
// Assert
Assert.True(result);
}
public void GenerateResetPasswordToken_ReturnsValidToken(string email, string token)
{
// Arrange
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Email = email
};
UserManager.Setup(u => u.GeneratePasswordResetTokenAsync(It.IsAny <NARE.Domain.Entities.Agent>())).ReturnsAsync(token);
// Act
var returnedToken = Handler.Handle(new GenerateResetPasswordTokenQuery(requestedAgent), CancellationToken.None).Result;
// Assert
Assert.Equal(returnedToken, token);
}
public void AddAgentClaim_KeyIsInvalid(string key, string value)
{
// Arrange
var agent = new NARE.Domain.Entities.Agent()
{
UserName = "******",
Id = "123"
};
// Act
var result = Validator.Validate(new AddAgentClaimCommand(agent, key, value));
// Assert
Assert.Contains("Key required", result.Errors.First().ErrorMessage);
Assert.False(result.IsValid);
}
public async Task RemoveAgentTest_RemovesSuccessfully(string agentId)
{
// Arrange
var agent = new NARE.Domain.Entities.Agent()
{
Id = agentId
};
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByIdQuery>(), default(CancellationToken))).ReturnsAsync(agent);
UserManager.Setup(u => u.DeleteAsync(It.IsAny <NARE.Domain.Entities.Agent>())).ReturnsAsync(IdentityResult.Success);
// Act
var result = await Handler.Handle(new RemoveAgentCommand(agentId), CancellationToken.None);
// Assert
Assert.True(result);
}
public void ResetPassword_ValidPasswordReset(string email, string token, string newPassword)
{
// Arrange
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Email = email
};
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByEmailQuery>(), default(CancellationToken))).ReturnsAsync(requestedAgent);
UserManager.Setup(u => u.ResetPasswordAsync(It.IsAny <NARE.Domain.Entities.Agent>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
// Act
var result = Handler.Handle(new ResetPasswordCommand(token, email, newPassword), CancellationToken.None).Result;
// Assert
Assert.True(result);
}
public void GetAgentDtoById_ReturnsExpectedAgent()
{
// Arrange
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Email = "*****@*****.**",
UserName = "******",
Id = "123"
};
// Act
var returnedAgent = Handler.Handle(new GetAgentByIdQuery(requestedAgent.Id), CancellationToken.None).Result;
// Assert
Assert.Equal(requestedAgent.Email, returnedAgent.Email);
Assert.Equal(requestedAgent.UserName, returnedAgent.UserName);
Assert.Equal(requestedAgent.Id, returnedAgent.Id);
}
public void GetAgentByEmail_ReturnsExpectedAgent(string email, string userName, string id)
{
// Arrange
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Email = email,
UserName = userName,
Id = id
};
// Act
var returnedAgent = Handler.Handle(new GetAgentByEmailQuery(requestedAgent.Email), CancellationToken.None).Result;
// Assert
Assert.Equal(requestedAgent.Email, returnedAgent.Email);
Assert.Equal(requestedAgent.UserName, returnedAgent.UserName);
Assert.Equal(requestedAgent.Id, returnedAgent.Id);
}
public async Task LoginAgent_ThrowsAccountLockedException(string email, string password)
{
// Arrange
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Email = email
};
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByEmailQuery>(), default(CancellationToken))).ReturnsAsync(requestedAgent);
SignInManager
.Setup(s => s.CheckPasswordSignInAsync(It.IsAny <NARE.Domain.Entities.Agent>(), It.IsAny <string>(), It.IsAny <bool>()))
.ReturnsAsync(SignInResult.LockedOut);
// Act / Assert
// Act / Assert
await Assert.ThrowsAsync <AccountLockedException>(() =>
Handler.Handle(new LoginAgentQuery(email, password), CancellationToken.None));
}
public async Task GetAgentById_ReturnsValidAgent(string agentId)
{
var agent = new NARE.Domain.Entities.Agent()
{
Id = agentId,
Email = "*****@*****.**"
};
// Arrange
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByIdQuery>(), default(CancellationToken))).ReturnsAsync(agent);
// Act
var result = await Handler.Handle(new GetAgentDtoByIdQuery(agentId), CancellationToken.None);
// Assert
Assert.Equal(agentId, result.Id);
Assert.Equal(agent.Email, result.Email);
}
public void GenerateResetPasswordEmail_EmailSent(string email, string token)
{
// Arrange
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Email = email
};
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByEmailQuery>(), default(CancellationToken))).ReturnsAsync(requestedAgent);
Mediator.Setup(m => m.Send(It.IsAny <GenerateResetPasswordTokenQuery>(), default(CancellationToken))).ReturnsAsync(token);
NotificationService.Setup(n => n.SendNotificationAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(true);
// Act
var result = Handler.Handle(new GenerateResetPasswordEmailQuery(email), CancellationToken.None).Result;
// Assert
Assert.Equal(token, result);
}
public async Task DisableAgent_ReturnsTrue(string agentId, string email)
{
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Id = agentId,
Email = email,
AccountEnabled = false
};
// Arrange
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByIdQuery>(), default(CancellationToken))).ReturnsAsync(requestedAgent);
Mediator.Setup(m => m.Send(It.IsAny <UpdateAgentCommand>(), default(CancellationToken))).ReturnsAsync(true);
// Act
var result = await Handler.Handle(new DisableAgentCommand(agentId), CancellationToken.None);
// Assert
Assert.True(result);
}
public void LoginAgent_ReturnsValidToken(string email, string password, string token, string id)
{
// Arrange
var requestedAgent = new NARE.Domain.Entities.Agent()
{
Id = id,
Email = email,
AccountEnabled = true
};
Mediator.Setup(m => m.Send(It.IsAny <GetAgentByEmailQuery>(), default(CancellationToken))).Returns(Task.FromResult(requestedAgent));
SignInManager
.Setup(s => s.CheckPasswordSignInAsync(It.IsAny <NARE.Domain.Entities.Agent>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(Task.FromResult(SignInResult.Success));
Mediator.Setup(m => m.Send(It.IsAny <GenerateLoginTokenQuery>(), default(CancellationToken))).Returns(Task.FromResult(token));
// Act
var returnedToken = Handler.Handle(new LoginAgentQuery(email, password), default(CancellationToken)).Result;
// Assert
Assert.Equal(token, returnedToken);
}
