IBKRTrader/tests/IBKRTrader.Tests/Capital/CapitalModelTests.cs

using FluentAssertions;
using IBKRTrader.Core.Capital;
using IBKRTrader.Core.Trading;

namespace IBKRTrader.Tests.Capital;

/// <summary>
/// Bücher, Pool und Obergrenzen (#302, #303) – die Invarianten aus dem Kapitalmodell, jede
/// einzeln prüfbar, weil die Rechnung ohne Datenbank und ohne Broker auskommt.
/// </summary>
[Trait("cat", "unit")]
public class CapitalModelTests
{
    private static readonly BookId Ct = BookId.ForModule("CT");
    private static readonly BookId Ow = BookId.ForModule("OW");

    // ─── Bücher und Eigentumsregeln ──────────────────────────────────────────────

    [Theory]
    [InlineData("MANUAL")]
    [InlineData("manual")]
    [InlineData("UNASSIGNED")]
    [InlineData("HOUSE")]
    public void ReservedBookNames_CannotBeClaimedByAModule(string name)
    {
        // Sonst gaebe sich ein Modul als MANUAL aus und waere damit von jedem Limit befreit.
        var act = () => BookId.ForModule(name);
        act.Should().Throw<ArgumentException>();
    }

    [Fact]
    public void OnlyStrategyBooks_MayTrade_AndAreSubjectToLimits()
    {
        Ct.MayTrade.Should().BeTrue();
        Ct.SubjectToLimits.Should().BeTrue();

        BookId.Manual.MayTrade.Should().BeFalse();
        BookId.Manual.SubjectToLimits.Should().BeFalse();
        BookId.Unassigned.MayTrade.Should().BeFalse();
        BookId.House.MayTrade.Should().BeFalse();
    }

    [Fact]
    public void Registry_RejectsUnknownModules()
    {
        var registry = new BookRegistry(["CT", "OW"]);

        registry.Resolve("CT").Should().Be(Ct);
        registry.Resolve("ct").Should().Be(Ct);          // Schreibweise egal
        registry.Resolve("Tippfehler").Should().BeNull(); // ein Buch ohne Cap waere unbegrenzt
        registry.Resolve(null).Should().BeNull();
    }

    [Fact]
    public void Registry_NeverCreatesReservedBooks()
    {
        var registry = new BookRegistry(["CT", "MANUAL", "HOUSE"]);

        registry.StrategyBooks.Should().ContainSingle().Which.Should().Be(Ct);
    }

    // ─── Pool ────────────────────────────────────────────────────────────────────

    [Fact]
    public void Distributable_IsFreeCashPlusPositions_WithTheHouseReserveTakenOnlyOnce()
    {
        // Die Hausreserve steckt bereits in FreeCash (§4 Schicht A). Wuerde sie hier erneut
        // abgezogen, laege bei 5 % Reserve rund ein Zehntel des Kapitals still, ohne dass es
        // irgendwo sichtbar waere.
        var snapshot = new CapitalSnapshot(
            FreeCash: 9_500m, PositionValue: 4_000m, HouseReserve: 500m, NetLiquidation: 14_000m);

        snapshot.Distributable.Should().Be(13_500m);
    }

    [Fact]
    public void Distributable_IsNeverNegative()
    {
        new CapitalSnapshot(0m, 0m, 5_000m, 1_000m).Distributable.Should().Be(0m);
    }

    [Fact]
    public void EqualShares_SplitsTheDistributableEvenly()
    {
        var pool     = CapitalPool.EqualShares([Ct, Ow]);
        var snapshot = new CapitalSnapshot(10_000m, 0m, 0m, 10_000m);

        pool.CapOf(Ct, snapshot).Should().Be(5_000m);
        pool.CapOf(Ow, snapshot).Should().Be(5_000m);
    }

    [Fact]
    public void SharesOverOneHundredPercent_AreRefusedAtStartup()
    {
        // Sonst entscheidet nicht die Konfiguration, wer wie viel bekommt, sondern wer zuerst
        // handelt - ein schnelles Buch hungerte ein langsames aus.
        var pool = new CapitalPool(
            new Dictionary<string, decimal> { ["CT"] = 0.7m, ["OW"] = 0.6m }, defaultShare: 0m);

        pool.ValidateShares([Ct, Ow]).Should().NotBeNull().And.Contain("verdrängte");
    }

    [Fact]
    public void SharesWithinOneHundredPercent_AreAccepted()
    {
        var pool = new CapitalPool(
            new Dictionary<string, decimal> { ["CT"] = 0.5m, ["OW"] = 0.4m }, defaultShare: 0m);

        pool.ValidateShares([Ct, Ow]).Should().BeNull();
    }

    [Fact]
    public void NegativeShare_IsRefused()
    {
        var pool = new CapitalPool(
            new Dictionary<string, decimal> { ["CT"] = -0.1m }, defaultShare: 0m);

        pool.ValidateShares([Ct]).Should().NotBeNull().And.Contain("Negativer Anteil");
    }

    // ─── Spielraum ───────────────────────────────────────────────────────────────

    [Fact]
    public void Headroom_IsTheSmallerOfRemainingCapAndFreeCash()
    {
        // Cap 5.000, davon 1.000 gebunden -> 4.000 Rest; aber nur 2.500 Bargeld frei.
        var headroom = new Headroom(Ct, Cap: 5_000m, Bound: 1_000m, FreePoolCash: 2_500m);

        headroom.Available.Should().Be(2_500m);
        headroom.OverCap.Should().BeFalse();
    }

    [Fact]
    public void BookOverItsCap_IsLegal_ButHasNoHeadroomLeft()
    {
        // Ein zulaessiger Zustand: steigen die Positionen im Wert, passiert nichts, ausser dass
        // nicht mehr nachgekauft werden darf. Geheilt wird er nie - es wird niemals eine Position
        // geschlossen, um eine Zielquote herzustellen.
        var headroom = new Headroom(Ct, Cap: 5_000m, Bound: 9_000m, FreePoolCash: 20_000m);

        headroom.OverCap.Should().BeTrue();
        headroom.Available.Should().Be(0m);
    }

    // ─── Konzentration ───────────────────────────────────────────────────────────

    [Fact]
    public void SymbolExposure_CountsEveryBook_IncludingManual()
    {
        // Haelt der Betreiber die Haelfte seines Kontos in AAPL von Hand, sind die Module bei AAPL
        // gesperrt. So gewollt: MANUAL ist von der Pruefung befreit, zaehlt aber voll in den Zaehler.
        var positions = new[]
        {
            new Position("CT",     InstrumentRef.ForStock("AAPL"), 10, 100m),
            new Position("MANUAL", InstrumentRef.ForStock("AAPL"), 40, 100m),
            new Position("CT",     InstrumentRef.ForStock("MSFT"), 10, 200m)
        };

        CapitalPool.SymbolExposure(positions, "AAPL").Should().Be(5_000m);
        CapitalPool.SymbolExposure(positions, "aapl").Should().Be(5_000m);
        CapitalPool.SymbolExposure(positions, "MSFT").Should().Be(2_000m);
    }

    [Fact]
    public void SymbolExposure_OfAShortPut_CountsTheObligation()
    {
        var spec = new OptionSpec("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Put);
        var positions = new[] { new Position("OW", InstrumentRef.ForOption(spec), -1, 2.50m) };

        // Nicht 250 (Praemie), sondern 15.000 (Verpflichtung).
        CapitalPool.SymbolExposure(positions, "AAPL").Should().Be(15_000m);
    }
}