feat: add tester deletion endpoint

src/Endpoints/TesterEndpoints.cs

@@ -34,6 +34,15 @@ public static void MapTesterEndpoints(this WebApplication app)
         })
         .Produces<Result<UpdateTesterResponse>>();
 
+        testerGroup.MapDelete("/{name}", async (
+            string name,
+            DeleteTesterUseCase useCase) =>
+        {
+            var response = await useCase.ExecuteAsync(name);
+            return response.ToHttpResult();
+        })
+        .Produces<Result<DeleteTesterResponse>>();
+
         testerGroup.MapPatch("/{accessKey}/playtime", async (
             string accessKey,
             [FromBody]UpdatePlaytimeRequest request,

src/Extensions/ServiceCollectionExtensions.cs

@@ -11,6 +11,7 @@ public static IServiceCollection AddServices(this IServiceCollection services)
         services
             .AddScoped<CreateTesterUseCase>()
             .AddScoped<UpdateTesterUseCase>()
+            .AddScoped<DeleteTesterUseCase>()
             .AddScoped<UpdatePlaytimeUseCase>()
             .AddScoped<GetTestersUseCase>()
             .AddScoped<ValidateTesterAccessUseCase>()

src/Playtesters.API.http

@@ -47,6 +47,15 @@ X-Api-Key: {{adminKey}}
 
 ###
 
+### ---------------------------------------------------------
+### DELETE TESTER (by name)
+### DELETE /api/testers/{name}
+### ---------------------------------------------------------
+DELETE {{host}}/api/testers/Tester123
+X-Api-Key: {{adminKey}}
+
+###
+
 ### ---------------------------------------------------------
 ### LIST ALL TESTERS
 ### GET /api/testers

src/UseCases/Testers/Delete.cs

@@ -0,0 +1,27 @@
+using Microsoft.EntityFrameworkCore;
+using Playtesters.API.Data;
+using Playtesters.API.Entities;
+using SimpleResults;
+
+namespace Playtesters.API.UseCases.Testers;
+
+public record DeleteTesterResponse(string Name, string AccessKey);
+
+public class DeleteTesterUseCase(AppDbContext dbContext)
+{
+    public async Task<Result<DeleteTesterResponse>> ExecuteAsync(string name)
+    {
+        var tester = await dbContext
+            .Set<Tester>()
+            .FirstOrDefaultAsync(t => t.Name == name);
+
+        if (tester is null)
+            return Result.NotFound();
+
+        dbContext.Remove(tester);
+        await dbContext.SaveChangesAsync();
+
+        var response = new DeleteTesterResponse(tester.Name, tester.AccessKey);
+        return Result.Success(response);
+    }
+}

tests/Common/DbContextHelpers.cs

@@ -14,6 +14,13 @@ protected async Task<TEntity> FirstOrDefaultAsync<TEntity>(
         return await dbContext.Set<TEntity>().FirstOrDefaultAsync(predicate);
     }
 
+    protected int Count<TEntity>() where TEntity : class
+    {
+        using var scope = ApplicationFactory.Services.CreateScope();
+        var dbContext = scope.ServiceProvider.GetService<AppDbContext>();
+        return dbContext.Set<TEntity>().Count();
+    }
+
     protected async Task<List<TEntity>> ToListAsync<TEntity>() where TEntity : class
     {
         using var scope = ApplicationFactory.Services.CreateScope();

tests/UseCases/Testers/Delete.cs

@@ -0,0 +1,88 @@
+using FluentAssertions;
+using Playtesters.API.Entities;
+using Playtesters.API.Tests.Common;
+using Playtesters.API.UseCases.Testers;
+using SimpleResults;
+using System.Net;
+
+namespace Playtesters.API.Tests.UseCases.Testers;
+
+public class DeleteTesterApiTests : TestBase
+{
+    [Test]
+    public async Task Delete_WhenTesterExists_ShouldDeleteTester()
+    {
+        // Arrange
+        var client = CreateHttpClientWithApiKey();
+
+        var createRequest = new CreateTesterRequest(Name: "Alice");
+        await client.PostAsJsonAsync("/api/testers", createRequest);
+
+        // Act
+        var response = await client.DeleteAsync("/api/testers/Alice");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+
+        var body = await response.Content.ReadFromJsonAsync<Result<DeleteTesterResponse>>();
+
+        body.Should().NotBeNull();
+        body.IsSuccess.Should().BeTrue();
+        body.Data.Name.Should().Be("Alice");
+
+        var tester = await FirstOrDefaultAsync<Tester>(t => t.Name == createRequest.Name);
+        tester.Should().BeNull();
+    }
+
+    [Test]
+    public async Task Delete_WhenTesterDoesNotExist_ShouldReturnNotFound()
+    {
+        // Arrange
+        var client = CreateHttpClientWithApiKey();
+
+        // Act
+        var response = await client.DeleteAsync("/api/testers/Unknown");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
+
+        var body = await response.Content.ReadFromJsonAsync<Result<DeleteTesterResponse>>();
+        body.Should().NotBeNull();
+        body.IsSuccess.Should().BeFalse();
+        body.Status.Should().Be(ResultStatus.NotFound);
+    }
+
+    [Test]
+    public async Task Delete_WhenTesterHasAccessHistory_ShouldDeleteAccessHistory()
+    {
+        // Arrange
+        var client = CreateHttpClientWithApiKey();
+        var createRequest = new CreateTesterRequest(Name: "Alice");
+        var createResponse = await client.PostAsJsonAsync("/api/testers", createRequest);
+        var createdTester = await createResponse.Content.ReadFromJsonAsync<Result<CreateTesterResponse>>();
+        var validateRequest = new ValidateTesterAccessRequest(createdTester.Data.AccessKey);
+        await client.PostAsJsonAsync("/api/testers/validate-access", validateRequest);
+        Count<AccessValidationHistory>().Should().Be(1);
+
+        // Act
+        var response = await client.DeleteAsync("/api/testers/Alice");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        Count<Tester>().Should().Be(0);
+        Count<AccessValidationHistory>().Should().Be(0);
+    }
+
+    [Test]
+    public async Task Delete_WhenMissingApiKey_ShouldReturnUnauthorized()
+    {
+        // Arrange
+        var client = ApplicationFactory.CreateClient();
+
+        // Act
+        var response = await client.DeleteAsync("/api/testers/Alice");
+
+        // Assert
+        response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
+    }
+}