Testowanie za pomocą elementu FakeTimeProvider

📦 Microsoft.Extensions.TimeProvider.Testing Pakiet NuGet udostępnia klasęFakeTimeProvider, która umożliwia deterministyczne testowanie kodu, który zależy od czasu. Ta fałszywa implementacja pozwala kontrolować czas systemowy w testach, zapewniając przewidywalne i powtarzalne wyniki.

Dlaczego warto używać elementu FakeTimeProvider

Testowanie kodu zależnego od bieżącego czasu lub użycia czasomierzy może być trudne:

  • Testy niedeterministyczne: testy, które zależą od czasu rzeczywistego, mogą generować niespójne wyniki.
  • Powolne testy: testy, które muszą czekać na upływ rzeczywistego czasu, mogą znacznie spowolnić wykonywanie testów.
  • Warunki wyścigu: Logika zależna od czasu może wprowadzać warunki wyścigu, które są trudne do odtworzenia.
  • Przypadki brzegowe: Testowanie logiki opartej na czasie w określonych godzinach (takich jak północ lub granice miesiąca) jest trudne w czasie rzeczywistym.

FakeTimeProvider rozwiązuje te problemy poprzez:

  • Zapewnienie pełnej kontroli nad bieżącym czasem.
  • Umożliwia natychmiastowe przesunięcie czasu bez oczekiwania.
  • Umożliwienie deterministycznego testowania zachowania zależnego od czasu.
  • Ułatwianie testowania przypadków brzegowych i warunków granicznych.

Zacznij

Aby rozpocząć pracę z FakeTimeProvider, zainstaluj pakiet Microsoft.Extensions.TimeProvider.Testing NuGet.

dotnet add package Microsoft.Extensions.TimeProvider.Testing

Aby uzyskać więcej informacji, zobacz dotnet add package lub Zarządzanie zależnościami pakietów w aplikacjach .NET.

Podstawowy sposób użycia

FakeTimeProvider rozszerza TimeProvider w celu zapewnienia możliwości kontrolowania czasu na potrzeby testowania:

var fakeTimeProvider = new FakeTimeProvider();

// Get the current time (defaults to January 1, 2000, midnight UTC).
Console.WriteLine($"Start time: {fakeTimeProvider.GetUtcNow()}");

Inicjowanie z określonym czasem

Można zainicjować FakeTimeProvider przy użyciu określonego czasu rozpoczęcia:

DateTimeOffset startTime = new(2025, 10, 20, 12, 0, 0, TimeSpan.Zero);
fakeTimeProvider = new FakeTimeProvider(startTime);

Console.WriteLine($"Started at: {fakeTimeProvider.GetUtcNow()}");

Przesuń czas do przodu

Metoda Advance przenosi czas do przodu o określony czas:

// Advance time by 30 minutes.
fakeTimeProvider.Advance(TimeSpan.FromMinutes(30));
Console.WriteLine($"After advancing 30 minutes: {fakeTimeProvider.GetUtcNow()}");

Konfigurowanie strefy czasowej

Ustaw lokalną strefę czasową dla dostawcy fałszywego czasu:

var timeZoneId = OperatingSystem.IsWindows() ? "Pacific Standard Time" : "America/Los_Angeles";
var pacificTimeZone = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
fakeTimeProvider.SetLocalTimeZone(pacificTimeZone);

var localTime = fakeTimeProvider.GetLocalNow();
Console.WriteLine($"Local time: {localTime}");

Testuj opóźnione operacje

FakeTimeProvider jest szczególnie przydatna w przypadku operacji testowania, które obejmują opóźnienia:

public class DelayedOperationTests
{
    [Fact]
    public async Task DelayedOperation_CompletesAfterDelay()
    {
        // Arrange
        var fakeTimeProvider = new FakeTimeProvider();
        var operation = new DelayedOperation(fakeTimeProvider);

        // Act
        Task task = operation.ExecuteAsync(TimeSpan.FromMinutes(5));

        // Assert - operation should not be complete yet
        Assert.False(task.IsCompleted);

        // Advance time by 5 minutes
        fakeTimeProvider.Advance(TimeSpan.FromMinutes(5));

        // Wait for the task to complete
        await task;

        // Operation should now be complete
        Assert.True(task.IsCompleted);
    }
}

public class DelayedOperation(TimeProvider timeProvider)
{
    public async Task ExecuteAsync(TimeSpan delay)
    {
        await Task.Delay(delay, timeProvider);
    }
}

Testowanie okresowych operacji

Operacje testowe, które są wykonywane okresowo przy użyciu czasomierzy:

public class PeriodicOperationTests
{
    [Fact]
    public void PeriodicOperation_ExecutesAtIntervals()
    {
        // Arrange
        var fakeTimeProvider = new FakeTimeProvider();
        var counter = new PeriodicCounter(fakeTimeProvider);
        counter.Start(TimeSpan.FromSeconds(10));

        // Act & Assert
        Assert.Equal(0, counter.Count);

        // Advance by 10 seconds
        fakeTimeProvider.Advance(TimeSpan.FromSeconds(10));
        Assert.Equal(1, counter.Count);

        // Advance by 20 more seconds
        fakeTimeProvider.Advance(TimeSpan.FromSeconds(20));
        Assert.Equal(3, counter.Count);

        // Clean up
        counter.Stop();
    }
}

