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());
}
}
