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();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Configuration;
|
||||
using IBKRTrader.Core.Settings;
|
||||
|
||||
namespace IBKRTrader.Tests.Configuration;
|
||||
|
||||
/// <summary>
|
||||
/// Die eine maßgebliche Datenbankverbindung. Vorher lasen EF-Kontexte und BackupWorker je eine
|
||||
/// eigene Konfiguration – eine Installation konnte laufen und dabei eine andere Datenbank sichern.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class DatabaseEndpointTests
|
||||
{
|
||||
private static DatabaseSettings Settings() => new()
|
||||
{
|
||||
Host = "db.example",
|
||||
Port = 3306,
|
||||
Database = "ibkrtrader",
|
||||
User = "trader",
|
||||
Password = "geheim"
|
||||
};
|
||||
|
||||
[Fact]
|
||||
public void ConfiguredConnectionString_Wins_AndIsDecomposed()
|
||||
{
|
||||
var endpoint = DatabaseEndpoint.Resolve(
|
||||
"Server=127.0.0.1;Port=3999;Database=ibkrtrader_test;User ID=tester;Password=x;", Settings());
|
||||
|
||||
endpoint.Source.Should().Be("appsettings");
|
||||
endpoint.Host.Should().Be("127.0.0.1");
|
||||
endpoint.Port.Should().Be(3999);
|
||||
endpoint.Database.Should().Be("ibkrtrader_test");
|
||||
endpoint.User.Should().Be("tester");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WithoutConnectionString_SettingsJsonIsUsed()
|
||||
{
|
||||
var endpoint = DatabaseEndpoint.Resolve(null, Settings());
|
||||
|
||||
endpoint.Source.Should().Be("settings.json");
|
||||
endpoint.Host.Should().Be("db.example");
|
||||
endpoint.Database.Should().Be("ibkrtrader");
|
||||
endpoint.DescribeDivergence(Settings()).Should().BeNull("aus einer Quelle kann nichts auseinanderlaufen");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DivergingSources_AreReported()
|
||||
{
|
||||
var endpoint = DatabaseEndpoint.Resolve(
|
||||
"Server=127.0.0.1;Port=3306;Database=ibkrtrader_test;User ID=tester;Password=x;", Settings());
|
||||
|
||||
var divergence = endpoint.DescribeDivergence(Settings());
|
||||
|
||||
divergence.Should().NotBeNull();
|
||||
divergence.Should().Contain("ibkrtrader_test").And.Contain("db.example");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void MatchingSources_AreSilent()
|
||||
{
|
||||
var settings = Settings();
|
||||
var endpoint = DatabaseEndpoint.Resolve(settings.BuildConnectionString(), settings);
|
||||
|
||||
endpoint.DescribeDivergence(settings).Should().BeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UnreadableConnectionString_FallsBackToSettingsJson()
|
||||
{
|
||||
var endpoint = DatabaseEndpoint.Resolve("das ist kein Connection-String", Settings());
|
||||
|
||||
endpoint.Host.Should().Be("db.example");
|
||||
endpoint.Source.Should().StartWith("settings.json");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ToString_NeverContainsThePassword()
|
||||
{
|
||||
var endpoint = DatabaseEndpoint.Resolve(null, Settings());
|
||||
|
||||
endpoint.ToString().Should().NotContain("geheim");
|
||||
endpoint.ToString().Should().Be("trader@db.example:3306/ibkrtrader");
|
||||
}
|
||||
}
|
||||
@@ -24,6 +24,7 @@
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\..\src\IBKRTrader.Core\IBKRTrader.Core.csproj" />
|
||||
<ProjectReference Include="..\..\src\IBKRTrader.Modules.CongressTrading\IBKRTrader.Modules.CongressTrading.csproj" />
|
||||
<ProjectReference Include="..\..\src\IBKRTrader.Modules.OptionsWheel\IBKRTrader.Modules.OptionsWheel.csproj" />
|
||||
<ProjectReference Include="..\..\src\IBKRTrader.Modules.Accounting\IBKRTrader.Modules.Accounting.csproj" />
|
||||
<ProjectReference Include="..\..\src\IBKRTrader.Modules.Supervisor\IBKRTrader.Modules.Supervisor.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
using System.Net;
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Logging;
|
||||
using IBKRTrader.Modules.CongressTrading.Scraper;
|
||||
|
||||
namespace IBKRTrader.Tests.Modules;
|
||||
|
||||
/// <summary>
|
||||
/// Verhalten des Scrapers, wenn capitoltrades.com den Abruf begrenzt. Ohne Netzwerk: der
|
||||
/// Nachrichten-Handler wird untergeschoben und zählt die Anfragen mit.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class CapitolTradesRateLimitTests
|
||||
{
|
||||
/// <summary>Antwortet mit einer festen Folge von Antworten und zählt die Anfragen.</summary>
|
||||
private sealed class StubHandler(Func<int, HttpResponseMessage> responder) : HttpMessageHandler
|
||||
{
|
||||
public int Requests;
|
||||
|
||||
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken ct)
|
||||
{
|
||||
var n = Interlocked.Increment(ref Requests);
|
||||
return Task.FromResult(responder(n));
|
||||
}
|
||||
}
|
||||
|
||||
private static HttpResponseMessage TooManyRequests(TimeSpan retryAfter)
|
||||
{
|
||||
var response = new HttpResponseMessage(HttpStatusCode.TooManyRequests);
|
||||
response.Headers.RetryAfter = new System.Net.Http.Headers.RetryConditionHeaderValue(retryAfter);
|
||||
return response;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task RateLimit_EndsWithRateLimitedException_NotAnHttpError()
|
||||
{
|
||||
// Retry-After deutlich über dem, was innerhalb eines Laufs abgewartet wird → sofort zurückstellen.
|
||||
var handler = new StubHandler(_ => TooManyRequests(TimeSpan.FromHours(1)));
|
||||
var scraper = new CapitolTradesScraper(new LoggingService(), handler);
|
||||
|
||||
var act = async () => await scraper.ScrapeTradesPageAsync(1, CancellationToken.None);
|
||||
|
||||
var ex = await act.Should().ThrowAsync<CapitolTradesRateLimitedException>();
|
||||
ex.Which.RetryAfterUtc.Should().BeAfter(DateTime.UtcNow);
|
||||
handler.Requests.Should().Be(1, "ohne Retry-After-Spielraum wird nicht nachgefasst");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task AfterRateLimit_NoFurtherRequestsUntilBlockExpires()
|
||||
{
|
||||
var handler = new StubHandler(_ => TooManyRequests(TimeSpan.FromHours(1)));
|
||||
var scraper = new CapitolTradesScraper(new LoggingService(), handler);
|
||||
|
||||
await Assert.ThrowsAsync<CapitolTradesRateLimitedException>(
|
||||
() => scraper.ScrapeTradesPageAsync(1, CancellationToken.None));
|
||||
|
||||
// Zweiter Aufruf – etwa der andere CT-Worker – läuft nicht erneut gegen die Sperre.
|
||||
await Assert.ThrowsAsync<CapitolTradesRateLimitedException>(
|
||||
() => scraper.GetTotalPagesAsync(CancellationToken.None));
|
||||
|
||||
handler.Requests.Should().Be(1, "das Sperrfenster hält weitere Abrufe zurück");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OtherHttpErrors_StayErrors()
|
||||
{
|
||||
var handler = new StubHandler(_ => new HttpResponseMessage(HttpStatusCode.InternalServerError));
|
||||
var scraper = new CapitolTradesScraper(new LoggingService(), handler);
|
||||
|
||||
await Assert.ThrowsAsync<HttpRequestException>(
|
||||
() => scraper.ScrapeTradesPageAsync(1, CancellationToken.None));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task SuccessfulResponse_IsParsedAsBefore()
|
||||
{
|
||||
var handler = new StubHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = new StringContent(@"self.__next_f.push([1,""\""totalPages\"":7""])")
|
||||
});
|
||||
var scraper = new CapitolTradesScraper(new LoggingService(), handler);
|
||||
|
||||
var pages = await scraper.GetTotalPagesAsync(CancellationToken.None);
|
||||
|
||||
pages.Should().Be(7);
|
||||
handler.Requests.Should().Be(1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Capital;
|
||||
using IBKRTrader.Core.Modularity;
|
||||
using IBKRTrader.Modules.Accounting;
|
||||
using IBKRTrader.Modules.CongressTrading;
|
||||
using IBKRTrader.Modules.OptionsWheel;
|
||||
using IBKRTrader.Modules.Supervisor;
|
||||
|
||||
namespace IBKRTrader.Tests.Modules.OptionsWheel;
|
||||
|
||||
/// <summary>
|
||||
/// Der Modulvertrag des OptionsWheels und die Buchzuordnung.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class OptionsWheelModuleTests
|
||||
{
|
||||
private static IModule[] AllModules() =>
|
||||
[
|
||||
new CongressTradingModule(),
|
||||
new OptionsWheelModule(),
|
||||
new AccountingModule(),
|
||||
new SupervisorModule()
|
||||
];
|
||||
|
||||
private static string BookNameOf(IModule m) => m.DbPrefix.TrimEnd('_').ToUpperInvariant();
|
||||
|
||||
[Fact]
|
||||
public void Module_UsesItsOwnTablePrefix()
|
||||
{
|
||||
var module = new OptionsWheelModule();
|
||||
|
||||
module.Name.Should().Be("OptionsWheel");
|
||||
module.DbPrefix.Should().Be("ow_");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Module_CarriesNoUiCode()
|
||||
{
|
||||
// RegisterUi bleibt leer, sonst muesste das Modul Avalonia referenzieren und waere nicht
|
||||
// mehr kopflos lauffaehig. Das Fenster registriert die Shell zentral.
|
||||
var act = () => new OptionsWheelModule().RegisterUi(null!, null!);
|
||||
|
||||
act.Should().NotThrow();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Module_NamesItsMissingPrerequisites_InsteadOfSilentlyDoingNothing()
|
||||
{
|
||||
// Der Handelsbetrieb haengt an #299 und #294. Ein aktiviertes Modul, das nichts tut und
|
||||
// nicht sagt warum, kostet den Betreiber eine Stunde Fehlersuche.
|
||||
var blocker = new OptionsWheelModule().GetActivationBlocker(null!);
|
||||
|
||||
blocker.Should().NotBeNull();
|
||||
blocker.Should().Contain("#299").And.Contain("#294");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EveryModuleMapsToItsOwnBook()
|
||||
{
|
||||
// Zwei Module, die auf denselben Buchnamen fallen, teilten sich unbemerkt ein Cap und eine
|
||||
// Buchfuehrung.
|
||||
var names = AllModules().Select(BookNameOf).ToList();
|
||||
|
||||
names.Should().OnlyHaveUniqueItems();
|
||||
names.Should().Contain("OW");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NoModuleClaimsAReservedBookName()
|
||||
{
|
||||
foreach (var name in AllModules().Select(BookNameOf))
|
||||
BookId.IsReserved(name).Should().BeFalse($"'{name}' darf kein reservierter Name sein");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TheDiagnosticsBookIsSeparateFromEveryModule()
|
||||
{
|
||||
// Eine Prueforder darf nicht in der Buchfuehrung eines Strategiemoduls landen: sie
|
||||
// verfaelschte dessen Auslastung und dessen GuV, und zwar dauerhaft.
|
||||
AllModules().Select(BookNameOf).Should().NotContain(BookId.Diagnostics.Value);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,172 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Trading;
|
||||
using IBKRTrader.Modules.OptionsWheel.Logic;
|
||||
|
||||
namespace IBKRTrader.Tests.Modules.OptionsWheel;
|
||||
|
||||
/// <summary>
|
||||
/// Roll-Entscheidung und Prämienrechnung – die beiden Stellen, an denen das Wheel Geld verliert,
|
||||
/// wenn sie falsch sind.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class RollAndPremiumTests
|
||||
{
|
||||
private static readonly DateOnly Today = new(2026, 8, 1);
|
||||
|
||||
private static OptionSpec Put(decimal strike = 150m, DateOnly? expiry = null) =>
|
||||
new("AAPL", expiry ?? new DateOnly(2026, 9, 5), strike, OptionRight.Put);
|
||||
|
||||
private static WheelRules Rules => new();
|
||||
|
||||
// ─── Prämienrechnung ─────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void PremiumPerContract_UsesTheContractSize()
|
||||
{
|
||||
PremiumMath.PremiumPerContract(2.50m, Put()).Should().Be(250m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CapitalAtRisk_IsCashForPuts_AndShareValueForCalls()
|
||||
{
|
||||
PremiumMath.CapitalAtRisk(Put(150m), underlyingPrice: 160m).Should().Be(15_000m);
|
||||
|
||||
var call = new OptionSpec("AAPL", new DateOnly(2026, 9, 5), 150m, OptionRight.Call);
|
||||
PremiumMath.CapitalAtRisk(call, underlyingPrice: 160m).Should().Be(16_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnnualizedReturn_PutsShortAndLongContractsOnTheSameScale()
|
||||
{
|
||||
// 250 auf 15.000 in 30 Tagen sind gut 20 % p. a. Ohne den Zeitbezug wuerde die Auswahl
|
||||
// systematisch die lang laufenden Kontrakte bevorzugen - die mit dem langsamsten
|
||||
// Zeitwertverfall.
|
||||
var r = PremiumMath.AnnualizedReturnPercent(250m, 15_000m, 30);
|
||||
|
||||
r.Should().BeApproximately(20.28m, 0.01m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnnualizedReturn_OfAContractExpiringToday_IsZero_NotADivisionByZero()
|
||||
{
|
||||
PremiumMath.AnnualizedReturnPercent(250m, 15_000m, 0).Should().Be(0m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BreakEven_IsStrikeMinusPremiumForAPut()
|
||||
{
|
||||
PremiumMath.BreakEven(Put(150m), premiumPerShare: 2.50m).Should().Be(147.50m);
|
||||
|
||||
var call = new OptionSpec("AAPL", new DateOnly(2026, 9, 5), 150m, OptionRight.Call);
|
||||
PremiumMath.BreakEven(call, 2.50m).Should().Be(152.50m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EffectiveCostBasis_FallsWithEveryPremiumCollected()
|
||||
{
|
||||
// Zugeteilt zu 150, insgesamt 600 Praemie auf 100 Stueck -> Einstand 144.
|
||||
PremiumMath.EffectiveCostBasis(150m, 600m, 100).Should().Be(144m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DaysToExpiry_IsNeverNegative()
|
||||
{
|
||||
PremiumMath.DaysToExpiry(new DateOnly(2026, 7, 1), Today).Should().Be(0);
|
||||
}
|
||||
|
||||
// ─── Rollen ──────────────────────────────────────────────────────────────────
|
||||
|
||||
private static RollDecider.OpenLeg Leg(
|
||||
DateOnly expiry, decimal delta, decimal underlying, decimal currentPrice = 1.00m,
|
||||
decimal premiumReceived = 250m) =>
|
||||
new(Put(150m, expiry), premiumReceived, currentPrice, delta, underlying);
|
||||
|
||||
[Fact]
|
||||
public void PlentyOfTimeLeft_MeansHold()
|
||||
{
|
||||
var leg = Leg(new DateOnly(2026, 9, 5), delta: 0.20m, underlying: 160m); // 35 Tage
|
||||
|
||||
RollDecider.Decide(leg, Rules, Today).Action.Should().Be(LegAction.Hold);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShortTimeLeftButFarOutOfTheMoney_MeansHold()
|
||||
{
|
||||
// Die Restlaufzeit allein ist kein Grund: ein weit aus dem Geld liegender Kontrakt darf
|
||||
// wertlos verfallen - das ist der Normalfall und der billigste Ausgang.
|
||||
var leg = Leg(new DateOnly(2026, 8, 15), delta: 0.10m, underlying: 180m); // 14 Tage
|
||||
|
||||
RollDecider.Decide(leg, Rules, Today).Action.Should().Be(LegAction.Hold);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShortTimeLeftAndInTheMoney_RollsWhenTheTargetPaysACredit()
|
||||
{
|
||||
var leg = Leg(new DateOnly(2026, 8, 15), delta: 0.60m, underlying: 140m, currentPrice: 11m);
|
||||
var target = Put(145m, new DateOnly(2026, 9, 18));
|
||||
|
||||
// Rueckkauf 1.100, neue Praemie 1.400 -> 300 Netto-Kredit.
|
||||
var d = RollDecider.Decide(leg, Rules, Today, target, rollTargetPremium: 1_400m);
|
||||
|
||||
d.Action.Should().Be(LegAction.Roll);
|
||||
d.Target.Should().Be(target);
|
||||
d.Reason.Should().Contain("Netto-Kredit");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ADebitRoll_IsRefused_AndAssignmentIsAllowedInstead()
|
||||
{
|
||||
// Ein Debit-Roll kauft nur Zeit und kostet dabei Geld: er verschiebt das Problem und
|
||||
// verkleinert das Konto.
|
||||
var leg = Leg(new DateOnly(2026, 8, 15), delta: 0.60m, underlying: 140m, currentPrice: 11m);
|
||||
|
||||
var d = RollDecider.Decide(leg, Rules, Today, Put(145m), rollTargetPremium: 900m);
|
||||
|
||||
d.Action.Should().Be(LegAction.AllowAssignment);
|
||||
d.Reason.Should().Contain("Belastung");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WithoutAnEligibleTarget_AssignmentIsAllowed()
|
||||
{
|
||||
var leg = Leg(new DateOnly(2026, 8, 15), delta: 0.60m, underlying: 140m, currentPrice: 11m);
|
||||
|
||||
RollDecider.Decide(leg, Rules, Today, rollTarget: null).Action
|
||||
.Should().Be(LegAction.AllowAssignment);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProfitTarget_IsOffByDefault()
|
||||
{
|
||||
// 250 vereinnahmt, Rueckkauf kostet nur noch 20 -> 92 % erreicht. Ohne eingeschaltetes
|
||||
// Ziel bleibt das folgenlos.
|
||||
var leg = Leg(new DateOnly(2026, 9, 5), delta: 0.10m, underlying: 170m, currentPrice: 0.20m);
|
||||
|
||||
RollDecider.Decide(leg, Rules, Today).Action.Should().Be(LegAction.Hold);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ProfitTarget_ClosesTheLeg_WhenSwitchedOn()
|
||||
{
|
||||
var rules = Rules;
|
||||
rules.ProfitTargetPercent = 50m;
|
||||
var leg = Leg(new DateOnly(2026, 9, 5), delta: 0.10m, underlying: 170m, currentPrice: 0.20m);
|
||||
|
||||
var d = RollDecider.Decide(leg, rules, Today);
|
||||
|
||||
d.Action.Should().Be(LegAction.Close);
|
||||
d.Reason.Should().Contain("vereinnahmt");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void InTheMoney_IsSideAware()
|
||||
{
|
||||
var put = Put(150m);
|
||||
var call = new OptionSpec("AAPL", new DateOnly(2026, 9, 5), 150m, OptionRight.Call);
|
||||
|
||||
RollDecider.IsInTheMoney(put, 140m).Should().BeTrue();
|
||||
RollDecider.IsInTheMoney(put, 160m).Should().BeFalse();
|
||||
RollDecider.IsInTheMoney(call, 160m).Should().BeTrue();
|
||||
RollDecider.IsInTheMoney(call, 140m).Should().BeFalse();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Trading;
|
||||
using IBKRTrader.Modules.OptionsWheel.Logic;
|
||||
|
||||
namespace IBKRTrader.Tests.Modules.OptionsWheel;
|
||||
|
||||
/// <summary>
|
||||
/// Die Strike-Wahl (#310). Delta-basiert im Band 0,15–0,30, nur Watchlist, kein Screening – und
|
||||
/// jede Verwerfung mit Begründung, weil bei Vollautomatik die nicht getroffene Wahl die wichtigste
|
||||
/// Information für die spätere Fehlersuche ist.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class StrikeSelectorTests
|
||||
{
|
||||
private readonly StrikeSelector _sut = new();
|
||||
private static readonly DateOnly Today = new(2026, 8, 1);
|
||||
|
||||
/// <summary>35 Tage Restlaufzeit – mitten im Fenster 30–45.</summary>
|
||||
private static readonly DateOnly Good = new(2026, 9, 5);
|
||||
|
||||
private static WheelRules Rules => new();
|
||||
|
||||
private static OptionQuote Put(
|
||||
decimal strike, decimal delta, decimal bid = 3.00m, decimal ask = 3.20m,
|
||||
DateOnly? expiry = null, int openInterest = 5000) =>
|
||||
new(new OptionSpec("AAPL", expiry ?? Good, strike, OptionRight.Put),
|
||||
bid, ask, Last: 0m, Delta: -delta, ImpliedVolatility: 0.27m, OpenInterest: openInterest);
|
||||
|
||||
private static OptionQuote Call(
|
||||
decimal strike, decimal delta, decimal bid = 3.00m, decimal ask = 3.20m) =>
|
||||
new(new OptionSpec("AAPL", Good, strike, OptionRight.Call),
|
||||
bid, ask, Last: 0m, Delta: delta, ImpliedVolatility: 0.27m, OpenInterest: 5000);
|
||||
|
||||
// ─── Auswahl ─────────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void PicksTheStrikeClosestToTheTargetDelta()
|
||||
{
|
||||
// Ziel 0,20. Nicht die hoechste Praemie gewinnt - die haette immer der Kontrakt mit dem
|
||||
// groessten Zuteilungsrisiko.
|
||||
var chain = new[] { Put(145m, 0.28m), Put(140m, 0.19m), Put(135m, 0.16m) };
|
||||
|
||||
var result = _sut.Select(chain, Rules, Today, underlyingPrice: 150m);
|
||||
|
||||
result.Chosen.Should().NotBeNull();
|
||||
result.Chosen!.Quote.Spec.Strike.Should().Be(140m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EveryCandidate_IsKept_WithItsReason()
|
||||
{
|
||||
var chain = new[] { Put(140m, 0.19m), Put(120m, 0.05m) };
|
||||
|
||||
var result = _sut.Select(chain, Rules, Today, 150m);
|
||||
|
||||
result.Evaluated.Should().HaveCount(2);
|
||||
result.Evaluated.Should().ContainSingle(c => c.IsEligible);
|
||||
result.Evaluated.Single(c => !c.IsEligible).Rejection
|
||||
.Should().Be(RejectionReason.DeltaOutOfBand);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void NothingEligible_MeansNoChoice_NotABadChoice()
|
||||
{
|
||||
var result = _sut.Select([Put(120m, 0.05m)], Rules, Today, 150m);
|
||||
|
||||
result.Chosen.Should().BeNull();
|
||||
result.Evaluated.Should().HaveCount(1);
|
||||
}
|
||||
|
||||
// ─── Verwerfungen ────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void ExpiryOutsideTheWindow_IsRejected()
|
||||
{
|
||||
var tooSoon = Put(140m, 0.20m, expiry: new DateOnly(2026, 8, 10)); // 9 Tage
|
||||
var tooLate = Put(140m, 0.20m, expiry: new DateOnly(2026, 12, 18)); // 139 Tage
|
||||
|
||||
_sut.Select([tooSoon], Rules, Today, 150m).Evaluated[0].Rejection
|
||||
.Should().Be(RejectionReason.DaysToExpiry);
|
||||
_sut.Select([tooLate], Rules, Today, 150m).Evaluated[0].Rejection
|
||||
.Should().Be(RejectionReason.DaysToExpiry);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void WithoutADelta_TheChoiceIsNotJustifiable_AndTheCandidateIsRejected()
|
||||
{
|
||||
var noDelta = new OptionQuote(
|
||||
new OptionSpec("AAPL", Good, 140m, OptionRight.Put), 3.00m, 3.20m, Delta: null);
|
||||
|
||||
_sut.Select([noDelta], Rules, Today, 150m).Evaluated[0].Rejection
|
||||
.Should().Be(RejectionReason.NoDelta);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PutDeltaIsJudgedByItsMagnitude()
|
||||
{
|
||||
// TWS meldet fuer Puts ein negatives Delta. Das Zielband ist fuer beide Seiten als Betrag
|
||||
// gemeint - ohne den Betrag faende die Auswahl bei Puts nie einen Treffer.
|
||||
var result = _sut.Select([Put(140m, 0.20m)], Rules, Today, 150m);
|
||||
|
||||
result.Chosen.Should().NotBeNull();
|
||||
result.Chosen!.Quote.Delta.Should().Be(-0.20m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AWideSpread_IsRejected()
|
||||
{
|
||||
// Ein weiter Markt kostet beim Oeffnen, beim Schliessen erneut und beim Rollen ein drittes Mal.
|
||||
var wide = Put(140m, 0.20m, bid: 2.00m, ask: 4.00m); // Spanne 66 %
|
||||
|
||||
_sut.Select([wide], Rules, Today, 150m).Evaluated[0].Rejection
|
||||
.Should().Be(RejectionReason.SpreadTooWide);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AOneSidedMarket_IsRejected_NotTreatedAsZeroSpread()
|
||||
{
|
||||
var oneSided = Put(140m, 0.20m, bid: 0m, ask: 3.20m);
|
||||
|
||||
_sut.Select([oneSided], Rules, Today, 150m).Evaluated[0].Rejection
|
||||
.Should().Be(RejectionReason.SpreadTooWide);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnIlliquidContract_IsRejected_BecauseItCannotBeLeft()
|
||||
{
|
||||
var thin = Put(140m, 0.20m, openInterest: 3);
|
||||
|
||||
_sut.Select([thin], Rules, Today, 150m).Evaluated[0].Rejection
|
||||
.Should().Be(RejectionReason.Illiquid);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void APremiumBelowTheFloor_IsRejected()
|
||||
{
|
||||
var rules = Rules;
|
||||
rules.MinPremiumPerContract = 500m; // 3,10 x 100 = 310 liegt darunter
|
||||
|
||||
_sut.Select([Put(140m, 0.20m)], rules, Today, 150m).Evaluated[0].Rejection
|
||||
.Should().Be(RejectionReason.PremiumTooLow);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AnAnnualizedReturnBelowTheFloor_IsRejected()
|
||||
{
|
||||
var rules = Rules;
|
||||
rules.MinAnnualizedReturnPercent = 500m;
|
||||
|
||||
_sut.Select([Put(140m, 0.20m)], rules, Today, 150m).Evaluated[0].Rejection
|
||||
.Should().Be(RejectionReason.ReturnTooLow);
|
||||
}
|
||||
|
||||
// ─── Die Regel, die den Wheel vor sich selbst schützt ────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void ACallBelowTheEffectiveCostBasis_IsRejected()
|
||||
{
|
||||
// Sonst realisiert das Wheel bei jedem Abruf einen Verlust und verdient dennoch Praemie –
|
||||
// ein Muster, das in der Auswertung lange gut aussieht.
|
||||
var result = _sut.Select([Call(130m, 0.20m)], Rules, Today, 150m, minCallStrike: 145m);
|
||||
|
||||
result.Chosen.Should().BeNull();
|
||||
result.Evaluated[0].Rejection.Should().Be(RejectionReason.BelowCostBasis);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ACallAtOrAboveTheCostBasis_IsAllowed()
|
||||
{
|
||||
_sut.Select([Call(150m, 0.20m)], Rules, Today, 150m, minCallStrike: 145m)
|
||||
.Chosen.Should().NotBeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ThePutPath_IgnoresTheCostBasisFloor()
|
||||
{
|
||||
// Der Einstand betrifft nur den Covered Call: beim Put gibt es noch keine Aktien.
|
||||
_sut.Select([Put(140m, 0.20m)], Rules, Today, 150m, minCallStrike: 145m)
|
||||
.Chosen.Should().NotBeNull();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Trading;
|
||||
using IBKRTrader.Modules.OptionsWheel.Logic;
|
||||
|
||||
namespace IBKRTrader.Tests.Modules.OptionsWheel;
|
||||
|
||||
/// <summary>
|
||||
/// Der Zustandsautomat je Basiswert. Er wird aus den Positionen <b>abgeleitet</b> und nicht
|
||||
/// fortgeschrieben – Zuteilung und Verfall ändern Positionen ohne Order von uns, ein mitgeführter
|
||||
/// Zustand liefe zwangsläufig aus dem Tritt.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class WheelStateMachineTests
|
||||
{
|
||||
private static readonly DateOnly Expiry = new(2026, 9, 18);
|
||||
|
||||
private static Position Shares(int qty) =>
|
||||
new("OW", InstrumentRef.ForStock("AAPL"), qty, 140m);
|
||||
|
||||
private static Position Contract(OptionRight right, int qty, decimal strike = 150m) =>
|
||||
new("OW", InstrumentRef.ForOption(new OptionSpec("AAPL", Expiry, strike, right)), qty, 2.50m);
|
||||
|
||||
[Fact]
|
||||
public void NoPositions_MeansIdle_AndTheNextStepIsAPut()
|
||||
{
|
||||
var state = WheelStateMachine.Derive([]);
|
||||
|
||||
state.Should().Be(WheelState.Idle);
|
||||
WheelStateMachine.NextAction(state).Should().Be(WheelStateMachine.WheelAction.SellPut);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AWrittenPut_MeansShortPut()
|
||||
{
|
||||
WheelStateMachine.Derive([Contract(OptionRight.Put, -1)])
|
||||
.Should().Be(WheelState.ShortPut);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SharesWithoutACall_MeanStock_AndTheNextStepIsACall()
|
||||
{
|
||||
// Der Zustand nach einer Zuteilung.
|
||||
var state = WheelStateMachine.Derive([Shares(100)]);
|
||||
|
||||
state.Should().Be(WheelState.Stock);
|
||||
WheelStateMachine.NextAction(state).Should().Be(WheelStateMachine.WheelAction.SellCall);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SharesWithAWrittenCall_MeanShortCall()
|
||||
{
|
||||
WheelStateMachine.Derive([Shares(100), Contract(OptionRight.Call, -1)])
|
||||
.Should().Be(WheelState.ShortCall);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BoughtOptions_DoNotCreateAWheelState()
|
||||
{
|
||||
// Eine gekaufte Option ist keine geschriebene; sie gehoert nicht zum Wheel.
|
||||
WheelStateMachine.Derive([Contract(OptionRight.Put, +2)])
|
||||
.Should().Be(WheelState.Idle);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void APendingOrder_OutweighsThePositions()
|
||||
{
|
||||
// Sonst bekaeme derselbe Basiswert ein zweites Leg, waehrend das erste noch im Buch liegt.
|
||||
WheelStateMachine.Derive([Shares(100)], hasPendingOrder: true)
|
||||
.Should().Be(WheelState.PendingOrder);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void HaltedOutweighsEverything_AndStopsAnyAction()
|
||||
{
|
||||
var state = WheelStateMachine.Derive([Shares(100)], hasPendingOrder: true, halted: true);
|
||||
|
||||
state.Should().Be(WheelState.Halted);
|
||||
WheelStateMachine.NextAction(state).Should().Be(WheelStateMachine.WheelAction.None);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void OpenLegs_AreManaged_NotReopened()
|
||||
{
|
||||
WheelStateMachine.NextAction(WheelState.ShortPut)
|
||||
.Should().Be(WheelStateMachine.WheelAction.ManageOpenLeg);
|
||||
WheelStateMachine.NextAction(WheelState.ShortCall)
|
||||
.Should().Be(WheelStateMachine.WheelAction.ManageOpenLeg);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AssignmentIsARegularPath_NotAFault()
|
||||
{
|
||||
// Amerikanische Optionen koennen jederzeit ausgeuebt werden. Ein Automat, der Zuteilung als
|
||||
// Stoerfall behandelte, waere im Normalbetrieb staendig gestoert.
|
||||
WheelStateMachine.DescribeTransition(WheelState.ShortPut, WheelState.Stock)
|
||||
.Should().Contain("zugeteilt");
|
||||
WheelStateMachine.DescribeTransition(WheelState.ShortCall, WheelState.Idle)
|
||||
.Should().Contain("abgerufen");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
using System.Globalization;
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Analytics;
|
||||
using IBKRTrader.Core.Persistence.Entities;
|
||||
using IBKRTrader.Core.Trading;
|
||||
|
||||
namespace IBKRTrader.Tests.Trading;
|
||||
|
||||
/// <summary>
|
||||
/// Zahlen und Zeitpunkte, die in Logs, Dossiers oder in die Datenbank gehen, dürfen nicht an der
|
||||
/// Kultur des Hosts hängen. Wir betreiben Instanzen in EU und US und vergleichen deren Ausgaben
|
||||
/// miteinander – "373,67" auf der einen und "373.67" auf der anderen wäre dasselbe Ereignis in
|
||||
/// zwei Schreibweisen.
|
||||
///
|
||||
/// <para>Die Tests setzen bewusst eine Kultur mit Dezimalkomma und prüfen, dass sich davon nichts
|
||||
/// beeindrucken lässt. Der laufende Prozess stellt zusätzlich die invariante Kultur ein
|
||||
/// (AppHostBuilder), aber genau darauf soll sich der einzelne Codepfad <b>nicht</b> verlassen.</para>
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class CultureIndependenceTests
|
||||
{
|
||||
/// <summary>Führt die Prüfung unter einer Kultur mit Dezimalkomma aus.</summary>
|
||||
private static void UnderGermanCulture(Action assert)
|
||||
{
|
||||
var previous = CultureInfo.CurrentCulture;
|
||||
try
|
||||
{
|
||||
CultureInfo.CurrentCulture = new CultureInfo("de-DE");
|
||||
assert();
|
||||
}
|
||||
finally
|
||||
{
|
||||
CultureInfo.CurrentCulture = previous;
|
||||
}
|
||||
}
|
||||
|
||||
private static BrokerPosition Position() => new()
|
||||
{
|
||||
Symbol = "GOOG",
|
||||
SecType = "STK",
|
||||
Currency = "USD",
|
||||
ConId = 208813720,
|
||||
Quantity = 10,
|
||||
AvgCost = 373.67m
|
||||
};
|
||||
|
||||
[Fact]
|
||||
public void BrokerPosition_ToString_UsesInvariantNumbers()
|
||||
{
|
||||
UnderGermanCulture(() =>
|
||||
Position().ToString().Should().Be("GOOG (STK) 10 @ 373.67 USD"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BrokerExecution_ToString_UsesInvariantNumbers()
|
||||
{
|
||||
var execution = new BrokerExecution
|
||||
{
|
||||
ExecId = "0001",
|
||||
Time = new DateTime(2026, 9, 3, 18, 26, 13, DateTimeKind.Utc),
|
||||
Symbol = "AAPL",
|
||||
SecType = "STK",
|
||||
Side = TradeSide.Buy,
|
||||
Quantity = 5,
|
||||
Price = 327.27m
|
||||
};
|
||||
|
||||
UnderGermanCulture(() =>
|
||||
execution.ToString().Should().Be("2026-09-03 18:26:13 Buy 5x AAPL @ 327.27"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Dossier_WritesInvariantNumbers()
|
||||
{
|
||||
var dossier = new TradeDossier(
|
||||
SignalId: "sig-1",
|
||||
Decisions: [],
|
||||
OrderEvents: [],
|
||||
Trades:
|
||||
[
|
||||
new CoreTrade
|
||||
{
|
||||
Module = "CT",
|
||||
Symbol = "AAPL",
|
||||
Action = "BUY",
|
||||
Quantity = 3,
|
||||
Price = 327.27m,
|
||||
TotalValue = 981.81m,
|
||||
Status = "Filled",
|
||||
TradedAt = new DateTime(2026, 9, 3, 18, 26, 13, DateTimeKind.Utc)
|
||||
}
|
||||
],
|
||||
LogLines: []);
|
||||
|
||||
UnderGermanCulture(() =>
|
||||
{
|
||||
var markdown = DossierBuilder.ToMarkdown(dossier);
|
||||
|
||||
markdown.Should().Contain("327.27").And.Contain("981.81");
|
||||
markdown.Should().NotContain("327,27");
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -38,8 +38,8 @@ public class DashboardServiceTests
|
||||
var (sut, factory) = Create();
|
||||
await using (var db = await factory.CreateDbContextAsync())
|
||||
{
|
||||
db.Positions.Add(new CorePosition { Module = "CT", Symbol = "AAPL", Quantity = 5, AvgPrice = 100m });
|
||||
db.Positions.Add(new CorePosition { Module = "CT", Symbol = "MSFT", Quantity = 2, AvgPrice = 200m });
|
||||
db.Positions.Add(new CorePosition { Module = "CT", ContractKey = "AAPL", Symbol = "AAPL", Quantity = 5, AvgPrice = 100m });
|
||||
db.Positions.Add(new CorePosition { Module = "CT", ContractKey = "MSFT", Symbol = "MSFT", Quantity = 2, AvgPrice = 200m });
|
||||
db.TradeHistory.Add(new CoreTrade { Module = "CT", Symbol = "AAPL", Action = "BUY", Quantity = 5, Price = 100m });
|
||||
await db.SaveChangesAsync();
|
||||
}
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Capital;
|
||||
using IBKRTrader.Core.Logging;
|
||||
using IBKRTrader.Core.Persistence;
|
||||
using IBKRTrader.Core.Persistence.Entities;
|
||||
using IBKRTrader.Core.Settings;
|
||||
using IBKRTrader.Core.Trading;
|
||||
using NSubstitute;
|
||||
@@ -16,9 +18,12 @@ public class ExecutionServiceTests
|
||||
private readonly SettingsService _settings = new();
|
||||
private readonly IDecisionJournal _journal = Substitute.For<IDecisionJournal>();
|
||||
private readonly IOrderEventLog _orderLog = Substitute.For<IOrderEventLog>();
|
||||
private readonly ICapitalService _capital = Substitute.For<ICapitalService>();
|
||||
|
||||
private static readonly BookId Book = BookId.ForModule("CT");
|
||||
|
||||
private ExecutionService CreateSut() =>
|
||||
new(_broker, _risk, _portfolio, _settings, new LoggingService(), _journal, _orderLog);
|
||||
new(_broker, _risk, _portfolio, _settings, new LoggingService(), _journal, _orderLog, _capital);
|
||||
|
||||
private static readonly TradeSignal BuySignal = new()
|
||||
{
|
||||
@@ -27,6 +32,29 @@ public class ExecutionServiceTests
|
||||
|
||||
private void EnableTrading() => _settings.Settings.Trading.TradingEnabled = true;
|
||||
|
||||
/// <summary>
|
||||
/// Kapital-Seam im Normalfall: Buch bekannt, Kontext leer, Bindung geht durch. Die Regeln des
|
||||
/// Kapitalmodells werden einzeln in CapitalTests geprueft – hier geht es nur darum, dass der
|
||||
/// Ausfuehrungspfad sie an der richtigen Stelle aufruft.
|
||||
/// </summary>
|
||||
private void ArrangeCapital(long reservationId = 1)
|
||||
{
|
||||
_capital.ResolveBook("CT").Returns(Book);
|
||||
_capital.BuildContextAsync(Arg.Any<BookId>(), Arg.Any<InstrumentRef>(), Arg.Any<decimal>(),
|
||||
Arg.Any<AccountState>(), Arg.Any<CancellationToken>())
|
||||
.Returns(ci => Task.FromResult(new RiskContext
|
||||
{
|
||||
Price = ci.ArgAt<decimal>(2),
|
||||
NetLiquidation = ci.ArgAt<AccountState>(3).NetLiquidation
|
||||
}));
|
||||
_capital.ReserveAsync(Arg.Any<BookId>(), Arg.Any<TradeSignal>(), Arg.Any<InstrumentRef>(),
|
||||
Arg.Any<TradeSide>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<decimal>(),
|
||||
Arg.Any<OrderType>(), Arg.Any<AccountState>(), Arg.Any<string>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.Returns(Task.FromResult(new ReservationService.ReserveResult(
|
||||
new CoreReservation { Id = reservationId }, null, false)));
|
||||
}
|
||||
|
||||
private void ArrangeHappyPath()
|
||||
{
|
||||
EnableTrading();
|
||||
@@ -36,8 +64,9 @@ public class ExecutionServiceTests
|
||||
.Returns(Task.FromResult(new AccountState(10_000m, 10_000m)));
|
||||
_portfolio.GetModuleExposureAsync(Arg.Any<string>(), Arg.Any<CancellationToken>())
|
||||
.Returns(Task.FromResult(0m));
|
||||
_portfolio.GetPositionQuantityAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
|
||||
_portfolio.GetPositionQuantityAsync(Arg.Any<string>(), Arg.Any<InstrumentRef>(), Arg.Any<CancellationToken>())
|
||||
.Returns(Task.FromResult(0));
|
||||
ArrangeCapital();
|
||||
_risk.Evaluate(Arg.Any<TradeSignal>(), Arg.Any<RiskContext>(), Arg.Any<RiskParameters>())
|
||||
.Returns(RiskDecision.Approve(5));
|
||||
_broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
|
||||
@@ -75,6 +104,7 @@ public class ExecutionServiceTests
|
||||
.Returns(Task.FromResult<Quote?>(new Quote("AAPL", 100m, 99m, 101m)));
|
||||
_broker.GetAccountStateAsync(Arg.Any<CancellationToken>())
|
||||
.Returns(Task.FromResult(new AccountState(10_000m, 10_000m)));
|
||||
ArrangeCapital();
|
||||
_risk.Evaluate(Arg.Any<TradeSignal>(), Arg.Any<RiskContext>(), Arg.Any<RiskParameters>())
|
||||
.Returns(RiskDecision.Reject("Modul-Limit überschritten."));
|
||||
|
||||
@@ -95,7 +125,7 @@ public class ExecutionServiceTests
|
||||
result.Executed.Should().BeTrue();
|
||||
result.Order!.OrderId.Should().Be("O1");
|
||||
await _portfolio.Received(1).RecordFillAsync(
|
||||
"CT", "AAPL", TradeSide.Buy, 5, 100m, "O1", Arg.Any<string?>(), Arg.Any<CancellationToken>());
|
||||
"CT", InstrumentRef.ForStock("AAPL"), TradeSide.Buy, 5, 100m, "O1", Arg.Any<string?>(), Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
@@ -129,7 +159,7 @@ public class ExecutionServiceTests
|
||||
await CreateSut().ExecuteAsync(signal);
|
||||
|
||||
await _portfolio.Received(1).RecordFillAsync(
|
||||
"CT", "AAPL", TradeSide.Buy, 5, 100m, "O1", "sig-abc", Arg.Any<CancellationToken>());
|
||||
"CT", InstrumentRef.ForStock("AAPL"), TradeSide.Buy, 5, 100m, "O1", "sig-abc", Arg.Any<CancellationToken>());
|
||||
_journal.Received().Write(Arg.Is<IBKRTrader.Core.Persistence.Entities.CoreDecisionRecord>(
|
||||
d => d.SignalId == "sig-abc" &&
|
||||
d.Decision == IBKRTrader.Core.Persistence.Entities.TradeDecision.Executed));
|
||||
@@ -138,6 +168,85 @@ public class ExecutionServiceTests
|
||||
e.EventType == IBKRTrader.Core.Persistence.Entities.OrderEventType.Filled));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UnknownBook_IsRejected_BeforeAnyOrder()
|
||||
{
|
||||
// SourceModule kommt aus dem Modul und ist kein Ausweis: ein nicht registrierter Name
|
||||
// wuerde ein Buch ohne Cap erzeugen - also ein unbegrenztes.
|
||||
ArrangeHappyPath();
|
||||
_capital.ResolveBook("CT").Returns((BookId?)null);
|
||||
|
||||
var result = await CreateSut().ExecuteAsync(BuySignal);
|
||||
|
||||
result.Action.Should().Be("SKIP");
|
||||
result.Reason.Should().Contain("Unbekanntes Buch");
|
||||
await _broker.DidNotReceive().PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task CapitalRejects_NoOrderIsPlaced()
|
||||
{
|
||||
ArrangeHappyPath();
|
||||
_capital.ReserveAsync(Arg.Any<BookId>(), Arg.Any<TradeSignal>(), Arg.Any<InstrumentRef>(),
|
||||
Arg.Any<TradeSide>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<decimal>(),
|
||||
Arg.Any<OrderType>(), Arg.Any<AccountState>(), Arg.Any<string>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.Returns(Task.FromResult(new ReservationService.ReserveResult(
|
||||
null,
|
||||
new LimitBreach(LimitKind.CashAvailable, "AAPL", 5000m, 1000m, 10, 1000m),
|
||||
false)));
|
||||
|
||||
var result = await CreateSut().ExecuteAsync(BuySignal);
|
||||
|
||||
result.Action.Should().Be("SKIP");
|
||||
result.Reason.Should().Contain("Freies Bargeld");
|
||||
await _broker.DidNotReceive().PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task ExistingReservationForTheSameSignal_DoesNotPlaceASecondOrder()
|
||||
{
|
||||
// Der Fall, gegen den die Idempotenz gebaut ist: ein Reconnect schickt dasselbe Signal
|
||||
// erneut. Ohne diese Sperre laege dieselbe Order zweimal beim Broker.
|
||||
ArrangeHappyPath();
|
||||
_capital.ReserveAsync(Arg.Any<BookId>(), Arg.Any<TradeSignal>(), Arg.Any<InstrumentRef>(),
|
||||
Arg.Any<TradeSide>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<decimal>(),
|
||||
Arg.Any<OrderType>(), Arg.Any<AccountState>(), Arg.Any<string>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.Returns(Task.FromResult(new ReservationService.ReserveResult(
|
||||
new CoreReservation { Id = 7 }, null, WasExisting: true)));
|
||||
|
||||
var result = await CreateSut().ExecuteAsync(BuySignal);
|
||||
|
||||
result.Action.Should().Be("SKIP");
|
||||
await _broker.DidNotReceive().PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task FailedOrder_ReleasesTheReservation()
|
||||
{
|
||||
// Sonst bliebe das Geld bis zum Fristablauf gebunden, obwohl gar keine Order existiert.
|
||||
ArrangeHappyPath();
|
||||
_broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
|
||||
.Returns(Task.FromResult(OrderResult.Fail("Broker abgelehnt")));
|
||||
|
||||
await CreateSut().ExecuteAsync(BuySignal);
|
||||
|
||||
await _capital.Received(1).CancelReservationAsync(1, Arg.Any<string>(), Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task FilledOrder_SettlesTheReservation()
|
||||
{
|
||||
ArrangeHappyPath();
|
||||
|
||||
await CreateSut().ExecuteAsync(BuySignal);
|
||||
|
||||
// Reserviert wurde mit Puffer, ausgefuehrt zum echten Preis: 5 x 100 = 500 fliessen als
|
||||
// tatsaechlicher Bedarf zurueck, der Rest wird freigegeben.
|
||||
await _capital.Received(1).SettleReservationAsync(1, 5, 500m, Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OrderFails_ReturnsError_AndDoesNotBook()
|
||||
{
|
||||
@@ -150,7 +259,7 @@ public class ExecutionServiceTests
|
||||
result.Action.Should().Be("ERROR");
|
||||
result.Reason.Should().Contain("Broker abgelehnt");
|
||||
await _portfolio.DidNotReceive().RecordFillAsync(
|
||||
Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TradeSide>(),
|
||||
Arg.Any<string>(), Arg.Any<InstrumentRef>(), Arg.Any<TradeSide>(),
|
||||
Arg.Any<int>(), Arg.Any<decimal>(), Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<CancellationToken>());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -62,6 +62,58 @@ public class IbkrMappingTests
|
||||
contract.Currency.Should().Be("USD");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Option_BuildsSmartRoutedContract_WithFullExpiryDate()
|
||||
{
|
||||
var spec = new OptionSpec("aapl", new DateOnly(2026, 9, 18), 150m, OptionRight.Call);
|
||||
|
||||
var contract = IbkrMapping.Option(spec);
|
||||
|
||||
contract.Symbol.Should().Be("AAPL");
|
||||
contract.SecType.Should().Be("OPT");
|
||||
contract.Exchange.Should().Be("SMART");
|
||||
contract.Currency.Should().Be("USD");
|
||||
contract.Right.Should().Be("C");
|
||||
contract.Strike.Should().Be(150d);
|
||||
contract.Multiplier.Should().Be("100");
|
||||
// Der volle Tag, nicht nur der Monat: sonst liefert TWS bei woechentlichen Verfaellen
|
||||
// stillschweigend den Standardtermin und damit einen anderen Kontrakt.
|
||||
contract.LastTradeDateOrContractMonth.Should().Be("20260918");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Option_Put_MapsToP()
|
||||
{
|
||||
var spec = new OptionSpec("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Put);
|
||||
|
||||
IbkrMapping.Option(spec).Right.Should().Be("P");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Option_TradingClass_IsOnlySetWhenKnown()
|
||||
{
|
||||
var spec = new OptionSpec("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Put);
|
||||
|
||||
IbkrMapping.Option(spec).TradingClass.Should().BeEmpty();
|
||||
IbkrMapping.Option(spec with { TradingClass = "AAPL1" }).TradingClass.Should().Be("AAPL1");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ForRequest_PicksStockOrOption_ByTheSignalsInstrument()
|
||||
{
|
||||
var stock = new OrderRequest
|
||||
{
|
||||
Symbol = "AAPL", Side = TradeSide.Buy, Quantity = 10, Type = OrderType.Market
|
||||
};
|
||||
var option = stock with
|
||||
{
|
||||
Option = new OptionSpec("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Put)
|
||||
};
|
||||
|
||||
IbkrMapping.ForRequest(stock).SecType.Should().Be("STK");
|
||||
IbkrMapping.ForRequest(option).SecType.Should().Be("OPT");
|
||||
}
|
||||
|
||||
// ─── Order ────────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
|
||||
@@ -0,0 +1,133 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Trading;
|
||||
|
||||
namespace IBKRTrader.Tests.Trading;
|
||||
|
||||
/// <summary>
|
||||
/// Das Options-Fundament (#298): Instrumentenschlüssel, Kontraktgröße und die Bewertung, die ohne
|
||||
/// den Multiplikator um Faktor 100 danebenläge.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class InstrumentTests
|
||||
{
|
||||
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);
|
||||
|
||||
// ─── Schlüssel ───────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Stock_Key_IsTheTicker()
|
||||
{
|
||||
InstrumentRef.ForStock("aapl").Key.Should().Be("AAPL");
|
||||
InstrumentRef.ForStock(" AAPL ").Key.Should().Be("AAPL");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Option_Key_CarriesExpiryRightAndStrike()
|
||||
{
|
||||
InstrumentRef.ForOption(Put150).Key.Should().Be("AAPL|20260918|P|150");
|
||||
InstrumentRef.ForOption(Call150).Key.Should().Be("AAPL|20260918|C|150");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Option_Key_NormalizesTrailingZeroesOfTheStrike()
|
||||
{
|
||||
// decimal merkt sich die Nachkommastellen: 150m, 150.0m und 150.000m sind zwar gleich,
|
||||
// formatieren sich aber unterschiedlich. Ohne Normalisierung waeren das drei Positionen
|
||||
// auf denselben Kontrakt. (Als double waeren alle drei buchstaeblich derselbe Wert und
|
||||
// der Test pruefte nichts.)
|
||||
foreach (var strike in new[] { 150m, 150.0m, 150.000m })
|
||||
InstrumentRef.ForOption(Put150 with { Strike = strike }).Key
|
||||
.Should().Be("AAPL|20260918|P|150", "Strike {0}", strike);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Option_Key_KeepsHalfDollarStrikes()
|
||||
{
|
||||
InstrumentRef.ForOption(Put150 with { Strike = 302.5m }).Key
|
||||
.Should().Be("AAPL|20260918|P|302.5");
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("AAPL")]
|
||||
[InlineData("AAPL|20260918|P|150")]
|
||||
[InlineData("AAPL|20260918|C|302.5")]
|
||||
public void Key_RoundTrips(string key)
|
||||
{
|
||||
InstrumentRef.TryParse(key, out var parsed).Should().BeTrue();
|
||||
parsed.Key.Should().Be(key);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("")]
|
||||
[InlineData(" ")]
|
||||
[InlineData("AAPL|20260918|P")] // zu wenige Teile
|
||||
[InlineData("AAPL|20260918|P|150|X")] // zu viele Teile
|
||||
[InlineData("AAPL|18.09.2026|P|150")] // Datum im falschen Format
|
||||
[InlineData("AAPL|20260918|X|150")] // weder Call noch Put
|
||||
[InlineData("AAPL|20260918|P|einhundert")] // Strike keine Zahl
|
||||
public void UnreadableKey_IsRejected_NotGuessed(string key)
|
||||
{
|
||||
InstrumentRef.TryParse(key, out _).Should().BeFalse();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void UnderlyingRef_OfAnOption_IsTheStock()
|
||||
{
|
||||
InstrumentRef.ForOption(Put150).UnderlyingRef.Should().Be(InstrumentRef.ForStock("AAPL"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SymbolContainingTheSeparator_IsRefused()
|
||||
{
|
||||
var act = () => InstrumentRef.ForStock("AA|PL");
|
||||
act.Should().Throw<ArgumentException>();
|
||||
}
|
||||
|
||||
// ─── Bewertung ───────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void Stock_Notional_IsUnchanged()
|
||||
{
|
||||
var pos = new Position("CT", InstrumentRef.ForStock("AAPL"), 5, 100m);
|
||||
pos.Notional.Should().Be(500m);
|
||||
pos.BoundCapital.Should().Be(500m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Option_Notional_UsesTheMultiplier()
|
||||
{
|
||||
// Genau der Fehler aus #298: ohne Multiplikator waeren das 2,50 statt 250.
|
||||
var pos = new Position("OW", InstrumentRef.ForOption(Put150), 1, 2.50m);
|
||||
pos.Notional.Should().Be(250m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShortPut_BindsTheObligation_NotThePremium()
|
||||
{
|
||||
// Praemie 250 USD, Verpflichtung 15.000 USD. Wer hier den Marktwert einsetzt, haelt eine
|
||||
// Verpflichtung fuer ein Sechzigstel ihrer Groesse.
|
||||
var pos = new Position("OW", InstrumentRef.ForOption(Put150), -1, 2.50m);
|
||||
|
||||
pos.IsShort.Should().BeTrue();
|
||||
pos.Notional.Should().Be(250m);
|
||||
pos.BoundCapital.Should().Be(15_000m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShortCall_BindsNoCash_BecauseItIsCoveredByShares()
|
||||
{
|
||||
var pos = new Position("OW", InstrumentRef.ForOption(Call150), -1, 2.50m);
|
||||
pos.BoundCapital.Should().Be(0m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CoverageRequirements_AreStrikeTimesMultiplier_AndOneRoundLot()
|
||||
{
|
||||
Put150.CashCoveragePerContract.Should().Be(15_000m);
|
||||
Call150.CoverageShares.Should().Be(100);
|
||||
}
|
||||
}
|
||||
@@ -21,6 +21,9 @@ public class PortfolioServiceTests
|
||||
public CoreDbContext CreateDbContext() => new(_options);
|
||||
}
|
||||
|
||||
/// <summary>Kurzform fuer ein Aktien-Instrument – haelt die Testfaelle lesbar.</summary>
|
||||
private static InstrumentRef Stk(string symbol) => InstrumentRef.ForStock(symbol);
|
||||
|
||||
private static PortfolioService CreateSut(out IDbContextFactory<CoreDbContext> factory)
|
||||
{
|
||||
var options = new DbContextOptionsBuilder<CoreDbContext>()
|
||||
@@ -39,9 +42,9 @@ public class PortfolioServiceTests
|
||||
{
|
||||
var sut = CreateSut(out var factory);
|
||||
|
||||
await sut.RecordFillAsync("CT", "AAPL", TradeSide.Buy, 5, 100m, "O1");
|
||||
await sut.RecordFillAsync("CT", Stk("AAPL"), TradeSide.Buy, 5, 100m, "O1");
|
||||
|
||||
(await sut.GetPositionQuantityAsync("CT", "AAPL")).Should().Be(5);
|
||||
(await sut.GetPositionQuantityAsync("CT", Stk("AAPL"))).Should().Be(5);
|
||||
(await sut.GetModuleExposureAsync("CT")).Should().Be(500m);
|
||||
|
||||
await using var db = await factory.CreateDbContextAsync();
|
||||
@@ -54,10 +57,10 @@ public class PortfolioServiceTests
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
|
||||
await sut.RecordFillAsync("CT", "AAPL", TradeSide.Buy, 10, 100m, "O1");
|
||||
await sut.RecordFillAsync("CT", "AAPL", TradeSide.Buy, 10, 120m, "O2");
|
||||
await sut.RecordFillAsync("CT", Stk("AAPL"), TradeSide.Buy, 10, 100m, "O1");
|
||||
await sut.RecordFillAsync("CT", Stk("AAPL"), TradeSide.Buy, 10, 120m, "O2");
|
||||
|
||||
(await sut.GetPositionQuantityAsync("CT", "AAPL")).Should().Be(20);
|
||||
(await sut.GetPositionQuantityAsync("CT", Stk("AAPL"))).Should().Be(20);
|
||||
// Durchschnitt: (10*100 + 10*120) / 20 = 110
|
||||
var positions = await sut.GetPositionsAsync("CT");
|
||||
positions.Single().AvgPrice.Should().Be(110m);
|
||||
@@ -67,22 +70,22 @@ public class PortfolioServiceTests
|
||||
public async Task Sell_Partial_ReducesQuantity()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
await sut.RecordFillAsync("CT", "AAPL", TradeSide.Buy, 10, 100m, "O1");
|
||||
await sut.RecordFillAsync("CT", Stk("AAPL"), TradeSide.Buy, 10, 100m, "O1");
|
||||
|
||||
await sut.RecordFillAsync("CT", "AAPL", TradeSide.Sell, 4, 130m, "O2");
|
||||
await sut.RecordFillAsync("CT", Stk("AAPL"), TradeSide.Sell, 4, 130m, "O2");
|
||||
|
||||
(await sut.GetPositionQuantityAsync("CT", "AAPL")).Should().Be(6);
|
||||
(await sut.GetPositionQuantityAsync("CT", Stk("AAPL"))).Should().Be(6);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Sell_Full_RemovesPosition()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
await sut.RecordFillAsync("CT", "AAPL", TradeSide.Buy, 10, 100m, "O1");
|
||||
await sut.RecordFillAsync("CT", Stk("AAPL"), TradeSide.Buy, 10, 100m, "O1");
|
||||
|
||||
await sut.RecordFillAsync("CT", "AAPL", TradeSide.Sell, 10, 130m, "O2");
|
||||
await sut.RecordFillAsync("CT", Stk("AAPL"), TradeSide.Sell, 10, 130m, "O2");
|
||||
|
||||
(await sut.GetPositionQuantityAsync("CT", "AAPL")).Should().Be(0);
|
||||
(await sut.GetPositionQuantityAsync("CT", Stk("AAPL"))).Should().Be(0);
|
||||
(await sut.GetPositionsAsync("CT")).Should().BeEmpty();
|
||||
}
|
||||
|
||||
@@ -90,8 +93,8 @@ public class PortfolioServiceTests
|
||||
public async Task Exposure_IsIsolatedPerModule()
|
||||
{
|
||||
var sut = CreateSut(out _);
|
||||
await sut.RecordFillAsync("CT", "AAPL", TradeSide.Buy, 5, 100m, "O1");
|
||||
await sut.RecordFillAsync("XX", "MSFT", TradeSide.Buy, 2, 200m, "O2");
|
||||
await sut.RecordFillAsync("CT", Stk("AAPL"), TradeSide.Buy, 5, 100m, "O1");
|
||||
await sut.RecordFillAsync("XX", Stk("MSFT"), TradeSide.Buy, 2, 200m, "O2");
|
||||
|
||||
(await sut.GetModuleExposureAsync("CT")).Should().Be(500m);
|
||||
(await sut.GetModuleExposureAsync("XX")).Should().Be(400m);
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Trading;
|
||||
|
||||
namespace IBKRTrader.Tests.Trading;
|
||||
|
||||
/// <summary>
|
||||
/// Fortschreibung einer Position durch eine Ausführung. Die Long-Fälle bildeten vorher der
|
||||
/// PortfolioService ab; die drei Short-Fälle konnten bis zur Optionserweiterung gar nicht auftreten.
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class PositionMathTests
|
||||
{
|
||||
[Fact]
|
||||
public void Buy_FromFlat_SetsTheCostBasis()
|
||||
{
|
||||
var r = PositionMath.Apply(0, 0m, TradeSide.Buy, 10, 100m);
|
||||
|
||||
r.Quantity.Should().Be(10);
|
||||
r.AvgPrice.Should().Be(100m);
|
||||
r.ClosedQuantity.Should().Be(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Buy_More_AveragesTheCostBasis()
|
||||
{
|
||||
var r = PositionMath.Apply(10, 100m, TradeSide.Buy, 10, 120m);
|
||||
|
||||
r.Quantity.Should().Be(20);
|
||||
r.AvgPrice.Should().Be(110m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Sell_Partial_LeavesTheCostBasisAlone()
|
||||
{
|
||||
// Das Ergebnis des geschlossenen Teils ist realisiert; es gehoert in die Trade-Historie und
|
||||
// darf den Einstand der Restposition nicht verschieben.
|
||||
var r = PositionMath.Apply(10, 100m, TradeSide.Sell, 4, 130m);
|
||||
|
||||
r.Quantity.Should().Be(6);
|
||||
r.AvgPrice.Should().Be(100m);
|
||||
r.ClosedQuantity.Should().Be(4);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Sell_Everything_ClosesThePosition()
|
||||
{
|
||||
var r = PositionMath.Apply(10, 100m, TradeSide.Sell, 10, 130m);
|
||||
|
||||
r.Quantity.Should().Be(0);
|
||||
r.ClosedQuantity.Should().Be(10);
|
||||
}
|
||||
|
||||
// ─── Was es vor den Optionen nicht gab ───────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void SellToOpen_FromFlat_CreatesAShortPosition()
|
||||
{
|
||||
var r = PositionMath.Apply(0, 0m, TradeSide.Sell, 1, 2.50m);
|
||||
|
||||
r.Quantity.Should().Be(-1);
|
||||
r.AvgPrice.Should().Be(2.50m); // vereinnahmte Praemie je Kontrakt
|
||||
r.ClosedQuantity.Should().Be(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SellToOpen_Again_AveragesThePremiumReceived()
|
||||
{
|
||||
var r = PositionMath.Apply(-1, 2.00m, TradeSide.Sell, 1, 3.00m);
|
||||
|
||||
r.Quantity.Should().Be(-2);
|
||||
r.AvgPrice.Should().Be(2.50m);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BuyToClose_RemovesTheShort()
|
||||
{
|
||||
var r = PositionMath.Apply(-2, 2.50m, TradeSide.Buy, 2, 0.40m);
|
||||
|
||||
r.Quantity.Should().Be(0);
|
||||
r.ClosedQuantity.Should().Be(2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BuyToClose_Partial_KeepsThePremiumBasis()
|
||||
{
|
||||
var r = PositionMath.Apply(-3, 2.50m, TradeSide.Buy, 1, 0.40m);
|
||||
|
||||
r.Quantity.Should().Be(-2);
|
||||
r.AvgPrice.Should().Be(2.50m);
|
||||
r.ClosedQuantity.Should().Be(1);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CrossingZero_ClosesTheOldPosition_AndOpensTheOppositeAtTheFillPrice()
|
||||
{
|
||||
// Short 1 Kontrakt, 3 gekauft: 1 geschlossen, 2 neu long – und der Einstand der neuen
|
||||
// Position ist der Ausfuehrungspreis, nicht die alte Praemie.
|
||||
var r = PositionMath.Apply(-1, 2.50m, TradeSide.Buy, 3, 0.40m);
|
||||
|
||||
r.Quantity.Should().Be(2);
|
||||
r.AvgPrice.Should().Be(0.40m);
|
||||
r.ClosedQuantity.Should().Be(1);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ZeroFill_ChangesNothing()
|
||||
{
|
||||
var r = PositionMath.Apply(5, 100m, TradeSide.Buy, 0, 120m);
|
||||
|
||||
r.Quantity.Should().Be(5);
|
||||
r.AvgPrice.Should().Be(100m);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
using FluentAssertions;
|
||||
using IBKRTrader.Core.Capital;
|
||||
using IBKRTrader.Core.Trading;
|
||||
|
||||
namespace IBKRTrader.Tests.Trading;
|
||||
|
||||
/// <summary>
|
||||
/// Sell-to-open und Deckungsprüfung im Core (#300).
|
||||
///
|
||||
/// <para>Bis hierher lehnte <c>EvaluateSell</c> jeden Verkauf ohne Bestand grundsätzlich ab – und
|
||||
/// genau das ist die Kernoperation des OptionsWheels. Die Prüfung sitzt bewusst im Core: ein
|
||||
/// Modul, das sich selbst prüft, prüft sich irgendwann nicht mehr.</para>
|
||||
/// </summary>
|
||||
[Trait("cat", "unit")]
|
||||
public class RiskServiceOptionTests
|
||||
{
|
||||
private readonly RiskService _risk = new();
|
||||
|
||||
private static readonly DateOnly Expiry = new(2026, 9, 18);
|
||||
private static readonly RiskParameters Params = new(5m, 20m, 5m);
|
||||
|
||||
private static OptionSpec Put(decimal strike = 150m) => new("AAPL", Expiry, strike, OptionRight.Put);
|
||||
private static OptionSpec Call(decimal strike = 150m) => new("AAPL", Expiry, strike, OptionRight.Call);
|
||||
|
||||
private static TradeSignal Sell(OptionSpec spec, int? qty = 1) => new()
|
||||
{
|
||||
Symbol = "AAPL", Side = TradeSide.Sell, SourceModule = "OW",
|
||||
Option = spec, SuggestedQuantity = qty
|
||||
};
|
||||
|
||||
private static TradeSignal Buy(OptionSpec spec, int? qty = null) => new()
|
||||
{
|
||||
Symbol = "AAPL", Side = TradeSide.Buy, SourceModule = "OW",
|
||||
Option = spec, SuggestedQuantity = qty
|
||||
};
|
||||
|
||||
/// <summary>Reichlich Konto, reichlich Spielraum – damit nur die geprüfte Regel greift.</summary>
|
||||
private static RiskContext Ctx(
|
||||
decimal price = 2.50m, int held = 0, int shares = 0, int boundShares = 0,
|
||||
decimal cash = 1_000_000m, decimal bookHeadroom = 1_000_000m,
|
||||
decimal symbolExposure = 0m, decimal symbolLimit = 0m, bool halted = false) => new()
|
||||
{
|
||||
Price = price,
|
||||
NetLiquidation = 1_000_000m,
|
||||
ExistingQuantity = held,
|
||||
Coverage = new CoverageCalculator.Coverage(shares, boundShares, 0m),
|
||||
AvailableCashForReservation = cash,
|
||||
BookHeadroom = bookHeadroom,
|
||||
SymbolExposure = symbolExposure,
|
||||
SymbolLimit = symbolLimit,
|
||||
BuyingHalted = halted
|
||||
};
|
||||
|
||||
// ─── Cash-Secured Put ────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void SellingAPutWithoutHolding_IsApproved_WhenCashCoversTheObligation()
|
||||
{
|
||||
var d = _risk.Evaluate(Sell(Put()), Ctx(cash: 15_000m), Params);
|
||||
|
||||
d.Approved.Should().BeTrue();
|
||||
d.Quantity.Should().Be(1);
|
||||
d.ClosingQuantity.Should().Be(0); // eroeffnet, schliesst nichts
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SellingAPut_IsRefused_WhenCashIsShort()
|
||||
{
|
||||
var d = _risk.Evaluate(Sell(Put()), Ctx(cash: 14_999m), Params);
|
||||
|
||||
d.Approved.Should().BeFalse();
|
||||
d.Breach!.Kind.Should().Be(LimitKind.Coverage);
|
||||
d.Reason.Should().Contain("Deckung");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SellingThreePuts_WithCashForTwo_IsRefused_AndSaysTwoWouldWork()
|
||||
{
|
||||
var d = _risk.Evaluate(Sell(Put(), qty: 3), Ctx(cash: 32_000m), Params);
|
||||
|
||||
d.Approved.Should().BeFalse();
|
||||
d.Breach!.MaxQuantity.Should().Be(2);
|
||||
}
|
||||
|
||||
// ─── Covered Call ────────────────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void SellingACall_IsApproved_WithOneHundredFreeShares()
|
||||
{
|
||||
var d = _risk.Evaluate(Sell(Call()), Ctx(shares: 100), Params);
|
||||
|
||||
d.Approved.Should().BeTrue();
|
||||
d.Quantity.Should().Be(1);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SellingASecondCallAgainstTheSameShares_IsRefused()
|
||||
{
|
||||
var d = _risk.Evaluate(Sell(Call()), Ctx(shares: 100, boundShares: 100), Params);
|
||||
|
||||
d.Approved.Should().BeFalse();
|
||||
d.Breach!.Kind.Should().Be(LimitKind.Coverage);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CashDoesNotCoverACall_OnlySharesDo()
|
||||
{
|
||||
// Ein Call wird mit Stuecken gedeckt, nicht mit Geld. Eine Million Bargeld traegt keinen
|
||||
// einzigen geschriebenen Call.
|
||||
var d = _risk.Evaluate(Sell(Call()), Ctx(shares: 0, cash: 1_000_000m), Params);
|
||||
|
||||
d.Approved.Should().BeFalse();
|
||||
}
|
||||
|
||||
// ─── Schließen ist nie limitiert ─────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void BuyingToCloseAWrittenContract_IsAllowed_EvenWhenBuyingIsHalted()
|
||||
{
|
||||
// Ein Rueckkauf baut eine Verpflichtung ab. Der Kaufstopp soll Neuengagements verhindern,
|
||||
// nicht deren Aufloesung - sonst sperrt die Sicherung den Ausgang.
|
||||
var d = _risk.Evaluate(Buy(Put()), Ctx(held: -2, halted: true, cash: 0m, bookHeadroom: 0m), Params);
|
||||
|
||||
d.Approved.Should().BeTrue();
|
||||
d.Quantity.Should().Be(2);
|
||||
d.ClosingQuantity.Should().Be(2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BuyingToClose_IsCappedAtTheWrittenQuantity()
|
||||
{
|
||||
var d = _risk.Evaluate(Buy(Put(), qty: 5), Ctx(held: -2), Params);
|
||||
|
||||
d.Quantity.Should().Be(2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SellingToCloseABoughtContract_IsAllowed_WithoutAnyCoverage()
|
||||
{
|
||||
var d = _risk.Evaluate(Sell(Put(), qty: 1), Ctx(held: 3, cash: 0m), Params);
|
||||
|
||||
d.Approved.Should().BeTrue();
|
||||
d.Quantity.Should().Be(1);
|
||||
d.ClosingQuantity.Should().Be(1);
|
||||
}
|
||||
|
||||
// ─── Grenzen des eröffnenden Teils ───────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void OpeningIsRefused_WhenTheBookHasNoHeadroomLeft()
|
||||
{
|
||||
var d = _risk.Evaluate(Sell(Put()), Ctx(cash: 1_000_000m, bookHeadroom: 10_000m), Params);
|
||||
|
||||
d.Approved.Should().BeFalse();
|
||||
d.Breach!.Kind.Should().Be(LimitKind.BookCap);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void OpeningIsRefused_WhenItWouldBreachTheSymbolConcentration()
|
||||
{
|
||||
var d = _risk.Evaluate(Sell(Put()),
|
||||
Ctx(cash: 1_000_000m, symbolExposure: 40_000m, symbolLimit: 50_000m), Params);
|
||||
|
||||
d.Approved.Should().BeFalse();
|
||||
d.Breach!.Kind.Should().Be(LimitKind.SymbolConcentration);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BuyingAnOption_SizesByContractCost_NotByShareCost()
|
||||
{
|
||||
// Kurs 2,50 je Kontrakt = 250 je Stueck. Bei 5 % von 1.000.000 = 50.000 Budget waeren das
|
||||
// 200 Kontrakte - ohne den Multiplikator kaeme das Hundertfache heraus.
|
||||
var d = _risk.Evaluate(Buy(Put()), Ctx(price: 2.50m), Params);
|
||||
|
||||
d.Approved.Should().BeTrue();
|
||||
d.Quantity.Should().Be(200);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BuyingIsRefused_WhileTheWatchdogHoldsTheLine()
|
||||
{
|
||||
var d = _risk.Evaluate(Buy(Put()), Ctx(halted: true), Params);
|
||||
|
||||
d.Approved.Should().BeFalse();
|
||||
d.Breach!.Kind.Should().Be(LimitKind.BuyingHalted);
|
||||
}
|
||||
|
||||
// ─── Der Aktienpfad bleibt, wie er war ───────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public void SellingStockWithoutHolding_IsStillRefused()
|
||||
{
|
||||
var signal = new TradeSignal { Symbol = "AAPL", Side = TradeSide.Sell, SourceModule = "CT" };
|
||||
|
||||
var d = _risk.Evaluate(signal, Ctx(price: 100m, cash: 1_000_000m), Params);
|
||||
|
||||
d.Approved.Should().BeFalse();
|
||||
d.Reason.Should().Contain("Keine Position");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SellingStockYouHold_StillClosesTheWholePosition()
|
||||
{
|
||||
var signal = new TradeSignal { Symbol = "AAPL", Side = TradeSide.Sell, SourceModule = "CT" };
|
||||
|
||||
var d = _risk.Evaluate(signal, Ctx(price: 100m, held: 7), Params);
|
||||
|
||||
d.Approved.Should().BeTrue();
|
||||
d.Quantity.Should().Be(7);
|
||||
d.ClosingQuantity.Should().Be(7);
|
||||
}
|
||||
}
|
||||
@@ -126,4 +126,48 @@ public class WorkerBaseTests
|
||||
|
||||
worker.Info.Status.Should().Be(WorkerStatus.Stopped);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Intervalle über 24,85 Tage (int.MaxValue Millisekunden) beendeten den Worker früher still:
|
||||
/// SemaphoreSlim.WaitAsync wirft darüber, die Ausnahme verließ den Lauf-Loop, der Task
|
||||
/// faultete – und riss beim Herunterfahren den ganzen Prozess mit.
|
||||
/// Zwei ausgelieferte Vorgaben lagen über der Grenze.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task VeryLongInterval_KeepsWorkerAlive_AndStopsCleanly()
|
||||
{
|
||||
var worker = new TestWorker(TimeSpan.FromDays(400), _ => Task.CompletedTask);
|
||||
|
||||
await worker.StartAsync(CancellationToken.None);
|
||||
await WaitUntilAsync(() => worker.Runs == 1, "erster Lauf erfolgt");
|
||||
|
||||
// Der Trigger beweist, dass die Warteschleife lebt statt an einer Ausnahme gestorben zu sein.
|
||||
await worker.TriggerAsync();
|
||||
await WaitUntilAsync(() => worker.Runs == 2, "die Warteschleife nimmt weiter Trigger an");
|
||||
|
||||
worker.Info.Status.Should().NotBe(WorkerStatus.Error);
|
||||
|
||||
// Kein erneutes Werfen beim Stoppen – das war der zweite Teil des Fehlers.
|
||||
await worker.StopAsync(CancellationToken.None);
|
||||
worker.Info.Status.Should().Be(WorkerStatus.Stopped);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// "Letzter Lauf" muss auch nach einem Fehlschlag stehen: sonst ist ein Worker, der seit Tagen
|
||||
/// bei jedem Versuch scheitert, in der Tabelle nicht von einem zu unterscheiden, der noch nie
|
||||
/// gelaufen ist.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task FailedRun_StillRecordsLastRuntime()
|
||||
{
|
||||
var worker = new TestWorker(interval: null,
|
||||
_ => throw new InvalidOperationException("boom"));
|
||||
|
||||
await worker.StartAsync(CancellationToken.None);
|
||||
await WaitUntilAsync(() => worker.Info.Status == WorkerStatus.Error, "Status wird Error");
|
||||
|
||||
worker.Info.LastRuntime.Should().NotBeNull();
|
||||
|
||||
await worker.StopAsync(CancellationToken.None);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user