Add Fable's Stufe A invariant tests

src/Predictalytics.Application.Tests/Services/TradeRetentionWorkerTests.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
+using Predictalytics.Domain.Entities;
+using Predictalytics.Domain.Enums;
+using Predictalytics.Infrastructure.Data;
+using Predictalytics.Infrastructure.Services;
+using Predictalytics.Worker.Services;
+using Xunit;
+
+namespace Predictalytics.Application.Tests.Services;
+
+/// <summary>
+/// Invariant tests for the retention/compaction worker (added 2026-07-09).
+/// Uses SQLite in-memory instead of the InMemory provider because the worker
+/// relies on ExecuteDeleteAsync/ExecuteUpdateAsync (relational-only).
+/// </summary>
+public class TradeRetentionWorkerTests
+{
+    /// <summary>
+    /// Defect 2: Compaction bumps the position checkpoint to the aggregate
+    /// trade's Id — which is the highest Id in the table. Any UNAPPLIED real
+    /// trade with a smaller Id silently falls below the checkpoint and is never
+    /// booked (IsHistoryPruned additionally blocks the reset self-heal).
+    ///
+    /// Invariant: after compaction plus a PnL engine run, every previously
+    /// unapplied trade must be reflected in the position. Valid fixes include
+    /// skipping compaction while unapplied trades exist for the position, or
+    /// marking the aggregate as pre-applied without moving the checkpoint past
+    /// unapplied trades. EXPECTED TO BE RED until fixed.
+    /// </summary>
+    [Fact]
+    public async Task RunOptimizationAsync_CompactionWithUnappliedTrades_DoesNotLoseThem()
+    {
+        // ── Arrange: shared SQLite in-memory database ────────────────────────
+        using var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<AppDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        var baseDate = DateTime.UtcNow.Date;
+
+        using (var setup = new AppDbContext(options))
+        {
+            setup.Database.EnsureCreated();
+
+            var ev = new Event { Id = 1, Platform = PlatformType.Polymarket, Slug = "e", Title = "E" };
+            setup.Set<Event>().Add(ev);
+
+            var market = new Market { Id = 10, EventId = 1, PlatformMarketId = 1L, Question = "Q?" };
+            market.Outcomes.Add(new MarketOutcome { Id = 100, MarketId = 10, Label = "Yes", TokenId = "t100", CurrentPrice = 0.45m });
+            setup.Markets.Add(market);
+
+            // Bot trader → target of the compaction pass.
+            setup.Traders.Add(new Trader { Id = 1, PlatformUserId = "0x1", DisplayName = "Bot", IsSuspectedBot = true });
+
+            // Two APPLIED trades, older than the compaction cutoff, same day/side
+            // → they form a compactable group.
+            setup.Trades.Add(new Trade
+            {
+                Id = 10, TraderId = 1, DbMarketId = 10, MarketOutcomeId = 100, PlatformTradeId = "tx10",
+                Side = TradeSide.Buy, Price = 0.40m, Size = 50m, Amount = 20m,
+                ExecutedAt = baseDate.AddDays(-20).AddHours(10)
+            });
+            setup.Trades.Add(new Trade
+            {
+                Id = 11, TraderId = 1, DbMarketId = 10, MarketOutcomeId = 100, PlatformTradeId = "tx11",
+                Side = TradeSide.Buy, Price = 0.40m, Size = 50m, Amount = 20m,
+                ExecutedAt = baseDate.AddDays(-20).AddHours(11)
+            });
+
+            // One UNAPPLIED trade (imported but not yet analyzed): Id 12 is above
+            // the checkpoint (11) but below the aggregate's future Id.
+            setup.Trades.Add(new Trade
+            {
+                Id = 12, TraderId = 1, DbMarketId = 10, MarketOutcomeId = 100, PlatformTradeId = "tx12",
+                Side = TradeSide.Buy, Price = 0.50m, Size = 100m, Amount = 50m,
+                ExecutedAt = baseDate.AddDays(-5).AddHours(10)
+            });
+
+            // Position reflects exactly the two applied trades.
+            setup.TraderPositions.Add(new TraderPosition
+            {
+                Id = 1, TraderId = 1, MarketOutcomeId = 100,
+                SharesHeld = 100m, AvgCost = 0.40m, RealizedPnl = 0m,
+                LastAppliedTradeId = 11,
+                LastTradeExecutedAt = baseDate.AddDays(-20).AddHours(11),
+                IsHistoryPruned = false
+            });
+
+            setup.SaveChanges();
+        }
+
+        var services = new ServiceCollection();
+        services.AddScoped(_ => new AppDbContext(options));
+        using var provider = services.BuildServiceProvider();
+
+        var config = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?>
+        {
+            ["RetentionSettings:RetentionDays"] = "90",
+            ["RetentionSettings:CompactionDays"] = "14"
+        }).Build();
+
+        var worker = new TradeRetentionWorker(provider, config, NullLogger<TradeRetentionWorker>.Instance);
+
+        // RunOptimizationAsync is private; invoked via reflection on purpose so
+        // this test exercises the real production code path. Making the method
+        // internal (+ InternalsVisibleTo) instead of this reflection call is a
+        // welcome refactor.
+        var method = typeof(TradeRetentionWorker).GetMethod("RunOptimizationAsync", BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(method);
+
+        // ── Act 1: retention/compaction pass ─────────────────────────────────
+        await (Task)method!.Invoke(worker, new object[] { CancellationToken.None })!;
+
+        // ── Act 2: next analytics run ────────────────────────────────────────
+        using (var engineCtx = new AppDbContext(options))
+        {
+            var engine = new PositionPnLEngine(engineCtx, NullLogger<PositionPnLEngine>.Instance);
+            await engine.RecalculateTraderPositionsAsync(1);
+        }
+
+        // ── Assert: the unapplied trade (Id 12) must now be part of the position:
+        // 100 shares @0.40 (compacted or not) + 100 shares @0.50 → 200 @ 0.45.
+        using (var assertCtx = new AppDbContext(options))
+        {
+            var pos = await assertCtx.TraderPositions.SingleAsync(p => p.TraderId == 1 && p.MarketOutcomeId == 100);
+            Assert.Equal(200m, pos.SharesHeld);
+            Assert.Equal(0.45m, pos.AvgCost);
+        }
+    }
+}