Task manager

Wybod.TaskTest.UnitTests/TaskServiceTests.cs

@@ -2,6 +2,7 @@
 using Wybod.TaskTest.Data.Models;
 using Wybod.TaskTest.Data.Repositories;
 using Wybod.TaskTest.Services;
+using Xunit;
 
 namespace Wybod.TaskTest.UnitTests;
 
@@ -19,4 +20,57 @@ public void CreateTaskTest()
 
         taskRepository.Verify(tr => tr.Create(It.IsAny<TaskItem>()), Times.Once);
     }
+
+	[Fact]
+	public void GetTasks_ShouldReturnAllTasks()
+	{
+		var tasks = new List<TaskItem>
+			{
+				new() { Title = "Task 1" },
+				new() { Title = "Task 2" }
+			};
+
+		var taskRepository = new Mock<ITaskRepository>();
+		taskRepository.Setup(r => r.GetAll()).Returns(tasks);
+
+		var taskService = new TaskService(taskRepository.Object);
+
+		var result = taskService.GetTasks();
+
+		Assert.Equal(2, result.Count());
+		Assert.Contains(result, t => t.Title == "Task 1");
+	}
+
+	[Fact]
+	public void CompleteTask_ShouldUpdateStatus_WhenTaskExists()
+	{
+		var taskId = Guid.NewGuid();
+		var task = new TaskItem { Id = taskId, Title = "Test", IsCompleted = false };
+
+		var taskRepository = new Mock<ITaskRepository>();
+		taskRepository.Setup(r => r.GetById(taskId)).Returns(task);
+		taskRepository.Setup(r => r.Update(taskId, It.IsAny<TaskItem>())).Returns(true);
+
+		var taskService = new TaskService(taskRepository.Object);
+
+		var result = taskService.CompleteTask(taskId);
+
+		Assert.True(result);
+		taskRepository.Verify(r => r.Update(taskId, It.Is<TaskItem>(t => t.IsCompleted)), Times.Once);
+	}
+
+	[Fact]
+	public void DeleteTask_ShouldCallRepositoryDelete()
+	{
+		var taskId = Guid.NewGuid();
+		var taskRepository = new Mock<ITaskRepository>();
+		taskRepository.Setup(r => r.Delete(taskId)).Returns(true);
+
+		var taskService = new TaskService(taskRepository.Object);
+
+		var result = taskService.DeleteTask(taskId);
+
+		Assert.True(result);
+		taskRepository.Verify(r => r.Delete(taskId), Times.Once);
+	}
 }

Wybod.TaskTest.UnitTests/TasksControllerTests.cs

