public async Task Login_User_ShouldReturnToken()
{
// Arrange
var expectedUsers = new UserModel[] { new UserModel {
Username = "******", Password = "******"
} };
var mock = expectedUsers.AsQueryable().BuildMock();
Mock <IRepository <UserModel> > userRepo = new Mock <IRepository <UserModel> >();
userRepo.Setup(repo => repo.FindAll()).Returns(mock.Object);
userRepo.Setup(repo => repo.Find(It.IsAny <Expression <Func <UserModel, bool> > >()))
.Returns(mock.Object);
Mock <IOptions <JwtOptions> > config = new Mock <IOptions <JwtOptions> >();
config.Setup(x => x.Value).Returns(new JwtOptions {
Key = "testKey12312_woeifo23423",
Issuer = "http://localhost:5000"
});
var handler = new LoginCommandHandler(config.Object, userRepo.Object);
// Act
await handler.Handle(new LoginCommand {
Username = "******",
Password = "******"
}, It.IsAny <CancellationToken>());
// Assert
userRepo.Verify(x => x.Find(It.IsAny <Expression <Func <UserModel, bool> > >()), Times.Once);
}
public async Task Handle_ValidCommand_ShouldLoginSuccessfully(LoginOutput loginOutput)
{
// Arrange
_mapperMock.Setup(m => m.Map <LoginOutput>(It.IsAny <User>())).Returns(loginOutput); // AutoMapper setup
_appsettingMock.SetReturnsDefault(new AppSettings
{
Issuer = "key1",
Secret = "kesdfaaaaaasffffffffy1"
});
var sut = new LoginCommandHandler(_context, _mapperMock.Object, _appsettingMock.Object); // creating system under test
var temUser = _fixture.Create <User>();
temUser.PasswordHash = "3pRTT3NlZJrki0wrSlmOjA==";
// Act
await ContextOperation.CreateEntity(_context, temUser);
var password = SecurityHelper.Decrypt(temUser.PasswordHash);
var output = await sut.Handle(new LoginCommand { Email = temUser.Email, Password = password }, CancellationToken.None);
// Assert
Assert.True(!string.IsNullOrEmpty(output.Token));
}
public async Task SuccessfulLogin()
{
// Arrange
_command.Email = "*****@*****.**";
_command.Password = "******";
var fakeStaff = Mock.Of <Staff>();
fakeStaff.Id = 123;
fakeStaff.Name = "FakeName";
fakeStaff.Role = Role.LIBRARYASSISTANT;
_staffRepo.Setup(x => x.GetByEmail(It.IsAny <string>())).Returns(fakeStaff);
_passwordHelper.Setup(x => x.ValidatePassword(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(true);
_signInManager.Setup(x => x.SignInAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <bool>())).Returns(Task.FromResult(0));
var cacheEntry = Mock.Of <ICacheEntry>();
_memoryCache
.Setup(m => m.CreateEntry(It.IsAny <object>()))
.Returns(cacheEntry);
var sut = new LoginCommandHandler(_signInManager.Object, _passwordHelper.Object, _memoryCache.Object, _staffRepo.Object);
// Act
var result = await sut.Handle(_command, default);
// Assert
Assert.True(result);
}
public async Task Login_User_ShouldReturnBadRequestException(string exceptionMessage)
{
// Arrange
var expectedUsers = new UserModel[] { new UserModel {
Username = "******", Password = "******"
} };
var mock = expectedUsers.AsQueryable().BuildMock();
Mock <IRepository <UserModel> > userRepo = new Mock <IRepository <UserModel> >();
userRepo.Setup(repo => repo.FindAll()).Returns(mock.Object);
userRepo.Setup(repo => repo.Find(It.IsAny <Expression <Func <UserModel, bool> > >()))
.Returns(new UserModel[] { }.AsQueryable().BuildMock().Object);
Mock <IOptions <JwtOptions> > config = new Mock <IOptions <JwtOptions> >();
config.Setup(x => x.Value).Returns(new JwtOptions {
Key = "testKey12312_woeifo23423",
Issuer = "http://localhost:5000"
});
var handler = new LoginCommandHandler(config.Object, userRepo.Object);
// Act
var ex = await Assert.ThrowsAsync <BadRequestException>(() => handler.Handle(new LoginCommand {
Username = "******",
Password = "******"
}, It.IsAny <CancellationToken>()));
// Assert
ex.Message.Should().Be(string.Format(exceptionMessage, "testUsername"));
}
// Command Handling
#region Command Handling
public CommandStatus Handle(LoginCommand command)
{
ICollectionRead <Usuario> cmdData = new UsuarioData();
LoginCommandHandler cmdHandler = new LoginCommandHandler(cmdData);
return(cmdHandler.Handle(command));
}
public LoginCommandHandlerTests()
{
_refreshTokenRepositoryMock = new Mock <IRefreshTokenRepository>();
_userRepositoryMock = new Mock <IUserRepository>();
_encryptorMock = new Mock <IEncryptor>();
_emailValidatorMock = new Mock <IEmailValidator>();
_tokenServiceMock = new Mock <ITokenService>();
_handler = new LoginCommandHandler(_userRepositoryMock.Object, _encryptorMock.Object, _emailValidatorMock.Object, _tokenServiceMock.Object, _refreshTokenRepositoryMock.Object);
}
public LoginCommandHandlerTests()
{
_securityUserManager = new Mock <ISecurityUserManager>(MockBehavior.Strict);
_jwtFactory = new Mock <IJwtFactory>(MockBehavior.Strict);
_userRepo = new Mock <IUserRepository>(MockBehavior.Strict);
_sut = new LoginCommandHandler(_securityUserManager.Object, _jwtFactory.Object, _userRepo.Object);
_outputPort = new Mock <IOutputPort <LoginCommandResponse> >(MockBehavior.Strict);
}
public async Task RejectsOnNOnExistingEmail()
{
_command.Email = "*****@*****.**";
_command.Password = "******";
var sut = new LoginCommandHandler(_signInManager.Object, _passwordHelper.Object, _memoryCache.Object, _staffRepo.Object);
var result = await sut.Handle(_command, default);
Assert.False(result);
}
public async Task LoginCommandHandler_ShouldReturn_LoginCommandResult()
{
// var mockIHttpClientFactory = Substitute.For<IHttpClientFactory>();
var messageHandler = new MockHttpMessageHandler("As per our requirement we mock string!", HttpStatusCode.OK);
var httpClient = new HttpClient(messageHandler);
httpClient.BaseAddress = new Uri("https://www.google.com");
var handler = new LoginCommandHandler(httpClient);
var result = await handler.Handle(new LoginCommand(), new CancellationToken());
Assert.NotNull(result);
}
public IServiceProvider Initialize()
{
var loginCommandhandler = new LoginCommandHandler();
var positionsReader = new PositionsReader();
IServiceProvider serviceProvider = new ServiceCollection()
.AddSingleton <IValidator <LoginCommand> >(loginCommandhandler)
.AddSingleton <ICommandHandler <LoginCommand> >(loginCommandhandler)
.AddSingleton <IValidator <PositionsQuery> >(positionsReader)
.AddSingleton <IQueryHandler <PositionsQuery, PositionsList> >(positionsReader)
.BuildServiceProvider();
return(serviceProvider);
}
// Command Handling
public void In_LoginCommand(LoginCommand command)
{
try
{
ICollectionRead <Usuario> cmdData = new UsuarioData();
LoginCommandHandler cmdHandler = new LoginCommandHandler(cmdData);
Out_LoginCommandResult(cmdHandler.Handle(command));
}
catch (Exception)
{
throw;
}
}
public async Task RejectsOnWrongPassword()
{
_command.Email = "*****@*****.**";
_command.Password = "******";
_staffRepo.Setup(x => x.GetByEmail(It.IsAny <string>())).Returns(new Staff());
_passwordHelper.Setup(x => x.ValidatePassword(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(false);
var sut = new LoginCommandHandler(_signInManager.Object, _passwordHelper.Object, _memoryCache.Object, _staffRepo.Object);
var result = await sut.Handle(_command, default);
Assert.False(result);
}
public UserTest_Creation()
{
var cnnString = "mongodb://192.168.99.100:27017/TestDb";
_userRepository = new UserRepository(new AppSettings {
MongoDbCnnString = cnnString
});
_createUserCommand = new CreateUserCommandHandler(_userRepository);
_loginCommandHandler = new LoginCommandHandler(_userRepository, new LoginService(new JwtTokenGeneratorStrategy(new AppSettings {
JwtSecret = _jwtSecret
})));
var mongoUrl = new MongoUrl(cnnString);
_database = new MongoClient(mongoUrl).GetDatabase(mongoUrl.DatabaseName);
}
public override IController CreateController(RequestContext requestContext, string controllerName)
{
Type controllerType = GetControllerType(requestContext, controllerName);
var perRequestStore = PerRequestStore.Current;
if (controllerType == typeof(HomeController))
{
var movieRepository = new EfMovieViewRepository(perRequestStore.Context.Value);
return new HomeController(movieRepository);
}
if (controllerType == typeof(ReservationController))
{
var handler = new ReserveSeatCommandHandler(
perRequestStore.UserRepository.Value,
perRequestStore.RoomRepository.Value,
new PureWinChanceCalculatorFactory(perRequestStore.UserRepository.Value));
var auditingHandler = new AuditingCommandHandler<ReserveSeatCommand>(
handler,
perRequestStore.AuditLogger.Value);
var transactionalHandler = new TransactionalCommandHandler<ReserveSeatCommand>(
auditingHandler,
perRequestStore.Context.Value);
return new ReservationController(transactionalHandler);
}
if (controllerType == typeof(LoginController))
{
var handler = new LoginCommandHandler(new EfAuthenticationRepository(perRequestStore.Context.Value), perRequestStore.CurrentUserProvider.Value, new StringHasher());
var auditingHandler = new AuditingLoginCommandHandler(handler, perRequestStore.AuditLogger.Value);
var transactionalHandler = new TransactionalCommandHandler<LoginCommand>(auditingHandler, perRequestStore.Context.Value);
return new LoginController(new EfLoginRepository(perRequestStore.Context.Value), transactionalHandler);
}
if (controllerType == typeof(AuditController))
{
return new AuditController(new EfAuditViewRepository(perRequestStore.Context.Value));
}
if (controllerType == typeof(NotificationController))
{
return new NotificationController(new EfNotificationViewRepository(perRequestStore.Context.Value));
}
return base.CreateController(requestContext, controllerName);
}
public async Task Should_ThrowException_When_InputIsNull()
{
// Arrange
var userStore = new Mock <IUserStore <User> >();
userStore.Setup(x => x.FindByIdAsync("123", CancellationToken.None))
.ReturnsAsync(new User()
{
UserName = "******",
Id = 123
});
var userManager = new UserManager <User>(userStore.Object, null, null, null, null, null, null, null, null);
var jwtService = new Mock <IJwtService>();
// Act
var commandHandler = new LoginCommandHandler(userManager, jwtService.Object);
// Assert
await Assert.ThrowsAsync <InvalidNullInputException>(() => commandHandler.Handle(null, CancellationToken.None));
}
public void ExecuteCommand(ICommand command)
{
//var commandName = command.GetType().Name;
//var handler = GetType().Assembly.GetTypes().FirstOrDefault(f => f.Name == $"{commandName}Handler");
//if (handler != null)
//{
// var handlerInstace = Activator.CreateInstance(handler, command, null);
// var handlerMethod = handler.GetMethods().FirstOrDefault(f => f.Name == "Execute");
// if (handlerMethod != null)
// handlerMethod.Invoke(handlerInstace, new object[] { });
//}
if (command.GetType() == typeof(LoginCommand))
{
var authCommand = (LoginCommand)command;
var handler = new LoginCommandHandler(authCommand, UserRepository);
handler.Execute();
}
if (command.GetType() == typeof(CreateMovieCommand))
{
var createMovieCommand = (CreateMovieCommand)command;
var handler = new CreateMovieCommandHandler(createMovieCommand, MovieRepository);
handler.Execute();
}
if (command.GetType() == typeof(EditMovieCommand))
{
var editCommand = (EditMovieCommand)command;
var handler = new EditMovieCommandHandler(editCommand, Context, MovieRepository);
handler.Execute();
}
if (command.GetType() == typeof(DeleteMovieCommand))
{
var deleteCommand = (DeleteMovieCommand)command;
var handler = new DeleteMovieCommandHandler(deleteCommand, MovieRepository);
handler.Execute();
}
}
public async Task Handle_InValidCommand_ShouldLoginWithError(LoginOutput loginOutput)
{
// Arrange
_mapperMock.Setup(m => m.Map <LoginOutput>(It.IsAny <User>())).Returns(loginOutput); // AutoMapper setup
_appsettingMock.SetReturnsDefault(new AppSettings
{
Issuer = "key1",
Secret = "kesdfaaaaaasffffffffy1"
});
var sut = new LoginCommandHandler(_context, _mapperMock.Object, _appsettingMock.Object); // creating system under test
var temUser = _fixture.Create <User>();
// Act
// Assert
await Assert.ThrowsAsync <NotFoundException>(() => sut.Handle(new LoginCommand {
Email = _fixture.Create <string>(), Password = _fixture.Create <string>()
}, CancellationToken.None));
}
public LoginCommandHandlerTest()
{
_handler = new LoginCommandHandler(_accountRepositoryMock.Object, _tokenCreatorMock.Object, _userStatusVerificationMock.Object);
}
void GivenSystemUnderTest()
{
_sut = new LoginCommandHandler(_userAccountDataRepository, _jwtSettings);
}
public LoginCommandTests()
{
_handler = new LoginCommandHandler(Context, HasherServiceMock);
}
