Clean Architecture Demo
Loading...
Searching...
No Matches
TasksControllerTests.cs
Go to the documentation of this file.
1using System.Net;
2using System.Net.Http.Headers;
3using System.Net.Http.Json;
4using System.Text.Json;
5using Microsoft.AspNetCore.Mvc.Testing;
9
11
17[TestFixture]
19{
20 private WebApplicationFactory<Program> _factory = null!;
21 private HttpClient _httpClient = null!;
22 private static string _bearerToken => BearerToken.Value;
23
24 [SetUp]
25 public void Setup()
26 {
27 _factory = new WebApplicationFactory<Program>()
28 .WithWebHostBuilder(builder =>
29 {
30 // Disable HTTPS redirect for testing
31 builder.UseSetting("https_port", "");
32 // Mostrar los mensajes de los manejadores de eventos del dominio; se ven con
33 // dotnet test --logger "console;verbosity=detailed"
34 builder.UseSetting("Logging:LogLevel:Default", "Information");
35 });
36 _httpClient = _factory.CreateClient();
37 }
38
39 [TearDown]
40 public void TearDown()
41 {
42 _httpClient.Dispose();
43 _factory.Dispose();
44 }
45
46 #region Create Task Tests
47
54 [Test]
56 {
57 // Arrange
58 var createRequest = new CreateTaskRequest(
59 title: "Finish Clean Architecture demo",
60 description: "Wire up in-memory SQLite and verify endpoint tests",
61 priority: TaskPriorityLevel.High,
62 dueDate: new DateTime(2027, 5, 20, 18, 0, 0, DateTimeKind.Utc)
63 );
64
65 var request = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
66 {
67 Content = JsonContent.Create(createRequest),
68 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
69 };
70
71 // Act
72 var response = await _httpClient.SendAsync(request);
73
74 // Assert
75 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created), "Expected 201 Created status");
76
77 var taskId = await response.Content.ReadAsAsync<Guid>();
78 Assert.That(taskId, Is.Not.EqualTo(Guid.Empty), "Expected a valid task ID");
79
80 // Verify the task was persisted by retrieving it
81 var getResponse = await _httpClient.GetAsync($"/api/tasks/{taskId}");
82 Assert.That(getResponse.StatusCode, Is.EqualTo(HttpStatusCode.OK), "Task should exist after creation");
83
84 var retrievedTask = await getResponse.Content.ReadAsAsync<TaskViewModel>();
85 Assert.That(retrievedTask.Title, Is.EqualTo(createRequest.Title), "Task title should match");
86 Assert.That(retrievedTask.Description, Is.EqualTo(createRequest.Description), "Task description should match");
87 Assert.That(retrievedTask.Priority, Is.EqualTo(createRequest.Priority.ToString()), "Task priority should match");
88 }
89
96 [Test]
98 {
99 // Arrange
100 var createRequest = new CreateTaskRequest(
101 title: "Test Task",
102 description: "Test Description",
103 priority: TaskPriorityLevel.Medium,
104 dueDate: DateTime.UtcNow.AddDays(7)
105 );
106
107 var request = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
108 {
109 Content = JsonContent.Create(createRequest)
110 };
111
112 // Act
113 var response = await _httpClient.SendAsync(request);
114
115 // Assert
116 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized), "Expected 401 Unauthorized when no bearer token");
117 }
118
125 [Test]
127 {
128 // Arrange
129 var createRequest = new CreateTaskRequest(
130 title: "",
131 description: "Valid Description",
132 priority: TaskPriorityLevel.High,
133 dueDate: DateTime.UtcNow.AddDays(7)
134 );
135
136 var request = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
137 {
138 Content = JsonContent.Create(createRequest),
139 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
140 };
141
142 // Act
143 var response = await _httpClient.SendAsync(request);
144
145 // Assert
146 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Expected 400 BadRequest for missing title");
147 }
148
155 [Test]
156 [TestCase(TaskPriorityLevel.Low)]
157 [TestCase(TaskPriorityLevel.Medium)]
158 [TestCase(TaskPriorityLevel.High)]
160 {
161 // Arrange
162 var createRequest = new CreateTaskRequest(
163 title: $"Task with {priority} priority",
164 description: "Test task for priority validation",
165 priority: priority,
166 dueDate: DateTime.UtcNow.AddDays(7)
167 );
168
169 var request = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
170 {
171 Content = JsonContent.Create(createRequest),
172 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
173 };
174
175 // Act
176 var response = await _httpClient.SendAsync(request);
177
178 // Assert
179 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created), $"Expected 201 Created for {priority} priority");
180
181 var taskId = await response.Content.ReadAsAsync<Guid>();
182 var getResponse = await _httpClient.GetAsync($"/api/tasks/{taskId}");
183 var task = await getResponse.Content.ReadAsAsync<TaskViewModel>();
184
185 Assert.That(task.Priority, Is.EqualTo(priority.ToString()), $"Task priority should be {priority}");
186 }
187
188 #endregion
189
190 #region Get Task By Id Tests
191
198 [Test]
200 {
201 // Arrange - Create a task first
202 var createRequest = new CreateTaskRequest(
203 title: "Task to Retrieve",
204 description: "This task will be retrieved",
205 priority: TaskPriorityLevel.Medium,
206 dueDate: new DateTime(2027, 6, 15, 10, 0, 0, DateTimeKind.Utc)
207 );
208
209 var createHttpRequest = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
210 {
211 Content = JsonContent.Create(createRequest),
212 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
213 };
214
215 var createResponse = await _httpClient.SendAsync(createHttpRequest);
216 var taskId = await createResponse.Content.ReadAsAsync<Guid>();
217
218 // Act
219 var getResponse = await _httpClient.GetAsync($"/api/tasks/{taskId}");
220
221 // Assert
222 Assert.That(getResponse.StatusCode, Is.EqualTo(HttpStatusCode.OK), "Expected 200 OK when task exists");
223
224 var task = await getResponse.Content.ReadAsAsync<TaskViewModel>();
225 Assert.That(task.Id, Is.EqualTo(taskId.ToString()).IgnoreCase, "Task ID should match");
226 Assert.That(task.Title, Is.EqualTo(createRequest.Title), "Task title should match");
227 Assert.That(task.Status, Is.EqualTo("Todo"), "New task should have Todo status");
228 Assert.That(task.CreatedBy, Is.Not.Empty, "Task should have a creator");
229 }
230
237 [Test]
239 {
240 // Arrange
241 var nonExistentId = Guid.NewGuid();
242
243 // Act
244 var response = await _httpClient.GetAsync($"/api/tasks/{nonExistentId}");
245
246 // Assert
247 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound), "Expected 404 NotFound for non-existent task");
248 }
249
256 [Test]
258 {
259 // Arrange
260 var invalidId = "not-a-guid";
261
262 // Act
263 var response = await _httpClient.GetAsync($"/api/tasks/{invalidId}");
264
265 // Assert
266 Assert.That(
267 response.StatusCode == HttpStatusCode.BadRequest || response.StatusCode == HttpStatusCode.NotFound,
268 "Expected 400 BadRequest or 404 NotFound for invalid GUID format"
269 );
270 }
271
272 #endregion
273
274 #region Complete Task Tests
275
282 [Test]
284 {
285 // Arrange - Create a task first
286 var createRequest = new CreateTaskRequest(
287 title: "Task to Complete",
288 description: "This task will be completed",
289 priority: TaskPriorityLevel.High,
290 dueDate: DateTime.UtcNow.AddDays(3)
291 );
292
293 var createHttpRequest = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
294 {
295 Content = JsonContent.Create(createRequest),
296 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
297 };
298
299 var createResponse = await _httpClient.SendAsync(createHttpRequest);
300 var taskId = await createResponse.Content.ReadAsAsync<Guid>();
301
302 // Act - Complete the task
303 var completeRequest = new HttpRequestMessage(HttpMethod.Post, $"/api/tasks/{taskId}/complete")
304 {
305 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
306 };
307
308 var completeResponse = await _httpClient.SendAsync(completeRequest);
309
310 // Assert
311 Assert.That(completeResponse.StatusCode, Is.EqualTo(HttpStatusCode.NoContent), "Expected 204 NoContent when task completed");
312
313 // Verify the task status was updated
314 var getResponse = await _httpClient.GetAsync($"/api/tasks/{taskId}");
315 var completedTask = await getResponse.Content.ReadAsAsync<TaskViewModel>();
316
317 Assert.That(completedTask.Status, Is.EqualTo("Completed"), "Task status should be Completed");
318 Assert.That(completedTask.Id, Is.EqualTo(taskId.ToString()).IgnoreCase, "Task ID should remain unchanged");
319 }
320
327 [Test]
329 {
330 // Arrange
331 var taskId = Guid.NewGuid();
332
333 // Act
334 var response = await _httpClient.PostAsync($"/api/tasks/{taskId}/complete", null);
335
336 // Assert
337 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized), "Expected 401 Unauthorized when no bearer token");
338 }
339
346 [Test]
348 {
349 // Arrange
350 var nonExistentId = Guid.NewGuid();
351
352 var request = new HttpRequestMessage(HttpMethod.Post, $"/api/tasks/{nonExistentId}/complete")
353 {
354 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
355 };
356
357 // Act
358 var response = await _httpClient.SendAsync(request);
359
360 // Assert
361 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound), "Expected 404 NotFound for non-existent task");
362 }
363
371 [Test]
373 {
374 // Arrange - Create and complete a task
375 var createRequest = new CreateTaskRequest(
376 title: "Already Completed Task",
377 description: "This task is already completed",
378 priority: TaskPriorityLevel.Low,
379 dueDate: DateTime.UtcNow.AddDays(1)
380 );
381
382 var createHttpRequest = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
383 {
384 Content = JsonContent.Create(createRequest),
385 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
386 };
387
388 var createResponse = await _httpClient.SendAsync(createHttpRequest);
389 var taskId = await createResponse.Content.ReadAsAsync<Guid>();
390
391 // Complete it once
392 var completeRequest1 = new HttpRequestMessage(HttpMethod.Post, $"/api/tasks/{taskId}/complete")
393 {
394 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
395 };
396 await _httpClient.SendAsync(completeRequest1);
397
398 // Act - Try to complete it again
399 var completeRequest2 = new HttpRequestMessage(HttpMethod.Post, $"/api/tasks/{taskId}/complete")
400 {
401 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
402 };
403
404 var response = await _httpClient.SendAsync(completeRequest2);
405
406 // Assert
407 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest), "Expected 400 BadRequest when completing already completed task");
408
409 var jsonContent = await response.Content.ReadAsStringAsync();
410 using var jsonDoc = JsonDocument.Parse(jsonContent);
411 var detail = jsonDoc.RootElement.GetProperty("detail").GetString();
412 Assert.That(detail, Does.Contain("already completed"), "Error message should mention task is already completed");
413 }
414
415 #endregion
416
417 #region Workflow Tests
418
431 [Test]
433 {
434 // Arrange
435 var createRequest = new CreateTaskRequest(
436 title: "Finish Clean Architecture demo",
437 description: "Wire up in-memory SQLite and verify endpoint tests",
438 priority: TaskPriorityLevel.High,
439 dueDate: new DateTime(2027, 5, 20, 18, 0, 0, DateTimeKind.Utc)
440 );
441
442 // Act 1 - Create Task
443 var createHttpRequest = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
444 {
445 Content = JsonContent.Create(createRequest),
446 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
447 };
448
449 var createResponse = await _httpClient.SendAsync(createHttpRequest);
450 Assert.That(createResponse.StatusCode, Is.EqualTo(HttpStatusCode.Created), "Task creation should succeed");
451
452 var taskId = await createResponse.Content.ReadAsAsync<Guid>();
453
454 // Act 2 - Get Task By Id
455 var getResponse = await _httpClient.GetAsync($"/api/tasks/{taskId}");
456 Assert.That(getResponse.StatusCode, Is.EqualTo(HttpStatusCode.OK), "Task retrieval should succeed");
457
458 var task = await getResponse.Content.ReadAsAsync<TaskViewModel>();
459 Assert.That(task.Title, Is.EqualTo(createRequest.Title), "Retrieved task should have correct title");
460 Assert.That(task.Status, Is.EqualTo("Todo"), "New task should have Todo status");
461
462 // Act 3 - Complete Task
463 var completeRequest = new HttpRequestMessage(HttpMethod.Post, $"/api/tasks/{taskId}/complete")
464 {
465 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
466 };
467
468 var completeResponse = await _httpClient.SendAsync(completeRequest);
469 Assert.That(completeResponse.StatusCode, Is.EqualTo(HttpStatusCode.NoContent), "Task completion should succeed");
470
471 // Act 4 - Verify Status Updated
472 var verifyResponse = await _httpClient.GetAsync($"/api/tasks/{taskId}");
473 var completedTask = await verifyResponse.Content.ReadAsAsync<TaskViewModel>();
474
475 Assert.That(completedTask.Status, Is.EqualTo("Completed"), "Completed task should have Completed status");
476 Assert.That(completedTask.Title, Is.EqualTo(task.Title), "Task title should remain unchanged");
477 Assert.That(completedTask.Description, Is.EqualTo(task.Description), "Task description should remain unchanged");
478 }
479
480 #endregion
481
482 #region Concurrent Operations Tests
483
490 [Test]
492 {
493 // Arrange
494 var taskData = new[]
495 {
496 new CreateTaskRequest("Task 1", "Description 1", TaskPriorityLevel.Low, null),
497 new CreateTaskRequest("Task 2", "Description 2", TaskPriorityLevel.Medium, DateTime.UtcNow.AddDays(5)),
498 new CreateTaskRequest("Task 3", "Description 3", TaskPriorityLevel.High, DateTime.UtcNow.AddDays(10))
499 };
500
501 // Act - Create all tasks concurrently
502 var createTasks = taskData.Select(async taskRequest =>
503 {
504 var request = new HttpRequestMessage(HttpMethod.Post, "/api/tasks")
505 {
506 Content = JsonContent.Create(taskRequest),
507 Headers = { Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken) }
508 };
509
510 var response = await _httpClient.SendAsync(request);
511 Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created), "Each task creation should succeed");
512
513 return await response.Content.ReadAsAsync<Guid>();
514 }).ToList();
515
516 var taskIds = new List<Guid>(await Task.WhenAll(createTasks));
517
518 // Assert
519 Assert.That(taskIds.Count, Is.EqualTo(3), "Should have created 3 tasks");
520 Assert.That(taskIds.Distinct().Count(), Is.EqualTo(3), "All task IDs should be unique");
521
522 // Verify each task exists with correct data
523 for (int i = 0; i < taskIds.Count; i++)
524 {
525 var response = await _httpClient.GetAsync($"/api/tasks/{taskIds[i]}");
526 var task = await response.Content.ReadAsAsync<TaskViewModel>();
527
528 Assert.That(task.Title, Is.EqualTo(taskData[i].Title), $"Task {i} title should match");
529 Assert.That(task.Description, Is.EqualTo(taskData[i].Description), $"Task {i} description should match");
530 }
531 }
532
533 #endregion
534}
var builder
Definition Program.cs:60
TasksControllerTests contiene pruebas de integración para los endpoints del TasksController....
async Task CreateTask_WithValidData_ReturnsCreatedStatusAndTaskId()
Prueba crear una tarea exitosamente. Valida el endpoint "Create Task" en forma análoga al archivo ....
async Task GetTaskById_WithInvalidGuid_ReturnsBadRequestOrNotFound()
Prueba obtener tarea con GUID inválido. Valida la validación de entrada para el ID de la tarea....
async Task CompleteTask_WhenAlreadyCompleted_ReturnsBadRequest()
Prueba completar tarea ya completada. Valida la regla de negocio: No se puede completar una tarea ya ...
async Task CompleteWorkflow_CreateGetAndCompleteTask_SucceedsWithConsistentData()
Prueba flujo de trabajo completo: Crear → Obtener → Completar → Verificar Valida el flujo de trabajo ...
async Task CreateTask_WithMissingTitle_ReturnsBadRequest()
Prueba crear una tarea sin título. Valida la validación de campos requeridos. En este escenario el us...
async Task CreateMultipleTasks_WithDifferentData_CreatesMultipleIndependentTasks()
Prueba creación de múltiples tareas simultáneamente. Valida la creación de múltiples tareas de forma ...
async Task GetTaskById_WithNonExistentId_ReturnsNotFound()
Prueba obtener una tarea con ID inexistente. Valida el manejo de errores para tareas que no existen....
async Task CreateTask_WithDifferentPriorities_CreatesTasksSuccessfully(TaskPriorityLevel priority)
Prueba crear una tarea con diferentes prioridades. Valida la creación de tareas con diferentes nivele...
async Task CompleteTask_WithoutAuthentication_ReturnsUnauthorized()
Prueba completar tarea sin autenticación. Valida el requisito de autorización para la finalización de...
async Task CompleteTask_WithValidId_ReturnsNoContentAndUpdatesStatus()
Prueba completar una tarea exitosamente. Valida el endpoint "CompleteTask" en forma análoga al archiv...
async Task CompleteTask_WithNonExistentId_ReturnsNotFound()
Prueba completar tarea inexistente. Valida el manejo de errores al completar una tarea que no existe....
async Task GetTaskById_WithValidId_ReturnsOkAndTaskDetails()
Prueba obtener una tarea por ID exitosamente. Valida el endpoint "GetTask By Id" en forma análoga al ...
async Task CreateTask_WithoutAuthentication_ReturnsUnauthorized()
Prueba crear una tarea sin autenticación. Valida el requisito de autorización para la creación de tar...
TaskViewModel es la representación de una tarea en las respuestas de la API REST.
TaskPriorityLevel
TaskPriorityLevel es la prioridad de una tarea tal como la ven los DTO de los casos de uso....
CreateTaskRequest(string title, string description, TaskPriorityLevel priority, DateTime? dueDate)