@@ -0,0 +1,163 @@
+using Moq;
+using System;
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Mvc;
+using Wybod.TaskTest.Controllers;
+using Wybod.TaskTest.Data.Models;
+using Wybod.TaskTest.Data.Repositories;
+using Wybod.TaskTest.Services;
+using Xunit;
+
+namespace Wybod.TaskTest.UnitTests;
+
+public class TasksControllerTests
+{
+	[Fact]
+	public void GetTasks_ShouldReturnOKWithTasks()
+	{
+		// Arrange
+		var tasks = new List<TaskItem> { new() { Title = "Task 1" } };
+		var testRepo = new Mock<ITaskRepository>();
+		testRepo.Setup(r => r.GetAll()).Returns(tasks);
+		var controller = new TasksController(testRepo.Object);
+
+		// Act
+		var result = controller.GetTasks();
+
+		// Assert
+		var okResult = Assert.IsType<OkObjectResult>(result.Result);
+		var returnedTasks = Assert.IsAssignableFrom<IEnumerable<TaskItem>>(okResult.Value);
+		Assert.Single(returnedTasks);
+	}
+
+	[Fact]
+	public void CreateTask_ShouldReturnCreatedResult()
+	{
+		// Arrange
+		var task = new TaskItem { Id = Guid.NewGuid(), Title = "New Task" };
+		var testRepo = new Mock<ITaskRepository>();
+
+		var controller = new TasksController(testRepo.Object);
+
+		// Act
+		var result = controller.CreateTask(task);
+
+		// Assert
+		var created = Assert.IsType<CreatedAtActionResult>(result.Result);
+		var returnTask = Assert.IsType<TaskItem>(created.Value);
+		Assert.Equal(task.Id, returnTask.Id);
+		testRepo.Verify(r => r.Create(It.IsAny<TaskItem>()), Times.Once);
+	}
+
+	[Fact]
+	public void DeleteTask_ShouldReturnNoContent_WhenSuccessful()
+	{
+		// Arrange
+		var id = Guid.NewGuid();
+		var task = new TaskItem { Id = id, Title = "Test Task" };
+
+		var testRepo = new Mock<ITaskRepository>();
+		testRepo.Setup(r => r.GetById(id)).Returns(task);  // controller finds the task
+		testRepo.Setup(r => r.Delete(id)).Returns(true);   // delete succeeds
+
+		var controller = new TasksController(testRepo.Object);
+
+		// Act
+		var result = controller.DeleteTask(id);
+
+		// Assert
+		Assert.IsType<NoContentResult>(result);
+		testRepo.Verify(r => r.GetById(id), Times.Once);
+		testRepo.Verify(r => r.Delete(id), Times.Once);
+	}
+
+
+	[Fact]
+	public void UpdateTask_ShouldReturnNoContent_WhenSuccessful()
+	{
+		// Arrange
+		var id = Guid.NewGuid();
+		var existingTask = new TaskItem { Id = id, Title = "Old Task", Description = "Old Desc", IsCompleted = false };
+		var updatedTask = new TaskItem { Title = "New Task", Description = "New Desc", IsCompleted = true };
+
+		var testRepo = new Mock<ITaskRepository>();
+		testRepo.Setup(r => r.GetById(id)).Returns(existingTask);
+		testRepo.Setup(r => r.Update(id, It.IsAny<TaskItem>())).Returns(true);
+
+		var controller = new TasksController(testRepo.Object);
+
+		// Act
+		var result = controller.UpdateTask(id, updatedTask);
+
+		// Assert
+		Assert.IsType<NoContentResult>(result);
+		testRepo.Verify(r => r.GetById(id), Times.Once);
+		testRepo.Verify(r => r.Update(id, It.Is<TaskItem>(t =>
+			t.Title == "New Task" &&
+			t.Description == "New Desc" &&
+			t.IsCompleted == true
+		)), Times.Once);
+	}
+
+	[Fact]
+	public void UpdateTask_ShouldReturnNotFound_WhenTaskDoesNotExist()
+	{
+		// Arrange
+		var id = Guid.NewGuid();
+		var updatedTask = new TaskItem { Title = "Updated", Description = "Updated Desc", IsCompleted = true };
+
+		var testRepo = new Mock<ITaskRepository>();
+		testRepo.Setup(r => r.GetById(id)).Returns((TaskItem?)null);
+
+		var controller = new TasksController(testRepo.Object);
+
+		// Act
+		var result = controller.UpdateTask(id, updatedTask);
+
+		// Assert
+		Assert.IsType<NotFoundResult>(result);
+		testRepo.Verify(r => r.GetById(id), Times.Once);
+		testRepo.Verify(r => r.Update(It.IsAny<Guid>(), It.IsAny<TaskItem>()), Times.Never);
+	}
+
+	[Fact]
+	public void UpdateTask_ShouldReturnServerError_WhenUpdateFails()
+	{
+		// Arrange
+		var id = Guid.NewGuid();
+		var existingTask = new TaskItem { Id = id, Title = "Existing" };
+		var updatedTask = new TaskItem { Title = "Updated" };
+
+		var testRepo = new Mock<ITaskRepository>();
+		testRepo.Setup(r => r.GetById(id)).Returns(existingTask);
+		testRepo.Setup(r => r.Update(id, It.IsAny<TaskItem>())).Returns(false);
+
+		var controller = new TasksController(testRepo.Object);
+
+		// Act
+		var result = controller.UpdateTask(id, updatedTask);
+
+		// Assert
+		var statusResult = Assert.IsType<ObjectResult>(result);
+		Assert.Equal(500, statusResult.StatusCode);
+		testRepo.Verify(r => r.Update(id, It.IsAny<TaskItem>()), Times.Once);
+	}
+
+
+	[Fact]
+	public void DeleteTask_ShouldReturnNotFound_WhenNotDeleted()
+	{
+		// Arrange
+		var id = Guid.NewGuid();
+		var testRepo = new Mock<ITaskRepository>();
+		testRepo.Setup(r => r.Delete(id)).Returns(false);
+
+		var controller = new TasksController(testRepo.Object);
+
+		// Act
+		var result = controller.DeleteTask(id);
+
+		// Assert
+		Assert.IsType<NotFoundResult>(result);
+	}
+}

Wybod.TaskTest.UnitTests/Wybod.TaskTest.UnitTests.csproj

@@ -10,15 +10,18 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="coverlet.collector" Version="6.0.0"/>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
+        <PackageReference Include="coverlet.collector" Version="6.0.0" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
         <PackageReference Include="Moq" Version="4.20.72" />
-        <PackageReference Include="xunit" Version="2.5.3"/>
-        <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3"/>
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+		<PrivateAssets>all</PrivateAssets>
+      		<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	</PackageReference>
     </ItemGroup>
 
     <ItemGroup>
-        <Using Include="Xunit"/>
+        <Using Include="Xunit" />
     </ItemGroup>
 
     <ItemGroup>