public void InvalidRegisterShouldNotCerateANewUserWithTheSameUsername()
{
var options = new DbContextOptionsBuilder <UserDbContext>()
.UseInMemoryDatabase(databaseName: nameof(InvalidRegisterShouldNotCerateANewUserWithTheSameUsername))
.Options;
using (var context = new UserDbContext(options))
{
var userService = new UserService(context, config);
var added1 = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdf",
LastName = "asdfgh",
Password = "******",
Username = "******"
};
var added2 = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfg",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
userService.Register(added1);
var result = userService.Register(added2);
Assert.AreEqual(null, result);
}
}
public void ValidGetAllShouldReturnAllUsers()
{
var options = new DbContextOptionsBuilder <UserDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidGetAllShouldReturnAllUsers))
.Options;
using (var context = new UserDbContext(options))
{
var userService = new UserService(context, config);
var addedUser1 = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfg",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
var addedUser2 = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfgh",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
var addedUser3 = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfgh",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
UserGetModel user1 = userService.Register(addedUser1);
UserGetModel user2 = userService.Register(addedUser2);
UserGetModel user3 = userService.Register(addedUser3);
List <UserGetModel> actual = new List <UserGetModel>();
user1.Token = null;
user2.Token = null;
user3.Token = null;
actual.Add(user1);
actual.Add(user2);
actual.Add(user3);
IEnumerable <UserGetModel> result = userService.GetAll();
IEnumerable <UserGetModel> expected = actual.AsEnumerable();
Assert.IsTrue(expected.SequenceEqual(actual));
}
}
public void DeleteShouldDeleteUser()
{
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldDeleteUser))
.Options;
using (var context = new AppDbContext(options))
{
var userService = new UserService(context, config);
userService.Register(user);
User addedUser = context.Users.Last();
context.Entry(addedUser).State = EntityState.Detached;
//var addedUser = context.Users.Where(u => u.Username == "alina3").FirstOrDefault();
userService.DeleteUser(addedUser.Id);
int users = userService.GetAll().Count();
Assert.Zero(users);
}
}
public void AuthenticateShouldLoginAUser()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginAUser))
.Options;
using (var context = new MoviesDbContext(options))
{
var usersService = new UserService(context, config);
var added = new RegisterPostModel
{
FirstName = "alina",
LastName = "demian",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new LoginPostModel
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.Username);
}
}
public void Login()
{
var options = new DbContextOptionsBuilder <UsersDbContext>()
.UseInMemoryDatabase(databaseName: nameof(Login))
.Options;
using (var context = new UsersDbContext(options))
{
var userService = new UserService(context, config);
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "Gavrilut",
LastName = "Lucian",
Password = "******",
Username = "******"
};
userService.Register(added);
var loggedIn = new LoginPostModel
{
Username = "******",
Password = "******"
};
var result = userService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(result);
//Assert.AreEqual(7, result.Id);
Assert.AreEqual(loggedIn.Username, result.Username);
}
}
public void Register()
{
var options = new DbContextOptionsBuilder <UsersDbContext>()
.UseInMemoryDatabase(databaseName: nameof(Register))
.Options;
using (var context = new UsersDbContext(options))
{
var userService = new UserService(context, config);
var addedUser = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "Pop",
LastName = "Mihai",
Password = "******",
Username = "******",
DateRegister = DateTime.Now,
};
var result = userService.Register(addedUser);
Assert.IsNotNull(result);
Assert.AreEqual(addedUser.Username, result.Username);
}
}
public void Register_ValidData_RegisteredUser()
{
// Arrange
IOptions <AppSettings> mockOptions = Options.Create <AppSettings>(new AppSettings()
{
Secret = "SECRET FOR TESTING"
});
IUserService userService = new UserService(new FakeUserRepository(), mockOptions);
RegisterModel model = new RegisterModel()
{
FirstName = "Greg",
LastName = "Gregsky",
Password = "******",
ConfirmPassword = "******",
Username = "******"
};
// Act
userService.Register(model);
// Assert
UserModel newUser = userService.Authenticate(model.Username, model.Password);
Assert.AreEqual(model.FirstName, newUser.FirstName);
Assert.AreEqual(model.LastName, newUser.LastName);
}
public void AuthenticateShouldLoginAUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginAUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UserService(context, config);
var added = new RegisterUserPostDto
//
{
FullName = "codruta",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new LoginPostDto
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.Username);
}
}
public void DeleteShouldDeleteUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldDeleteUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var userService = new UserService(context, null, config);
var newUser = new RegisterUserPostDto
{
Email = "*****@*****.**",
FullName = "dana",
Password = "******",
Username = "******"
};
userService.Register(newUser);
User addedUser = context.Users.Last();
context.Entry(addedUser).State = EntityState.Detached;
//var addedUser = context.Users.Where(u => u.Username == "alina3").FirstOrDefault();
userService.Delete(addedUser.Id, User);
int users = userService.GetAll().Count();
Assert.Zero(users);
}
}
public void InvalidAuthentificationShouldNotAuthenticateUserWithInvalidPassword()
{
var options = new DbContextOptionsBuilder <UserDbContext>()
.UseInMemoryDatabase(databaseName: nameof(InvalidAuthentificationShouldNotAuthenticateUserWithInvalidPassword))
.Options;
using (var context = new UserDbContext(options))
{
var userService = new UserService(context, config);
var addedUser = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfg",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
var addResult = userService.Register(addedUser);
Assert.IsNotNull(addResult);
Assert.AreEqual(addedUser.Username, addResult.Username);
var authentificate = new Examen.ViewModels.UserGetModel
{
Email = "[email protected]",
Username = "******"
};
var result = userService.Authenticate(addedUser.Username, "11111111");
Assert.AreEqual(null, result);
}
}
public void ValidRegisterShouldCerateANewUser()
{
var options = new DbContextOptionsBuilder <UserDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCerateANewUser))
.Options;
using (var context = new UserDbContext(options))
{
var userService = new UserService(context, config);
var added = new Examen.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdf",
LastName = "asdfgh",
Password = "******",
Username = "******"
};
var result = userService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(added.Username, result.Username);
}
}
public void GetAll()
{
var options = new DbContextOptionsBuilder <UsersDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAll))
.Options;
using (var context = new UsersDbContext(options))
{
//context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
var userService = new UserService(context, config);
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "Gavrilut",
LastName = "Lucian",
Password = "******",
Username = "******"
};
var added1After = userService.Register(added);
}
using (var context = new UsersDbContext(options))
{
var userService = new UserService(context, config);
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "Pop",
LastName = "Mihai",
Password = "******",
Username = "******"
};
var added2After = userService.Register(added);
}
using (var context = new UsersDbContext(options))
{
var userService = new UserService(context, config);
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "Luminita",
LastName = "Aconstantinesei",
Password = "******",
Username = "******"
};
var added2After = userService.Register(added);
}
using (var context = new UsersDbContext(options))
{
var userService = new UserService(context, config);
var result = userService.GetAll();
Assert.AreEqual(3, result.Count());
}
}
public void Delete()
{
var options = new DbContextOptionsBuilder <UsersDbContext>()
.UseInMemoryDatabase(databaseName: nameof(Delete))
.Options;
using (var context = new UsersDbContext(options))
{
var usersService = new UserService(context, config);
UserRole userRole = new UserRole
{
Id = 3,
Name = RoleConstants.ADMIN
};
HistoryUserRole history = new HistoryUserRole
{
StartTime = DateTime.Now,
UserRoleId = 3,
UserRole = userRole,
};
List <HistoryUserRole> list = new List <HistoryUserRole>
{
history
};
User user1 = new User
{
Username = "******",
HistoryUserRole = list,
DateRegister = DateTime.Now
};
//aragorn.History.Add(history);
var addedCosmin = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "Cosmin",
LastName = "Cosmin",
Password = "******",
Username = "******"
};
usersService.Register(addedCosmin);
User expected = context.Users.AsNoTracking()
.Include(x => x.HistoryUserRole)
.ThenInclude(x => x.UserRole)
.FirstOrDefault(x => x.FirstName.Equals(addedCosmin.FirstName));
usersService.Delete(expected.Id, user1);
Assert.IsNull(usersService.GetById(expected.Id));
}
}
public void GetAllShouldReturnAllUser()
{
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllUser))
.Options;
using (var context = new AppDbContext(options))
{
var usersService = new UserService(context, config);
var added1 = new RegisterPostModel
{
FirstName = "alina",
LastName = "demian",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var added2 = new RegisterPostModel
{
FirstName = "alina",
LastName = "demian",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Register(added1);
usersService.Register(added2);
int numberOfElements = usersService.GetAll().Count();
Assert.NotZero(numberOfElements);
Assert.AreEqual(2, numberOfElements);
}
}
public void GetAllShouldReturnAllUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UserService(context, config);
var added1 = new RegisterUserPostDto
{
FullName = "codruta1",
Email = "*****@*****.**",
Username = "******",
Password = "******"
};
var added2 = new RegisterUserPostDto
{
FullName = "codruta3",
Email = "*****@*****.**",
Username = "******",
Password = "******"
};
usersService.Register(added1);
usersService.Register(added2);
int numberOfElements = usersService.GetAll().Count();
Assert.NotZero(numberOfElements);
}
}
public void ValidRegisterShouldCreateANewUser()
{
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateANewUser))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new AppDbContext(options))
{
var userService = new UserService(context, config);
var result = userService.Register(user);
Assert.IsNotNull(result);
Assert.AreEqual(user.Username, result.Username);
}
}
public void GetUserByIdShouldReturnTheCorrectUser()
{
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetUserByIdShouldReturnTheCorrectUser))
.Options;
using (var context = new AppDbContext(options))
{
var userService = new UserService(context, config);
userService.Register(user);
var addedUser = context.Users.Last();
User userById = userService.GetUserById(addedUser.Id);
Assert.AreEqual(userById.Id, addedUser.Id);
}
}
public void ValidRegisterShouldCreateNewUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateNewUser))// "ValidRegisterShouldCreateNewUser")
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UserService(context, null, config);
var added = new RegisterUserPostDto
{
FullName = "fdsfsdfs",
Username = "******",
Email = "[email protected]",
Password = "******",
};
var result = usersService.Register(added);
Assert.IsNotNull(result);
}
}
public void ValidRegisterShouldCreateANewUser()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateANewUser))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new MoviesDbContext(options))
{
var userService = new UserService(context, config);
var added = new Lab2B.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "fdsfsdfs",
LastName = "fdsfs",
Password = "******",
Username = "******"
};
var result = userService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(added.Username, result.Username);
}
}
public void AuthenticateShouldLoginAUser()
{
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginAUser))
.Options;
using (var context = new AppDbContext(options))
{
var usersService = new UserService(context, config);
var result = usersService.Register(user);
var authenticated = new LoginPostModel
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(user.Username, user.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.Username);
}
}
public void ValidAuthentificationShouldAuthenticateValidUser()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidAuthentificationShouldAuthenticateValidUser))
.Options;
using (var context = new MoviesDbContext(options))
{
var userService = new UserService(context, config);
var addedUser = new Lab2.ViewModels.RegisterPostModel
{
Email = "[email protected]",
FirstName = "asdfg",
LastName = "asdsdfgfgh",
Password = "******",
Username = "******"
};
var addResult = userService.Register(addedUser);
Assert.IsNotNull(addResult);
Assert.AreEqual(addedUser.Username, addResult.Username);
var authentificate = new Lab2.ViewModels.UserGetModel
{
Email = "[email protected]",
Username = "******"
};
var result = userService.Authenticate(addedUser.Username, addedUser.Password);
Assert.IsNotNull(result);
Assert.AreEqual(authentificate.Username, result.Username);
}
}
public void LogInUser()
{
var data = new List <User>
{
new User
{
FirstName = "Stamat",
LastName = "Stamatov",
Age = 13,
Email = "*****@*****.**",
PhoneNumber = "0877253698",
Username = "******",
Password = "******",
ConfirmPassword = "******",
IsEmployer = false
}
}.AsQueryable();
var mockSet = new Mock <DbSet <User> >();
mockSet.As <IQueryable <User> >().Setup(u => u.Provider).Returns(data.Provider);
mockSet.As <IQueryable <User> >().Setup(u => u.Expression).Returns(data.Expression);
mockSet.As <IQueryable <User> >().Setup(u => u.ElementType).Returns(data.ElementType);
mockSet.As <IQueryable <User> >().Setup(u => u.GetEnumerator()).Returns(data.GetEnumerator());
var mockContext = new Mock <JobApplicationDbContext>();
mockContext.Setup(c => c.Users).Returns(mockSet.Object);
var service = new UserService(mockContext.Object);
var users = data.ToList();
users.ForEach(u => service.Register(u.FirstName, u.LastName, u.Age.Value, u.Email, u.PhoneNumber, u.Username, u.Password, u.ConfirmPassword, u.IsEmployer));
int logInResult = service.Login(users[0].Username, users[0].Password);
Assert.AreEqual(0, logInResult);
}
public void CreateCvTest()
{
var userData = new List <User>
{
new User
{
Id = 1,
FirstName = "Stamat",
LastName = "Stamatov",
Age = 13,
Email = "*****@*****.**",
PhoneNumber = "0877253698",
Username = "******",
Password = "******",
ConfirmPassword = "******",
IsEmployer = false
}
}.AsQueryable();
var cvData = new List <CV>
{
new CV
{
Id = 1,
Education = "Bachelors",
Experience = 5
}
}.AsQueryable();
var userMockSet = new Mock <DbSet <User> >();
userMockSet.As <IQueryable <User> >().Setup(u => u.Provider).Returns(userData.Provider);
userMockSet.As <IQueryable <User> >().Setup(u => u.Expression).Returns(userData.Expression);
userMockSet.As <IQueryable <User> >().Setup(u => u.ElementType).Returns(userData.ElementType);
userMockSet.As <IQueryable <User> >().Setup(u => u.GetEnumerator()).Returns(userData.GetEnumerator());
var cvMockSet = new Mock <DbSet <CV> >();
cvMockSet.As <IQueryable <CV> >().Setup(c => c.Provider).Returns(cvData.Provider);
cvMockSet.As <IQueryable <CV> >().Setup(c => c.Expression).Returns(cvData.Expression);
cvMockSet.As <IQueryable <CV> >().Setup(c => c.ElementType).Returns(cvData.ElementType);
cvMockSet.As <IQueryable <CV> >().Setup(c => c.GetEnumerator()).Returns(cvData.GetEnumerator());
var mockContext = new Mock <JobApplicationDbContext>();
mockContext.Setup(c => c.Users).Returns(userMockSet.Object);
mockContext.Setup(c => c.CVs).Returns(cvMockSet.Object);
var userService = new UserService(mockContext.Object);
var cvService = new CvService(mockContext.Object, userService);
var users = userData.ToList();
var cvs = cvData.ToList();
users.ForEach(u => userService.Register(u.FirstName, u.LastName, u.Age.Value, u.Email, u.PhoneNumber, u.Username, u.Password, u.ConfirmPassword, u.IsEmployer));
mockContext.Object.Users.FirstOrDefault(u => u.FirstName == "Stamat").Id = users[0].Id;
cvs.ForEach(c => cvService.CreateCv(c.Education, c.Experience, users[0].Id));
mockContext.Object.CVs.FirstOrDefault(c => c.Education == "Bachelors").Id = cvs[0].Id;
Assert.AreEqual(1, mockContext.Object.CVs.FirstOrDefault(c => c.Education == "Bachelors").Id);
//projects.ForEach(p => service.CreateProject(p.Name, p.Technology, p.Description, p.AchievedGoals, p.FutureGoals));
//projects.FirstOrDefault(p => p.Name == "Qko ime").CvId = cvs.FirstOrDefault(c => c.Education == "Bachelors").Id;
//projects.FirstOrDefault(p => p.Name == "Qko ime").Cv = cvs.FirstOrDefault(c => c.Education == "Bachelors");
//Assert.AreEqual("Qko ime", mockContext.Object.Projects.FirstOrDefault(p => p.Name == "Qko ime"));
}
