public void Delete_ShouldRemove_EntityFromDb() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: "Get_all_groups") .Options; using (var context = new TasksDbContext(options)) { context.TaskGroups.AddRange(new TaskGroupEntity { Name = "TestGroup1", UserTasks = new List <UserTaskEntity> { new UserTaskEntity { Name = "TestTask" } } }); context.SaveChanges(); var groupsDbManger = new TaskGroupDbManager(context, _mapper); groupsDbManger.Remove(1); } using (var context = new TasksDbContext(options)) { Assert.That(context.TaskGroups.Count(), Is.EqualTo(0)); Assert.That(context.UserTasks.Count(), Is.EqualTo(0)); context.Database.EnsureDeleted(); } }
public void AuthenticateShouldLogInAUser() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogInAUser)) .Options; using (var context = new TasksDbContext(options)) { var usersService = new UsersService(context, config); var added = new LabIV.DTO.RegisterPostDTO { FirstName = "Julia", LastName = "Bush", Username = "******", Email = "*****@*****.**", Password = "******" }; var result = usersService.Register(added); var authenticated = new LabIV.DTO.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 GetAllShouldReturnAllRegisteredUsers() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllRegisteredUsers)) .Options; using (var context = new TasksDbContext(options)) { var usersService = new UsersService(context, config); var added = new TaskAgendaProj.ViewModels.RegisterPostModel { Email = "*****@*****.**", FirstName = "FirstNameTest", LastName = "LastNameTest", Password = "******", Username = "******" }; var newadded = new TaskAgendaProj.ViewModels.RegisterPostModel { Email = "*****@*****.**", FirstName = "FirstNameTest2", LastName = "LastNameTest2", Password = "******", Username = "******" }; usersService.Register(added); usersService.Register(newadded); int number = usersService.GetAll().Count(); Assert.IsNotNull(number); Assert.AreEqual(2, number); } }
public void UpsertShouldModifyTheGivenComment() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyTheGivenComment)) .Options; using (var context = new TasksDbContext(options)) { var commentsService = new CommentsService(context); var toAdd = new CommentPostDTO() { Important = true, Text = "A nice task...", }; var added = commentsService.Create(toAdd, null); context.Entry(added).State = EntityState.Detached; var update = new Comment() { Important = false, Text = "A nice task...", }; var updateResult = commentsService.Upsert(added.Id, update); Assert.NotNull(updateResult); Assert.False(updateResult.Important); Assert.AreEqual(added.Text, updateResult.Text); } }
public void InvalidTypeOfTaskShouldNotCreatANewTask() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(InvalidTypeOfTaskShouldNotCreatANewTask)) .Options; using (var context = new TasksDbContext(options)) { var taskService = new TaskService(context); var expected = taskService.Create(new TaskAgendaProj.ViewModels.TaskPostModel { Title = "task de test 1", Description = "agfas", DateTimeAdded = new DateTime(), Deadline = new DateTime(), Importance = "high", Status = "in_progress", DateTimeClosedAt = new DateTime(), Comments = null }, null); var actual = taskService.GetById(expected.Id); Assert.IsNotNull(actual); } }
public GetQueryValidator(TasksDbContext context) { RuleFor(c => c.TaskId) .NotEmpty(); RuleFor(m => m.TaskId).MustFindEntityById <Get.Query, TaskModel>(context, StatusCodes.Status404NotFound); }
public void DeleteShouldDeleteAGivenComment() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(DeleteShouldDeleteAGivenComment)) .Options; using (var context = new TasksDbContext(options)) { var commentsService = new CommentsService(context); var toAdd = new CommentPostDTO() { Important = true, Text = "A nice task...", }; var actual = commentsService.Create(toAdd, null); var afterDelete = commentsService.Delete(actual.Id); int numberOfCommentsInDb = context.Comments.CountAsync().Result; var resultComment = context.Comments.Find(actual.Id); Assert.IsNotNull(afterDelete); Assert.IsNull(resultComment); Assert.AreEqual(0, numberOfCommentsInDb); } }
public void GetAllShouldReturnAllRegisteredUsers() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllRegisteredUsers)) .Options; using (var context = new TasksDbContext(options)) { var usersService = new UsersService(context, config); var added1 = new lab2_web_api.ViewModels.RegisterPostModel { FirstName = "firstName1", LastName = "firstName1", Username = "******", Email = "*****@*****.**", Password = "******" }; var added2 = new lab2_web_api.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 IActionResult Create() { using (var db = new TasksDbContext()) { return(View()); } }
public void AuthenticateShouldLoginAUser() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginAUser)) .Options; using (var context = new TasksDbContext(options)) { var usersService = new UsersService(context, config); var added = new Lab_2_webapi.ViewModels.RegisterPostModel { FirstName = "pomihai2", LastName = "popmihai2", Username = "******", Email = "x@x", Password = "******" }; var result = usersService.Register(added); var authenticated = new Lab_2_webapi.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 AuthenticateShouldLogTheRegisteredUser() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogTheRegisteredUser)) .Options; using (var context = new TasksDbContext(options)) { var usersService = new UsersService(context, config); var added = new lab2_web_api.ViewModels.RegisterPostModel { FirstName = "firstName1", LastName = "lastName1", Username = "******", Email = "*****@*****.**", Password = "******" }; var result = usersService.Register(added); var authenticated = new lab2_web_api.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 Create_ShouldAdd_CorrectEntityToDb() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: "Get_create_group") .Options; using (var context = new TasksDbContext(options)) { var taskGroupManager = new TaskGroupDbManager(context, _mapper); taskGroupManager.Create(new TaskGroupViewModel { Name = "TestGroup", UserTasks = new List <UserTaskViewModel> { new UserTaskViewModel { Name = "TestTask1" }, new UserTaskViewModel { Name = "TestTask2" } } }); } using (var context = new TasksDbContext(options)) { Assert.That(context.TaskGroups.Count(), Is.EqualTo(1)); Assert.That(context.UserTasks.Count(), Is.EqualTo(2)); var result = context.TaskGroups.Include(g => g.UserTasks).First(); Assert.That(result.Name, Is.EqualTo("TestGroup")); Assert.That(result.UserTasks.Count, Is.EqualTo(2)); Assert.That(result.UserTasks.ToList().Exists(t => t.Name == "TestTask1" || t.Name == "TestTask2"), Is.True); context.Database.EnsureDeleted(); } }
public void GetById_ShouldReturn_CorrectGroupFromDb() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: "Get_group_by_id") .Options; using (var context = new TasksDbContext(options)) { context.TaskGroups.AddRange(new TaskGroupEntity { Name = "TestGroup1", UserTasks = new List <UserTaskEntity> { new UserTaskEntity { Name = "TestTask" } } }, new TaskGroupEntity { Name = "TestGroup2" }); context.SaveChanges(); } using (var context = new TasksDbContext(options)) { var taskGroupManager = new TaskGroupDbManager(context, _mapper); var result = taskGroupManager.Get(1); Assert.That(result.Id, Is.EqualTo(1)); Assert.That(result.Name, Is.EqualTo("TestGroup1")); Assert.That(result.UserTasks.ToList().Exists(t => t.Name == "TestTask"), Is.True); context.Database.EnsureDeleted(); } }
public void Get_ShouldReturn_AllGroupsFromDb() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: "Get_all_groups") .Options; using (var context = new TasksDbContext(options)) { context.TaskGroups.AddRange(new TaskGroupEntity { Name = "TestGroup1", UserTasks = new List <UserTaskEntity> { new UserTaskEntity { Name = "TestTask" } } }, new TaskGroupEntity { Name = "TestGroup2" }); context.SaveChanges(); } using (var context = new TasksDbContext(options)) { var taskGroupManager = new TaskGroupDbManager(context, _mapper); var result = taskGroupManager.Get(); Assert.That(result.Count, Is.EqualTo(2)); Assert.That(result.Exists(group => group.Name == "TestGroup1" && group.Id == 1 && group.UserTasks.Count() == 1), Is.True); Assert.That(result.Exists(group => group.Name == "TestGroup2" && group.Id == 2 && !group.UserTasks.Any()), Is.True); context.Database.EnsureDeleted(); } }
public void UpsertShouldModifyTheGivenUserRole() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyTheGivenUserRole)) .EnableSensitiveDataLogging() .Options; using (var context = new TasksDbContext(options)) { var userRoleService = new UserRoleService(context); var toAdd = new UserRolePostDTO { Name = "Newcomer", Description = "A new guy..." }; var added = userRoleService.Create(toAdd); //context.Entry(added).State = EntityState.Detached; var update = new UserRolePostDTO { Name = "Rouge" }; //var updateResult = userRoleService.Upsert(added.Id, update); Assert.NotNull(added); Assert.AreEqual(toAdd.Name, toAdd.Name); Assert.AreNotEqual(update.Name, toAdd.Name); } }
public void GetAllShouldReturnCorrectNumberOfPages() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPages)) .Options; using (var context = new TasksDbContext(options)) { var commentService = new CommentService(context); var taskService = new TaskService(context); var addedTask = taskService.Create(new Lab_2_webapi.Models.Task { Title = "fdsfsd", DateAdded = new DateTime(), Description = "large", Deadline = new DateTime(), ClosedAt = new DateTime() }); addedTask.Comments.Add(new Comment { Text = "vvv", Important = true }); var allComments = commentService.GetAll(1, string.Empty); Assert.AreEqual(1, allComments.NumberOfPages); } }
public void DeleteShouldRemoveAndReturnUserRole() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(DeleteShouldRemoveAndReturnUserRole)) .EnableSensitiveDataLogging() .Options; using (var context = new TasksDbContext(options)) { var userRoleService = new UserRoleService(context); var addUserRole = userRoleService.Create(new TaskAgendaProj.ViewModels.UserRolePostModel { Name = "Rol testare", Description = "Creat pentru testare" }); Assert.IsNotNull(addUserRole); Assert.AreEqual("Rol testare", context.UserRole.Find(1).Name); var deletedUserRole = userRoleService.Delete(1); Assert.IsNotNull(deletedUserRole); Assert.AreEqual(addUserRole.Name, deletedUserRole.Name); } }
public void Create_ShouldAdd_NewTaskGroupEntityToDb() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: "Create_test") .Options; var expected = new TaskGroupEntity { Name = "TestGroup" }; using (var context = new TasksDbContext(options)) { context.TaskGroups.Add(expected); context.SaveChanges(); } using (var context = new TasksDbContext(options)) { Assert.That(context.TaskGroups.Count(), Is.EqualTo(1)); var groupFromDb = context.TaskGroups.First(); Assert.That(groupFromDb.Id, Is.Not.EqualTo(0)); Assert.That(groupFromDb.Name, Is.EqualTo(expected.Name)); context.Database.EnsureDeleted(); } }
public ErrorsCollection Validate(UserUserRolePostDTO userUserRolePostDTO, TasksDbContext context) { ErrorsCollection errorsCollection = new ErrorsCollection { Entity = nameof(UserUserRolePostDTO) }; List <string> userRoles = context .UserRoles .Select(userRole => userRole.Name) .ToList(); if (!userRoles.Contains(userUserRolePostDTO.UserRoleName)) { errorsCollection.ErrorMessages.Add($"The UserRole {userUserRolePostDTO.UserRoleName} does not exist!"); } if (errorsCollection.ErrorMessages.Count > 0) { return(errorsCollection); } return(null); }
public TaskGroupDbManager(TasksDbContext dbContext, IMapper mapper) { _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext)); _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); _dbContext.Database.EnsureCreated(); }
public void GetByIdShouldReturnCommentWithCorrectId() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnCommentWithCorrectId)) .Options; using (var context = new TasksDbContext(options)) { var commentsService = new CommentsService(context); var toAdd = new CommentPostDTO() { Important = true, Text = "A nice task...", }; var current = commentsService.Create(toAdd, null); var expected = commentsService.GetById(current.Id); Assert.IsNotNull(expected); Assert.AreEqual(expected.Text, current.Text); Assert.AreEqual(expected.Id, current.Id); } }
public void InvalidRegisterShouldReturnErrorsCollection() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(InvalidRegisterShouldReturnErrorsCollection)) .Options; using (var context = new TasksDbContext(options)) { var validator = new RegisterValidator(); var usersService = new UsersService(context, validator, null, null, config); var added = new LabIV.DTO.RegisterPostDTO { FirstName = "Julia", LastName = "Bush", Username = "******", Email = "*****@*****.**", Password = "******" }; var result = usersService.Register(added); Assert.IsNotNull(result); Assert.AreEqual(1, result.ErrorMessages.Count()); } }
public void DeleteTaskTest() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(DeleteTaskTest)) .Options; using (var context = new TasksDbContext(options)) { var taskService = new TaskService(context); var addedTask = taskService.Create(new TaskAgendaProj.ViewModels.TaskPostModel { Title = "task de test 1", Description = "agfas", DateTimeAdded = new DateTime(), Deadline = new DateTime(), Importance = "high", Status = "in_progress", DateTimeClosedAt = new DateTime(), Comments = new List <Comment>() { new Comment { Important = true, Text = "bla", Owner = null } }, }, null); var taskDeleted = taskService.Delete(addedTask.Id); Assert.IsNotNull(taskDeleted); } }
public void GetByIdShouldReturnAnValidUser() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnAnValidUser)) .Options; using (var context = new TasksDbContext(options)) { var validator = new RegisterValidator(); var usersService = new UsersService(context, validator, null, null, config); var added = new RegisterPostDTO() { FirstName = "Julia", LastName = "Bush", Username = "******", Email = "*****@*****.**", Password = "******" }; usersService.Register(added); var userById = usersService.GetById(3); Assert.NotNull(userById); Assert.AreEqual("Julia", userById.FirstName); } }
public void GetAllShouldReturnCorrectNumberOfPages() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPages)) .Options; using (var context = new TasksDbContext(options)) { var taskService = new TaskService(context); var addedTask = taskService.Create(new TaskAgendaProj.ViewModels.TaskPostModel { Title = "task de test 1", Description = "agfas", DateTimeAdded = new DateTime(), Deadline = new DateTime(), Importance = "high", Status = "in_progress", DateTimeClosedAt = new DateTime(), Comments = new List <Comment>() { new Comment { Important = true, Text = "bla", Owner = null } }, }, null); var allTasks = taskService.GetAll(1); Assert.NotNull(allTasks); } }
public void ValidRegisterShouldCreateANewUser() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(ValidRegisterShouldCreateANewUser))// "ValidRegisterShouldCreateANewUser") .Options; using (var context = new TasksDbContext(options)) { var validator = new RegisterValidator(); var usersService = new UsersService(context, validator, null, null, config); var added = new RegisterPostDTO() { FirstName = "Julia", LastName = "Bush", 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 void GetAllShouldReturnAllUser() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogInAUser)) .Options; using (var context = new TasksDbContext(options)) { var usersService = new UsersService(context, config); var added = new LabIV.DTO.RegisterPostDTO { FirstName = "Julia", LastName = "Bush", Username = "******", Email = "*****@*****.**", Password = "******" }; var result = usersService.Register(added); var users = usersService.GetAll(); Assert.IsNotEmpty(users); Assert.AreEqual(1, users.Count()); //Assert.IsEmpty(users); } }
public void DeleteShouldDeleteAndReturnTheDeletedUserRole() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(DeleteShouldDeleteAndReturnTheDeletedUserRole)) .Options; using (var context = new TasksDbContext(options)) { var userRoleService = new UserRoleService(context); var addUserRole = new UserRolePostDTO() { Name = "Newcomer", Description = "A new guy..." }; var actual = userRoleService.Create(addUserRole); var afterDelete = userRoleService.Delete(actual.Id); int numberOfUserRoleInDb = context.UserRoles.CountAsync().Result; var resultUR = context.UserRoles.Find(actual.Id); Assert.IsNotNull(afterDelete); Assert.IsNull(resultUR); Assert.AreEqual(0, numberOfUserRoleInDb); } }
public void AuthenticateShouldLogTheUser() { var options = new DbContextOptionsBuilder <TasksDbContext>() .UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogTheUser)) .Options; using (var context = new TasksDbContext(options)) { var usersService = new UsersService(context, config); var added = new TaskAgendaProj.ViewModels.RegisterPostModel { Email = "*****@*****.**", FirstName = "FirstNameTest3", LastName = "LastNameTest3", Password = "******", Username = "******" }; var result = usersService.Register(added); var authenticate = new TaskAgendaProj.ViewModels.LoginPostModel { Username = "******", Password = "******", }; var authenticateresult = usersService.Authenticate(added.Username, added.Password); Assert.IsNotNull(authenticateresult); Assert.AreEqual(1, authenticateresult.Id); Assert.AreEqual(authenticate.Username, authenticateresult.Username); } }
public IEnumerable <UserTask> GetTasks() { using (var db = new TasksDbContext()) { return(db.UserTasks.ToList()); } }