RichardandClaude Opus 5
c87b0195fd
Im Logverzeichnis der Test-VM lagen neben 2026-09-03.jsonl auch 1405-06-12.jsonl und 2569-09-03.jsonl - dieselben Tage im Sonnen-Hidschra- und im buddhistischen Kalender. Eine interpolierte Zeichenkette formatiert mit CurrentCulture, und die bringt ihren Kalender mit. Betroffen waren beide Schreibpfade des LoggingService und die Lesestelle im DossierService, die denselben Namen wieder zusammensetzt. CA1305 greift hier nicht: die Regel sieht string.Format und ToString, nicht die interpolierte Form. Die .editorconfig deckt diesen Fall also nicht ab. FormattableString.Invariant an allen drei Stellen, dazu ein Regressionstest ueber fa-IR, th-TH und de-DE - mit Gegenbeweis, dass die naive Form tatsaechlich abweicht, damit der Test nicht eines Tages unbemerkt trivial wird. Ausserdem: Verweise auf die Bugtracker-Nummern richtiggestellt (488/489). 461 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 (#488) ─────────────────────────────
|
||
|
||
/// <summary>
|
||
/// <b>Der Test, um den es bei #488 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 #488 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));
|
||
}
|
||
}
|