public async Task TaskControllerDeleteUserTest()
{
var uDAL = new DemoUsersDAL();
var tBLL = new DemoTasksBLL(uDAL);
var tasksController = new TasksController(tBLL);
var result = await tasksController.DeleteById(1);
var objectResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(403, objectResult.StatusCode);
await tasksController.Add(new TasklifyTask(1, "summary", "description"));
result = await tasksController.DeleteById(1);
Assert.IsType <NoContentResult>(result);
result = await tasksController.GetAll();
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var taskList = Assert.IsType <List <TasklifyTask> >(okObjectResult.Value);
Assert.Empty(taskList);
}
public void ConfigureServices(IServiceCollection services)
{
var _uDal = new DemoUsersDAL();
services.AddSingleton <IUsersDAL, DemoUsersDAL>(u => _uDal);
services.AddSingleton <ITasksBLL, DemoTasksBLL>(x => new DemoTasksBLL(_uDal));
services.AddControllers().AddNewtonsoftJson();
}
public async Task TaskControllerUpdateTaskTest()
{
var uDAL = new DemoUsersDAL();
var tBLL = new DemoTasksBLL(uDAL);
var tasksController = new TasksController(tBLL);
var result = await tasksController.UpdateById(1, new TasklifyTask(1, "summary", "description"));
var objectResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(403, objectResult.StatusCode);
result = await tasksController.PatchById(1, new JsonPatchDocument <TasklifyTask>());
objectResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(403, objectResult.StatusCode);
await tasksController.Add(new TasklifyTask(1, "summary", "description"));
result = await tasksController.UpdateById(1, new TasklifyTask(1, "", "description"));
var errorObject = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(400, errorObject.StatusCode);
var patchDocument = new JsonPatchDocument <TasklifyTask>();
patchDocument.Replace(task => task.Summary, "");
result = await tasksController.PatchById(1, patchDocument);
errorObject = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(400, errorObject.StatusCode);
var errorString = Assert.IsType <String>(errorObject.Value);
Assert.Equal("Task summary cannot be empty or all whitespace.", errorString);
result = await tasksController.UpdateById(1, new TasklifyTask(1, "newsummary", "description"));
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var task = Assert.IsType <TasklifyTask>(okObjectResult.Value);
Assert.Equal(1, task.Id);
Assert.Equal("newsummary", task.Summary);
Assert.Equal("description", task.Description);
patchDocument = new JsonPatchDocument <TasklifyTask>();
patchDocument.Replace(task => task.Summary, "updatedsummary");
result = await tasksController.PatchById(1, patchDocument);
okObjectResult = Assert.IsType <OkObjectResult>(result);
task = Assert.IsType <TasklifyTask>(okObjectResult.Value);
Assert.Equal(1, task.Id);
Assert.Equal("updatedsummary", task.Summary);
Assert.Equal("description", task.Description);
}
public async Task TaskControllerAddAndGetTest()
{
var uDAL = new DemoUsersDAL();
var tBLL = new DemoTasksBLL(uDAL);
var tasksController = new TasksController(tBLL);
var result = await tasksController.GetAll();
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var taskList = Assert.IsType <List <TasklifyTask> >(okObjectResult.Value);
Assert.Empty(taskList);
result = await tasksController.Add(new TasklifyTask(1, "summary", "description"));
okObjectResult = Assert.IsType <OkObjectResult>(result);
var value = Assert.IsType <TasklifyTask>(okObjectResult.Value);
Assert.Equal(1, value.Id);
Assert.Equal("summary", value.Summary);
Assert.Equal("description", value.Description);
result = await tasksController.Add(new TasklifyTask(1, "", "description"));
var objectResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(400, objectResult.StatusCode);
var errorString = Assert.IsType <String>(objectResult.Value);
Assert.Equal("Task summary cannot be empty or all whitespace.", errorString);
await tasksController.Add(new TasklifyTask(2, "summary2", "description2"));
result = await tasksController.GetAll();
okObjectResult = Assert.IsType <OkObjectResult>(result);
taskList = Assert.IsType <List <TasklifyTask> >(okObjectResult.Value);
Assert.Collection(taskList.OrderBy(user => user.Id),
task => {
Assert.Equal(1, task.Id);
Assert.Equal("summary", task.Summary);
Assert.Equal("description", task.Description);
},
task => {
Assert.Equal(2, task.Id);
Assert.Equal("summary2", task.Summary);
Assert.Equal("description2", task.Description);
});
}
public async Task UserDALSameEmailTestAsync()
{
var userDAL = new DemoUsersDAL();
var userList = await userDAL.GetUsersAsync();
Assert.Empty(userList);
var email = "*****@*****.**";
await userDAL.AddUserAsync(email, "test");
await userDAL.AddUserAsync("*****@*****.**", "test2");
userList = await userDAL.GetUsersAsync();
Assert.Collection(userList.OrderBy(user => user.Id),
user => {
Assert.Equal(1, user.Id);
Assert.Equal(email, user.Email);
Assert.Equal("test", user.Name);
},
user => {
Assert.Equal(2, user.Id);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("test2", user.Name);
});
// Attempt to add a user with the same email as an existing one, exception should be thrown
var exception = await Assert.ThrowsAsync <ValidationException>(() => userDAL.AddUserAsync(email, "test3"));
Assert.Equal("Email already exists for a different user.", exception.Message);
await userDAL.RemoveUserByIdAsync(1);
await userDAL.AddUserAsync(email, "test3");
userList = await userDAL.GetUsersAsync();
Assert.Collection(userList.OrderBy(user => user.Id),
user => {
Assert.Equal(2, user.Id);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("test2", user.Name);
},
user => {
Assert.Equal(3, user.Id);
Assert.Equal(email, user.Email);
Assert.Equal("test3", user.Name);
});
}
public async Task UserControllerAddAndGetTest()
{
var uDAL = new DemoUsersDAL();
var userController = new UsersController(uDAL);
var result = await userController.GetAll();
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var userList = Assert.IsType <List <TasklifyUser> >(okObjectResult.Value);
Assert.Empty(userList);
result = await userController.AddUser(new TasklifyUser(1, "*****@*****.**", "test"));
okObjectResult = Assert.IsType <OkObjectResult>(result);
var value = Assert.IsType <TasklifyUser>(okObjectResult.Value);
Assert.Equal(1, value.Id);
Assert.Equal("*****@*****.**", value.Email);
Assert.Equal("test", value.Name);
result = await userController.AddUser(new TasklifyUser(1, "", "test"));
var objectResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(400, objectResult.StatusCode);
var errorString = Assert.IsType <String>(objectResult.Value);
Assert.Equal("Email cannot be empty or all whitespace.", errorString);
await userController.AddUser(new TasklifyUser(2, "*****@*****.**", "test2"));
result = await userController.GetAll();
okObjectResult = Assert.IsType <OkObjectResult>(result);
userList = Assert.IsType <List <TasklifyUser> >(okObjectResult.Value);
Assert.Collection(userList.OrderBy(user => user.Id),
user => {
Assert.Equal(1, user.Id);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("test", user.Name);
},
user => {
Assert.Equal(2, user.Id);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("test2", user.Name);
});
}
public async Task UserDALValidationTestAsync()
{
async Task TestValidation(Func <string, string, Task <TasklifyUser> > testMethod)
{
var exception = await Assert.ThrowsAsync <ValidationException>(() => testMethod("", "test"));
Assert.Equal("Email cannot be empty or all whitespace.", exception.Message);
exception = await Assert.ThrowsAsync <ValidationException>(() => testMethod(" ", "test"));
Assert.Equal("Email cannot be empty or all whitespace.", exception.Message);
exception = await Assert.ThrowsAsync <ValidationException>(() => testMethod(new String('a', 101), "test"));
Assert.Equal("User email should be less than or equal to 100 characters", exception.Message);
exception = await Assert.ThrowsAsync <ValidationException>(() => testMethod("*****@*****.**", ""));
Assert.Equal("Name cannot be empty or all whitespace.", exception.Message);
exception = await Assert.ThrowsAsync <ValidationException>(() => testMethod("*****@*****.**", " "));
Assert.Equal("Name cannot be empty or all whitespace.", exception.Message);
exception = await Assert.ThrowsAsync <ValidationException>(() => testMethod("*****@*****.**", new String('a', 151)));
Assert.Equal("User name should be less than or equal to 150 characters", exception.Message);
}
var uDAL = new DemoUsersDAL();
await TestValidation((string email, string name) => uDAL.AddUserAsync(email, name));
await uDAL.AddUserAsync("*****@*****.**", "test");
await TestValidation((string email, string name) => uDAL.UpdateUserByIdAsync(1, new TasklifyUser(1, email, name)));
await uDAL.UpdateUserByIdAsync(1, new TasklifyUser(1, "*****@*****.**", "newname"));
var userList = await uDAL.GetUsersAsync();
Assert.Collection(userList,
user => {
Assert.Equal(1, user.Id);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("newname", user.Name);
});
}
public async Task TaskBLLValidAssigneeIdTest()
{
async Task TestValidation(Func <Task <TasklifyTask> > testMethod)
{
var exception = await Assert.ThrowsAsync <ValidationException>(() => testMethod());
Assert.Equal("User with id 1 does not exist.", exception.Message);
}
var uDAL = new DemoUsersDAL();
var tBLL = new DemoTasksBLL(uDAL);
await TestValidation(() => tBLL.AddAsync("summary", "description", 1));
await TestValidation(() => tBLL.UpdateByIdAsync(1, new TasklifyTask(1, "newsummary", "description", 1)));
var patchDocument = new JsonPatchDocument <TasklifyTask>();
patchDocument.Replace(task => task.Assignee_Id, 1);
await TestValidation(() => tBLL.PatchByIdAsync(1, patchDocument));
// Add a user with id 1, now the above operations should go through
await uDAL.AddUserAsync("*****@*****.**", "test");
await tBLL.AddAsync("summary", "description", 1);
await tBLL.UpdateByIdAsync(1, new TasklifyTask(1, "newsummary", "description", 1));
// Add another user so a user with id 2 exists
await uDAL.AddUserAsync("*****@*****.**", "test2");
// Now this id can be assigned to the assignee_id for task 1
patchDocument = new JsonPatchDocument <TasklifyTask>();
patchDocument.Replace(task => task.Assignee_Id, 2);
var task = await tBLL.PatchByIdAsync(1, patchDocument);
Assert.Equal(1, task.Id);
Assert.Equal("newsummary", task.Summary);
Assert.Equal("description", task.Description);
Assert.Equal(2, task.Assignee_Id);
}
public async Task UserControllerGetByIdOrEmailTest()
{
void CheckExpectedResult(IActionResult result)
{
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var user = Assert.IsType <TasklifyUser>(okObjectResult.Value);
Assert.Equal(2, user.Id);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("test2", user.Name);
}
var uDAL = new DemoUsersDAL();
var userController = new UsersController(uDAL);
await userController.AddUser(new TasklifyUser(1, "*****@*****.**", "test"));
await userController.AddUser(new TasklifyUser(2, "*****@*****.**", "test2"));
await userController.AddUser(new TasklifyUser(3, "*****@*****.**", "test3"));
var result = await userController.GetById(2);
CheckExpectedResult(result);
result = await userController.GetByEmail("*****@*****.**");
CheckExpectedResult(result);
result = await userController.GetById(5);
var objectResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(403, objectResult.StatusCode);
result = await userController.GetByEmail("*****@*****.**");
objectResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(403, objectResult.StatusCode);
}
public async Task UserControllerUpdateUserTest()
{
var uDAL = new DemoUsersDAL();
var userController = new UsersController(uDAL);
var result = await userController.UpdateById(1, new TasklifyUser(1, "*****@*****.**", "test"));
var objectResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(403, objectResult.StatusCode);
await userController.AddUser(new TasklifyUser(1, "*****@*****.**", "test"));
result = await userController.UpdateById(1, new TasklifyUser(1, "*****@*****.**", "test"));
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var user = Assert.IsType <TasklifyUser>(okObjectResult.Value);
Assert.Equal(1, user.Id);
Assert.Equal("*****@*****.**", user.Email);
Assert.Equal("test", user.Name);
}
public async Task UserDALGetByEmailTestAsync()
{
async Task TestSearchByEmail(DemoUsersDAL userDAL, string email, int expectedId, string expectedName)
{
var user = await userDAL.GetUserByEmailAsync(email);
Assert.Equal(expectedId, user.Id);
Assert.Equal(email, user.Email);
Assert.Equal(expectedName, user.Name);
}
var uDAL = new DemoUsersDAL();
await uDAL.AddUserAsync("*****@*****.**", "test1");
await uDAL.AddUserAsync("*****@*****.**", "test2");
await uDAL.AddUserAsync("*****@*****.**", "test3");
await TestSearchByEmail(uDAL, "*****@*****.**", 2, "test2");
await TestSearchByEmail(uDAL, "*****@*****.**", 1, "test1");
await TestSearchByEmail(uDAL, "*****@*****.**", 3, "test3");
}
public async Task UserControllerDeleteUserTest()
{
var uDAL = new DemoUsersDAL();
var userController = new UsersController(uDAL);
var result = await userController.DeleteById(1);
var objectResult = Assert.IsType <StatusCodeResult>(result);
Assert.Equal(403, objectResult.StatusCode);
await userController.AddUser(new TasklifyUser(1, "*****@*****.**", "test"));
result = await userController.DeleteById(1);
Assert.IsType <NoContentResult>(result);
result = await userController.GetAll();
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var userList = Assert.IsType <List <TasklifyUser> >(okObjectResult.Value);
Assert.Empty(userList);
}
