Richard/IBKRTrader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Options-Fundament und Kapitalmodell im Core; Modul OptionsWheel
Build & Test / build (ubuntu-latest) (push) Canceled after 0s
Details
Build & Test / build (windows-latest) (push) Canceled after 0s
Details

Browse Source 
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
2026-09-04 09:35:38 +02:00
co-authored by Claude Opus 5
parent 9f66183f1c
commit 084cd7ef77
99 changed files with 9947 additions and 445 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/IBKRTrader.Tests/Trading/CultureIndependenceTests.cs
+103
View File
@@ -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");
});
}
}
tests/IBKRTrader.Tests/Trading/DashboardServiceTests.cs
+2 -2
View File
@@ -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();
}
tests/IBKRTrader.Tests/Trading/ExecutionServiceTests.cs
+114 -5
View File
@@ -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>());
}
}
tests/IBKRTrader.Tests/Trading/IbkrMappingTests.cs
+52
View File
@@ -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]
tests/IBKRTrader.Tests/Trading/InstrumentTests.cs
+133
View File
@@ -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);
}
}
tests/IBKRTrader.Tests/Trading/PortfolioServiceTests.cs
+16 -13
View File
@@ -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);
tests/IBKRTrader.Tests/Trading/PositionMathTests.cs
+113
View File
@@ -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);
}
}
tests/IBKRTrader.Tests/Trading/RiskServiceOptionTests.cs
+212
View File
@@ -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);
}
}