Probar la caducidad de licencias con un reloj inyectable
El código de licencias que lee el reloj del sistema directamente es casi imposible de probar: no puedes esperar un año a que caduque una clave, y simular DateTime.UtcNow de forma global es frágil. Este artículo muestra cómo hacer que la caducidad, el NotBefore y el comportamiento del periodo de gracia de Keyright sean totalmente deterministas en xUnit inyectando la abstracción TimeProvider de .NET y controlándola con FakeTimeProvider, avanzando el tiempo milisegundo a milisegundo para comprobar cada límite.
Algunos errores solo se encuentran esperando un año. Una licencia que caduca al final de su término, una clave que es NotBefore hasta una fecha de activación futura, un periodo de gracia que vence tras setenta y dos horas sin conexión: todo esto es lógica dependiente del tiempo, y la forma obvia de probarla es cambiar el reloj del sistema y ver qué pasa. Eso no escala a una ejecución de CI, y no sobrevive a dos pruebas ejecutándose en paralelo.
La buena noticia es que nada de eso es necesario. Si tu código de licencias nunca lee el reloj ambiental directamente, puedes avanzar el tiempo en cantidades exactas dentro de una prueba unitaria y comprobar cada límite de forma determinista, en milisegundos.
Idea clave: Deja de llamar a DateTimeOffset.UtcNow dentro de la lógica de licencias. Lee el tiempo a través de TimeProvider de .NET, inyéctalo en el SDK de Keyright y, en las pruebas, pasa un FakeTimeProvider cuyo reloj mueves con Advance(...). Ahora “el día antes de caducar”, “el instante exacto de caducidad” y “un tick después de la gracia” son tres comprobaciones ordinarias, rápidas y seguras en paralelo.
La verdadera pregunta: ¿de dónde viene el tiempo?
Una comprobación de licencia es una comparación contra ahora. Validate() pregunta si la concesión en caché sigue dentro de su ventana de validez, si ha llegado su NotBefore y si el periodo de gracia sin conexión ha vencido. Cada una de ellas es algo <= ahora o ahora < algo. Todo el problema de comprobabilidad está en esa única palabra: ahora.
Si ahora es DateTimeOffset.UtcNow, no hay punto de extensión. UtcNow es una propiedad estática que lee el reloj del sistema operativo; no puedes sobrescribirla por prueba sin un parche ambiental global, y un global ambiental es exactamente el estado mutable compartido que vuelve inestable a una suite bajo paralelismo.
TimeProvider, incorporado en .NET 8 y versiones posteriores, es el punto de extensión. Es una pequeña clase abstracta con los métodos que importan aquí:
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.
}
El SDK de Keyright lee el tiempo exclusivamente a través de un TimeProvider. Lo suministras una vez, en KeyrightOptions; si lo dejas sin asignar, usa TimeProvider.System por defecto, de modo que el código de producción lee el reloj real y nunca tienes que pensar en ello.
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
});
Controlar el reloj con FakeTimeProvider
El doble de prueba es FakeTimeProvider, del paquete Microsoft.Extensions.TimeProvider.Testing. Lo construyes en un instante fijo y lo mueves hacia adelante a mano. Nada avanza por su cuenta, así que una prueba es perfectamente reproducible.
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 figura siguiente es el modelo mental: un único reloj falso que deslizas a lo largo del término, leyendo el estado de la licencia en cada parada.
Comprobar los límites, no solo el centro
El tiempo determinista te permite probar las partes que importan —los bordes— en lugar de un punto cómodo del medio. Tres casos merecen una prueba cada uno.
Aún no ha llegado NotBefore. Una clave activada para una fecha futura debe leerse como aún-no-válida, y luego cambiar en el instante en que el reloj la alcanza.
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);
El margen de desfase de reloj en el borde. Si permites un pequeño NotBeforeLeeway para la deriva del reloj del cliente, el reloj falso demuestra que tiene exactamente esa anchura —válido un tick dentro del margen, inválido un tick fuera— sin tocar jamás el reloj real.
// 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 gracia que vence tras la última confirmación. Para la ruta en línea, fija el último instante confirmado en la concesión, luego avanza más allá de GracePeriod y comprueba la vuelta a Community Edition. Como la cuenta atrás está anclada a una marca de tiempo de confirmación, un FakeTimeProvider reproduce toda la ventana con exactitud.
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
Cómo encaja en un proyecto de pruebas real
Un pequeño ayudante mantiene cada prueba en sus tres líneas de intención. Construye el cliente a partir de un reloj, reparte concesiones de prueba firmadas y deja que xUnit ejecute la clase en paralelo: no hay reloj estático compartido con el que colisionar.
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),
});
Genera un par de claves de prueba dedicado en una fixture para poder firmar concesiones con valores arbitrarios de NotBefore/ExpiresAt y verificarlas con la clave pública correspondiente. Estás probando tu integración frente al comportamiento de lectura del reloj del SDK, no volviendo a probar el esquema de firma, así que las claves pueden ser efímeras. Mantén la clave pública real de producción totalmente fuera del proyecto de pruebas.
Advertencias: qué demuestra y qué no el reloj falso
Un FakeTimeProvider es un punto de extensión para pruebas unitarias, y es honesto sobre sus límites.
Controla solo dónde lee el SDK el reloj local. No mueve un ConfirmedAtUtc firmado por el servidor dentro de una concesión, y no vence las comprobaciones de manipulación del SDK: en producción, atrasar el reloj real se detecta frente a una marca monótona de máximo histórico y falla en modo cerrado. Así que una prueba puede simular el paso del tiempo hacia adelante limpiamente, pero para probar el comportamiento ante manipulación por retroceso mueves el reloj falso hacia atrás y compruebas que el SDK informa ClockStatus.WentBackwards, que es en sí misma una prueba determinista valiosa.
Es una herramienta de nivel unitario. Demuestra que tu lógica de control responde correctamente al tiempo; no ejercita la ruta de red real a tu servicio de emisión autoalojado. Mantén una capa fina de pruebas de integración que ejecuten el RefreshAsync real contra una instancia de prueba, y deja que la rápida suite de FakeTimeProvider cubra las decenas de casos límite.
Por último, sé deliberado con GetUtcNow frente a GetTimestamp. Las decisiones de calendario —caducidad, NotBefore, una marca de tiempo firmada— usan GetUtcNow. Las duraciones cortas dentro del proceso —un TTL de caché, un intervalo de actualización— usan el par monótono GetTimestamp/GetElapsedTime para que un operador que toque el reloj del sistema no pueda distorsionarlas. FakeTimeProvider.Advance mueve ambos a la vez, así que un solo reloj sigue controlando toda la prueba.
Conclusión
La lógica de licencias dependiente del tiempo solo es difícil de probar cuando lee el reloj que no puede ver. Encamina cada “qué hora es” a través de TimeProvider, déjalo como TimeProvider.System en producción y pásale al SDK un FakeTimeProvider en las pruebas. La caducidad, el not-before, el margen de desfase de reloj y la gracia se reducen a comprobaciones rápidas y seguras en paralelo donde avanzas el reloj exactamente la cantidad que importa y lees el resultado. El año que habrías esperado se convierte en una llamada a Advance.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.