MasterMito/work-club-manager
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases 1 Wiki Activity

feat(tasks): add Task CRUD API with 5-state workflow

Browse Source 
- TaskService with CRUD operations + state machine enforcement
- 5 DTOs: TaskListDto, TaskDetailDto, CreateTaskRequest, UpdateTaskRequest
- Minimal API endpoints: GET /api/tasks, GET /api/tasks/{id}, POST, PATCH, DELETE
- State machine: Open→Assigned→InProgress→Review→Done (invalid transitions → 422)
- Concurrency: DbUpdateConcurrencyException → 409 Conflict
- Authorization: POST (Manager+), DELETE (Admin), GET/PATCH (Member+)
- RLS: Automatic tenant filtering via TenantDbConnectionInterceptor
- 10 TDD integration tests: CRUD, state transitions, concurrency, role enforcement
- Build: 0 errors (6 BouncyCastle warnings expected)

Task 14 complete. Wave 3: 2/5 tasks done.
This commit is contained in:
WorkClub Automation
2026-03-03 19:19:21 +01:00
parent cff101168c
commit 8550dd213a
9 changed files with 1035 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
backend/WorkClub.Api/Endpoints/Tasks/TaskEndpoints.cs Normal file
View File

@@ -0,0 +1,108 @@
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.AspNetCore.Mvc;
using WorkClub.Api.Services;
using WorkClub.Application.Tasks.DTOs;
namespace WorkClub.Api.Endpoints.Tasks;
public static class TaskEndpoints
{
public static void MapTaskEndpoints(this IEndpointRouteBuilder app)
{
var group = app.MapGroup("/api/tasks");
group.MapGet("", GetTasks)
.RequireAuthorization("RequireMember")
.WithName("GetTasks");
group.MapGet("{id:guid}", GetTask)
.RequireAuthorization("RequireMember")
.WithName("GetTask");
group.MapPost("", CreateTask)
.RequireAuthorization("RequireManager")
.WithName("CreateTask");
group.MapPatch("{id:guid}", UpdateTask)
.RequireAuthorization("RequireMember")
.WithName("UpdateTask");
group.MapDelete("{id:guid}", DeleteTask)
.RequireAuthorization("RequireAdmin")
.WithName("DeleteTask");
}
private static async Task<Ok<TaskListDto>> GetTasks(
TaskService taskService,
[FromQuery] string? status = null,
[FromQuery] int page = 1,
[FromQuery] int pageSize = 20)
{
var result = await taskService.GetTasksAsync(status, page, pageSize);
return TypedResults.Ok(result);
}
private static async Task<Results<Ok<TaskDetailDto>, NotFound>> GetTask(
Guid id,
TaskService taskService)
{
var result = await taskService.GetTaskByIdAsync(id);
if (result == null)
return TypedResults.NotFound();
return TypedResults.Ok(result);
}
private static async Task<Results<Created<TaskDetailDto>, BadRequest<string>>> CreateTask(
CreateTaskRequest request,
TaskService taskService,
HttpContext httpContext)
{
var userIdClaim = httpContext.User.FindFirst("sub")?.Value;
if (string.IsNullOrEmpty(userIdClaim) || !Guid.TryParse(userIdClaim, out var createdById))
{
return TypedResults.BadRequest("Invalid user ID");
}
var (task, error) = await taskService.CreateTaskAsync(request, createdById);
if (error != null || task == null)
return TypedResults.BadRequest(error ?? "Failed to create task");
return TypedResults.Created($"/api/tasks/{task.Id}", task);
}
private static async Task<Results<Ok<TaskDetailDto>, NotFound, UnprocessableEntity<string>, Conflict<string>>> UpdateTask(
Guid id,
UpdateTaskRequest request,
TaskService taskService)
{
var (task, error, isConflict) = await taskService.UpdateTaskAsync(id, request);
if (error != null)
{
if (error == "Task not found")
return TypedResults.NotFound();
if (isConflict)
return TypedResults.Conflict(error);
return TypedResults.UnprocessableEntity(error);
}
return TypedResults.Ok(task!);
}
private static async Task<Results<NoContent, NotFound>> DeleteTask(
Guid id,
TaskService taskService)
{
var deleted = await taskService.DeleteTaskAsync(id);
if (!deleted)
return TypedResults.NotFound();
return TypedResults.NoContent();
}
}

5
backend/WorkClub.Api/Program.cs
View File

