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,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");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user