feat: Support apiKey for GO Feature Flag relay proxy v1.7.0 (#59)

Author: thomaspoignant

src/OpenFeature.Contrib.Providers.GOFeatureFlag/GoFeatureFlagProvider.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -62,6 +63,10 @@ private void InitializeProvider(GoFeatureFlagProviderOptions options)
             _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(ApplicationJson));
             _httpClient.BaseAddress = new Uri(options.Endpoint);
             _serializerOptions = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
+
+            if (options.ApiKey != null)
+                _httpClient.DefaultRequestHeaders.Authorization =
+                    new AuthenticationHeaderValue("Bearer", options.ApiKey);
         }
 
         /// <summary>
@@ -181,7 +186,8 @@ public override async Task<ResolutionDetails<double>> ResolveDoubleValue(string
             try
             {
                 var resp = await CallApi(flagKey, defaultValue, context);
-                return new ResolutionDetails<double>(flagKey, double.Parse(resp.value.ToString(), System.Globalization.CultureInfo.InvariantCulture), ErrorType.None,
+                return new ResolutionDetails<double>(flagKey,
+                    double.Parse(resp.value.ToString(), CultureInfo.InvariantCulture), ErrorType.None,
                     resp.reason, resp.variationType);
             }
             catch (FormatException e)
@@ -257,6 +263,9 @@ private async Task<GoFeatureFlagResponse> CallApi<T>(string flagKey, T defaultVa
             if (response.StatusCode == HttpStatusCode.NotFound)
                 throw new FlagNotFoundError($"flag {flagKey} was not found in your configuration");
 
+            if (response.StatusCode == HttpStatusCode.Unauthorized)
+                throw new UnauthorizedError("invalid token used to contact GO Feature Flag relay proxy instance");
+
             if (response.StatusCode >= HttpStatusCode.BadRequest)
                 throw new GeneralError("impossible to contact GO Feature Flag relay proxy instance");
 

src/OpenFeature.Contrib.Providers.GOFeatureFlag/GoFeatureFlagProviderOptions.cs

@@ -25,5 +25,14 @@ public class GoFeatureFlagProviderOptions
         ///     Default: null
         /// </Summary>
         public HttpMessageHandler HttpMessageHandler { get; set; }
+
+        /// <Summary>
+        ///     (optional) If the relay proxy is configured to authenticate the request, you should provide
+        ///     an API Key to the provider.
+        ///     Please ask the administrator of the relay proxy to provide an API Key.
+        ///     (This feature is available only if you are using GO Feature Flag relay proxy v1.7.0 or above)
+        ///     Default: null
+        /// </Summary>
+        public string ApiKey { get; set; }
     }
 }

src/OpenFeature.Contrib.Providers.GOFeatureFlag/GoFeatureFlagUser.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using System.Linq;
-
 using OpenFeature.Contrib.Providers.GOFeatureFlag.exception;
 using OpenFeature.Model;
 
@@ -15,17 +14,17 @@ public class GoFeatureFlagUser
         private const string KeyField = "targetingKey";
 
         /// <summary>
-        ///   The targeting key for the user.
+        ///     The targeting key for the user.
         /// </summary>
         public string Key { get; private set; }
 
         /// <summary>
-        ///   Is the user Anonymous.
+        ///     Is the user Anonymous.
         /// </summary>
         public bool Anonymous { get; private set; }
 
         /// <summary>
-        ///   Additional Custom Data to pass to GO Feature Flag.
+        ///     Additional Custom Data to pass to GO Feature Flag.
         /// </summary>
         public Dictionary<string, object> Custom { get; private set; }
 

src/OpenFeature.Contrib.Providers.GOFeatureFlag/exception/UnauthorizedError.cs

@@ -0,0 +1,22 @@
+using System;
+using OpenFeature.Constant;
+using OpenFeature.Error;
+
+namespace OpenFeature.Contrib.Providers.GOFeatureFlag.exception
+{
+    /// <summary>
+    ///     Exception throw when we are not authorized to call the API in the relay proxy.
+    /// </summary>
+    public class UnauthorizedError : FeatureProviderException
+    {
+        /// <summary>
+        ///     Constructor of the exception
+        /// </summary>
+        /// <param name="message">Message to display</param>
+        /// <param name="innerException">Original exception</param>
+        public UnauthorizedError(string message, Exception innerException = null) : base(ErrorType.General, message,
+            innerException)
+        {
+        }
+    }
+}

test/OpenFeature.Contrib.Providers.GOFeatureFlag.Test/GoFeatureFlagProviderTest.cs

@@ -24,6 +24,8 @@ private static HttpMessageHandler InitMock()
         const string mediaType = "application/json";
         var mockHttp = new MockHttpMessageHandler();
         mockHttp.When($"{prefixEval}fail_500{suffixEval}").Respond(HttpStatusCode.InternalServerError);
+        mockHttp.When($"{prefixEval}api_key_missing{suffixEval}").Respond(HttpStatusCode.BadRequest);
+        mockHttp.When($"{prefixEval}invalid_api_key{suffixEval}").Respond(HttpStatusCode.Unauthorized);
         mockHttp.When($"{prefixEval}flag_not_found{suffixEval}").Respond(HttpStatusCode.NotFound);
         mockHttp.When($"{prefixEval}bool_targeting_match{suffixEval}").Respond(mediaType,
             "{\"trackEvents\":true,\"variationType\":\"True\",\"failed\":false,\"version\":\"\",\"reason\":\"TARGETING_MATCH\",\"errorCode\":\"\",\"value\":true}");
@@ -149,6 +151,43 @@ private void should_throw_an_error_if_endpoint_not_available()
         Assert.Equal(Reason.Error, res.Result.Reason);
     }
 