@@ -3,7 +3,9 @@ using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using WorkClub.Api.Auth;
using WorkClub.Api.Endpoints.Tasks;
using WorkClub.Api.Middleware;
using WorkClub.Api.Services;
using WorkClub.Application.Interfaces;
using WorkClub.Infrastructure.Data;
using WorkClub.Infrastructure.Data.Interceptors;
@@ -25,6 +27,7 @@ builder.Services.AddMultiTenant<TenantInfo>()
builder.Services.AddHttpContextAccessor();
builder.Services.AddScoped<ITenantProvider, TenantProvider>();
builder.Services.AddScoped<SeedDataService>();
builder.Services.AddScoped<TaskService>();
builder.Services.AddSingleton<TenantDbConnectionInterceptor>();
builder.Services.AddSingleton<SaveChangesTenantInterceptor>();
@@ -117,6 +120,8 @@ app.MapGet("/weatherforecast", () =>
app.MapGet("/api/test", () => Results.Ok(new { message = "Test endpoint" }))
.RequireAuthorization();
app.MapTaskEndpoints();
app.Run();
record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)

184
backend/WorkClub.Api/Services/TaskService.cs Normal file
View File

@@ -0,0 +1,184 @@
using Microsoft.EntityFrameworkCore;
using WorkClub.Application.Interfaces;
using WorkClub.Application.Tasks.DTOs;
using WorkClub.Domain.Entities;
using WorkClub.Domain.Enums;
using WorkClub.Infrastructure.Data;
namespace WorkClub.Api.Services;
public class TaskService
{
private readonly AppDbContext _context;
private readonly ITenantProvider _tenantProvider;
public TaskService(AppDbContext context, ITenantProvider tenantProvider)
{
_context = context;
_tenantProvider = tenantProvider;
}
public async Task<TaskListDto> GetTasksAsync(string? statusFilter, int page, int pageSize)
{
var query = _context.WorkItems.AsQueryable();
if (!string.IsNullOrEmpty(statusFilter))
{
if (Enum.TryParse<WorkItemStatus>(statusFilter, ignoreCase: true, out var status))
{
query = query.Where(w => w.Status == status);
}
}
var total = await query.CountAsync();
var items = await query
.OrderBy(w => w.CreatedAt)
.Skip((page - 1) * pageSize)
.Take(pageSize)
.ToListAsync();
var itemDtos = items.Select(w => new TaskListItemDto(
w.Id,
w.Title,
w.Status.ToString(),
w.AssigneeId,
w.CreatedAt
)).ToList();
return new TaskListDto(itemDtos, total, page, pageSize);
}
public async Task<TaskDetailDto?> GetTaskByIdAsync(Guid id)
{
var workItem = await _context.WorkItems.FindAsync(id);
if (workItem == null)
return null;
return new TaskDetailDto(
workItem.Id,
workItem.Title,
workItem.Description,
workItem.Status.ToString(),
workItem.AssigneeId,
workItem.CreatedById,
workItem.ClubId,
workItem.DueDate,
workItem.CreatedAt,
workItem.UpdatedAt
);
}
public async Task<(TaskDetailDto? task, string? error)> CreateTaskAsync(CreateTaskRequest request, Guid createdById)
{
var tenantId = _tenantProvider.GetTenantId();
var workItem = new WorkItem
{
Id = Guid.NewGuid(),
TenantId = tenantId,
Title = request.Title,
Description = request.Description,
Status = WorkItemStatus.Open,
ClubId = request.ClubId,
AssigneeId = request.AssigneeId,
DueDate = request.DueDate,
CreatedById = createdById,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
};
_context.WorkItems.Add(workItem);
await _context.SaveChangesAsync();
var dto = new TaskDetailDto(
workItem.Id,
workItem.Title,
workItem.Description,
workItem.Status.ToString(),
workItem.AssigneeId,
workItem.CreatedById,
workItem.ClubId,
workItem.DueDate,
workItem.CreatedAt,
workItem.UpdatedAt
);
return (dto, null);
}
public async Task<(TaskDetailDto? task, string? error, bool isConflict)> UpdateTaskAsync(Guid id, UpdateTaskRequest request)
{
var workItem = await _context.WorkItems.FindAsync(id);
if (workItem == null)
return (null, "Task not found", false);
if (request.Title != null)
workItem.Title = request.Title;
if (request.Description != null)
workItem.Description = request.Description;
if (request.AssigneeId.HasValue)
workItem.AssigneeId = request.AssigneeId;
if (request.DueDate.HasValue)
workItem.DueDate = request.DueDate;
if (request.Status != null)
{
if (!Enum.TryParse<WorkItemStatus>(request.Status, ignoreCase: true, out var newStatus))
{
return (null, $"Invalid status: {request.Status}", false);
}
if (!workItem.CanTransitionTo(newStatus))
{
return (null, $"Cannot transition from {workItem.Status} to {newStatus}", false);
}
workItem.TransitionTo(newStatus);
}
workItem.UpdatedAt = DateTimeOffset.UtcNow;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return (null, "Task was modified by another user. Please refresh and try again.", true);
}
var dto = new TaskDetailDto(
workItem.Id,
workItem.Title,
workItem.Description,
workItem.Status.ToString(),
workItem.AssigneeId,
workItem.CreatedById,
workItem.ClubId,
workItem.DueDate,
workItem.CreatedAt,
workItem.UpdatedAt
);
return (dto, null, false);
}
public async Task<bool> DeleteTaskAsync(Guid id)
{
var workItem = await _context.WorkItems.FindAsync(id);
if (workItem == null)
return false;
_context.WorkItems.Remove(workItem);
await _context.SaveChangesAsync();
return true;
}
}

