Lizenzablauf mit einer injizierbaren Uhr testen
Lizenzcode, der die Systemuhr direkt ausliest, ist kaum testbar: Man kann nicht ein Jahr auf den Ablauf eines Schlüssels warten, und DateTime.UtcNow global zu mocken ist fragil. Dieser Beitrag zeigt, wie sich Ablauf, NotBefore und das Kulanzfenster-Verhalten von Keyright in xUnit vollständig deterministisch machen lassen, indem man die TimeProvider-Abstraktion von .NET injiziert und sie mit FakeTimeProvider steuert, um die Zeit millisekundengenau vorzurücken und jede Grenze zu prüfen.
Manche Fehler findet man nur, indem man ein Jahr wartet. Eine Lizenz, die am Ende ihrer Laufzeit abläuft, ein Schlüssel, der bis zu einem künftigen Aktivierungsdatum NotBefore ist, ein Kulanzfenster, das nach zweiundsiebzig Offline-Stunden verfällt – all das ist zeitabhängige Logik, und der naheliegende Weg, sie zu testen, besteht darin, die Systemuhr zu verstellen und zuzusehen, was passiert. Das skaliert nicht auf einen CI-Lauf und übersteht nicht zwei parallel laufende Tests.
Die gute Nachricht ist: Nichts davon ist nötig. Wenn Ihr Lizenzcode die Umgebungsuhr nie direkt ausliest, können Sie die Zeit in einem Unit-Test um exakte Beträge vorrücken und jede Grenze deterministisch prüfen – in Millisekunden.
Kernaussage: Rufen Sie DateTimeOffset.UtcNow nicht mehr in der Lizenzlogik auf. Lesen Sie die Zeit über TimeProvider von .NET, injizieren Sie ihn in das Keyright-SDK, und übergeben Sie in Tests einen FakeTimeProvider, dessen Uhr Sie mit Advance(...) bewegen. Jetzt sind „der Tag vor dem Ablauf“, „der genaue Ablaufzeitpunkt“ und „ein Tick nach der Kulanz“ drei gewöhnliche, schnelle, parallelsichere Assertions.
Die eigentliche Frage: Woher kommt die Zeit?
Eine Lizenzprüfung ist ein Vergleich mit jetzt. Validate() fragt, ob der zwischengespeicherte Lease noch in seinem Gültigkeitsfenster liegt, ob sein NotBefore erreicht ist und ob das Offline-Kulanzfenster verfallen ist. Jede davon ist etwas <= jetzt oder jetzt < etwas. Das gesamte Testbarkeitsproblem steckt in diesem einen Wort: jetzt.
Ist jetzt DateTimeOffset.UtcNow, gibt es keinen Erweiterungspunkt. UtcNow ist eine statische Eigenschaft, die die Betriebssystemuhr liest; Sie können sie nicht pro Test überschreiben ohne einen globalen Umgebungs-Shim, und ein Umgebungs-Global ist genau jener geteilte veränderliche Zustand, der eine Suite unter Parallelität instabil macht.
TimeProvider, ab .NET 8 integriert, ist der Erweiterungspunkt. Es ist eine kleine abstrakte Klasse mit den hier relevanten Methoden:
public abstract class TimeProvider
{
public static TimeProvider System { get; } // reads the real OS clock
public abstract DateTimeOffset GetUtcNow(); // calendar time
public abstract long GetTimestamp(); // monotonic ticks
public TimeSpan GetElapsedTime(long startingTimestamp);
// ... CreateTimer, GetLocalNow, etc.
}
Das Keyright-SDK liest die Zeit ausschließlich über einen TimeProvider. Sie liefern ihn einmal, an KeyrightOptions; lassen Sie ihn ungesetzt, ist TimeProvider.System der Standard, sodass Produktionscode die echte Uhr liest und Sie nie daran denken müssen.
static readonly KeyrightClient License = KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-suite",
PublicKeyBase64 = "MIIBIjANBgkq...", // ships in your binary; not a secret
ServiceUrl = "https://keyright.example.com", // your self-hosted instance
TimeProvider = TimeProvider.System, // the default; override it in tests
});
Die Uhr mit FakeTimeProvider steuern
Das Test-Double ist FakeTimeProvider aus dem Paket Microsoft.Extensions.TimeProvider.Testing. Sie konstruieren es zu einem festen Zeitpunkt und bewegen es von Hand vorwärts. Nichts rückt von selbst vor, daher ist ein Test perfekt reproduzierbar.
using Microsoft.Extensions.Time.Testing;
var clock = new FakeTimeProvider(new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero));
var license = KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-suite",
PublicKeyBase64 = TestKeys.PublicKey,
TimeProvider = clock, // the SDK now reads *this* clock
Offline = true, // unit test: validate the embedded lease, no network
});
license.ImportLicense(TestKeys.SignForTest(expiresAtUtc: new DateTimeOffset(2026, 4, 1, 0, 0, 0, TimeSpan.Zero)));
Assert.Equal(LicenseStatus.Valid, license.Validate().Status); // 2026-01-01: well inside the term
clock.Advance(TimeSpan.FromDays(89)); // -> 2026-03-31
Assert.Equal(LicenseStatus.Valid, license.Validate().Status);
clock.Advance(TimeSpan.FromDays(1)); // -> 2026-04-01, the expiry instant
Assert.Equal(LicenseStatus.Expired, license.Validate().Status);
Assert.Equal(LicenseEdition.Community, license.Validate().Edition); // fell back cleanly
Die folgende Abbildung ist das gedankliche Modell: eine einzige gefälschte Uhr, die Sie entlang der Laufzeit verschieben und an jeder Station den Lizenzzustand ablesen.
Die Grenzen prüfen, nicht nur die Mitte
Deterministische Zeit lässt Sie die wichtigen Teile testen – die Ränder – statt eines bequemen Punkts in der Mitte. Drei Fälle sind je einen Test wert.
NotBefore ist noch nicht erreicht. Ein für ein künftiges Datum aktivierter Schlüssel muss als noch-nicht-gültig gelesen werden und dann in dem Moment umschlagen, in dem die Uhr ihn erreicht.
var clock = new FakeTimeProvider(new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero));
var license = NewClient(clock);
license.ImportLicense(TestKeys.SignForTest(
notBeforeUtc: new DateTimeOffset(2026, 2, 1, 0, 0, 0, TimeSpan.Zero),
expiresAtUtc: new DateTimeOffset(2027, 2, 1, 0, 0, 0, TimeSpan.Zero)));
Assert.Equal(LicenseStatus.NotYetValid, license.Validate().Status);
clock.Advance(TimeSpan.FromDays(31)); // -> 2026-02-01 exactly
Assert.Equal(LicenseStatus.Valid, license.Validate().Status);
Die Uhrabweichungs-Toleranz am Rand. Wenn Sie eine kleine NotBeforeLeeway für die Uhrdrift des Clients zulassen, beweist die gefälschte Uhr, dass sie genau diese Breite hat – gültig einen Tick innerhalb der Toleranz, ungültig einen Tick außerhalb – ohne die echte Uhr je anzufassen.
// Lease NotBefore = 2026-02-01, configured leeway = 5 minutes.
clock.SetUtcNow(new DateTimeOffset(2026, 1, 31, 23, 56, 0, TimeSpan.Zero)); // 4 min early
Assert.Equal(LicenseStatus.Valid, license.Validate().Status); // inside leeway
clock.SetUtcNow(new DateTimeOffset(2026, 1, 31, 23, 54, 0, TimeSpan.Zero)); // 6 min early
Assert.Equal(LicenseStatus.NotYetValid, license.Validate().Status); // outside leeway
Die Kulanz, die nach der letzten Bestätigung verfällt. Setzen Sie für den Online-Pfad den letzten bestätigten Zeitpunkt auf dem Lease, rücken Sie dann über GracePeriod hinaus und prüfen Sie den Rückfall auf Community Edition. Da der Countdown an einen Bestätigungszeitstempel verankert ist, reproduziert ein FakeTimeProvider das gesamte Fenster exakt.
var clock = new FakeTimeProvider(new DateTimeOffset(2026, 6, 1, 12, 0, 0, TimeSpan.Zero));
var license = NewClient(clock, grace: TimeSpan.FromHours(72));
license.ImportLeaseForTest(confirmedAtUtc: clock.GetUtcNow()); // "service last answered now"
clock.Advance(TimeSpan.FromHours(71));
Assert.Equal(LicenseEdition.Pro, license.Validate().Edition); // still inside grace
clock.Advance(TimeSpan.FromHours(2)); // 73h since confirmation
Assert.Equal(LicenseEdition.Community, license.Validate().Edition); // grace exhausted, failed closed
Wie das in ein echtes Testprojekt passt
Ein kleiner Helfer hält jeden Test bei seinen drei Zeilen Absicht. Bauen Sie den Client aus einer Uhr, teilen Sie signierte Test-Leases aus und lassen Sie xUnit die Klasse parallel ausführen – es gibt keine geteilte statische Uhr, mit der man kollidieren könnte.
static KeyrightClient NewClient(TimeProvider clock, TimeSpan? grace = null) =>
KeyrightClient.Initialize(new KeyrightOptions
{
Product = "acme-suite",
PublicKeyBase64 = TestKeys.PublicKey, // a throwaway keypair generated for the test run
TimeProvider = clock,
Offline = true,
GracePeriod = grace ?? TimeSpan.FromHours(72),
});
Erzeugen Sie ein eigenes Test-Schlüsselpaar in einer Fixture, damit Sie Leases mit beliebigen NotBefore/ExpiresAt-Werten signieren und mit dem passenden öffentlichen Schlüssel verifizieren können. Sie testen Ihre Integration gegen das Uhrlese-Verhalten des SDK, nicht erneut das Signaturverfahren, daher dürfen die Schlüssel kurzlebig sein. Halten Sie den echten Produktions-Public-Key komplett aus dem Testprojekt heraus.
Vorbehalte: Was die gefälschte Uhr beweist und was nicht
Ein FakeTimeProvider ist ein Erweiterungspunkt für Unit-Tests und ist ehrlich über seine Grenzen.
Er steuert nur, wo das SDK die lokale Uhr liest. Er bewegt nicht ein serversigniertes ConfirmedAtUtc innerhalb eines Lease und besiegt nicht die Manipulationsprüfungen des SDK: In der Produktion wird das Zurückstellen der echten Uhr gegen eine monotone Höchststandsmarke erkannt und geht fail-closed. Ein Test kann also das Verstreichen der Zeit vorwärts sauber simulieren, aber um das Verhalten bei Rückstell-Manipulation zu testen, bewegen Sie die gefälschte Uhr rückwärts und prüfen, dass das SDK ClockStatus.WentBackwards meldet – was selbst ein wertvoller deterministischer Test ist.
Es ist ein Werkzeug auf Unit-Ebene. Es beweist, dass Ihre Gating-Logik korrekt auf Zeit reagiert; es übt nicht den echten Netzwerkpfad zu Ihrem selbstgehosteten Ausstellungsdienst. Behalten Sie eine dünne Schicht von Integrationstests, die das echte RefreshAsync gegen eine Testinstanz ausführen, und lassen Sie die schnelle FakeTimeProvider-Suite die Dutzenden Grenzfälle abdecken.
Seien Sie schließlich bewusst bei GetUtcNow gegenüber GetTimestamp. Kalenderentscheidungen – Ablauf, NotBefore, ein signierter Zeitstempel – nutzen GetUtcNow. Kurze prozessinterne Dauern – ein Cache-TTL, ein Aktualisierungsintervall – nutzen das monotone Paar GetTimestamp/GetElapsedTime, damit ein Operator, der an der Systemuhr dreht, sie nicht verzerren kann. FakeTimeProvider.Advance bewegt beide zusammen, sodass eine einzige Uhr weiterhin den gesamten Test steuert.
Fazit
Zeitabhängige Lizenzlogik ist nur dann schwer zu testen, wenn sie die Uhr liest, die sie nicht sehen kann. Leiten Sie jedes „Wie spät ist es“ über TimeProvider, belassen Sie es in der Produktion bei TimeProvider.System, und übergeben Sie dem SDK in Tests einen FakeTimeProvider. Ablauf, Not-before, Uhrabweichungs-Toleranz und Kulanz reduzieren sich auf schnelle, parallelsichere Assertions, bei denen Sie die Uhr genau um den relevanten Betrag vorrücken und das Ergebnis ablesen. Das Jahr, das Sie gewartet hätten, wird zu einem Aufruf von Advance.
Nebula.NET testen
Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.