+    [Fact]
+    private void should_have_bad_request_if_no_token()
+    {
+        var g = new GoFeatureFlagProvider(new GoFeatureFlagProviderOptions
+        {
+            Endpoint = baseUrl,
+            HttpMessageHandler = _mockHttp,
+            Timeout = new TimeSpan(1000 * TimeSpan.TicksPerMillisecond)
+        });
+        Api.Instance.SetProvider(g);
+        var client = Api.Instance.GetClient("test-client");
+        var res = client.GetBooleanDetails("api_key_missing", false, _defaultEvaluationCtx);
+        Assert.NotNull(res.Result);
+        Assert.False(res.Result.Value);
+        Assert.Equal(Reason.Error, res.Result.Reason);
+        Assert.Equal(ErrorType.General, res.Result.ErrorType);
+    }
+
+    [Fact]
+    private void should_have_unauthorized_if_invalid_token()
+    {
+        var g = new GoFeatureFlagProvider(new GoFeatureFlagProviderOptions
+        {
+            Endpoint = baseUrl,
+            HttpMessageHandler = _mockHttp,
+            Timeout = new TimeSpan(1000 * TimeSpan.TicksPerMillisecond),
+            ApiKey = "ff877c7a-4594-43b5-89a8-df44c9984bd8"
+        });
+        Api.Instance.SetProvider(g);
+        var client = Api.Instance.GetClient("test-client");
+        var res = client.GetBooleanDetails("invalid_api_key", false, _defaultEvaluationCtx);
+        Assert.NotNull(res.Result);
+        Assert.False(res.Result.Value);
+        Assert.Equal(Reason.Error, res.Result.Reason);
+        Assert.Equal(ErrorType.General, res.Result.ErrorType);
+    }
+
     [Fact]
     private void should_throw_an_error_if_flag_does_not_exists()
     {

test/OpenFeature.Contrib.Providers.GOFeatureFlag.Test/GoFeatureFlagUserTest.cs

@@ -1,7 +1,5 @@
 using System.Text.Json;
-
 using OpenFeature.Model;
-
 using Xunit;
 
 namespace OpenFeature.Contrib.Providers.GOFeatureFlag.Test;
@@ -22,8 +20,10 @@ public void GoFeatureFlagUserSerializesCorrectly()
 
         GoFeatureFlagUser user = userContext;
 
-        var userAsString = JsonSerializer.Serialize(user, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
+        var userAsString = JsonSerializer.Serialize(user,
+            new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
 
-        Assert.Contains("{\"key\":\"1d1b9238-2591-4a47-94cf-d2bc080892f1\",\"anonymous\":false,\"custom\":{", userAsString);
+        Assert.Contains("{\"key\":\"1d1b9238-2591-4a47-94cf-d2bc080892f1\",\"anonymous\":false,\"custom\":{",
+            userAsString);
     }
 }