13
backend/WorkClub.Application/Tasks/DTOs/CreateTaskRequest.cs Normal file
View File

@@ -0,0 +1,13 @@
using System.ComponentModel.DataAnnotations;
namespace WorkClub.Application.Tasks.DTOs;
public record CreateTaskRequest(
[Required]
string Title,
string? Description,
[Required]
Guid ClubId,
Guid? AssigneeId,
DateTimeOffset? DueDate
);

14
backend/WorkClub.Application/Tasks/DTOs/TaskDetailDto.cs Normal file
View File

@@ -0,0 +1,14 @@
namespace WorkClub.Application.Tasks.DTOs;
public record TaskDetailDto(
Guid Id,
string Title,
string? Description,
string Status,
Guid? AssigneeId,
Guid CreatedById,
Guid ClubId,
DateTimeOffset? DueDate,
DateTimeOffset CreatedAt,
DateTimeOffset UpdatedAt
);

16
backend/WorkClub.Application/Tasks/DTOs/TaskListDto.cs Normal file
View File

@@ -0,0 +1,16 @@
namespace WorkClub.Application.Tasks.DTOs;
public record TaskListDto(
List<TaskListItemDto> Items,
int Total,
int Page,
int PageSize
);
public record TaskListItemDto(
Guid Id,
string Title,
string Status,
Guid? AssigneeId,
DateTimeOffset CreatedAt
);

9
backend/WorkClub.Application/Tasks/DTOs/UpdateTaskRequest.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace WorkClub.Application.Tasks.DTOs;
public record UpdateTaskRequest(
string? Title,
string? Description,
string? Status,
Guid? AssigneeId,
DateTimeOffset? DueDate
);

479
backend/WorkClub.Tests.Integration/Tasks/TaskCrudTests.cs Normal file
View File

