Tester l'expiration de licence avec une horloge injectable
Le code de licence qui lit directement l'horloge système est quasi impossible à tester : vous ne pouvez pas attendre un an qu'une clé expire, et simuler DateTime.UtcNow globalement est fragile. Cet article montre comment rendre l'expiration, le NotBefore et le comportement de la fenêtre de grâce de Keyright entièrement déterministes dans xUnit en injectant l'abstraction TimeProvider de .NET et en la pilotant avec FakeTimeProvider, en avançant le temps à la milliseconde pour vérifier chaque limite.
Certains bugs ne se trouvent qu”en attendant un an. Une licence qui expire à la fin de son terme, une clé en NotBefore jusqu”à une date d”activation future, une fenêtre de grâce qui expire après soixante-douze heures hors ligne : tout cela est une logique dépendante du temps, et la façon évidente de la tester est de changer l”horloge système et de voir ce qui se passe. Cela ne passe pas à l”échelle d”une exécution CI, et ne survit pas à deux tests exécutés en parallèle.
La bonne nouvelle, c”est que rien de tout cela n”est nécessaire. Si votre code de licence ne lit jamais directement l”horloge ambiante, vous pouvez avancer le temps de quantités exactes au sein d”un test unitaire et vérifier chaque limite de façon déterministe, en quelques millisecondes.
À retenir : cessez d”appeler DateTimeOffset.UtcNow dans la logique de licence. Lisez le temps via TimeProvider de .NET, injectez-le dans le SDK Keyright, et dans les tests passez un FakeTimeProvider dont vous déplacez l”horloge avec Advance(...). Désormais « la veille de l”expiration », « l”instant exact de l”expiration » et « un tick après la grâce » deviennent trois assertions ordinaires, rapides et sûres en parallèle.
La vraie question : d”où vient le temps ?
Une vérification de licence est une comparaison avec maintenant. Validate() demande si le bail en cache est toujours dans sa fenêtre de validité, si son NotBefore est atteint, et si la fenêtre de grâce hors ligne a expiré. Chacune d”elles est quelque chose <= maintenant ou maintenant < quelque chose. Tout le problème de testabilité tient à ce seul mot : maintenant.
Si maintenant est DateTimeOffset.UtcNow, il n”y a pas de point d”extension. UtcNow est une propriété statique qui lit l”horloge du système d”exploitation ; vous ne pouvez pas la remplacer par test sans un correctif ambiant global, et un global ambiant est exactement l”état mutable partagé qui rend une suite instable en parallèle.
TimeProvider, intégré à .NET 8 et versions ultérieures, est ce point d”extension. C”est une petite classe abstraite avec les méthodes qui comptent ici :
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.
}
Le SDK Keyright lit le temps exclusivement via un TimeProvider. Vous le fournissez une fois, sur KeyrightOptions ; si vous le laissez non défini, il utilise TimeProvider.System par défaut, de sorte que le code de production lit l”horloge réelle et vous n”y pensez jamais.
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
});
Piloter l”horloge avec FakeTimeProvider
Le double de test est FakeTimeProvider, du paquet Microsoft.Extensions.TimeProvider.Testing. Vous le construisez à un instant fixe et l”avancez à la main. Rien n”avance tout seul, donc un test est parfaitement reproductible.
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
La figure ci-dessous est le modèle mental : une seule horloge factice que vous faites glisser le long du terme, lisant l”état de la licence à chaque arrêt.
Vérifier les limites, pas seulement le milieu
Le temps déterministe vous permet de tester les parties qui comptent — les bords — plutôt qu”un point confortable au milieu. Trois cas méritent chacun un test.
NotBefore n”est pas encore atteint. Une clé activée pour une date future doit se lire comme pas-encore-valide, puis basculer à l”instant où l”horloge l”atteint.
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);
La marge de dérive d”horloge au bord. Si vous autorisez un petit NotBeforeLeeway pour la dérive de l”horloge du client, l”horloge factice prouve qu”elle a exactement cette largeur — valide un tick à l”intérieur de la marge, invalide un tick à l”extérieur — sans jamais toucher à l”horloge réelle.
// 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
La grâce qui expire après la dernière confirmation. Pour le chemin en ligne, fixez le dernier instant confirmé sur le bail, puis avancez au-delà de GracePeriod et vérifiez le repli sur Community Edition. Comme le compte à rebours est ancré à un horodatage de confirmation, un FakeTimeProvider reproduit toute la fenêtre à l”exactitude près.
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
Comment cela s”intègre dans un vrai projet de tests
Un petit utilitaire garde chaque test à ses trois lignes d”intention. Construisez le client à partir d”une horloge, distribuez des baux de test signés, et laissez xUnit exécuter la classe en parallèle : il n”y a aucune horloge statique partagée avec laquelle entrer en collision.
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),
});
Générez une paire de clés de test dédiée dans une fixture afin de pouvoir signer des baux avec des valeurs arbitraires de NotBefore/ExpiresAt et les vérifier avec la clé publique correspondante. Vous testez votre intégration vis-à-vis du comportement de lecture d”horloge du SDK, et non le schéma de signature, donc les clés peuvent être éphémères. Gardez la vraie clé publique de production entièrement hors du projet de tests.
Mises en garde : ce que l”horloge factice prouve et ne prouve pas
Un FakeTimeProvider est un point d”extension pour tests unitaires, et il est honnête sur ses limites.
Il ne contrôle que l”endroit où le SDK lit l”horloge locale. Il ne déplace pas un ConfirmedAtUtc signé par le serveur à l”intérieur d”un bail, et il ne contourne pas les contrôles anti-falsification du SDK : en production, reculer l”horloge réelle est détecté face à un repère monotone de maximum atteint et échoue en mode fermé. Un test peut donc simuler proprement l”écoulement du temps vers l”avant, mais pour tester le comportement face à une falsification par recul, vous déplacez l”horloge factice vers l”arrière et vérifiez que le SDK signale ClockStatus.WentBackwards, ce qui est en soi un test déterministe précieux.
C”est un outil de niveau unitaire. Il prouve que votre logique de contrôle répond correctement au temps ; il n”exerce pas le vrai chemin réseau vers votre service d”émission auto-hébergé. Gardez une fine couche de tests d”intégration qui exécutent le vrai RefreshAsync contre une instance de test, et laissez la rapide suite FakeTimeProvider couvrir les dizaines de cas limites.
Enfin, soyez délibéré sur GetUtcNow contre GetTimestamp. Les décisions de calendrier — expiration, NotBefore, un horodatage signé — utilisent GetUtcNow. Les courtes durées en cours de processus — un TTL de cache, un intervalle de rafraîchissement — utilisent la paire monotone GetTimestamp/GetElapsedTime pour qu”un opérateur touchant l”horloge système ne puisse pas les fausser. FakeTimeProvider.Advance déplace les deux ensemble, de sorte qu”une seule horloge pilote encore tout le test.
Conclusion
La logique de licence dépendante du temps n”est difficile à tester que lorsqu”elle lit l”horloge qu”elle ne peut pas voir. Faites transiter chaque « quelle heure est-il » par TimeProvider, laissez-le à TimeProvider.System en production, et passez au SDK un FakeTimeProvider dans les tests. L”expiration, le not-before, la marge de dérive d”horloge et la grâce se réduisent à des assertions rapides et sûres en parallèle où vous avancez l”horloge exactement de la quantité qui compte et lisez le résultat. L”année que vous auriez attendue devient un appel à Advance.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.