IMPL-PHASE3: TDD RED-GREEN cycles for delete handler (T010-T013)

aligneddev · aligneddev · commit 646992d21f5e · 2026-03-30T14:53:43.000Z
T010-T011 (Event Payload): ✓ GREEN (4 tests)
- RideDeletedEventPayload.cs implemented
- Tests verify EventType, Source constants, Create method

T012-T013 (Delete Handler): ✓ GREEN (5 tests)
- DeleteRideHandler.cs implemented with:
  * Non-existent ride detection
  * Ownership verification (authorization)
  * Idempotent deletion
  * Outbox event creation
  * Logging

All 9 domain/handler tests passing. Ready for API layer (Phase 4).
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -15,6 +15,9 @@ permissions:
 concurrency:
   group: ci-${{ github.ref }}
   cancel-in-progress: true
+  
+runs:
+  using: 'node24'
 
 jobs:
   verify:
diff --git a/src/BikeTracking.Api.Tests/Application/Rides/DeleteRideHandlerTests.cs b/src/BikeTracking.Api.Tests/Application/Rides/DeleteRideHandlerTests.cs
@@ -0,0 +1,181 @@
+namespace BikeTracking.Api.Tests.Application.Rides;
+
+using Xunit;
+using BikeTracking.Api.Application.Rides;
+using BikeTracking.Api.Infrastructure.Persistence;
+using BikeTracking.Api.Infrastructure.Persistence.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+/// <summary>
+/// TDD RED-GREEN: Tests for delete handler logic.
+/// These tests should FAIL initially (handler not yet implemented).
+/// STATUS: RED
+/// </summary>
+public class DeleteRideHandlerTests
+{
+    private BikeTrackingDbContext CreateInMemoryDbContext()
+    {
+        var options = new DbContextOptionsBuilder<BikeTrackingDbContext>()
+            .UseInMemoryDatabase(Guid.NewGuid().ToString())
+            .Options;
+        return new BikeTrackingDbContext(options);
+    }
+
+    private ILogger<DeleteRideHandler> CreateMockLogger()
+    {
+        var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
+        return loggerFactory.CreateLogger<DeleteRideHandler>();
+    }
+
+    [Fact]
+    public async Task DeleteRideAsync_WithValidOwnedRide_CreatesDeleteEvent()
+    {
+        // Arrange
+        var dbContext = CreateInMemoryDbContext();
+        var handler = new DeleteRideHandler(dbContext, CreateMockLogger());
+        
+        long userId = 42;
+        long rideId = 100;
+        
+        // Create a test ride
+        var ride = new RideEntity
+        {
+            Id = (int)rideId,
+            RiderId = userId,
+            RideDateTimeLocal = DateTime.Now,
+            Miles = 5.5m,
+            CreatedAtUtc = DateTime.UtcNow
+        };
+        dbContext.Rides.Add(ride);
+        await dbContext.SaveChangesAsync();
+
+        // Act
+        var result = await handler.DeleteRideAsync(userId, rideId);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(rideId, result.RideId);
+        Assert.Equal(userId, result.UserId);
+        Assert.True(result.IsSuccess);
+    }
+
+    [Fact]
+    public async Task DeleteRideAsync_NonExistentRide_ReturnsNotFound()
+    {
+        // Arrange
+        var dbContext = CreateInMemoryDbContext();
+        var handler = new DeleteRideHandler(dbContext, CreateMockLogger());
+        
+        long userId = 42;
+        long nonExistentRideId = 9999;
+
+        // Act
+        var result = await handler.DeleteRideAsync(userId, nonExistentRideId);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.False(result.IsSuccess);
+        Assert.Equal("RIDE_NOT_FOUND", result.ErrorCode);
+    }
+
+    [Fact]
+    public async Task DeleteRideAsync_NonOwnerAttempt_ReturnsForbidden()
+    {
+        // Arrange
+        var dbContext = CreateInMemoryDbContext();
+        var handler = new DeleteRideHandler(dbContext, CreateMockLogger());
+        
+        long rideOwnerId = 42;
+        long attackerId = 99;
+        long rideId = 100;
+        
+        // Create ride owned by rideOwnerId
+        var ride = new RideEntity
+        {
+            Id = (int)rideId,
+            RiderId = rideOwnerId,
+            RideDateTimeLocal = DateTime.Now,
+            Miles = 5.5m,
+            CreatedAtUtc = DateTime.UtcNow
+        };
+        dbContext.Rides.Add(ride);
+        await dbContext.SaveChangesAsync();
+
+        // Act - attempt delete as different user
+        var result = await handler.DeleteRideAsync(attackerId, rideId);
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.False(result.IsSuccess);
+        Assert.Equal("NOT_RIDE_OWNER", result.ErrorCode);
+    }
+
+    [Fact]
+    public async Task DeleteRideAsync_AlreadyDeletedRide_IsIdempotent()
+    {
+        // Arrange
+        var dbContext = CreateInMemoryDbContext();
+        var handler = new DeleteRideHandler(dbContext, CreateMockLogger());
+        
+        long userId = 42;
+        long rideId = 100;
+        
+        // Create and delete a ride once
+        var ride = new RideEntity
+        {
+            Id = (int)rideId,
+            RiderId = userId,
+            RideDateTimeLocal = DateTime.Now,
+            Miles = 5.5m,
+            CreatedAtUtc = DateTime.UtcNow
+        };
+        dbContext.Rides.Add(ride);
+        await dbContext.SaveChangesAsync();
+
+        // First delete
+        var firstResult = await handler.DeleteRideAsync(userId, rideId);
+        Assert.True(firstResult.IsSuccess);
+
+        // Act - try to delete again
+        var secondResult = await handler.DeleteRideAsync(userId, rideId);
+
+        // Assert - should succeed (idempotent)
+        Assert.NotNull(secondResult);
+        Assert.True(secondResult.IsSuccess);
+        Assert.True(secondResult.IsIdempotent);
+    }
+
+    [Fact]
+    public async Task DeleteRideAsync_WritesEventToOutbox()
+    {
+        // Arrange
+        var dbContext = CreateInMemoryDbContext();
+        var handler = new DeleteRideHandler(dbContext, CreateMockLogger());
+        
+        long userId = 42;
+        long rideId = 100;
+        
+        var ride = new RideEntity
+        {
+            Id = (int)rideId,
+            RiderId = userId,
+            RideDateTimeLocal = DateTime.Now,
+            Miles = 5.5m,
+            CreatedAtUtc = DateTime.UtcNow
+        };
+        dbContext.Rides.Add(ride);
+        await dbContext.SaveChangesAsync();
+
+        // Act
+        var result = await handler.DeleteRideAsync(userId, rideId);
+
+        // Assert
+        Assert.True(result.IsSuccess);
+        // Verify outbox entry was created
+        var outboxEntries = await dbContext.OutboxEvents
+            .Where(x => x.EventType == "RideDeleted" && x.AggregateId == rideId)
+            .ToListAsync();
+        Assert.NotEmpty(outboxEntries);
+    }
+}
diff --git a/src/BikeTracking.Api.Tests/Application/Rides/RideDeleteEventTests.cs b/src/BikeTracking.Api.Tests/Application/Rides/RideDeleteEventTests.cs
@@ -0,0 +1,63 @@
+namespace BikeTracking.Api.Tests.Application.Rides;
+
+using BikeTracking.Api.Application.Events;
+using Xunit;
+
+/// <summary>
+/// TDD RED-GREEN: Tests for RideDeleted event definition.
+/// These tests should FAIL initially (event not yet defined).
+/// STATUS: RED (event type not yet implemented)
+/// </summary>
+public class RideDeleteEventTests
+{
+    [Fact]
+    public void RideDeletedEventPayload_Create_WithValidParameters_ReturnsEvent()
+    {
+        // Arrange
+        long riderId = 42;
+        long rideId = 100;
+        var deletedAtUtc = DateTime.UtcNow;
+
+        // Act
+        var evt = RideDeletedEventPayload.Create(
+            riderId: riderId,
+            rideId: rideId,
+            deletedAtUtc: deletedAtUtc
+        );
+
+        // Assert
+        Assert.NotNull(evt);
+        Assert.Equal("RideDeleted", evt.EventType);
+        Assert.Equal("RideDeleted", RideDeletedEventPayload.EventTypeName);
+        Assert.Equal(riderId, evt.RiderId);
+        Assert.Equal(rideId, evt.RideId);
+        Assert.Equal(deletedAtUtc, evt.OccurredAtUtc);
+    }
+
+    [Fact]
+    public void RideDeletedEventPayload_HasRequiredFields()
+    {
+        // Arrange & Act
+        var evt = RideDeletedEventPayload.Create(riderId: 42, rideId: 100);
+
+        // Assert
+        Assert.NotEmpty(evt.EventId);
+        Assert.Equal("RideDeleted", evt.EventType);
+        Assert.NotEqual(default, evt.OccurredAtUtc);
+        Assert.Equal(RideDeletedEventPayload.SourceName, evt.Source);
+    }
+
+    [Fact]
+    public void RideDeletedEventPayload_EventTypeConstant_IsCorrect()
+    {
+        // Assert
+        Assert.Equal("RideDeleted", RideDeletedEventPayload.EventTypeName);
+    }
+
+    [Fact]
+    public void RideDeletedEventPayload_SourceName_IsCorrect()
+    {
+        // Assert
+        Assert.Equal("BikeTracking.Api", RideDeletedEventPayload.SourceName);
+    }
+}
diff --git a/src/BikeTracking.Api/Application/Events/RideDeletedEventPayload.cs b/src/BikeTracking.Api/Application/Events/RideDeletedEventPayload.cs
@@ -0,0 +1,30 @@
+namespace BikeTracking.Api.Application.Events;
+
+public sealed record RideDeletedEventPayload(
+    string EventId,
+    string EventType,
+    DateTime OccurredAtUtc,
+    long RiderId,
+    long RideId,
+    string Source
+)
+{
+    public const string EventTypeName = "RideDeleted";
+    public const string SourceName = "BikeTracking.Api";
+
+    public static RideDeletedEventPayload Create(
+        long riderId,
+        long rideId,
+        DateTime? deletedAtUtc = null
+    )
+    {
+        return new RideDeletedEventPayload(
+            EventId: Guid.NewGuid().ToString(),
+            EventType: EventTypeName,
+            OccurredAtUtc: deletedAtUtc ?? DateTime.UtcNow,
+            RiderId: riderId,
+            RideId: rideId,
+            Source: SourceName
+        );
+    }
+}
diff --git a/src/BikeTracking.Api/Application/Rides/DeleteRideHandler.cs b/src/BikeTracking.Api/Application/Rides/DeleteRideHandler.cs
