refactor: change to use TimeProvider (#466)

Signed-off-by: André Silva <[email protected]>

Author: askpt

src/OpenFeature.Providers.Ofrep/Client/OfrepClient.cs

@@ -24,6 +24,7 @@ internal sealed partial class OfrepClient : IOfrepClient
     private readonly HttpClient _httpClient;
     private DateTimeOffset? _retryAfterDate;
     private readonly ILogger _logger;
+    private readonly TimeProvider _timeProvider;
     private bool _disposed;
 
     private static readonly JsonSerializerOptions JsonOptions = new()
@@ -37,8 +38,9 @@ internal sealed partial class OfrepClient : IOfrepClient
     /// </summary>
     /// <param name="configuration">The OFREP configuration.</param>
     /// <param name="logger">The logger for the client.</param>
-    public OfrepClient(OfrepOptions configuration, ILogger? logger = null)
-        : this(configuration, CreateDefaultHandler(), logger) // Use helper for default handler
+    /// <param name="timeProvider">The time provider for time-related operations. Defaults to TimeProvider.System.</param>
+    public OfrepClient(OfrepOptions configuration, ILogger? logger = null, TimeProvider? timeProvider = null)
+        : this(configuration, CreateDefaultHandler(), logger, timeProvider) // Use helper for default handler
     {
     }
 
@@ -47,7 +49,8 @@ public OfrepClient(OfrepOptions configuration, ILogger? logger = null)
     /// </summary>
     /// <param name="httpClient">The HttpClient to use for requests. Caller may provide one from IHttpClientFactory.</param>
     /// <param name="logger">The logger for the client.</param>
-    internal OfrepClient(HttpClient httpClient, ILogger? logger = null)
+    /// <param name="timeProvider">The time provider for time-related operations. Defaults to TimeProvider.System.</param>
+    internal OfrepClient(HttpClient httpClient, ILogger? logger = null, TimeProvider? timeProvider = null)
     {
 #if NET8_0_OR_GREATER
         ArgumentNullException.ThrowIfNull(httpClient);
@@ -60,6 +63,7 @@ internal OfrepClient(HttpClient httpClient, ILogger? logger = null)
 
         this._logger = logger ?? NullLogger<OfrepClient>.Instance;
         this._httpClient = httpClient;
+        this._timeProvider = timeProvider ?? TimeProvider.System;
     }
 
     /// <summary>
@@ -68,7 +72,8 @@ internal OfrepClient(HttpClient httpClient, ILogger? logger = null)
     /// <param name="configuration">The OFREP configuration.</param>
     /// <param name="handler">The HTTP message handler.</param>
     /// <param name="logger">The logger for the client.</param>
-    internal OfrepClient(OfrepOptions configuration, HttpMessageHandler handler, ILogger? logger = null)
+    /// <param name="timeProvider">The time provider for time-related operations. Defaults to TimeProvider.System.</param>
+    internal OfrepClient(OfrepOptions configuration, HttpMessageHandler handler, ILogger? logger = null, TimeProvider? timeProvider = null)
     {
 #if NET8_0_OR_GREATER
         ArgumentNullException.ThrowIfNull(configuration);
@@ -96,6 +101,8 @@ internal OfrepClient(OfrepOptions configuration, HttpMessageHandler handler, ILo
         {
             this._httpClient.DefaultRequestHeaders.TryAddWithoutValidation(header.Key, header.Value);
         }
+
+        this._timeProvider = timeProvider ?? TimeProvider.System;
     }
 
     /// <inheritdoc/>
@@ -111,7 +118,7 @@ public async Task<OfrepResponse<T>> EvaluateFlag<T>(string flagKey, T defaultVal
         }
 #endif
 
-        if (this._retryAfterDate.HasValue && this._retryAfterDate.Value > DateTimeOffset.UtcNow)
+        if (this._retryAfterDate.HasValue && this._retryAfterDate.Value > this._timeProvider.GetUtcNow())
         {
             return new OfrepResponse<T>(flagKey, defaultValue)
             {
@@ -190,15 +197,15 @@ private OfrepResponse<T> ProcessTooManyRequestsResponse<T>(string key, T default
         var retryAfter = response.Headers.RetryAfter;
         if (retryAfter?.Delta.HasValue == true)
         {
-            this._retryAfterDate = DateTimeOffset.UtcNow.Add(retryAfter.Delta.Value);
+            this._retryAfterDate = this._timeProvider.GetUtcNow().Add(retryAfter.Delta.Value);
         }
         else if (retryAfter?.Date.HasValue == true)
         {
             this._retryAfterDate = retryAfter.Date.Value;
         }
         else
         {
-            this._retryAfterDate = DateTimeOffset.UtcNow.AddMinutes(1);
+            this._retryAfterDate = this._timeProvider.GetUtcNow().AddMinutes(1);
         }
 
         return new OfrepResponse<T>(key, defaultValue)

src/OpenFeature.Providers.Ofrep/DependencyInjection/FeatureBuilderExtensions.cs

@@ -61,7 +61,8 @@ private static OfrepProvider CreateProvider(IServiceProvider sp, string? domain)
         // If no factory/client, let OfrepClient create its own HttpClient
         if (httpClient == null)
         {
-            return new OfrepProvider(ofrepOptions); // internal client management
+            var timeProviderService = sp.GetService<TimeProvider>();
+            return new OfrepProvider(ofrepOptions, timeProviderService); // internal client management
         }
 
         // Allow user to configure the HttpClient
@@ -84,7 +85,8 @@ private static OfrepProvider CreateProvider(IServiceProvider sp, string? domain)
         // Build OfrepClient using provided HttpClient and wire into OfrepProvider
         var loggerFactory = sp.GetService<ILoggerFactory>();
         var logger = loggerFactory?.CreateLogger<OfrepClient>();
-        var ofrepClient = new OfrepClient(httpClient, logger);
+        var timeProvider = sp.GetService<TimeProvider>();
+        var ofrepClient = new OfrepClient(httpClient, logger, timeProvider);
         return new OfrepProvider(ofrepClient);
     }
 }

src/OpenFeature.Providers.Ofrep/OfrepProvider.cs

@@ -22,13 +22,23 @@ public sealed class OfrepProvider : FeatureProvider, IDisposable
     /// </summary>
     /// <param name="configuration">The OFREP provider configuration.</param>
     public OfrepProvider(OfrepOptions configuration)
+        : this(configuration, null)
+    {
+    }
+
+    /// <summary>
+    /// Creates new instance of <see cref="OfrepProvider"/>
+    /// </summary>
+    /// <param name="configuration">The OFREP provider configuration.</param>
+    /// <param name="timeProvider">The time provider for time-related operations. Defaults to TimeProvider.System.</param>
+    public OfrepProvider(OfrepOptions configuration, TimeProvider? timeProvider)
     {
         if (configuration == null)
         {
             throw new ArgumentNullException(nameof(configuration));
         }
 
-        this._client = new OfrepClient(configuration);
+        this._client = new OfrepClient(configuration, timeProvider: timeProvider);
     }
 
     /// <summary>

src/OpenFeature.Providers.Ofrep/OpenFeature.Providers.Ofrep.csproj

@@ -20,24 +20,25 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0"/>
-    <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0"/>
-    <PackageReference Include="OpenFeature.DependencyInjection" Version="$(OpenFeatureVersion)"/>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
+    <PackageReference Include="OpenFeature.DependencyInjection" Version="$(OpenFeatureVersion)" />
   </ItemGroup>
   <PropertyGroup>
     <OpenFeatureVersion>[2.2,2.99999]</OpenFeatureVersion>
   </PropertyGroup>
 
   <ItemGroup
     Condition=" '$(TargetFramework)' == 'net462' or '$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="System.Net.Http" Version="4.3.4"/>
-    <PackageReference Include="System.Net.Http.Json" Version="8.0.1"/>
-    <PackageReference Include="System.Text.Json" Version="8.0.5"/>
+    <PackageReference Include="Microsoft.Bcl.TimeProvider" Version="8.0.0" />
+    <PackageReference Include="System.Net.Http" Version="4.3.4" />
+    <PackageReference Include="System.Net.Http.Json" Version="8.0.1" />
+    <PackageReference Include="System.Text.Json" Version="8.0.5" />
   </ItemGroup>
 
   <!-- documentation -->
   <ItemGroup>
-    <None Include="README.md" Pack="true" PackagePath="\"/>
+    <None Include="README.md" Pack="true" PackagePath="\" />
   </ItemGroup>
 
   <!-- make the internal methods visble to our test project -->

src/OpenFeature.Providers.Ofrep/README.md

@@ -67,6 +67,18 @@ var provider = new OfrepProvider(config);
 await Api.Instance.SetProviderAsync(provider);
 ```
 
+### TimeProvider Support
+
+For testing and scenarios where you need to control time-related behavior (such as rate limiting), you can provide a custom `TimeProvider`:
+
+```csharp
+// Using a custom TimeProvider for testing
+var customTimeProvider = new FakeTimeProvider(); // From Microsoft.Extensions.TimeProvider.Testing
+var provider = new OfrepProvider(config, customTimeProvider);
+```
+
+When using dependency injection, the provider will automatically use any registered `TimeProvider` from the service container.
+
 ## Configuration Options
 
 The `OfrepOptions` class supports the following options:

test/OpenFeature.Providers.Ofrep.Test/Client/OfrepClientTest.cs

@@ -5,6 +5,7 @@
 using System.Text.Json;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Time.Testing;
 using OpenFeature.Model;
 using OpenFeature.Providers.Ofrep.Client;
 using OpenFeature.Providers.Ofrep.Configuration;
@@ -750,6 +751,79 @@ public async Task EvaluateFlag_WithRetryAfterSet_ShouldReturnGeneralErrorForSubs
         Assert.Equal("Rate limit exceeded.", secondResult.ErrorMessage);
     }
 
+    [Fact]
+    public void Constructor_WithTimeProvider_ShouldInitializeSuccessfully()
+    {
+        // Arrange
+        var startTime = new DateTimeOffset(2023, 1, 1, 12, 0, 0, TimeSpan.Zero);
+        var fakeTimeProvider = new FakeTimeProvider(startTime);
+
+        // Act & Assert - Constructor should complete successfully
+        using var client = new OfrepClient(this._configuration, this._mockHandler, this._mockLogger, fakeTimeProvider);
+        Assert.NotNull(client);
+    }
+
+    [Fact]
+    public async Task EvaluateFlag_WithFakeTimeProvider_ShouldRespectRetryAfterTimeout()
+    {
+        // Arrange
+        const string flagKey = "rate-limited-flag";
+        const bool defaultValue = false;
+        var startTime = new DateTimeOffset(2023, 1, 1, 12, 0, 0, TimeSpan.Zero);
+        var fakeTimeProvider = new FakeTimeProvider(startTime);
+
+        // Create a custom mock handler that can set RetryAfter header
+        var mockHandler = new TestHttpMessageHandler();
+        var responseWithRetryAfter = new HttpResponseMessage((HttpStatusCode)429)
+        {
+            Content = new StringContent("Rate limit exceeded"),
+            Headers = { RetryAfter = new System.Net.Http.Headers.RetryConditionHeaderValue(TimeSpan.FromSeconds(60)) }
+        };
+
+        // Setup the custom response directly
+        mockHandler.SetupResponse(responseWithRetryAfter);
+
+        using var client = new OfrepClient(this._configuration, mockHandler, this._mockLogger, fakeTimeProvider);
+
+        // Act & Assert
+        // First request should trigger rate limit and set retry after
+        var firstResult = await client.EvaluateFlag(flagKey, defaultValue, EvaluationContext.Empty);
+        Assert.Equal("general_error", firstResult.ErrorCode);
+        Assert.Equal("Rate limit exceeded.", firstResult.ErrorMessage);
+
+        // Second request immediately should also be rate limited (no HTTP call due to client-side rate limiting)
+        var secondResult = await client.EvaluateFlag(flagKey, defaultValue, EvaluationContext.Empty);
+        Assert.Equal("general_error", secondResult.ErrorCode);
+        Assert.Equal("Rate limit exceeded.", secondResult.ErrorMessage);
+
+        // This should have made only 1 HTTP request (the first one), not 2
+        Assert.Single(mockHandler.Requests);
+
+        // Advance time by 30 seconds - should still be rate limited
+        fakeTimeProvider.Advance(TimeSpan.FromSeconds(30));
+        var thirdResult = await client.EvaluateFlag(flagKey, defaultValue, EvaluationContext.Empty);
+        Assert.Equal("general_error", thirdResult.ErrorCode);
+        Assert.Equal("Rate limit exceeded.", thirdResult.ErrorMessage);
+
+        // Still only 1 HTTP request should have been made
+        Assert.Single(mockHandler.Requests);
+
+        // Advance time by another 31 seconds (total 61 seconds) - rate limit should be cleared
+        fakeTimeProvider.Advance(TimeSpan.FromSeconds(31));
+
+        // Setup successful response for the next call
+        var successResponse = new OfrepResponse<bool>(flagKey, true) { Reason = "STATIC", Variant = "on" };
+        var json = JsonSerializer.Serialize(successResponse, this._jsonSerializerCamelCase);
+        mockHandler.SetupResponse(HttpStatusCode.OK, json);
+
+        var fourthResult = await client.EvaluateFlag(flagKey, defaultValue, EvaluationContext.Empty);
+        Assert.Equal("STATIC", fourthResult.Reason);
+        Assert.True(fourthResult.Value);
+
+        // Now we should have made 2 HTTP requests total
+        Assert.Equal(2, mockHandler.Requests.Count);
+    }
+
     #endregion
 
     #region Context Validation Tests

test/OpenFeature.Providers.Ofrep.Test/DependencyInjection/FeatureBuilderExtensionsTests.cs

@@ -1,5 +1,6 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Time.Testing;
 using OpenFeature.Providers.Ofrep.DependencyInjection;
 using Xunit;
 
@@ -242,4 +243,29 @@ public void AddOfrepProvider_Named_Domain_Works()
         Assert.IsType<OfrepProvider>(keyedProvider);
     }
 
+    [Fact]
+    public void AddOfrepProvider_WithRegisteredTimeProvider_UsesCustomTimeProvider()
+    {
+        // Arrange
+        var customTimeProvider = new FakeTimeProvider(new DateTimeOffset(2023, 1, 1, 12, 0, 0, TimeSpan.Zero));
+
+        using var services = new ServiceCollection()
+            .AddSingleton<TimeProvider>(customTimeProvider)
+            .AddOpenFeature(builder =>
+            {
+                builder.AddOfrepProvider(o => { o.BaseUrl = "https://api.example.com/"; });
+            })
+            .BuildServiceProvider();
+
+        // Act
+        var provider = services.GetRequiredService<FeatureProvider>();
+
+        // Assert
+        Assert.NotNull(provider);
+        Assert.IsType<OfrepProvider>(provider);
+
+        // The provider should be created successfully with the custom TimeProvider
+        // We can't directly verify the TimeProvider usage without making the field public,
+        // but successful construction indicates it was passed correctly
+    }
 }

test/OpenFeature.Providers.Ofrep.Test/Helpers/TestHttpMessageHandler.cs

@@ -8,21 +8,31 @@ namespace OpenFeature.Providers.Ofrep.Test.Helpers;
 
 internal class TestHttpMessageHandler : HttpMessageHandler
 {
-    private readonly Queue<(HttpStatusCode statusCode, string content, string? etag, Exception? exception)>
+    private readonly Queue<(HttpResponseMessage? responseMessage, Exception? exception)>
         _responses = new();
 
     private readonly List<HttpRequestMessage> _requests = new();
 
     public IReadOnlyList<HttpRequestMessage> Requests => this._requests.AsReadOnly();
 
-    public void SetupResponse(HttpStatusCode statusCode, string content, string? etag = null)
+    public void SetupResponse(HttpStatusCode statusCode, string content)
     {
-        this._responses.Enqueue((statusCode, content, etag, null));
+        var httpResponse = new HttpResponseMessage(statusCode)
+        {
+            Content = new StringContent(content, Encoding.UTF8, "application/json")
+        };
+
+        this.SetupResponse(httpResponse);
+    }
+
+    public void SetupResponse(HttpResponseMessage responseMessage)
+    {
+        this._responses.Enqueue((responseMessage, null));
     }
 
     public void SetupException(Exception exception)
     {
-        this._responses.Enqueue((HttpStatusCode.OK, "", null, exception));
+        this._responses.Enqueue((null, exception));
     }
 
     protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
@@ -31,11 +41,11 @@ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage reques
         this._requests.Add(request);
 
 #if NETFRAMEWORK
-        var response = this._responses.Count > 0 ? this._responses.Dequeue() : (HttpStatusCode.OK, "{}", null, null);
+        var response = this._responses.Count > 0 ? this._responses.Dequeue() : (new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") }, null);
 #else
         if (!this._responses.TryDequeue(out var response))
         {
-            response = (HttpStatusCode.OK, "{}", null, null);
+            response = (new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}", Encoding.UTF8, "application/json") }, null);
         }
 #endif
 
@@ -44,19 +54,8 @@ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage reques
             throw response.exception;
         }
 
-        var httpResponse = new HttpResponseMessage(response.statusCode)
-        {
-            Content = new StringContent(response.content, Encoding.UTF8, "application/json")
-        };
-
-        if (!string.IsNullOrEmpty(response.etag))
-        {
-            httpResponse.Headers.ETag = new System.Net.Http.Headers.EntityTagHeaderValue(response.etag);
-        }
-
-        // If status code indicates an error and no specific exception was set,
-        // let EnsureSuccessStatusCode handle it
-        return Task.FromResult(httpResponse);
+        // Return the pre-built response message
+        return Task.FromResult(response.responseMessage!);
     }
 
     protected override void Dispose(bool disposing)

test/OpenFeature.Providers.Ofrep.Test/OpenFeature.Providers.Ofrep.Test.csproj

@@ -14,6 +14,10 @@
       Include="..\..\src\OpenFeature.Providers.Ofrep\OpenFeature.Providers.Ofrep.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.TimeProvider.Testing" Version="9.9.0" />
+  </ItemGroup>
+
   <ItemGroup Condition=" '$(TargetFramework)' == 'net9.0' ">
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.0.9" />
     <PackageReference Include="Microsoft.AspNetCore.TestHost" Version="9.0.9" />