RichardandClaude Opus 5
e7e3970dec
Am geschlossenen Markt gemessen: IBKR nimmt eine Order an und merkt sie fuer die naechste Eroeffnung vor. Dazu schickt es Code 399 - eine Mitteilung, deren Text mit "Warning" beginnt. Der Adapter las jede Meldung aus dem Fehler-Callback als Ablehnung, meldete "Order abgelehnt", und das Kapitalmodell gab die Bindung frei. Auf dem Testkonto lagen dadurch 67 Orders ueber 306 BAS, 140 SAP und 43 ALV beim Broker, vorgemerkt fuer Montag 09:00, ohne eine einzige Reservierung dahinter. OrderResult kannte nur "erfolgreich" und "gescheitert". Der haeufigste Fall passte in keines von beiden. Es gibt jetzt einen dritten Ausgang - Working: abgesendet, Ausgang offen. Die Trennlinie ist, ob BEWIESEN ist, dass beim Broker nichts liegt; ohne Beweis bleibt das Kapital gebunden. Eine Bindung, die zu lange steht, kostet Spielraum und faellt auf. Eine, die zu frueh verschwindet, kostet Geld und faellt nicht auf. - 399/404 sind Ordermeldungen, keine Ablehnungen; nur 201/202/203 u. a. beenden eine Order beweisbar. Ein Verbindungsabbruch beendet unsere Sicht, nicht die Order. - IsDeadStatus ist enger als IsTerminalStatus: "Inactive" ist kein Beweis. - ExecutionService haelt die Bindung bei Working (MarkSubmittedAsync statt CancelReservationAsync) und journalisiert Pending/OrderWorking statt Failed. - Neu lesbar: das Orderbuch des Brokers (reqAllOpenOrders) samt Storno. --open-orders stellt Orderbuch und eigene Bindungen gegenueber, --cancel-order <ID>|all --confirm nimmt zurueck (Sammelstorno nur im Paper-Modus). - Der Wiederanlauf-Abgleich lief bisher gegen eine leere Orderliste und haette ab jetzt jede gesunde Bindung in Quarantaene gestellt. Er sitzt jetzt im ReservationWatchdogWorker, hinter dem Beweis, dass der Broker antwortet. 457 Tests gruen. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
378 lines
17 KiB
C#
378 lines
17 KiB
C#
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;
|
||
|
||
namespace IBKRTrader.Tests.Trading;
|
||
|
||
[Trait("cat", "unit")]
|
||
public class ExecutionServiceTests
|
||
{
|
||
private readonly IBrokerClient _broker = Substitute.For<IBrokerClient>();
|
||
private readonly IRiskService _risk = Substitute.For<IRiskService>();
|
||
private readonly IPortfolioService _portfolio = Substitute.For<IPortfolioService>();
|
||
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, _capital);
|
||
|
||
private static readonly TradeSignal BuySignal = new()
|
||
{
|
||
Symbol = "AAPL", Side = TradeSide.Buy, SourceModule = "CT"
|
||
};
|
||
|
||
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();
|
||
_broker.GetQuoteAsync(Arg.Any<InstrumentRef>(), Arg.Any<CancellationToken>())
|
||
.Returns(Task.FromResult<Quote?>(new Quote("AAPL", 100m, 99m, 101m)));
|
||
_broker.GetAccountStateAsync(Arg.Any<CancellationToken>())
|
||
.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<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>())
|
||
.Returns(Task.FromResult(OrderResult.Filled("O1", 5, 100m)));
|
||
}
|
||
|
||
[Fact]
|
||
public async Task TradingDisabled_Skips_WithoutTouchingBroker()
|
||
{
|
||
// TradingEnabled ist standardmäßig false
|
||
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 NoQuote_Skips()
|
||
{
|
||
EnableTrading();
|
||
_broker.GetQuoteAsync(Arg.Any<InstrumentRef>(), Arg.Any<CancellationToken>())
|
||
.Returns(Task.FromResult<Quote?>(null));
|
||
|
||
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 RiskRejects_Skips_WithReason()
|
||
{
|
||
EnableTrading();
|
||
_broker.GetQuoteAsync(Arg.Any<InstrumentRef>(), Arg.Any<CancellationToken>())
|
||
.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."));
|
||
|
||
var result = await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
result.Action.Should().Be("SKIP");
|
||
result.Reason.Should().Contain("Modul-Limit");
|
||
await _broker.DidNotReceive().PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task HappyPath_PlacesOrder_AndBooksFill()
|
||
{
|
||
ArrangeHappyPath();
|
||
|
||
var result = await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
result.Executed.Should().BeTrue();
|
||
result.Order!.OrderId.Should().Be("O1");
|
||
await _portfolio.Received(1).RecordFillAsync(
|
||
"CT", InstrumentRef.ForStock("AAPL"), TradeSide.Buy, 5, 100m, "O1", Arg.Any<string?>(), Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task HappyPath_MarketOrder_WhenNoLimitPrice()
|
||
{
|
||
ArrangeHappyPath();
|
||
|
||
await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
await _broker.Received(1).PlaceOrderAsync(
|
||
Arg.Is<OrderRequest>(o => o.Type == OrderType.Market && o.Quantity == 5),
|
||
Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task TradingDisabled_WritesSkippedDecision()
|
||
{
|
||
await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
_journal.Received().Write(Arg.Is<IBKRTrader.Core.Persistence.Entities.CoreDecisionRecord>(
|
||
d => d.Decision == IBKRTrader.Core.Persistence.Entities.TradeDecision.Skipped &&
|
||
d.Reason == IBKRTrader.Core.Persistence.Entities.DecisionReason.TradingDisabled));
|
||
}
|
||
|
||
[Fact]
|
||
public async Task HappyPath_PropagatesSignalId_AndJournalsExecuted()
|
||
{
|
||
ArrangeHappyPath();
|
||
var signal = new TradeSignal { Symbol = "AAPL", Side = TradeSide.Buy, SourceModule = "CT", SignalId = "sig-abc" };
|
||
|
||
await CreateSut().ExecuteAsync(signal);
|
||
|
||
await _portfolio.Received(1).RecordFillAsync(
|
||
"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));
|
||
_orderLog.Received().Write(Arg.Is<IBKRTrader.Core.Persistence.Entities.CoreOrderEvent>(
|
||
e => e.SignalId == "sig-abc" &&
|
||
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. Die Order-ID gehoert dazu -
|
||
// ohne sie kann der Abgleich beim Neustart keine Bindung einer Order zuordnen.
|
||
await _capital.Received(1).SettleReservationAsync(1, 5, 500m, "O1", Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task TheOrderCarriesTheSignalsCurrency_NotTheDefault()
|
||
{
|
||
// Am 2026-09-04 gegen das Paper-Konto beobachtet: geprueft und reserviert wurde SAP:EUR,
|
||
// gehandelt wurde die SAP-ADR in New York, weil die OrderRequest aus Einzelfeldern gebaut
|
||
// wurde und die Waehrung dabei auf USD zurueckfiel. Ohne Fehlermeldung.
|
||
ArrangeHappyPath();
|
||
var signal = new TradeSignal
|
||
{
|
||
Symbol = "SAP", Side = TradeSide.Buy, SourceModule = "CT", Currency = "EUR"
|
||
};
|
||
|
||
await CreateSut().ExecuteAsync(signal);
|
||
|
||
await _broker.Received(1).PlaceOrderAsync(
|
||
Arg.Is<OrderRequest>(o => o.Currency == "EUR" && o.Instrument.Key == "SAP:EUR"),
|
||
Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task TheOrderCarriesTheOptionContract()
|
||
{
|
||
ArrangeHappyPath();
|
||
var spec = new OptionSpec("AAPL", new DateOnly(2026, 9, 18), 150m, OptionRight.Put);
|
||
var signal = new TradeSignal
|
||
{
|
||
Symbol = "AAPL", Side = TradeSide.Sell, SourceModule = "CT", Option = spec
|
||
};
|
||
|
||
await CreateSut().ExecuteAsync(signal);
|
||
|
||
await _broker.Received(1).PlaceOrderAsync(
|
||
Arg.Is<OrderRequest>(o => o.Option == spec && o.Instrument.Kind == InstrumentKind.Option),
|
||
Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task OrderFails_ReturnsError_AndDoesNotBook()
|
||
{
|
||
ArrangeHappyPath();
|
||
_broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
|
||
.Returns(Task.FromResult(OrderResult.Fail("Broker abgelehnt")));
|
||
|
||
var result = await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
result.Action.Should().Be("ERROR");
|
||
result.Reason.Should().Contain("Broker abgelehnt");
|
||
await _portfolio.DidNotReceive().RecordFillAsync(
|
||
Arg.Any<string>(), Arg.Any<InstrumentRef>(), Arg.Any<TradeSide>(),
|
||
Arg.Any<int>(), Arg.Any<decimal>(), Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
// ─── Die Order, die beim Broker liegt (#489) ─────────────────────────────
|
||
|
||
/// <summary>
|
||
/// <b>Der Test, um den es bei #489 geht.</b> Am 2026-09-06 wurden 67 Orders bei geschlossener
|
||
/// Börse angenommen und für Montag vorgemerkt, während der Adapter sie als abgelehnt meldete und
|
||
/// jede Bindung freigegeben wurde. Das Geld war wieder im Topf, die Orders lebten weiter.
|
||
/// </summary>
|
||
[Fact]
|
||
public async Task WorkingOrder_KeepsTheCapitalBound()
|
||
{
|
||
ArrangeHappyPath();
|
||
_broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
|
||
.Returns(Task.FromResult(OrderResult.Working("O-77", "PreSubmitted", "wartet auf Eröffnung")));
|
||
|
||
var result = await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
result.Action.Should().Be("PENDING");
|
||
result.IsPending.Should().BeTrue();
|
||
result.Executed.Should().BeFalse("nichts ist ausgeführt – PENDING ist kein Erfolg");
|
||
|
||
await _capital.Received(1).MarkSubmittedAsync(1, "O-77", Arg.Any<CancellationToken>());
|
||
await _capital.DidNotReceive().CancelReservationAsync(
|
||
Arg.Any<long>(), Arg.Any<string>(), Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task WorkingOrder_BooksNothing()
|
||
{
|
||
// Eine Position zu buchen, bevor ausgeführt wurde, wäre der Fehler in die andere Richtung.
|
||
ArrangeHappyPath();
|
||
_broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
|
||
.Returns(Task.FromResult(OrderResult.Working("O-77", "PreSubmitted", "wartet")));
|
||
|
||
await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
await _portfolio.DidNotReceive().RecordFillAsync(
|
||
Arg.Any<string>(), Arg.Any<InstrumentRef>(), Arg.Any<TradeSide>(),
|
||
Arg.Any<int>(), Arg.Any<decimal>(), Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<CancellationToken>());
|
||
await _capital.DidNotReceive().SettleReservationAsync(
|
||
Arg.Any<long>(), Arg.Any<int>(), Arg.Any<decimal>(), Arg.Any<string>(), Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task RejectedOrder_StillReleasesTheCapital()
|
||
{
|
||
// Die Gegenprobe: Bei einer beweisbar abgelehnten Order MUSS das Geld zurück. Sonst hätte
|
||
// der Fix aus #489 nur die eine Klemme gegen die andere getauscht.
|
||
ArrangeHappyPath();
|
||
_broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
|
||
.Returns(Task.FromResult(OrderResult.Fail("Order abgelehnt")));
|
||
|
||
await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
await _capital.Received(1).CancelReservationAsync(
|
||
1, Arg.Any<string>(), Arg.Any<CancellationToken>());
|
||
await _capital.DidNotReceive().MarkSubmittedAsync(
|
||
Arg.Any<long>(), Arg.Any<string>(), Arg.Any<CancellationToken>());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task WorkingOrder_IsJournalledAsPending_NotAsFailure()
|
||
{
|
||
// Das Journal ist die Grundlage der Supervisor-Forensik. Stuende dort "Failed", suchte
|
||
// später jemand einen Fehler, den es nicht gab - und uebersaehe die offene Order.
|
||
ArrangeHappyPath();
|
||
_broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
|
||
.Returns(Task.FromResult(OrderResult.Working("O-77", "PreSubmitted", "wartet")));
|
||
|
||
await CreateSut().ExecuteAsync(BuySignal);
|
||
|
||
_journal.Received().Write(Arg.Is<CoreDecisionRecord>(r =>
|
||
r.Decision == TradeDecision.Pending && r.Reason == DecisionReason.OrderWorking));
|
||
_orderLog.Received().Write(Arg.Is<CoreOrderEvent>(e => e.EventType == OrderEventType.Placed));
|
||
}
|
||
}
|