public class PeriodicCounter(TimeProvider timeProvider)
{
    private ITimer? _timer;

    public int Count { get; private set; }

    public void Start(TimeSpan interval)
    {
        _timer = timeProvider.CreateTimer(
            callback: _ => Count++,
            state: null,
            dueTime: interval,
            period: interval);
    }

    public void Stop()
    {
        _timer?.Dispose();
    }
}

Testowanie logiki biznesowej opartej na czasie

Testowanie logiki biznesowej, która zależy od określonych godzin lub dat:

public class SubscriptionTests
{
    [Fact]
    public void Subscription_ExpiresAfterOneYear()
    {
        // Arrange
        var fakeTimeProvider = new FakeTimeProvider();
        var startDate = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero);
        fakeTimeProvider.SetUtcNow(startDate);

        var subscription = new Subscription(fakeTimeProvider);
        subscription.Activate();

        // Assert - subscription is active
        Assert.True(subscription.IsActive);

        // Act - advance time by 11 months
        fakeTimeProvider.Advance(TimeSpan.FromDays(30 * 11));
        Assert.True(subscription.IsActive);

        // Advance time by 2 more months
        fakeTimeProvider.Advance(TimeSpan.FromDays(60));
        Assert.False(subscription.IsActive);
    }
}

public class Subscription(TimeProvider timeProvider)
{
    private DateTimeOffset _activationDate;

    public void Activate()
    {
        _activationDate = timeProvider.GetUtcNow();
    }

    public bool IsActive
    {
        get
        {
            DateTimeOffset currentTime = timeProvider.GetUtcNow();
            DateTimeOffset expirationDate = _activationDate.AddYears(1);
            return currentTime < expirationDate;
        }
    }
}

Integracja z iniekcją zależności

Użyj FakeTimeProvider w testach dla usług zarejestrowanych za pomocą wstrzykiwania zależności:

public class CacheServiceTests
{
    [Fact]
    public void Cache_ExpiresAfterTimeout()
    {
        // Arrange
        var fakeTimeProvider = new FakeTimeProvider();

        var services = new ServiceCollection();
        services.AddSingleton<TimeProvider>(fakeTimeProvider);
        services.AddSingleton<CacheService>();

        ServiceProvider provider = services.BuildServiceProvider();
        CacheService cache = provider.GetRequiredService<CacheService>();

        // Act
        cache.Set("key", "value", TimeSpan.FromMinutes(10));

        // Assert - value is present
        Assert.True(cache.TryGet("key", out string? value));
        Assert.Equal("value", value);

        // Advance time beyond expiration
        fakeTimeProvider.Advance(TimeSpan.FromMinutes(11));

        // Value should be expired
        Assert.False(cache.TryGet("key", out _));
    }
}

public class CacheService(TimeProvider timeProvider)
{
    private readonly Dictionary<string, CacheEntry> _cache = [];

    public void Set(string key, string value, TimeSpan expiration)
    {
        DateTimeOffset expiresAt = timeProvider.GetUtcNow() + expiration;
        _cache[key] = new CacheEntry(value, expiresAt);
    }

    public bool TryGet(string key, out string? value)
    {
        if (_cache.TryGetValue(key, out CacheEntry? entry))
        {
            if (timeProvider.GetUtcNow() < entry.ExpiresAt)
            {
                value = entry.Value;
                return true;
            }

            // Entry expired, remove it
            _cache.Remove(key);
        }

        value = null;
        return false;
    }

    private record CacheEntry(string Value, DateTimeOffset ExpiresAt);
}

Najlepsze rozwiązania

W przypadku korzystania z usługi FakeTimeProvidernależy wziąć pod uwagę następujące najlepsze rozwiązania:

  • Wstrzykiwanie elementu TimeProvider: zawsze wstrzykuj TimeProvider jako zależność, a nie używaj DateTime lub DateTimeOffset bezpośrednio. Dzięki temu kod jest możliwy do testowania.
  • Użyj czasu UTC: Pracuj z czasem UTC w swojej logice biznesowej i konwertuj na czas lokalny tylko kiedy to potrzebne do wyświetlenia.
  • Testowanie przypadków brzegowych: użyj FakeTimeProvider do testowania przypadków brzegowych, takich jak północ, granice miesiąca, przejścia czasu letniego i lata przestępne.
  • Usuń czasomierze: Usuń czasomierze utworzone za pomocą CreateTimer, aby uniknąć wycieków zasobów w testach.
  • Przesuń czas celowo: Przesuń czas w testach wyraźnie, aby zachowanie testu było jasne i przewidywalne.
  • Unikaj mieszania czasu rzeczywistego i fałszywego: nie mieszaj rzeczywistych TimeProvider.System z FakeTimeProvider w tym samym teście, ponieważ może to prowadzić do nieprzewidywalnego zachowania.

Zobacz także

  • Last updated on