Options-Fundament und Kapitalmodell im Core; Modul OptionsWheel
Das OptionsWheel setzt auf Dingen auf, die es im Core nicht gab. Diese Sitzung baut sie. #298 Optionen als Instrument. InstrumentKind/OptionSpec und ein druckbarer Instrumentenschluessel ("AAPL|20260918|C|150"); TradeSignal und OrderRequest tragen ein optionales OptionSpec, ohne das sich der Aktienpfad unveraendert verhaelt. Position.Notional rechnet ab jetzt mit der Kontraktgroesse - vorher war jede Option um Faktor 100 zu klein bewertet und damit jedes Risikolimit wirkungslos, lautlos und in die gefaehrliche Richtung. Daneben neu BoundCapital: ein Short Put bindet Strike x Kontraktgroesse, nicht die vereinnahmte Praemie. #300 sell-to-open. Jeder Auftrag zerfaellt in einen schliessenden und einen eroeffnenden Teil; der schliessende wird von keinem Limit verhindert - auch nicht vom Kaufstopp, denn ein Rueckkauf baut eine Verpflichtung ab. Deckungspruefung im Core, nicht im Modul: Short Call nur mit freien Aktien, Short Put nur mit reservierbarem Bargeld. #302-#305 Kapital- und Buchmodell. Buecher mit reservierten Namen und Eigentumsregeln, Pool mit Caps und Headroom, Margin-Sperre in vier Schichten, core_reservation mit Lebenszyklus, Frist, Idempotenz ueber (SignalId, ContractKey) und Quarantaene beim Start. #309/#310 Modul OptionsWheel: ow_-Schema mit fuenf Tabellen, Zustandsautomat, StrikeSelector, RollDecider, PremiumMath - vollstaendig ohne Broker testbar. Der Handelsbetrieb bleibt gesperrt, solange #299 und #294 fehlen; das Modul sagt das ueber GetActivationBlocker, statt still nichts zu tun. #293 --verify-order am Daemon: eine Order durch die vollstaendige Kette (Buch, Risiko, Bindung, Order, Fill, Buchung, Abschluss). Ohne --confirm ein Trockenlauf; Abbruch ausserhalb von Paper-Modus UND Paper-Port. Drei Widersprueche in den Konzepten sind dabei entschieden worden: Schicht B heisst ab jetzt "kein UNGEDECKTER Short" (der Grund der Regel war der Kredit, nicht der Short), die Hausreserve wird einmal abgezogen statt zweimal, und der Positionsschluessel ist eine Spalte statt eines Sechser-Verbunds (MySQL verlangt NOT NULL fuer Schluesselspalten). Begruendungen stehen in docs/ROADMAP.md. Enthaelt ausserdem die noch nicht committete Arbeit aus der vorigen Sitzung: die Fehlerbehebungen aus Epic X (WorkerBase-Intervall, BackupWorker, --check gegen die Datenbank, CapitolTrades-429, SIGTERM) samt DatabaseEndpoint, MysqlDumpTool und der Roadmap-Umstellung. Sie lag im Arbeitsbaum und liess sich nicht abtrennen, weil beide Staende dieselben Dateien beruehren. 213 -> 369 Tests, Build ohne Warnung. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Richard
@@ -0,0 +1,173 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Capital;
|
||||
using IBKRTrader.Core.Trading;
|
||||
|
||||
namespace IBKRTrader.Tests.Capital;
|
||||
|
||||
/// <summary>
|
||||
/// Welche Aktien und welches Bargeld sind frei? Der Baustein, ohne den „hat er die Aktien?" beim
|
||||
/// zweiten Call eine ungedeckte Option schreibt.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class CoverageCalculatorTests
|
||||
{
|
||||
private static readonly DateOnly Expiry = new(2026, 9, 18);
|
||||
|
||||
private static Position Stock(int qty, decimal price = 140m) =>
|
||||
new("OW", InstrumentRef.ForStock("AAPL"), qty, price);
|
||||
|
||||
private static Position Option(OptionRight right, decimal strike, int qty, decimal premium = 2.50m) =>
|
||||
new("OW", InstrumentRef.ForOption(new OptionSpec("AAPL", Expiry, strike, right)), qty, premium);
|
||||
|
||||
[Fact]
|
||||
public void SharesAlone_AreAllFree()
|
||||
{
|
||||
var c = CoverageCalculator.For([Stock(300)]);
|
||||
|
||||
c.Shares.Should().Be(300);
|
||||
c.SharesBoundByShortCalls.Should().Be(0);
|
||||
c.FreeShares.Should().Be(300);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EachWrittenCall_BindsOneRoundLot()
|
||||
{
|
||||
var c = CoverageCalculator.For([Stock(300), Option(OptionRight.Call, 150m, -2)]);
|
||||
|
||||
c.SharesBoundByShortCalls.Should().Be(200);
|
||||
c.FreeShares.Should().Be(100);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BoughtOptions_BindNothing()
|
||||
{
|
||||
// Eine gekaufte Option ist ein Recht, keine Verpflichtung - sie deckt nichts und bindet nichts.
|
||||
var c = CoverageCalculator.For([Stock(100), Option(OptionRight.Call, 150m, +3)]);
|
||||
|
||||
c.FreeShares.Should().Be(100);
|
||||
c.CashBoundByShortPuts.Should().Be(0m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WrittenPuts_BindCash_AtStrikeTimesMultiplier()
|
||||
{
|
||||
var c = CoverageCalculator.For([Option(OptionRight.Put, 150m, -2)]);
|
||||
|
||||
c.CashBoundByShortPuts.Should().Be(30_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MoreShortCallsThanShares_LeavesNoFreeShares_ButNeverNegative()
|
||||
{
|
||||
// Sollte durch die Deckungspruefung nicht entstehen koennen; entstuende es doch durch einen
|
||||
// Abgleich, darf daraus keine negative "Deckung" werden, die eine weitere Option traegt.
|
||||
var c = CoverageCalculator.For([Stock(100), Option(OptionRight.Call, 150m, -3)]);
|
||||
|
||||
c.FreeShares.Should().Be(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShortStockPosition_DoesNotCountAsCoverage()
|
||||
{
|
||||
var c = CoverageCalculator.For([Stock(-100)]);
|
||||
|
||||
c.Shares.Should().Be(0);
|
||||
c.FreeShares.Should().Be(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MaxCoveredContracts_ForCalls_CountsFreeRoundLots()
|
||||
{
|
||||
var call = new OptionSpec("AAPL", Expiry, 150m, OptionRight.Call);
|
||||
|
||||
CoverageCalculator.MaxCoveredContracts(call, new(250, 0, 0m), 0m).Should().Be(2);
|
||||
CoverageCalculator.MaxCoveredContracts(call, new(250, 200, 0m), 0m).Should().Be(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MaxCoveredContracts_ForPuts_CountsAffordableObligations()
|
||||
{
|
||||
var put = new OptionSpec("AAPL", Expiry, 150m, OptionRight.Put);
|
||||
|
||||
CoverageCalculator.MaxCoveredContracts(put, default, 45_000m).Should().Be(3);
|
||||
CoverageCalculator.MaxCoveredContracts(put, default, 14_999m).Should().Be(0);
|
||||
CoverageCalculator.MaxCoveredContracts(put, default, -1m).Should().Be(0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,183 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Capital;
|
||||
using IBKRTrader.Core.Trading;
|
||||
|
||||
namespace IBKRTrader.Tests.Capital;
|
||||
|
||||
/// <summary>
|
||||
/// Die Margin-Sperre in vier Schichten (#304). Sie ist testpflichtig, weil sie das Einzige ist,
|
||||
/// was zwischen einem Cash-Konto mit brokerseitig verfügbarer Margin und einem kreditfinanzierten
|
||||
/// Modul-Handel steht.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class MarginGuardTests
|
||||
{
|
||||
private static AccountState Account(
|
||||
decimal netLiq = 100_000m, decimal available = 50_000m, decimal cash = 20_000m,
|
||||
Dictionary<string, decimal>? byCurrency = null) =>
|
||||
new(netLiq, available, cash, byCurrency);
|
||||
|
||||
private static OptionSpec Put150 => new("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Put);
|
||||
private static OptionSpec Call150 => new("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Call);
|
||||
|
||||
// ─── Schicht A: Bemessungsgrundlage ──────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void FreeCash_UsesRealCash_NotTheLeveragedAvailableFunds()
|
||||
{
|
||||
// AvailableFunds 50.000 ist auf einem Margin-Konto bereits gehebelt. Massgeblich sind die
|
||||
// 20.000 echtes Bargeld.
|
||||
MarginGuard.FreeCash(Account(available: 50_000m, cash: 20_000m), 0m, 0m)
|
||||
.Should().Be(20_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FreeCash_SubtractsHouseReserveAndOpenReservations()
|
||||
{
|
||||
MarginGuard.FreeCash(Account(cash: 20_000m), houseReserve: 5_000m, openReservations: 3_000m)
|
||||
.Should().Be(12_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FreeCash_AppliesTheHaircutBeforeTheDeductions()
|
||||
{
|
||||
// 20.000 abzueglich 10 % = 18.000, davon 5.000 Reserve = 13.000.
|
||||
MarginGuard.FreeCash(Account(cash: 20_000m), 5_000m, 0m, haircutPercent: 10m)
|
||||
.Should().Be(13_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ManualMarginPosition_ShrinksModuleBuyingPowerAutomatically()
|
||||
{
|
||||
// Der Betreiber eroeffnet von Hand eine Margin-Position: TotalCashValue faellt auf 0,
|
||||
// AvailableFunds bleibt hoch. Die Modul-Kaufkraft ist damit null - ohne Sonderlogik.
|
||||
MarginGuard.FreeCash(Account(available: 40_000m, cash: 0m), 0m, 0m).Should().Be(0m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FreeCash_IsNeverNegative()
|
||||
{
|
||||
MarginGuard.FreeCash(Account(cash: 1_000m), houseReserve: 9_000m, openReservations: 0m)
|
||||
.Should().Be(0m);
|
||||
}
|
||||
|
||||
// ─── Schicht B: kein ungedeckter Short ───────────────────────────────────────
|
||||
|
||||
private static CoverageCalculator.Coverage Cover(int shares, int bound = 0) =>
|
||||
new(shares, bound, 0m);
|
||||
|
||||
[Fact]
|
||||
public void SellingStockWithoutHolding_IsAlwaysRefused()
|
||||
{
|
||||
// Ein Aktien-Short ist immer ein Kredit. Diese Schicht bleibt unveraendert scharf.
|
||||
var breach = MarginGuard.CheckShortCoverage(
|
||||
InstrumentRef.ForStock("AAPL"), quantity: 10, heldQuantity: 0, Cover(0), 1_000_000m);
|
||||
|
||||
breach.Should().NotBeNull();
|
||||
breach!.Kind.Should().Be(LimitKind.Coverage);
|
||||
breach.MaxQuantity.Should().Be(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SellingStockYouHold_IsNotACoverageQuestion()
|
||||
{
|
||||
MarginGuard.CheckShortCoverage(
|
||||
InstrumentRef.ForStock("AAPL"), quantity: 10, heldQuantity: 10, Cover(10), 0m)
|
||||
.Should().BeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CoveredCall_IsAllowed_WhenEnoughFreeShares()
|
||||
{
|
||||
MarginGuard.CheckShortCoverage(
|
||||
InstrumentRef.ForOption(Call150), quantity: 1, heldQuantity: 0, Cover(100), 0m)
|
||||
.Should().BeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SecondCallAgainstTheSameHundredShares_IsRefused()
|
||||
{
|
||||
// 100 Aktien decken EINEN Call, nicht zwei. Der erste hat sie bereits gebunden.
|
||||
var breach = MarginGuard.CheckShortCoverage(
|
||||
InstrumentRef.ForOption(Call150), quantity: 1, heldQuantity: 0,
|
||||
Cover(shares: 100, bound: 100), 1_000_000m);
|
||||
|
||||
breach.Should().NotBeNull();
|
||||
breach!.Kind.Should().Be(LimitKind.Coverage);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CashSecuredPut_NeedsStrikeTimesMultiplierInCash()
|
||||
{
|
||||
var instrument = InstrumentRef.ForOption(Put150);
|
||||
|
||||
// 15.000 reichen fuer genau einen Kontrakt.
|
||||
MarginGuard.CheckShortCoverage(instrument, 1, 0, Cover(0), 15_000m).Should().BeNull();
|
||||
|
||||
var breach = MarginGuard.CheckShortCoverage(instrument, 1, 0, Cover(0), 14_999m);
|
||||
breach.Should().NotBeNull();
|
||||
breach!.Current.Should().Be(15_000m);
|
||||
breach.Limit.Should().Be(14_999m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartlyCoveredSale_ReportsWhatWouldStillBePossible()
|
||||
{
|
||||
// 32.000 Bargeld tragen zwei Kontrakte zu je 15.000, nicht drei.
|
||||
var breach = MarginGuard.CheckShortCoverage(
|
||||
InstrumentRef.ForOption(Put150), quantity: 3, heldQuantity: 0, Cover(0), 32_000m);
|
||||
|
||||
breach.Should().NotBeNull();
|
||||
breach!.MaxQuantity.Should().Be(2);
|
||||
}
|
||||
|
||||
// ─── Schicht C: Währung ──────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BuyingInACurrency_NeedsCashInThatCurrency()
|
||||
{
|
||||
var account = Account(byCurrency: new() { ["USD"] = 10_000m, ["EUR"] = 500m });
|
||||
|
||||
MarginGuard.CheckCurrencyCash(account, "USD", 5_000m, 0m).Should().BeNull();
|
||||
|
||||
var breach = MarginGuard.CheckCurrencyCash(account, "EUR", 5_000m, 0m);
|
||||
breach.Should().NotBeNull();
|
||||
breach!.Kind.Should().Be(LimitKind.CurrencyCash);
|
||||
breach.Scope.Should().Be("EUR");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ReservationsInTheSameCurrency_ReduceWhatIsAvailable()
|
||||
{
|
||||
var account = Account(byCurrency: new() { ["USD"] = 10_000m });
|
||||
|
||||
MarginGuard.CheckCurrencyCash(account, "USD", 5_000m, reservedInCurrency: 6_000m)
|
||||
.Should().NotBeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WithoutACurrencyBreakdown_TheBuyIsRefused_NotWavedThrough()
|
||||
{
|
||||
// Eine unbekannte Waehrungsdeckung ist keine vorhandene. Ein positiver Gesamtsaldo sagt
|
||||
// nichts darueber, ob in DIESER Waehrung Geld da ist - ein Sollsaldo darin waere ein Kredit.
|
||||
MarginGuard.CheckCurrencyCash(Account(byCurrency: null), "USD", 100m, 0m)
|
||||
.Should().NotBeNull();
|
||||
}
|
||||
|
||||
// ─── Schicht D: Watchdog ─────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BuyingHalts_WhenCashFallsBelowTheThreshold()
|
||||
{
|
||||
MarginGuard.BuyingShouldHalt(Account(netLiq: 100_000m, cash: 1_500m), minCashPercent: 2m)
|
||||
.Should().BeTrue();
|
||||
MarginGuard.BuyingShouldHalt(Account(netLiq: 100_000m, cash: 2_500m), minCashPercent: 2m)
|
||||
.Should().BeFalse();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UnknownAccountValue_HaltsBuying()
|
||||
{
|
||||
MarginGuard.BuyingShouldHalt(Account(netLiq: 0m, cash: 0m), 2m).Should().BeTrue();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,272 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Capital;
|
||||
using IBKRTrader.Core.Logging;
|
||||
using IBKRTrader.Core.Persistence.Ef;
|
||||
using IBKRTrader.Core.Persistence.Entities;
|
||||
using IBKRTrader.Core.Settings;
|
||||
using IBKRTrader.Core.Trading;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
|
||||
namespace IBKRTrader.Tests.Capital;
|
||||
|
||||
/// <summary>
|
||||
/// Reservierungen über den Order-Lebenszyklus (#305), gegen die EF-InMemory-Datenbank – kein
|
||||
/// externer Zugriff, deterministisch.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class ReservationServiceTests
|
||||
{
|
||||
private sealed class InMemoryFactory(DbContextOptions<CoreDbContext> options)
|
||||
: IDbContextFactory<CoreDbContext>
|
||||
{
|
||||
public CoreDbContext CreateDbContext() => new(options);
|
||||
}
|
||||
|
||||
private static readonly BookId Ow = BookId.ForModule("OW");
|
||||
private static readonly InstrumentRef Aapl = InstrumentRef.ForStock("AAPL");
|
||||
|
||||
private static ReservationService CreateSut(
|
||||
out IDbContextFactory<CoreDbContext> factory, int ttlMinutes = 120)
|
||||
{
|
||||
var options = new DbContextOptionsBuilder<CoreDbContext>()
|
||||
.UseInMemoryDatabase(Guid.NewGuid().ToString())
|
||||
.Options;
|
||||
factory = new InMemoryFactory(options);
|
||||
|
||||
var settings = new SettingsService();
|
||||
settings.Settings.Capital.ReservationTtlMinutes = ttlMinutes;
|
||||
return new ReservationService(factory, settings, new LoggingService());
|
||||
}
|
||||
|
||||
private static Func<ReservationService.ReservationLoad, ReservationService.ReservationRequest>
|
||||
Bind(decimal amount, int shares = 0) =>
|
||||
_ => ReservationService.ReservationRequest.Bind(amount, shares);
|
||||
|
||||
// ─── Binden ──────────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task Reserve_BindsCapital_AndCountsAsOpen()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
|
||||
var result = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
result.Success.Should().BeTrue();
|
||||
result.WasExisting.Should().BeFalse();
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(1_000m);
|
||||
(await sut.GetOpenAmountAsync(Ow)).Should().Be(1_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Reserve_PassesTheCurrentLoadToTheCheck()
|
||||
{
|
||||
// Genau dafuer laeuft die Pruefung unter dem Schloss: sie muss den Stand sehen, der die
|
||||
// bereits gebundenen Betraege enthaelt - sonst geben zwei Signale dasselbe Geld aus.
|
||||
var sut = CreateSut(out _);
|
||||
await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
ReservationService.ReservationLoad seen = default;
|
||||
await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-2", load =>
|
||||
{
|
||||
seen = load;
|
||||
return ReservationService.ReservationRequest.Bind(500m);
|
||||
});
|
||||
|
||||
seen.TotalCash.Should().Be(1_000m);
|
||||
seen.CashOfBook.Should().Be(1_000m);
|
||||
seen.CashInCurrency.Should().Be(1_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Reserve_CanBeRefusedByTheCheck()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
var breach = new LimitBreach(LimitKind.CashAvailable, "AAPL", 5_000m, 100m, 0, 100m);
|
||||
|
||||
var result = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1",
|
||||
_ => ReservationService.ReservationRequest.Reject(breach));
|
||||
|
||||
result.Success.Should().BeFalse();
|
||||
result.Breach.Should().Be(breach);
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(0m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task SameSignalTwice_ReturnsTheExistingBinding_InsteadOfASecond()
|
||||
{
|
||||
// Der Reconnect-Fall. Ohne diese Sperre entstuende eine zweite Order fuer dasselbe Signal.
|
||||
var sut = CreateSut(out _);
|
||||
var first = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
var second = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
second.WasExisting.Should().BeTrue();
|
||||
second.Reservation!.Id.Should().Be(first.Reservation!.Id);
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(1_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task SameSignalForADifferentContract_IsItsOwnBinding()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
var put = InstrumentRef.ForOption(
|
||||
new OptionSpec("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Put));
|
||||
|
||||
await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
var second = await sut.ReserveAsync(Ow, put, TradeSide.Sell, 1, "USD", "sig-1", Bind(15_000m));
|
||||
|
||||
second.WasExisting.Should().BeFalse();
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(16_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task WrittenCalls_BindShares_NotCash()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
var call = InstrumentRef.ForOption(
|
||||
new OptionSpec("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Call));
|
||||
|
||||
await sut.ReserveAsync(Ow, call, TradeSide.Sell, 1, "USD", "sig-1", Bind(0m, shares: 100));
|
||||
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(0m);
|
||||
(await sut.GetOpenSharesAsync(Ow, "AAPL")).Should().Be(100);
|
||||
}
|
||||
|
||||
// ─── Abschließen ─────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task Settle_FullFill_ReleasesTheBinding_BecauseItBecameAPosition()
|
||||
{
|
||||
// Sonst zaehlte dasselbe Kapital doppelt: einmal als Reservierung, einmal als Position.
|
||||
var sut = CreateSut(out _);
|
||||
var r = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_050m));
|
||||
|
||||
await sut.SettleAsync(r.Reservation!.Id, filledQuantity: 10, actualAmount: 1_000m);
|
||||
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(0m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Settle_NoFill_ReleasesEverything()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
var r = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_050m));
|
||||
|
||||
await sut.SettleAsync(r.Reservation!.Id, filledQuantity: 0, actualAmount: 0m);
|
||||
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(0m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Settle_PartialFill_KeepsTheRestBound()
|
||||
{
|
||||
var sut = CreateSut(out var factory);
|
||||
var r = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
await sut.SettleAsync(r.Reservation!.Id, filledQuantity: 4, actualAmount: 400m);
|
||||
|
||||
// 6 von 10 Stueck offen -> 60 % der Bindung bleibt stehen.
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(600m);
|
||||
await using var db = await factory.CreateDbContextAsync();
|
||||
var row = await db.Reservations.FindAsync(r.Reservation!.Id);
|
||||
row!.State.Should().Be(ReservationState.PartiallyFilled);
|
||||
row.Quantity.Should().Be(6);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancel_ReleasesTheBinding()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
var r = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
await sut.CancelAsync(r.Reservation!.Id, "Order abgelehnt");
|
||||
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(0m);
|
||||
}
|
||||
|
||||
// ─── Frist ───────────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task OverdueBinding_IsReported_NotSilentlyReleased()
|
||||
{
|
||||
// Eine haengende Order, deren Reservierung stillschweigend freigegeben wird, gibt dasselbe
|
||||
// Geld zweimal aus. Deshalb: Alarm, und der Zustand heisst Expired, nicht Cancelled.
|
||||
var sut = CreateSut(out var factory, ttlMinutes: 1);
|
||||
var r = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
await using (var db = await factory.CreateDbContextAsync())
|
||||
{
|
||||
var row = await db.Reservations.FindAsync(r.Reservation!.Id);
|
||||
row!.ExpiresAt = DateTime.UtcNow.AddMinutes(-5);
|
||||
await db.SaveChangesAsync();
|
||||
}
|
||||
|
||||
var overdue = await sut.ExpireOverdueAsync();
|
||||
|
||||
overdue.Should().ContainSingle();
|
||||
overdue[0].State.Should().Be(ReservationState.Expired);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task BindingsWithinTheirDeadline_AreLeftAlone()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
(await sut.ExpireOverdueAsync()).Should().BeEmpty();
|
||||
}
|
||||
|
||||
// ─── Absturzwiederherstellung ────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task Recovery_KeepsBindingsWhoseBrokerOrderIsStillOpen()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
var r = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
await sut.MarkSubmittedAsync(r.Reservation!.Id, "O-42");
|
||||
|
||||
var orphans = await sut.RecoverAsync(["O-42"]);
|
||||
|
||||
orphans.Should().BeEmpty();
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(1_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Recovery_QuarantinesOrphans_AndKeepsTheirCapitalBound()
|
||||
{
|
||||
// Zwei Erklaerungen mit entgegengesetzter Folge: die Order wurde nie abgeschickt (Geld darf
|
||||
// zurueck) oder sie wurde ausgefuehrt, waehrend wir weg waren (es gibt eine Position, die
|
||||
// wir nicht kennen). Welche zutrifft, entscheidet nicht diese Methode.
|
||||
var sut = CreateSut(out _);
|
||||
var r = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
await sut.MarkSubmittedAsync(r.Reservation!.Id, "O-42");
|
||||
|
||||
var orphans = await sut.RecoverAsync(["O-99"]);
|
||||
|
||||
orphans.Should().ContainSingle();
|
||||
orphans[0].State.Should().Be(ReservationState.Quarantined);
|
||||
(await sut.GetOpenAmountAsync()).Should().Be(1_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Recovery_QuarantinesBindingsThatNeverReachedTheBroker()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
|
||||
var orphans = await sut.RecoverAsync([]);
|
||||
|
||||
orphans.Should().ContainSingle();
|
||||
orphans[0].BrokerOrderId.Should().BeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Recovery_IgnoresFinishedBindings()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
var r = await sut.ReserveAsync(Ow, Aapl, TradeSide.Buy, 10, "USD", "sig-1", Bind(1_000m));
|
||||
await sut.SettleAsync(r.Reservation!.Id, 10, 1_000m);
|
||||
|
||||
(await sut.RecoverAsync([])).Should().BeEmpty();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user