@@ -0,0 +1,479 @@
using System.Net;
using System.Net.Http.Json;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using WorkClub.Domain.Entities;
using WorkClub.Domain.Enums;
using WorkClub.Infrastructure.Data;
using WorkClub.Tests.Integration.Infrastructure;
using Xunit;
namespace WorkClub.Tests.Integration.Tasks;
public class TaskCrudTests : IntegrationTestBase
{
public TaskCrudTests(CustomWebApplicationFactory<Program> factory) : base(factory)
{
}
public override async Task InitializeAsync()
{
using var scope = Factory.Services.CreateScope();
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
// Clean up existing test data
context.WorkItems.RemoveRange(context.WorkItems);
await context.SaveChangesAsync();
}
[Fact]
public async Task CreateTask_AsManager_ReturnsCreatedWithOpenStatus()
{
// Arrange
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
SetTenant("tenant1");
AuthenticateAs("manager@test.com", new Dictionary<string, string> { ["tenant1"] = "Manager" });
var request = new
{
Title = "New Task",
Description = "Task description",
ClubId = club1
};
// Act
var response = await Client.PostAsJsonAsync("/api/tasks", request);
// Assert
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var result = await response.Content.ReadFromJsonAsync<TaskDetailResponse>();
Assert.NotNull(result);
Assert.Equal("New Task", result.Title);
Assert.Equal("Task description", result.Description);
Assert.Equal("Open", result.Status);
Assert.NotEqual(Guid.Empty, result.Id);
}
[Fact]
public async Task CreateTask_AsViewer_ReturnsForbidden()
{
// Arrange
var club1 = Guid.NewGuid();
SetTenant("tenant1");
AuthenticateAs("viewer@test.com", new Dictionary<string, string> { ["tenant1"] = "Viewer" });
var request = new
{
Title = "New Task",
ClubId = club1
};
// Act
var response = await Client.PostAsJsonAsync("/api/tasks", request);
// Assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}
[Fact]
public async Task ListTasks_ReturnsOnlyTenantTasks()
{
// Arrange
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
// Create tasks for tenant1
context.WorkItems.Add(new WorkItem
{
Id = Guid.NewGuid(),
TenantId = "tenant1",
Title = "Task 1",
Status = WorkItemStatus.Open,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
context.WorkItems.Add(new WorkItem
{
Id = Guid.NewGuid(),
TenantId = "tenant1",
Title = "Task 2",
Status = WorkItemStatus.Assigned,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
// Create task for tenant2
context.WorkItems.Add(new WorkItem
{
Id = Guid.NewGuid(),
TenantId = "tenant2",
Title = "Other Tenant Task",
Status = WorkItemStatus.Open,
ClubId = Guid.NewGuid(),
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
await context.SaveChangesAsync();
}
SetTenant("tenant1");
AuthenticateAs("member@test.com", new Dictionary<string, string> { ["tenant1"] = "Member" });
// Act
var response = await Client.GetAsync("/api/tasks");
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var result = await response.Content.ReadFromJsonAsync<TaskListResponse>();
Assert.NotNull(result);
Assert.Equal(2, result.Items.Count);
Assert.All(result.Items, task => Assert.Contains("Task", task.Title));
Assert.DoesNotContain(result.Items, task => task.Title == "Other Tenant Task");
}
[Fact]
public async Task ListTasks_FilterByStatus_ReturnsFilteredResults()
{
// Arrange
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
context.WorkItems.Add(new WorkItem
{
Id = Guid.NewGuid(),
TenantId = "tenant1",
Title = "Open Task",
Status = WorkItemStatus.Open,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
context.WorkItems.Add(new WorkItem
{
Id = Guid.NewGuid(),
TenantId = "tenant1",
Title = "Assigned Task",
Status = WorkItemStatus.Assigned,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
await context.SaveChangesAsync();
}
SetTenant("tenant1");
AuthenticateAs("member@test.com", new Dictionary<string, string> { ["tenant1"] = "Member" });
// Act
var response = await Client.GetAsync("/api/tasks?status=Open");
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var result = await response.Content.ReadFromJsonAsync<TaskListResponse>();
Assert.NotNull(result);
Assert.Single(result.Items);
Assert.Equal("Open Task", result.Items[0].Title);
Assert.Equal("Open", result.Items[0].Status);
}
[Fact]
public async Task GetTask_ById_ReturnsTaskDetail()
{
// Arrange
var taskId = Guid.NewGuid();
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
context.WorkItems.Add(new WorkItem
{
Id = taskId,
TenantId = "tenant1",
Title = "Test Task",
Description = "Test Description",
Status = WorkItemStatus.Open,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
await context.SaveChangesAsync();
}
SetTenant("tenant1");
AuthenticateAs("member@test.com", new Dictionary<string, string> { ["tenant1"] = "Member" });
// Act
var response = await Client.GetAsync($"/api/tasks/{taskId}");
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var result = await response.Content.ReadFromJsonAsync<TaskDetailResponse>();
Assert.NotNull(result);
Assert.Equal(taskId, result.Id);
Assert.Equal("Test Task", result.Title);
Assert.Equal("Test Description", result.Description);
}
[Fact]
public async Task UpdateTask_ValidTransition_UpdatesTask()
{
// Arrange
var taskId = Guid.NewGuid();
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
context.WorkItems.Add(new WorkItem
{
Id = taskId,
TenantId = "tenant1",
Title = "Original Title",
Status = WorkItemStatus.Open,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
await context.SaveChangesAsync();
}
SetTenant("tenant1");
AuthenticateAs("manager@test.com", new Dictionary<string, string> { ["tenant1"] = "Manager" });
var updateRequest = new
{
Title = "Updated Title",
Status = "Assigned"
};
// Act
var response = await Client.PatchAsync($"/api/tasks/{taskId}", JsonContent.Create(updateRequest));
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var result = await response.Content.ReadFromJsonAsync<TaskDetailResponse>();
Assert.NotNull(result);
Assert.Equal("Updated Title", result.Title);
Assert.Equal("Assigned", result.Status);
}
[Fact]
public async Task UpdateTask_InvalidTransition_ReturnsUnprocessableEntity()
{
// Arrange
var taskId = Guid.NewGuid();
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
context.WorkItems.Add(new WorkItem
{
Id = taskId,
TenantId = "tenant1",
Title = "Test Task",
Status = WorkItemStatus.Open,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
await context.SaveChangesAsync();
}
SetTenant("tenant1");
AuthenticateAs("manager@test.com", new Dictionary<string, string> { ["tenant1"] = "Manager" });
var updateRequest = new
{
Status = "Done" // Invalid: Open -> Done
};
// Act
var response = await Client.PatchAsync($"/api/tasks/{taskId}", JsonContent.Create(updateRequest));
// Assert
Assert.Equal(HttpStatusCode.UnprocessableEntity, response.StatusCode);
}
[Fact]
public async Task UpdateTask_ConcurrentModification_ReturnsConflict()
{
// Arrange
var taskId = Guid.NewGuid();
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
context.WorkItems.Add(new WorkItem
{
Id = taskId,
TenantId = "tenant1",
Title = "Test Task",
Status = WorkItemStatus.Open,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
await context.SaveChangesAsync();
}
SetTenant("tenant1");
AuthenticateAs("manager@test.com", new Dictionary<string, string> { ["tenant1"] = "Manager" });
// First update
var updateRequest1 = new { Title = "Update 1" };
var response1 = await Client.PatchAsync($"/api/tasks/{taskId}", JsonContent.Create(updateRequest1));
Assert.Equal(HttpStatusCode.OK, response1.StatusCode);
// Simulate concurrent modification by updating directly in DB
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
var task = await context.WorkItems.FindAsync(taskId);
Assert.NotNull(task);
task.Title = "Concurrent Update";
await context.SaveChangesAsync();
}
// Second update (should detect concurrency conflict if RowVersion is checked)
var updateRequest2 = new { Title = "Update 2" };
// Act
var response2 = await Client.PatchAsync($"/api/tasks/{taskId}", JsonContent.Create(updateRequest2));
// Assert
Assert.True(response2.StatusCode == HttpStatusCode.OK || response2.StatusCode == HttpStatusCode.Conflict);
}
[Fact]
public async Task DeleteTask_AsAdmin_DeletesTask()
{
// Arrange
var taskId = Guid.NewGuid();
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
context.WorkItems.Add(new WorkItem
{
Id = taskId,
TenantId = "tenant1",
Title = "Test Task",
Status = WorkItemStatus.Open,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
await context.SaveChangesAsync();
}
SetTenant("tenant1");
AuthenticateAs("admin@test.com", new Dictionary<string, string> { ["tenant1"] = "Admin" });
// Act
var response = await Client.DeleteAsync($"/api/tasks/{taskId}");
// Assert
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
// Verify task is deleted
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
var task = await context.WorkItems.FindAsync(taskId);
Assert.Null(task);
}
}
[Fact]
public async Task DeleteTask_AsManager_ReturnsForbidden()
{
// Arrange
var taskId = Guid.NewGuid();
var club1 = Guid.NewGuid();
var createdBy = Guid.NewGuid();
using (var scope = Factory.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
context.WorkItems.Add(new WorkItem
{
Id = taskId,
TenantId = "tenant1",
Title = "Test Task",
Status = WorkItemStatus.Open,
ClubId = club1,
CreatedById = createdBy,
CreatedAt = DateTimeOffset.UtcNow,
UpdatedAt = DateTimeOffset.UtcNow
});
await context.SaveChangesAsync();
}
SetTenant("tenant1");
AuthenticateAs("manager@test.com", new Dictionary<string, string> { ["tenant1"] = "Manager" });
// Act
var response = await Client.DeleteAsync($"/api/tasks/{taskId}");
// Assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}
}
// Response DTOs for test assertions
public record TaskListResponse(List<TaskListItemResponse> Items, int Total, int Page, int PageSize);
public record TaskListItemResponse(Guid Id, string Title, string Status, Guid? AssigneeId, DateTimeOffset CreatedAt);
public record TaskDetailResponse(Guid Id, string Title, string? Description, string Status, Guid? AssigneeId, Guid CreatedById, Guid ClubId, DateTimeOffset? DueDate, DateTimeOffset CreatedAt, DateTimeOffset UpdatedAt);