public void GetByIdShouldReturnAnValidUser()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnAnValidUser))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, null, config);
var added1 = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "firstName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Register(added1);
var userById = usersService.GetById(1);
Assert.NotNull(userById);
Assert.AreEqual("firstName1", userById.FirstName);
}
}
public void GetAllShouldReturnAllRegisteredUsers()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllRegisteredUsers))
.Options;
using (var context = new FilmeDbContext(options))
{
var usersService = new UsersService(context, config);
var added1 = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "firstName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var added2 = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "secondName2",
LastName = "secondName2",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Register(added1);
usersService.Register(added2);
int numberOfElements = usersService.GetAll().Count();
Assert.NotZero(numberOfElements);
Assert.AreEqual(2, numberOfElements);
}
}
public void CreateShouldReturnNullIfValidUserGetModel()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldReturnNullIfValidUserGetModel))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, null, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added1 = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "firstName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var userCreated = usersService.Create(added1);
Assert.IsNull(userCreated);
}
}
public void DeleteShouldEmptyTheDb()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldEmptyTheDb))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, null, config);
var added1 = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "firstName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var userCreated = usersService.Create(added1);
Assert.IsNull(userCreated);
Assert.AreEqual(1, usersService.GetAll().Count());
var userDeleted = usersService.Delete(1);
Assert.NotNull(userDeleted);
Assert.AreEqual(0, usersService.GetAll().Count());
}
}
public void CreateShouldAddAndReturnTheFilmCreated()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddAndReturnTheFilmCreated))
.Options;
using (var context = new FilmeDbContext(options))
{
var filmService = new FilmService(context);
var addedFilm = filmService.Create(new Lab3.ViewModels.FilmPostModel
{
Title = "Create",
Director = "dir1",
DateAdded = new DateTime(),
Duration = 100,
Description = "asdvadfbdbsb",
Genre = "Comedy",
ReleaseYear = 2000,
Rating = 3,
Watched = 0
}, null);
Assert.IsNotNull(addedFilm);
Assert.AreEqual("Create", addedFilm.Title);
}
}
public void DeleteShouldRemoveAndReturnUserRole()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldRemoveAndReturnUserRole))
.EnableSensitiveDataLogging()
.Options;
using (var context = new FilmeDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = userRoleService.Create(new Lab3.ViewModels.UserRolePostModel
{
Name = "Rol testare",
Description = "Creat pentru testare"
});
Assert.IsNotNull(addUserRole);
Assert.AreEqual("Rol testare", context.UserRoles.Find(1).Name);
var deletedUserRole = userRoleService.Delete(1);
Assert.IsNotNull(deletedUserRole);
Assert.AreEqual(addUserRole.Name, deletedUserRole.Name);
}
}
public void InvalidRegisterShouldReturnErrorsCollection()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(InvalidRegisterShouldReturnErrorsCollection))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, null, config);
var added = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "lastName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******" //invalid password should invalidate register
};
var result = usersService.Register(added);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.ErrorMessages.Count());
}
}
public void DeleteShouldRemoveAndReturnFilm()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldRemoveAndReturnFilm))
.EnableSensitiveDataLogging()
.Options;
using (var context = new FilmeDbContext(options))
{
var filmService = new FilmService(context);
var toAdd = filmService.Create(new Lab3.ViewModels.FilmPostModel
{
Title = "DeSters",
Director = "dir1",
DateAdded = new DateTime(),
Duration = 100,
Description = "asdvadfbdbsb",
Genre = "Comedy",
ReleaseYear = 2000,
Rating = 3,
Watched = 0
}, null);
Assert.IsNotNull(toAdd);
Assert.AreEqual(1, filmService.GetAll(new DateTime(), new DateTime(), 1).Entries.Count);
var deletedFilm = filmService.Delete(1);
Assert.IsNotNull(deletedFilm);
Assert.AreEqual(0, filmService.GetAll(new DateTime(), new DateTime(), 1).Entries.Count);
}
}
public void GetByIdShouldReturnFilmWithCorrectIdNumber()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnFilmWithCorrectIdNumber))
.Options;
using (var context = new FilmeDbContext(options))
{
var filmService = new FilmService(context);
var addedFilm = filmService.Create(new Lab3.ViewModels.FilmPostModel
{
Title = "Testare",
Director = "dir1",
DateAdded = new DateTime(),
Duration = 100,
Description = "asdvadfbdbsb",
Genre = "Comedy",
ReleaseYear = 2000,
Rating = 3,
Watched = 0
}, null);
var theFilm = filmService.GetById(1);
Assert.AreEqual("Testare", theFilm.Title);
}
}
public void AuthenticateShouldLogTheRegisteredUser()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogTheRegisteredUser))
.Options;
using (var context = new FilmeDbContext(options))
{
var usersService = new UsersService(context, config);
var added = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "lastName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new Lab3.ViewModels.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 DeleteShouldEmptyTheDb()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldEmptyTheDb))
.Options;
using (var context = new FilmeDbContext(options))
{
var pacheteService = new PacheteService(context);
var added = new Lab3.ViewModels.PachetPostModel
{
AdresaDestinatar = "adresa",
CodTracking = "123",
Cost = 23,
DenumireDestinatar = "mama",
DenumireExpeditor = "tata",
TaraDestinatie = "R0mania",
TaraOrigine = "Franta"
};
var pachet = pacheteService.Create(added);
Assert.IsNotNull(pachet);
var userDeleted = pacheteService.Delete(1);
Assert.NotNull(userDeleted);
}
}
public void ValidRegisterShouldCreateNewUser()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateNewUser))// "ValidRegisterShouldCreateANewUser")
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, null, config);
var added = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "lastName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
Assert.IsNull(result);
Assert.AreEqual(added.UserName, context.Users.FirstOrDefault(u => u.Id == 1).Username);
Assert.AreEqual(1, context.UserUserRoles.FirstOrDefault(uur => uur.Id == 1).UserId);
}
}
public UsersService(FilmeDbContext context,
IRegisterValidator registerValidator,
IUserUserRolesService userUserRolesService,
IOptions <AppSettings> appSettings)
{
this.context = context;
this.appSettings = appSettings.Value;
this.registerValidator = registerValidator;
this.userUserRolesService = userUserRolesService;
}
public void AuthenticateShouldLogTheRegisteredUser()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogTheRegisteredUser))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var validatorUser = new UserRoleValidator();
var userUserRoleService = new UserUserRolesService(validatorUser, context);
var usersService = new UsersService(context, validator, userUserRoleService, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "lastName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new Lab3.ViewModels.LoginPostModel
{
Username = "******",
Password = "******"
};
//valid authentification
var authresult = usersService.Authenticate(added.UserName, added.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.UserName);
//invalid user authentification
var authresult1 = usersService.Authenticate("unknown", "abcdefg");
Assert.IsNull(authresult1);
}
}
public void GetCurentUserShouldReturnAccesToKlaims()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetCurentUserShouldReturnAccesToKlaims))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var validatorUser = new UserRoleValidator();
var userUserRoleService = new UserUserRolesService(validatorUser, context);
var usersService = new UsersService(context, validator, userUserRoleService, config);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRoleRegular);
context.SaveChanges();
var added = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "firstName1",
LastName = "lastName1",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new Lab3.ViewModels.LoginPostModel
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(added.UserName, added.Password);
//nu stiu sa instantiez un HttpContext
//usersService.GetCurentUser(httpContext);
Assert.IsNotNull(authresult);
}
}
public void CreateShouldAddAndReturnTheRole()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddAndReturnTheRole))
.Options;
using (var context = new FilmeDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = userRoleService.Create(new Lab3.ViewModels.UserRolePostModel
{
Name = "Rol testare",
Description = "Creat pentru testare"
});
var userRole = context.UserRoles.Find(1);
Assert.AreEqual(addUserRole.Name, userRole.Name);
}
}
public void GetAllShouldReturnUserRoles()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnUserRoles))
.Options;
using (var context = new FilmeDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = userRoleService.Create(new Lab3.ViewModels.UserRolePostModel
{
Name = "Rol testare",
Description = "Creat pentru testare"
});
var allUsers = userRoleService.GetAll();
Assert.IsNotNull(allUsers);
}
}
public void GetByIdShouldReturnUserRole()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnUserRole))
.Options;
using (var context = new FilmeDbContext(options))
{
var userUserRolesService = new UserUserRolesService(null, context);
User userToAdd = new User
{
Email = "*****@*****.**",
LastName = "Ion",
FirstName = "POpescu",
Password = "******",
DataRegistered = DateTime.Now,
UserUserRoles = new List <UserUserRole>()
};
context.Users.Add(userToAdd);
UserRole addUserRole = new UserRole
{
Name = "Rol testare",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRole);
context.SaveChanges();
context.UserUserRoles.Add(new UserUserRole
{
User = userToAdd,
UserRole = addUserRole,
StartTime = DateTime.Now,
EndTime = null
});
context.SaveChanges();
var userUserRoleGetModels = userUserRolesService.GetHistoryRoleById(1);
Assert.IsNotNull(userUserRoleGetModels.FirstOrDefaultAsync(uur => uur.EndTime == null));
}
}
public void GetUserRoleNameByIdShouldReturnUserRoleName()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetUserRoleNameByIdShouldReturnUserRoleName))
.Options;
using (var context = new FilmeDbContext(options))
{
var userUserRolesService = new UserUserRolesService(null, context);
User userToAdd = new User
{
Email = "*****@*****.**",
LastName = "Ion",
FirstName = "POpescu",
Password = "******",
DataRegistered = DateTime.Now,
UserUserRoles = new List <UserUserRole>()
};
context.Users.Add(userToAdd);
UserRole addUserRole = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRole);
context.SaveChanges();
context.UserUserRoles.Add(new UserUserRole
{
User = userToAdd,
UserRole = addUserRole,
StartTime = DateTime.Parse("2019-06-13T00:00:00"),
EndTime = null
});
context.SaveChanges();
string userRoleName = userUserRolesService.GetUserRoleNameById(1);
Assert.AreEqual("Regular", userRoleName);
}
}
public void UpsertShouldChangeTheFildValuesForRole()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldChangeTheFildValuesForRole))
.EnableSensitiveDataLogging()
.Options;
using (var context = new FilmeDbContext(options))
{
var userRoleService = new UserRoleService(context);
var addUserRole = userRoleService.Create(new Lab3.ViewModels.UserRolePostModel
{
Name = "Rol testare",
Description = "Creat pentru testare"
});
var userRole = context.UserRoles.Find(1);
Assert.AreEqual(addUserRole.Name, userRole.Name);
}
}
public ErrorsCollection Validate(RegisterPostModel registerPostModel, FilmeDbContext context)
{
ErrorsCollection errorsCollection = new ErrorsCollection {
Entity = nameof(RegisterPostModel)
};
User existing = context.Users.FirstOrDefault(u => u.Username == registerPostModel.UserName);
if (existing != null)
{
errorsCollection.ErrorMessages.Add($"The username {registerPostModel.UserName} is already taken!");
}
if (registerPostModel.Password.Length < 6)
{
errorsCollection.ErrorMessages.Add("The password cannot be shorter than 6 characters!");
}
int nrOfDigits = 0;
foreach (char c in registerPostModel.Password)
{
if (c >= '0' && c <= '9')
{
nrOfDigits++;
}
}
if (nrOfDigits < 2)
{
errorsCollection.ErrorMessages.Add("The password must contain at least two digits!");
}
if (errorsCollection.ErrorMessages.Count > 0)
{
return(errorsCollection);
}
return(null);
}
public void GetAllShouldReturnCorrectNumberOfPagesForFilme()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPagesForFilme))
.Options;
using (var context = new FilmeDbContext(options))
{
var filmService = new FilmService(context);
var addedFilm = filmService.Create(new Lab3.ViewModels.FilmPostModel
{
Title = "film de test 1",
Director = "dir1",
DateAdded = DateTime.Parse("2019-06-11T00:00:00"),
Duration = 100,
Description = "asdvadfbdbsb",
Genre = "Comedy",
ReleaseYear = 2000,
Rating = 3,
Watched = 0,
Comentarii = new List <Comentariu>()
{
new Comentariu
{
Important = true,
Text = "asd",
AddedBy = null
}
},
}, null);
DateTime from = DateTime.Parse("2019-06-10T00:00:00");
DateTime to = DateTime.Parse("2019-06-12T00:00:00");
var allFilms = filmService.GetAll(from, to, 1);
Assert.AreEqual(1, allFilms.Entries.Count);
}
}
public void UpsertShouldModifyFildsValues()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyFildsValues))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new RegisterValidator();
var usersService = new UsersService(context, validator, null, config);
var added22 = new Lab3.ViewModels.RegisterPostModel
{
FirstName = "Nume",
LastName = "Prenume",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
usersService.Create(added22);
//context.Entry(added22).State = EntityState.Detached;
var updated = new Lab3.ViewModels.UserPostModel
{
FirstName = "Alin",
LastName = "Popescu",
UserName = "******",
Email = "*****@*****.**",
Password = "******"
};
var userUpdated = usersService.Upsert(1, updated);
Assert.NotNull(userUpdated);
Assert.AreEqual("Alin", userUpdated.FirstName);
Assert.AreEqual("Popescu", userUpdated.LastName);
}
}
public void UpsertShouldChangeTheFildValues()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldChangeTheFildValues))
.EnableSensitiveDataLogging()
.Options;
using (var context = new FilmeDbContext(options))
{
var filmService = new FilmService(context);
var original = filmService.Create(new Lab3.ViewModels.FilmPostModel
{
Title = "Original",
Director = "dir1",
DateAdded = new DateTime(),
Duration = 100,
Description = "asdvadfbdbsb",
Genre = "Comedy",
ReleaseYear = 2000,
Rating = 3,
Watched = 0
}, null);
var film = new Lab3.ViewModels.FilmPostModel
{
Title = "upsert"
};
context.Entry(original).State = EntityState.Detached;
var result = filmService.Upsert(1, film);
Assert.IsNotNull(original);
Assert.AreEqual("upsert", result.Title);
}
}
public void GetAllShouldReturnCorrectNumberOfPages()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPages))
.Options;
using (var context = new FilmeDbContext(options))
{
var commentService = new ComentariuService(context);
var filmService = new FilmService(context);
var addedFlower = filmService.Create(new Lab3.ViewModels.FilmPostModel
{
Title = "film de test 1",
Director = "dir1",
DateAdded = new DateTime(),
Duration = 100,
Description = "asdvadfbdbsb",
Genre = "Comedy",
ReleaseYear = 2000,
Rating = 3,
Watched = 0,
Comentarii = new List <Comentariu>()
{
new Comentariu
{
Important = true,
Text = "asd",
AddedBy = null
}
},
}, null);
var allComments = commentService.GetAll(string.Empty, 1);
Assert.AreEqual(1, allComments.NumberOfPages);
}
}
public void CreateShouldAddTheUserUserRole()
{
var options = new DbContextOptionsBuilder <FilmeDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddTheUserUserRole))
.Options;
using (var context = new FilmeDbContext(options))
{
var validator = new UserRoleValidator();
var userUserRolesService = new UserUserRolesService(validator, context);
User userToAdd = new User
{
Email = "*****@*****.**",
LastName = "Ion",
FirstName = "POpescu",
Password = "******",
DataRegistered = DateTime.Now,
UserUserRoles = new List <UserUserRole>()
};
context.Users.Add(userToAdd);
UserRole addUserRoleRegular = new UserRole
{
Name = "Regular",
Description = "Creat pentru testare"
};
UserRole addUserRoleAdmin = new UserRole
{
Name = "AdminDeTest",
Description = "Creat pentru testare"
};
context.UserRoles.Add(addUserRoleRegular);
context.UserRoles.Add(addUserRoleAdmin);
context.SaveChanges();
context.UserUserRoles.Add(new UserUserRole
{
User = userToAdd,
UserRole = addUserRoleRegular,
StartTime = DateTime.Parse("2019-06-13T00:00:00"),
EndTime = null
});
context.SaveChanges();
//sectiunea de schimbare valori invalidata de catre UserRoleValidator
var uurpm = new UserUserRolePostModel
{
UserId = userToAdd.Id,
UserRoleName = "Admin"
};
var result1 = userUserRolesService.Create(uurpm);
Assert.IsNotNull(result1); //User role nu exista in baza de date dupa validare, ==> exista erori la validare
//sectiunea de schimbare valori validata de catre UserRoleValidator
var uurpm1 = new UserUserRolePostModel
{
UserId = userToAdd.Id,
UserRoleName = "AdminDeTest"
};
var result2 = userUserRolesService.Create(uurpm1);
Assert.IsNull(result2); //User role exista si se face upsert
}
}
public FilmService(FilmeDbContext context)
{
this.context = context;
}
public UsersService(FilmeDbContext context, IOptions <AppSettings> appSettings)
{
this.context = context;
this.appSettings = appSettings.Value;
}
public FilmesController(FilmeDbContext contexto)
{
_context = contexto;
}
public AlbunsRepositorio(FilmeDbContext contexto)
: base(contexto)
{
}
