Bugtracker-Durchgang: 13 Bugs behoben, Build ohne Warnungen
Alle Behebungen auf der Linux-Test-VM gegengeprueft (Ubuntu, .NET 10.0.111): Build 0 Warnungen / 0 Fehler, 637 Tests gruen, 1 uebersprungen (WindowsFact). Sicherheit und Zielplattform #373 PathBoundary.Canonicalize fiel offen aus. File.ResolveLinkTarget wirft fuer einen fehlenden Abschnitt FileNotFoundException; der catch(IOException) verliess daraufhin die GANZE Aufloesung mit dem unaufgeloesten Pfad - und der besteht jede Praefixpruefung. Der Symlink-Schutz war damit bei jedem Schreibvorgang wirkungslos. Jetzt ueber FileSystemInfo.LinkTarget, und TryCanonicalize meldet "nicht bestimmbar", statt fail-open durchzureichen. #374 WorkspacePath weist den Backslash rundheraus ab, wie den Doppelpunkt. Eine Schreibweise statt einer Sonderregel je Windows-Form. #375 Log-Verzeichnis: leer heisst "Anwendungseinstellung"; ein relativer Wert zaehlt gegen das Instanzverzeichnis, nicht gegen das Arbeitsverzeichnis des Prozesses. Ein systemd-Dienst landet nicht mehr auf /Logs. Agentenkommunikation #206 Delegationskette gegen A->B->A (Test A13). Zyklusfrei per Bauart, dazu MaxDelegationDepth gegen die Staffel, die niemand beauftragt hat. #461 Zwei unabhaengige Ketten ueber Kreuz - beim Beheben von #206 gefunden und reproduziert. Ein delegierter Lauf wartet nur noch begrenzt auf ein fremdes Gate; ein Chat vom Menschen reiht sich weiter unbegrenzt ein. #234 Instanz-Id wird durchgereicht statt aus einem nur beilaeufig gesetzten Feld gelesen. Betrieb und Oberflaeche #376 Log-Ansicht chronologisch statt gruppiert je Moduldatei, mit Stacktraces an ihrer Meldung - auch ueber Taktgrenzen hinweg. #377 Info-Tabelle: feste Spaltenbreiten, damit ein langer Aenderungstext den anderen Spalten nicht den Platz nimmt. #378 Sicherung: Mindestabstand zwischen Ueberschrift und Schaltflaechenleiste. #379 Hellmodus: drei von vier gedaempften Textpinseln lagen unter 4,5:1. Die helle Palette ist als Ganzes verschoben, damit die Staffelung sichtbar bleibt statt auf einen Wert zusammenzufallen. Hygiene #233 stock_add: der Indexstand wird innerhalb der Sperre festgehalten. #235 Zeitumstellung: eine nicht existierende Ortszeit wird auf den ersten Zeitpunkt nach der Luecke verschoben statt uebersprungen (R4, R5). #236 45 Nullable-Warnungen und eine CA1416 - nicht unterdrueckt, sondern die Stellen so umgebaut, dass die Zusage nachvollziehbar wird. Mail meldet jetzt, WELCHER Zugangsschluessel fehlt, statt an einer KeyNotFoundException zu scheitern. #203 Kompaktiert wird vor dem API-Aufruf statt danach; die gemessenen Prompt-Groessen kalibrieren die Schaetzung je Modell. Neu: tests/ClawdDotNet.App.Tests - fuer #375 und #376 gab es keinen Ort fuer Tests. Dazu Regressionstests fuer jede Behebung; jeder wurde gegen den alten Stand geprueft, damit belegt ist, dass er den Fehler faengt. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Richard
@@ -89,7 +89,7 @@ public sealed class BudgetGuardTests : IDisposable
|
||||
|
||||
status.IsAllowed.ShouldBeFalse();
|
||||
status.Limit.ShouldBe(BudgetLimit.AgentCost);
|
||||
status.Reason.ShouldContain("5");
|
||||
status.Reason.ShouldNotBeNull().ShouldContain("5");
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
@@ -120,7 +120,7 @@ public sealed class BudgetGuardTests : IDisposable
|
||||
var status = await Guard().CheckAsync(Agent(costLimit: 5m), InstanceBudget.Unlimited, default);
|
||||
|
||||
status.IsAllowed.ShouldBeFalse();
|
||||
status.Reason.ShouldContain("keine Preise");
|
||||
status.Reason.ShouldNotBeNull().ShouldContain("keine Preise");
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
@@ -38,9 +38,9 @@ public sealed class ErrorReporterTests
|
||||
sent.ShouldBeTrue();
|
||||
handler.LastRequest!.RequestUri!.ToString().ShouldBe("https://dc.example/api/errors/v1/report");
|
||||
handler.LastBody!.ShouldContain("\"exception\":\"System.InvalidOperationException\"");
|
||||
handler.LastBody.ShouldContain("\"message\":\"Kaputt\"");
|
||||
handler.LastBody.ShouldContain("\"level\":\"fatal\"");
|
||||
handler.LastBody.ShouldContain("\"project_slug\":\"clawddotnet\"");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("\"message\":\"Kaputt\"");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("\"level\":\"fatal\"");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("\"project_slug\":\"clawddotnet\"");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
||||
@@ -101,7 +101,7 @@ public sealed class InstanceHealthProviderTests
|
||||
|
||||
var health = await provider.GetAsync(default);
|
||||
|
||||
health.Message.ShouldContain("Produktion");
|
||||
health.Message.ShouldNotBeNull().ShouldContain("Produktion");
|
||||
health.Metrics.Keys.ShouldNotContain("instanceName");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@ public sealed class TokenProvisionerTests
|
||||
handler.LastRequest!.RequestUri!.ToString().ShouldBe("https://dc.example/api/tokens/v1/provision");
|
||||
handler.LastRequest.Headers.Authorization!.ToString().ShouldBe("Bearer master");
|
||||
handler.LastBody!.ShouldContain("\"instance_id\":\"inst-1\"");
|
||||
handler.LastBody.ShouldContain("watchdog:ping");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("watchdog:ping");
|
||||
|
||||
token.Token.ShouldBe("dc_sub_abc");
|
||||
token.TokenId.ShouldBe("tok_s_1");
|
||||
|
||||
@@ -30,10 +30,10 @@ public sealed class WatchdogClientTests
|
||||
handler.LastRequest.Headers.Authorization!.ToString().ShouldBe("Bearer tok");
|
||||
|
||||
handler.LastBody.ShouldNotBeNull();
|
||||
handler.LastBody.ShouldContain("\"source\":\"clawddotnet\"");
|
||||
handler.LastBody.ShouldContain("\"instance\":\"inst-1\"");
|
||||
handler.LastBody.ShouldContain("\"type\":\"heartbeat\"");
|
||||
handler.LastBody.ShouldContain("\"interval\":60");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("\"source\":\"clawddotnet\"");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("\"instance\":\"inst-1\"");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("\"type\":\"heartbeat\"");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("\"interval\":60");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -84,7 +84,7 @@ public sealed class WatchdogClientTests
|
||||
60, default);
|
||||
|
||||
handler.LastBody!.ShouldContain("\"agentCount\":3");
|
||||
handler.LastBody.ShouldContain("\"scheduler\":{\"ok\":false,\"message\":\"Steht.\"}");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldContain("\"scheduler\":{\"ok\":false,\"message\":\"Steht.\"}");
|
||||
}
|
||||
|
||||
/// <summary>Leere Angaben bleiben weg, statt als leeres Objekt zu erscheinen.</summary>
|
||||
@@ -96,7 +96,7 @@ public sealed class WatchdogClientTests
|
||||
await Client(handler).SendHeartbeatAsync(Health(), 60, default);
|
||||
|
||||
handler.LastBody!.ShouldNotContain("\"checks\"");
|
||||
handler.LastBody.ShouldNotContain("\"metrics\"");
|
||||
handler.LastBody.ShouldNotBeNull().ShouldNotContain("\"metrics\"");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
||||
@@ -64,7 +64,7 @@ public sealed class WatchdogHeartbeatServiceTests
|
||||
|
||||
var last = client.Heartbeats[^1];
|
||||
last.Status.ShouldBe(WatchdogStatus.Maintenance);
|
||||
last.Message.ShouldContain("0.1.1");
|
||||
last.Message.ShouldNotBeNull().ShouldContain("0.1.1");
|
||||
|
||||
client.Events[^1].Kind.ShouldBe(WatchdogEventKind.MaintenanceStart);
|
||||
}
|
||||
|
||||
@@ -37,7 +37,7 @@ public sealed class ContextCompactorPropertyTests
|
||||
var client = new FakeChatClient().AlwaysRespondsWithText("- Zusammenfassung des Verlaufs.");
|
||||
var compactor = new ContextCompactor(client, TestLogging.Factory);
|
||||
|
||||
compactor.CompactIfNeededAsync(messages, 50_000, AlwaysCompact, Model, default)
|
||||
compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
var valid = ContextInvariants.IsValid(messages);
|
||||
@@ -55,7 +55,7 @@ public sealed class ContextCompactorPropertyTests
|
||||
var client = new FakeChatClient().AlwaysRespondsWithText("- Zusammenfassung.");
|
||||
var compactor = new ContextCompactor(client, TestLogging.Factory);
|
||||
|
||||
compactor.CompactIfNeededAsync(messages, 50_000, AlwaysCompact, Model, default)
|
||||
compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default)
|
||||
.GetAwaiter().GetResult();
|
||||
|
||||
var systemCount = messages.Count(m => m.Role == "system");
|
||||
|
||||
@@ -59,7 +59,7 @@ public sealed class ContextCompactorTests
|
||||
|
||||
ContextInvariants.AssertValid(messages); // Vorbedingung: Ausgangslage ist gültig
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 5_000, AlwaysCompact, Model, default);
|
||||
await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
ContextInvariants.AssertValid(messages);
|
||||
}
|
||||
@@ -77,7 +77,7 @@ public sealed class ContextCompactorTests
|
||||
.ToolCycle(count: 3, resultLength: 300)
|
||||
.Build();
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 5_000, AlwaysCompact, Model, default);
|
||||
await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
ContextInvariants.AssertValid(messages);
|
||||
|
||||
@@ -107,7 +107,7 @@ public sealed class ContextCompactorTests
|
||||
var (compactor, _) = CreateCompactor();
|
||||
var messages = Conversation.Start(systemPrompt).Repeat(6).Build();
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 5_000, AlwaysCompact, Model, default);
|
||||
await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
messages[0].Role.ShouldBe("system");
|
||||
messages[0].Content.ShouldBe(systemPrompt);
|
||||
@@ -120,7 +120,7 @@ public sealed class ContextCompactorTests
|
||||
var (compactor, _) = CreateCompactor();
|
||||
var messages = Conversation.Start(systemPrompt: null).Repeat(6).Build();
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 5_000, AlwaysCompact, Model, default);
|
||||
await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
messages.ShouldNotContain(m => m.Role == "system");
|
||||
}
|
||||
@@ -137,7 +137,7 @@ public sealed class ContextCompactorTests
|
||||
var messages = Conversation.Start().Repeat(6).Build();
|
||||
var before = messages.Count;
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 5_000, AlwaysCompact, Model, default);
|
||||
await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
ContextInvariants.AssertValid(messages);
|
||||
messages.Count.ShouldBe(before, "bei fehlgeschlagener Zusammenfassung darf nichts verloren gehen");
|
||||
@@ -151,7 +151,7 @@ public sealed class ContextCompactorTests
|
||||
var messages = Conversation.Start().Repeat(6).Build();
|
||||
var before = messages.Count;
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 5_000, AlwaysCompact, Model, default);
|
||||
await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
ContextInvariants.AssertValid(messages);
|
||||
messages.Count.ShouldBe(before);
|
||||
@@ -169,7 +169,7 @@ public sealed class ContextCompactorTests
|
||||
.Repeat(times: 5, toolCallsPerCycle: 1, resultLength: 8_000)
|
||||
.Build();
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 5_000, AlwaysCompact, Model, default);
|
||||
await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
ContextInvariants.AssertValid(messages);
|
||||
messages.Where(m => m.Role == "tool")
|
||||
@@ -185,7 +185,7 @@ public sealed class ContextCompactorTests
|
||||
.Repeat(times: 5, toolCallsPerCycle: 1, resultLength: 100)
|
||||
.Build();
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 5_000, AlwaysCompact, Model, default);
|
||||
await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
foreach (var content in messages.Where(m => m.Role == "tool").Select(m => m.Content))
|
||||
(content ?? "").ShouldNotContain("gekürzt", Case.Insensitive);
|
||||
@@ -217,7 +217,7 @@ public sealed class ContextCompactorTests
|
||||
var (compactor, client) = CreateCompactor();
|
||||
var messages = Conversation.Start().Repeat(2).Build();
|
||||
|
||||
var compacted = await compactor.CompactIfNeededAsync(messages, 10, NeverCompact, Model, default);
|
||||
var compacted = await compactor.CompactIfNeededAsync(messages, NeverCompact, Model, default);
|
||||
|
||||
compacted.ShouldBeFalse();
|
||||
client.CallCount.ShouldBe(0);
|
||||
@@ -230,7 +230,7 @@ public sealed class ContextCompactorTests
|
||||
var messages = Conversation.Start().Repeat(15).Build();
|
||||
var before = messages.Count;
|
||||
|
||||
var compacted = await compactor.CompactIfNeededAsync(messages, 50_000, AlwaysCompact, Model, default);
|
||||
var compacted = await compactor.CompactIfNeededAsync(messages, AlwaysCompact, Model, default);
|
||||
|
||||
compacted.ShouldBeTrue();
|
||||
messages.Count.ShouldBeLessThan(before);
|
||||
|
||||
@@ -0,0 +1,307 @@
|
||||
using ClawdDotNet.Core.Engine;
|
||||
using ClawdDotNet.Core.Tests.Infrastructure;
|
||||
using ClawdDotNet.Core.Tools;
|
||||
using Shouldly;
|
||||
|
||||
namespace ClawdDotNet.Core.Tests.Engine;
|
||||
|
||||
/// <summary>
|
||||
/// Test A13 der Teststrategie — Regressionstests für B8 (#206).
|
||||
///
|
||||
/// <para><c>send_message</c> ist ein synchroner Aufruf: A hält sein Gate, während es
|
||||
/// auf B wartet. Rief B nun A, wartete B auf ein Gate, das A erst freigibt, wenn B
|
||||
/// geantwortet hat. Beide standen, bis der Timeout des äußeren Laufs sie auflöste.</para>
|
||||
///
|
||||
/// <para>Die Tests prüfen die drei Zusagen aus <see cref="DelegationChain"/>: kein
|
||||
/// Agent zweimal in einer Kette, höchstens <c>MaxDelegationDepth</c> Weitergaben, und
|
||||
/// die Kette gehört zum Aufruf statt zum Agenten.</para>
|
||||
///
|
||||
/// <para>Ein Zeitlimit steht bewusst an jedem Test, der verklemmen könnte: Ohne die
|
||||
/// Prüfung liefe er nicht rot, sondern gar nicht mehr weiter.</para>
|
||||
/// </summary>
|
||||
public sealed class DelegationDepthTests
|
||||
{
|
||||
private static readonly TimeSpan Frist = TimeSpan.FromSeconds(20);
|
||||
|
||||
/// <summary>Wartet auf den Lauf, scheitert aber statt zu hängen.</summary>
|
||||
private static async Task<AgentRunResult> MitFrist(Task<AgentRunResult> lauf)
|
||||
{
|
||||
var fertig = await Task.WhenAny(lauf, Task.Delay(Frist));
|
||||
fertig.ShouldBe(lauf, "Der Lauf ist nicht zurückgekommen — das ist die Verklemmung aus B8.");
|
||||
return await lauf;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// A13 — der gemeldete Fall
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public async Task A_nach_B_nach_A_wird_abgebrochen_statt_zu_verklemmen()
|
||||
{
|
||||
var tool = new DelegatingTool(new Dictionary<string, string>
|
||||
{
|
||||
["agent-a"] = "agent-b",
|
||||
["agent-b"] = "agent-a" // zurück zu A — der Zyklus
|
||||
});
|
||||
|
||||
var fixture = new EngineFixture().WithTool(tool);
|
||||
var a = fixture.AddAgent("agent-a", "TestTool");
|
||||
fixture.AddAgent("agent-b", "TestTool");
|
||||
|
||||
fixture.Client.RespondsContextually();
|
||||
|
||||
var result = await MitFrist(
|
||||
fixture.Engine.ChatAsync(a, "Bitte klären", "test-instance", default));
|
||||
|
||||
result.Status.ShouldBe(AgentRunStatus.Completed);
|
||||
|
||||
// Der Rückweg B → A ist abgelehnt worden, der Hinweg A → B nicht.
|
||||
var rueckweg = tool.Handoffs.Single(h => h is { From: "agent-b", To: "agent-a" });
|
||||
rueckweg.Delivered.ShouldBeFalse();
|
||||
rueckweg.Error.ShouldNotBeNull().ShouldContain("Zyklus");
|
||||
rueckweg.Error.ShouldNotBeNull().ShouldContain("agent-a -> agent-b -> agent-a");
|
||||
|
||||
tool.Handoffs.Single(h => h is { From: "agent-a", To: "agent-b" }).Delivered.ShouldBeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Die_Ablehnung_kommt_als_Ergebnis_zurueck_nicht_als_Wurf()
|
||||
{
|
||||
// Der abgewiesene Agent soll weiterarbeiten können — er bekommt einen Grund,
|
||||
// keinen Abbruch. Sonst führte die Zyklusprüfung nur zu einem anderen Ausfall.
|
||||
var tool = new DelegatingTool(new Dictionary<string, string>
|
||||
{
|
||||
["agent-a"] = "agent-b",
|
||||
["agent-b"] = "agent-a"
|
||||
});
|
||||
|
||||
var fixture = new EngineFixture().WithTool(tool);
|
||||
var a = fixture.AddAgent("agent-a", "TestTool");
|
||||
fixture.AddAgent("agent-b", "TestTool");
|
||||
|
||||
fixture.Client.RespondsContextually();
|
||||
|
||||
var result = await MitFrist(
|
||||
fixture.Engine.ChatAsync(a, "Bitte klären", "test-instance", default));
|
||||
|
||||
result.Status.ShouldBe(AgentRunStatus.Completed);
|
||||
result.FinalMessage.ShouldBe("Fertig");
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// Die Staffel, die keinen Zyklus bildet
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public async Task Eine_Staffel_endet_an_der_Tiefengrenze()
|
||||
{
|
||||
// A → B → C → D wäre die Tiefe 3. Mit MaxDelegationDepth = 2 ist bei C Schluss.
|
||||
var tool = new DelegatingTool(new Dictionary<string, string>
|
||||
{
|
||||
["agent-a"] = "agent-b",
|
||||
["agent-b"] = "agent-c",
|
||||
["agent-c"] = "agent-d"
|
||||
});
|
||||
|
||||
var fixture = new EngineFixture().WithTool(tool);
|
||||
fixture.Engine.MaxDelegationDepth = 2;
|
||||
|
||||
var a = fixture.AddAgent("agent-a", "TestTool");
|
||||
fixture.AddAgent("agent-b", "TestTool");
|
||||
fixture.AddAgent("agent-c", "TestTool");
|
||||
fixture.AddAgent("agent-d", "TestTool");
|
||||
|
||||
fixture.Client.RespondsContextually();
|
||||
|
||||
await MitFrist(fixture.Engine.ChatAsync(a, "Bitte klären", "test-instance", default));
|
||||
|
||||
tool.Handoffs.Single(h => h.To == "agent-b").Delivered.ShouldBeTrue();
|
||||
tool.Handoffs.Single(h => h.To == "agent-c").Delivered.ShouldBeTrue();
|
||||
|
||||
var zuTief = tool.Handoffs.Single(h => h.To == "agent-d");
|
||||
zuTief.Delivered.ShouldBeFalse();
|
||||
zuTief.Error.ShouldNotBeNull().ShouldContain("Delegationstiefe");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Innerhalb_der_Grenze_geht_die_Staffel_durch()
|
||||
{
|
||||
var tool = new DelegatingTool(new Dictionary<string, string>
|
||||
{
|
||||
["agent-a"] = "agent-b",
|
||||
["agent-b"] = "agent-c"
|
||||
});
|
||||
|
||||
var fixture = new EngineFixture().WithTool(tool);
|
||||
fixture.Engine.MaxDelegationDepth = 2;
|
||||
|
||||
var a = fixture.AddAgent("agent-a", "TestTool");
|
||||
fixture.AddAgent("agent-b", "TestTool");
|
||||
fixture.AddAgent("agent-c", "TestTool");
|
||||
|
||||
fixture.Client.RespondsContextually();
|
||||
|
||||
var result = await MitFrist(
|
||||
fixture.Engine.ChatAsync(a, "Bitte klären", "test-instance", default));
|
||||
|
||||
result.Status.ShouldBe(AgentRunStatus.Completed);
|
||||
tool.Handoffs.ShouldAllBe(h => h.Delivered);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// Die Kette gehört zum Aufruf, nicht zum Agenten
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public async Task Zwei_Laeufe_nacheinander_erben_die_Kette_des_anderen_nicht()
|
||||
{
|
||||
// Sonst könnte ein Agent nach einer tiefen Kette dauerhaft „verbraucht" sein.
|
||||
var tool = new DelegatingTool(new Dictionary<string, string> { ["agent-a"] = "agent-b" });
|
||||
|
||||
var fixture = new EngineFixture().WithTool(tool);
|
||||
var a = fixture.AddAgent("agent-a", "TestTool");
|
||||
fixture.AddAgent("agent-b", "TestTool");
|
||||
|
||||
fixture.Client.RespondsContextually();
|
||||
|
||||
await MitFrist(fixture.Engine.ChatAsync(a, "Erste Frage", "test-instance", default));
|
||||
await MitFrist(fixture.Engine.ChatAsync(a, "Zweite Frage", "test-instance", default));
|
||||
|
||||
tool.Handoffs.Count(h => h.To == "agent-b").ShouldBe(2);
|
||||
tool.Handoffs.ShouldAllBe(h => h.Delivered);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// spawn zählt mit
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public async Task Auch_ueber_spawn_laesst_sich_die_Kette_nicht_umgehen()
|
||||
{
|
||||
var tool = new DelegatingTool(new Dictionary<string, string>
|
||||
{
|
||||
["agent-a"] = "agent-b",
|
||||
["agent-b"] = "agent-a"
|
||||
}, spawn: true);
|
||||
|
||||
var fixture = new EngineFixture().WithTool(tool);
|
||||
var a = fixture.AddAgent("agent-a", "TestTool");
|
||||
fixture.AddAgent("agent-b", "TestTool");
|
||||
|
||||
fixture.Client.RespondsContextually();
|
||||
|
||||
await MitFrist(fixture.Engine.ChatAsync(a, "Bitte klären", "test-instance", default));
|
||||
|
||||
var rueckweg = tool.Handoffs.Single(h => h is { From: "agent-b", To: "agent-a" });
|
||||
rueckweg.Delivered.ShouldBeFalse();
|
||||
rueckweg.Error.ShouldNotBeNull().ShouldContain("Zyklus");
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// #461 — was die Kette grundsätzlich nicht sehen kann
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
/// <summary>
|
||||
/// Zwei unabhängige Ketten über Kreuz: Lauf 1 startet bei A und beauftragt B, Lauf 2
|
||||
/// startet zeitgleich bei B und beauftragt A. Keine der beiden Ketten enthält den
|
||||
/// Agenten der anderen — beide sind für sich zyklusfrei, und trotzdem hält Lauf 1
|
||||
/// gate(A) und wartet auf gate(B), während Lauf 2 gate(B) hält und auf gate(A) wartet.
|
||||
///
|
||||
/// <para>Das kann die Delegationskette prinzipiell nicht erkennen; nur eine Frist
|
||||
/// löst es auf. Ein delegierter Lauf wartet deshalb höchstens
|
||||
/// <c>DelegationGateTimeout</c> auf ein fremdes Gate und sagt danach ab.</para>
|
||||
///
|
||||
/// <para>Die Pause vor der Weitergabe ist der Kern des Aufbaus: Der Fake-Client
|
||||
/// antwortet synchron, ohne sie liefe der erste Chat vollständig durch, bevor der
|
||||
/// zweite beginnt — die Ketten könnten sich gar nicht überschneiden, und der Test
|
||||
/// wäre grün, ohne etwas zu zeigen.</para>
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public async Task Zwei_unabhaengige_Ketten_ueber_Kreuz_verklemmen_sich_nicht()
|
||||
{
|
||||
var tool = new DelegatingTool(new Dictionary<string, string>
|
||||
{
|
||||
["agent-a"] = "agent-b",
|
||||
["agent-b"] = "agent-a"
|
||||
}, delayBeforeHandoff: TimeSpan.FromMilliseconds(300));
|
||||
|
||||
var fixture = new EngineFixture().WithTool(tool);
|
||||
fixture.Engine.DelegationGateTimeout = TimeSpan.FromSeconds(1);
|
||||
|
||||
var a = fixture.AddAgent("agent-a", "TestTool");
|
||||
var b = fixture.AddAgent("agent-b", "TestTool");
|
||||
|
||||
fixture.Client.RespondsContextually();
|
||||
|
||||
var laufA = fixture.Engine.ChatAsync(a, "A fragt B", "test-instance", default);
|
||||
var laufB = fixture.Engine.ChatAsync(b, "B fragt A", "test-instance", default);
|
||||
|
||||
var beide = Task.WhenAll(laufA, laufB);
|
||||
var fertig = await Task.WhenAny(beide, Task.Delay(Frist));
|
||||
|
||||
fertig.ShouldBe(beide, "Beide Laeufe warten auf das Gate des jeweils anderen (#461).");
|
||||
|
||||
// Beide äußeren Läufe kommen zu Ende. Mindestens eine Weitergabe ist an der
|
||||
// Frist gescheitert — welche, entscheidet die Reihenfolge und ist nicht
|
||||
// festgelegt; dass beide Läufe zurückkommen, schon.
|
||||
(await laufA).Status.ShouldBe(AgentRunStatus.Completed);
|
||||
(await laufB).Status.ShouldBe(AgentRunStatus.Completed);
|
||||
tool.Handoffs.ShouldContain(h => !h.Delivered && h.Error!.Contains("belegt"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Ein_Chat_vom_Menschen_wartet_weiter_so_lange_es_dauert()
|
||||
{
|
||||
// Die Gegenprobe zur Frist: Sie gilt nur für delegierte Läufe. Ein zweiter
|
||||
// Chat desselben Agenten reiht sich ein und wird bedient, auch wenn der erste
|
||||
// länger braucht als die Delegationsfrist.
|
||||
var fixture = new EngineFixture().WithTool(FakeTool.Slow(TimeSpan.FromMilliseconds(600)));
|
||||
fixture.Engine.DelegationGateTimeout = TimeSpan.FromMilliseconds(50);
|
||||
|
||||
var a = fixture.AddAgent("agent-a", "TestTool");
|
||||
|
||||
fixture.Client.RespondsContextually();
|
||||
|
||||
var erster = fixture.Engine.ChatAsync(a, "Erste Frage", "test-instance", default);
|
||||
var zweiter = fixture.Engine.ChatAsync(a, "Zweite Frage", "test-instance", default);
|
||||
|
||||
(await MitFrist(erster)).Status.ShouldBe(AgentRunStatus.Completed);
|
||||
(await MitFrist(zweiter)).Status.ShouldBe(AgentRunStatus.Completed);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// Die Kette selbst
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
[Fact]
|
||||
public void Die_Kette_zaehlt_Weitergaben_nicht_Agenten()
|
||||
{
|
||||
var kette = DelegationChain.Root("a");
|
||||
kette.Depth.ShouldBe(0);
|
||||
kette.Append("b").Depth.ShouldBe(1);
|
||||
kette.Append("b").Append("c").Depth.ShouldBe(2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Append_veraendert_die_Kette_des_Aufrufers_nicht()
|
||||
{
|
||||
// Unveränderlich: Zwei Weitergaben aus demselben Lauf dürfen sich nicht
|
||||
// gegenseitig sehen — sonst zählte die zweite die erste als Vorgänger.
|
||||
var kette = DelegationChain.Root("a");
|
||||
|
||||
var nachB = kette.Append("b");
|
||||
var nachC = kette.Append("c");
|
||||
|
||||
kette.Agents.ShouldBe(["a"]);
|
||||
nachB.Agents.ShouldBe(["a", "b"]);
|
||||
nachC.Agents.ShouldBe(["a", "c"]);
|
||||
nachB.Contains("c").ShouldBeFalse();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Die_Kette_liest_sich_als_Weg()
|
||||
{
|
||||
DelegationChain.Root("a").Append("b").Append("c").ToString()
|
||||
.ShouldBe("a -> b -> c");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
using ClawdDotNet.Core.Engine;
|
||||
using ClawdDotNet.Core.Tests.Infrastructure;
|
||||
using Shouldly;
|
||||
|
||||
namespace ClawdDotNet.Core.Tests.Engine;
|
||||
|
||||
/// <summary>
|
||||
/// #203 — die Compaction lief nach dem API-Aufruf.
|
||||
///
|
||||
/// <para>Sie stützte sich auf die <c>promptTokens</c> der gerade beantworteten Anfrage:
|
||||
/// Als der Wert vorlag, war der überfüllte Prompt längst abgerechnet, und gekürzt wurde
|
||||
/// erst für den nächsten Schritt. Genau ein Schritt zu spät — und zwar der teuerste.</para>
|
||||
///
|
||||
/// <para>Die Zusage lautet jetzt: <b>Keine Anfrage geht über die Kontextgrenze hinaus.</b>
|
||||
/// Geprüft wird vor dem Senden, mit der Schätzung; die gemessenen Werte ziehen die
|
||||
/// Schätzung hinterher nach.</para>
|
||||
/// </summary>
|
||||
public sealed class ProactiveCompactionTests
|
||||
{
|
||||
private const string AgentModel = "test/model";
|
||||
private const string SummaryModel = "test/summary";
|
||||
|
||||
[Fact]
|
||||
public async Task Keine_Anfrage_geht_ueber_die_Kontextgrenze_hinaus()
|
||||
{
|
||||
var fixture = new EngineFixture();
|
||||
var agent = fixture.AddAgent("agent-a");
|
||||
|
||||
// Schwelle: 1000 geschätzte Tokens.
|
||||
agent.LoopGuard.MaxContextTokens = 2_000;
|
||||
agent.LoopGuard.CompactionThreshold = 0.5;
|
||||
agent.LoopGuard.SummaryModel = SummaryModel;
|
||||
|
||||
fixture.Client.AlwaysRespondsWithText("Verstanden.");
|
||||
|
||||
// Jede Nachricht bringt rund 150 geschaetzte Tokens mit; nach wenigen Runden
|
||||
// waere der Kontext ohne Eingriff ueber der Grenze. Klein genug, dass auch die
|
||||
// sechs geschuetzten Tail-Nachrichten zusammen noch unter die Grenze passen -
|
||||
// sonst koennte selbst eine Kompaktierung sie nicht mehr unterschreiten.
|
||||
for (var i = 0; i < 20; i++)
|
||||
{
|
||||
await fixture.Engine.ChatAsync(
|
||||
agent, $"Frage {i}: " + new string('y', 600), "test-instance", default);
|
||||
}
|
||||
|
||||
var anfragenAnDenAgenten = fixture.Client.ReceivedRequests
|
||||
.Where(r => r.Model == AgentModel)
|
||||
.ToList();
|
||||
|
||||
anfragenAnDenAgenten.Count.ShouldBe(20);
|
||||
|
||||
// Der eigentliche Punkt: nicht "irgendwann wurde gekürzt", sondern "es ging nie
|
||||
// etwas Überfülltes hinaus". Vorher hing die Prüfung an den promptTokens der
|
||||
// Antwort — beim Fake immer 100 —, kam also nie über die Schwelle und kürzte nie.
|
||||
foreach (var anfrage in anfragenAnDenAgenten)
|
||||
{
|
||||
ContextCompactor.EstimateTokens(anfrage.Messages)
|
||||
.ShouldBeLessThan(agent.LoopGuard.MaxContextTokens);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Gekuerzt_wird_mit_dem_guenstigen_Modell_bevor_gesendet_wird()
|
||||
{
|
||||
var fixture = new EngineFixture();
|
||||
var agent = fixture.AddAgent("agent-a");
|
||||
|
||||
agent.LoopGuard.MaxContextTokens = 2_000;
|
||||
agent.LoopGuard.CompactionThreshold = 0.5;
|
||||
agent.LoopGuard.SummaryModel = SummaryModel;
|
||||
|
||||
fixture.Client.AlwaysRespondsWithText("Verstanden.");
|
||||
|
||||
for (var i = 0; i < 20; i++)
|
||||
{
|
||||
await fixture.Engine.ChatAsync(
|
||||
agent, $"Frage {i}: " + new string('y', 600), "test-instance", default);
|
||||
}
|
||||
|
||||
// Es wurde überhaupt kompaktiert — sonst sagt der Test darüber nichts aus.
|
||||
fixture.Client.ReceivedRequests.ShouldContain(r => r.Model == SummaryModel);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// Kalibrierung
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
private static ContextCompactor NeuerKompaktierer()
|
||||
=> new(new FakeChatClient(), TestLogging.Factory);
|
||||
|
||||
[Fact]
|
||||
public void Ohne_Messwerte_gilt_die_rohe_Schaetzung()
|
||||
{
|
||||
var messages = Conversation.Start().Repeat(4).Build();
|
||||
|
||||
NeuerKompaktierer().EstimateFor("m", messages)
|
||||
.ShouldBe(ContextCompactor.EstimateTokens(messages));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Eine_unterschaetzte_Anfrage_hebt_die_Schaetzung_an()
|
||||
{
|
||||
var messages = Conversation.Start().Repeat(4).Build();
|
||||
var roh = ContextCompactor.EstimateTokens(messages);
|
||||
|
||||
var compactor = NeuerKompaktierer();
|
||||
|
||||
// Die API berechnet durchweg doppelt so viel wie geschätzt.
|
||||
for (var i = 0; i < 20; i++)
|
||||
compactor.Calibrate("m", 1_000, 2_000);
|
||||
|
||||
compactor.EstimateFor("m", messages).ShouldBeGreaterThan(roh);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Ein_einzelner_Ausreisser_kippt_die_Schwelle_nicht()
|
||||
{
|
||||
var messages = Conversation.Start().Repeat(4).Build();
|
||||
var roh = ContextCompactor.EstimateTokens(messages);
|
||||
|
||||
var compactor = NeuerKompaktierer();
|
||||
compactor.Calibrate("m", 1_000, 4_000); // einmal weit daneben
|
||||
|
||||
// Ein Messwert verschiebt den Faktor nur um sein Gewicht, nicht auf seinen Wert.
|
||||
compactor.EstimateFor("m", messages).ShouldBeLessThan(roh * 2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Ein_absurder_Messwert_wird_gedeckelt()
|
||||
{
|
||||
var messages = Conversation.Start().Repeat(4).Build();
|
||||
var roh = ContextCompactor.EstimateTokens(messages);
|
||||
|
||||
var compactor = NeuerKompaktierer();
|
||||
for (var i = 0; i < 50; i++)
|
||||
compactor.Calibrate("m", 1, 1_000_000);
|
||||
|
||||
// Höchstens das Vierfache — was darüber läge, ist kein Kalibrierungsfall mehr.
|
||||
compactor.EstimateFor("m", messages).ShouldBeLessThanOrEqualTo(roh * 4);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Jedes_Modell_wird_fuer_sich_kalibriert()
|
||||
{
|
||||
// Verschiedene Tokenizer zerlegen denselben Text verschieden — ein gemeinsamer
|
||||
// Faktor wäre der Mittelwert von etwas, das nichts miteinander zu tun hat.
|
||||
var messages = Conversation.Start().Repeat(4).Build();
|
||||
var roh = ContextCompactor.EstimateTokens(messages);
|
||||
|
||||
var compactor = NeuerKompaktierer();
|
||||
for (var i = 0; i < 20; i++)
|
||||
compactor.Calibrate("gross", 1_000, 3_000);
|
||||
|
||||
compactor.EstimateFor("gross", messages).ShouldBeGreaterThan(roh);
|
||||
compactor.EstimateFor("unberuehrt", messages).ShouldBe(roh);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Unbrauchbare_Messwerte_werden_verworfen()
|
||||
{
|
||||
var messages = Conversation.Start().Repeat(4).Build();
|
||||
var roh = ContextCompactor.EstimateTokens(messages);
|
||||
|
||||
var compactor = NeuerKompaktierer();
|
||||
compactor.Calibrate("m", 0, 5_000); // ohne Schätzung kein Verhältnis
|
||||
compactor.Calibrate("m", 1_000, 0); // ohne Messwert auch nicht
|
||||
|
||||
compactor.EstimateFor("m", messages).ShouldBe(roh);
|
||||
}
|
||||
}
|
||||
@@ -100,14 +100,14 @@ public sealed class TokenAccountingTests
|
||||
|
||||
var guard = new LoopGuardConfig
|
||||
{
|
||||
MaxContextTokens = 1_000,
|
||||
MaxContextTokens = 100,
|
||||
CompactionThreshold = 0.5,
|
||||
SummaryModel = "google/gemini-2.5-flash"
|
||||
};
|
||||
|
||||
var messages = Conversation.Start().Repeat(10).Build();
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 50_000, guard, "anthropic/claude-opus-4", default);
|
||||
await compactor.CompactIfNeededAsync(messages, guard, "anthropic/claude-opus-4", default);
|
||||
|
||||
client.ReceivedRequests.ShouldNotBeEmpty();
|
||||
client.ReceivedRequests[0].Model.ShouldBe("google/gemini-2.5-flash",
|
||||
@@ -122,14 +122,14 @@ public sealed class TokenAccountingTests
|
||||
|
||||
var guard = new LoopGuardConfig
|
||||
{
|
||||
MaxContextTokens = 1_000,
|
||||
MaxContextTokens = 100,
|
||||
CompactionThreshold = 0.5,
|
||||
SummaryModel = ""
|
||||
};
|
||||
|
||||
var messages = Conversation.Start().Repeat(10).Build();
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 50_000, guard, "anthropic/claude-opus-4", default);
|
||||
await compactor.CompactIfNeededAsync(messages, guard, "anthropic/claude-opus-4", default);
|
||||
|
||||
client.ReceivedRequests[0].Model.ShouldBe("anthropic/claude-opus-4");
|
||||
}
|
||||
@@ -146,14 +146,14 @@ public sealed class TokenAccountingTests
|
||||
var client = new FakeChatClient().AlwaysRespondsWithText("- Zusammenfassung.");
|
||||
var compactor = new ContextCompactor(client, TestLogging.Factory);
|
||||
|
||||
var guard = new LoopGuardConfig { MaxContextTokens = 1_000, CompactionThreshold = 0.5 };
|
||||
var guard = new LoopGuardConfig { MaxContextTokens = 100, CompactionThreshold = 0.5 };
|
||||
|
||||
var messages = Conversation.Start()
|
||||
.Repeat(8)
|
||||
.User("EINZIGARTIGE-LETZTE-NACHRICHT")
|
||||
.Build();
|
||||
|
||||
await compactor.CompactIfNeededAsync(messages, 50_000, guard, "test/model", default);
|
||||
await compactor.CompactIfNeededAsync(messages, guard, "test/model", default);
|
||||
|
||||
var summaryPrompt = client.ReceivedRequests[0].Messages.Last().Content!;
|
||||
summaryPrompt.ShouldNotContain("EINZIGARTIGE-LETZTE-NACHRICHT");
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
using System.Collections.Concurrent;
|
||||
using System.Text.Json;
|
||||
using ClawdDotNet.Core.Tools;
|
||||
|
||||
namespace ClawdDotNet.Core.Tests.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// Ein Tool, das einen anderen Agenten beauftragt — der Nachbau dessen, was
|
||||
/// <c>AgentComm.send_message</c> und <c>AgentSpawn.spawn_agent</c> tun.
|
||||
///
|
||||
/// <para>Der Nachbau ist nötig, weil beide Werkzeuge in eigenen Projekten liegen, die
|
||||
/// <c>ClawdDotNet.Core.Tests</c> nicht referenziert. Entscheidend ist ohnehin nur die
|
||||
/// eine Zeile, in der sie sich hier gleichen: Die Delegationskette des eigenen Laufs
|
||||
/// wird weitergereicht. Ein Tool, das sie unterschlägt, macht aus einem Zyklus eine
|
||||
/// neue Beauftragung — genau der Fall, den B8 beschreibt.</para>
|
||||
///
|
||||
/// <para>Wen ein Agent beauftragt, steht in <paramref name="routes"/>: agentId → Ziel.
|
||||
/// Wer dort nicht vorkommt, delegiert nicht und antwortet schlicht.</para>
|
||||
/// </summary>
|
||||
internal sealed class DelegatingTool : IAgentTool
|
||||
{
|
||||
private readonly IReadOnlyDictionary<string, string> _routes;
|
||||
private readonly bool _spawn;
|
||||
private readonly TimeSpan _delayBeforeHandoff;
|
||||
|
||||
public string Name => "TestTool";
|
||||
public string Description => "Beauftragt einen anderen Agenten.";
|
||||
|
||||
public JsonElement InputSchema { get; } = JsonDocument.Parse("""
|
||||
{ "type": "object", "properties": { "message": { "type": "string" } } }
|
||||
""").RootElement.Clone();
|
||||
|
||||
/// <summary>Was zurückkam — Aufrufer, Ziel und das Ergebnis der Weitergabe.</summary>
|
||||
public ConcurrentBag<(string From, string To, bool Delivered, string? Error)> Handoffs { get; } = new();
|
||||
|
||||
/// <param name="delayBeforeHandoff">
|
||||
/// Wartezeit, bevor weitergegeben wird. Der Fake-Client antwortet synchron; ohne
|
||||
/// diese Pause läuft ein Chat vollständig durch, bevor der nächste überhaupt
|
||||
/// beginnt, und zwei Ketten können sich nicht überschneiden.
|
||||
/// </param>
|
||||
public DelegatingTool(
|
||||
IReadOnlyDictionary<string, string> routes,
|
||||
bool spawn = false,
|
||||
TimeSpan delayBeforeHandoff = default)
|
||||
{
|
||||
_routes = routes;
|
||||
_spawn = spawn;
|
||||
_delayBeforeHandoff = delayBeforeHandoff;
|
||||
}
|
||||
|
||||
public async Task<ToolResult> ExecuteAsync(
|
||||
JsonElement input, AgentToolContext context, CancellationToken ct)
|
||||
{
|
||||
if (!_routes.TryGetValue(context.AgentId, out var target))
|
||||
return ToolResult.Ok("nichts zu delegieren");
|
||||
|
||||
if (_delayBeforeHandoff > TimeSpan.Zero)
|
||||
await Task.Delay(_delayBeforeHandoff, ct);
|
||||
|
||||
if (_spawn)
|
||||
{
|
||||
var spawned = await context.MessageRouter!.SpawnAgentAsync(
|
||||
context.AgentId, target, "Auftrag", context.InstanceId, context.Delegation, ct);
|
||||
|
||||
Handoffs.Add((context.AgentId, target, spawned.Started, spawned.Error));
|
||||
|
||||
return spawned.Started
|
||||
? ToolResult.Ok(spawned.FinalMessage ?? "")
|
||||
: ToolResult.Ok(JsonSerializer.Serialize(new { spawned = false, error = spawned.Error }));
|
||||
}
|
||||
|
||||
var result = await context.MessageRouter!.SendMessageAsync(
|
||||
context.AgentId, target, "Frage", context.InstanceId, context.Delegation, ct);
|
||||
|
||||
Handoffs.Add((context.AgentId, target, result.Delivered, result.Error));
|
||||
|
||||
// Wie das echte Tool: Eine Ablehnung ist kein Wurf, sondern ein Ergebnis, das
|
||||
// der Agent lesen und auf das er anders reagieren kann.
|
||||
return result.Delivered
|
||||
? ToolResult.Ok(result.Response ?? "")
|
||||
: ToolResult.Ok(JsonSerializer.Serialize(new { delivered = false, error = result.Error }));
|
||||
}
|
||||
}
|
||||
@@ -50,7 +50,7 @@ public sealed class SecretProtectorTests : IDisposable
|
||||
|
||||
var protectedValue = SecretProtector.Protect(secret);
|
||||
|
||||
protectedValue.ShouldNotContain(secret);
|
||||
protectedValue.ShouldNotBeNull().ShouldNotContain(secret);
|
||||
protectedValue.ShouldNotBe(secret);
|
||||
}
|
||||
|
||||
@@ -190,7 +190,14 @@ public sealed class SecretProtectorTests : IDisposable
|
||||
SecretProtector.Unprotect(second).ShouldBe("noch-geheimer");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <c>[LinuxFact]</c> hält den Test unter Windows an, der Plattform-Analysator sieht
|
||||
/// das aber nicht — er kennt nur Attribute wie <c>SupportedOSPlatform</c>. Ohne die
|
||||
/// Angabe blieb CA1416 als einzige Warnung im Build stehen, und eine einzelne
|
||||
/// Warnung, die immer da ist, liest bald niemand mehr.
|
||||
/// </summary>
|
||||
[LinuxFact]
|
||||
[System.Runtime.Versioning.SupportedOSPlatform("linux")]
|
||||
public void Die_Schluesseldatei_ist_nur_fuer_den_Besitzer_lesbar()
|
||||
{
|
||||
SecretProtector.Protect("geheim");
|
||||
@@ -207,7 +214,7 @@ public sealed class SecretProtectorTests : IDisposable
|
||||
var ex = Should.Throw<SecretProtectionException>(
|
||||
() => SecretProtector.Unprotect("enc:v1:" + Convert.ToBase64String([1, 2, 3, 4])));
|
||||
|
||||
ex.Message.ShouldContain("neu eingetragen");
|
||||
ex.Message.ShouldNotBeNull().ShouldContain("neu eingetragen");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -270,8 +277,8 @@ public sealed class ConfigSecretsTests : IDisposable
|
||||
|
||||
ConfigSecrets.Protect(agent);
|
||||
|
||||
agent.Tools["Database"]["connectionString"]!.ToString().ShouldNotContain("geheim");
|
||||
agent.Tools["Mail"]["password"]!.ToString().ShouldNotContain("mail-passwort");
|
||||
agent.Tools["Database"]["connectionString"]!.ToString().ShouldNotBeNull().ShouldNotContain("geheim");
|
||||
agent.Tools["Mail"]["password"]!.ToString().ShouldNotBeNull().ShouldNotContain("mail-passwort");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
@@ -311,7 +318,7 @@ public sealed class ConfigSecretsTests : IDisposable
|
||||
|
||||
ConfigSecrets.Protect(agent);
|
||||
|
||||
agent.Tools["Mail"]["password"]!.ToString().ShouldNotContain("geheim123");
|
||||
agent.Tools["Mail"]["password"]!.ToString().ShouldNotBeNull().ShouldNotContain("geheim123");
|
||||
ConfigSecrets.Unprotect(agent);
|
||||
agent.Tools["Mail"]["password"].ShouldBe("geheim123");
|
||||
}
|
||||
|
||||
@@ -243,4 +243,94 @@ public sealed class TaskScheduleTests
|
||||
TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 9, 5))
|
||||
.ShouldBe("2026-07-31T09:00:00.0000000Z");
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// Zeitumstellung — R4 und R5 der Teststrategie
|
||||
//
|
||||
// Europe/Berlin 2026: Am 29. März springt die Uhr um 02:00 auf 03:00, am
|
||||
// 25. Oktober um 03:00 zurück auf 02:00. Ein täglicher Termin um 02:00 trifft
|
||||
// also einmal im Jahr eine Uhrzeit, die es nicht gibt, und einmal eine, die es
|
||||
// doppelt gibt.
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
private static TaskItem TaeglichUmZwei(DateTime angelegt) => new()
|
||||
{
|
||||
Id = "t-dst",
|
||||
CreatedAt = angelegt,
|
||||
When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 2 * * *", TimeZone = "Europe/Berlin" }
|
||||
};
|
||||
|
||||
/// <summary>R5 — der Fall, um den es in #235 geht.</summary>
|
||||
[Fact]
|
||||
public void Zeitumstellung_Maerz_wird_nicht_uebersprungen()
|
||||
{
|
||||
var task = TaeglichUmZwei(Utc(2026, 3, 28, 0, 0));
|
||||
|
||||
// "02:00" existiert am 29. März nicht. Der Termin fällt trotzdem an, und zwar
|
||||
// auf dem ersten Zeitpunkt danach: 03:00 MESZ = 01:00 UTC.
|
||||
// Vorher kam hier null — die Aufgabe fiel an diesem Tag ersatzlos aus.
|
||||
TaskSchedule.DueOccurrence(task, Utc(2026, 3, 29, 2, 0))
|
||||
.ShouldBe("2026-03-29T01:00:00.0000000Z");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Der_verschobene_Termin_feuert_trotzdem_nur_einmal()
|
||||
{
|
||||
var task = TaeglichUmZwei(Utc(2026, 3, 28, 0, 0));
|
||||
|
||||
var ersteFaelligkeit = TaskSchedule.DueOccurrence(task, Utc(2026, 3, 29, 2, 0));
|
||||
ersteFaelligkeit.ShouldNotBeNull();
|
||||
|
||||
TaskSchedule.DueOccurrence(task with { LastOccurrence = ersteFaelligkeit }, Utc(2026, 3, 29, 2, 30))
|
||||
.ShouldBeNull();
|
||||
}
|
||||
|
||||
/// <summary>R4 — die andere Richtung.</summary>
|
||||
[Fact]
|
||||
public void Zeitumstellung_Oktober_feuert_genau_einmal()
|
||||
{
|
||||
var task = TaeglichUmZwei(Utc(2026, 10, 24, 0, 0));
|
||||
|
||||
// 02:00 kommt am 25. Oktober zweimal vor: in Sommerzeit (00:00 UTC) und in
|
||||
// Normalzeit (01:00 UTC). Beide Durchläufe ergeben denselben Occurrence-Key —
|
||||
// der Marker fängt den zweiten ab.
|
||||
var ersterDurchlauf = TaskSchedule.DueOccurrence(task, Utc(2026, 10, 25, 0, 30));
|
||||
ersterDurchlauf.ShouldNotBeNull();
|
||||
|
||||
var zweiterDurchlauf = TaskSchedule.DueOccurrence(
|
||||
task with { LastOccurrence = ersterDurchlauf }, Utc(2026, 10, 25, 1, 30));
|
||||
zweiterDurchlauf.ShouldBeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void An_gewoehnlichen_Tagen_bleibt_es_bei_zwei_Uhr_Ortszeit()
|
||||
{
|
||||
// Die Gegenprobe: Die Verschiebung darf nur in der Lücke greifen.
|
||||
var task = TaeglichUmZwei(Utc(2026, 3, 21, 0, 0));
|
||||
|
||||
// 02:00 MEZ = 01:00 UTC.
|
||||
TaskSchedule.DueOccurrence(task, Utc(2026, 3, 22, 2, 0))
|
||||
.ShouldBe("2026-03-22T01:00:00.0000000Z");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Auch_ein_einmaliger_Termin_in_der_Luecke_faellt_nicht_aus()
|
||||
{
|
||||
// Derselbe Umgang auf dem at-Pfad — dort galt dieselbe Regel und dieselbe Lücke.
|
||||
var task = new TaskItem
|
||||
{
|
||||
Id = "t-1",
|
||||
When = new TaskWhen
|
||||
{
|
||||
Kind = TaskWhenKind.At,
|
||||
Value = "2026-03-29T02:30:00",
|
||||
TimeZone = "Europe/Berlin"
|
||||
}
|
||||
};
|
||||
|
||||
// 02:30 gibt es nicht; es wird 03:00 MESZ = 01:00 UTC.
|
||||
TaskSchedule.DueOccurrence(task, Utc(2026, 3, 29, 0, 59)).ShouldBeNull();
|
||||
TaskSchedule.DueOccurrence(task, Utc(2026, 3, 29, 1, 0))
|
||||
.ShouldBe("2026-03-29T01:00:00.0000000Z");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user