add TargetEnvironmentAttribute and FaultInjectorClient

Author: atakavci

tests/NRedisStack.Tests/TargetEnvironmentAttribute.cs

@@ -0,0 +1,35 @@
+using Xunit;
+
+namespace NRedisStack.Tests;
+public class TargetEnvironmentAttribute : SkipIfRedisAttribute
+{
+    private string targetEnv;
+    public TargetEnvironmentAttribute(string targetEnv) : base(Comparison.LessThan, "0.0.0")
+    {
+        this.targetEnv = targetEnv;
+    }
+
+    public TargetEnvironmentAttribute(string targetEnv, Is environment, Comparison comparison = Comparison.LessThan,
+            string targetVersion = "0.0.0") : base(environment, comparison, targetVersion)
+    {
+        this.targetEnv = targetEnv;
+    }
+
+    public TargetEnvironmentAttribute(string targetEnv, Is environment1, Is environment2, Comparison comparison = Comparison.LessThan,
+        string targetVersion = "0.0.0") : base(environment1, environment2, comparison, targetVersion)
+    {
+        this.targetEnv = targetEnv;
+    }
+
+    public override string? Skip
+    {
+        get
+        {
+            if (!new RedisFixture().IsTargetConnectionExist(targetEnv))
+            {
+                return "Test skipped, because: target environment not found.";
+            }
+            return base.Skip;
+        }
+    }
+}

tests/NRedisStack.Tests/TokenBasedAuthentication/AuthenticationTests.cs

@@ -6,29 +6,28 @@
 
 namespace NRedisStack.Tests.TokenBasedAuthentication
 {
-    public class AuthenticationTests 
+    public class AuthenticationTests : AbstractNRedisStackTest
     {
         static readonly string key = "myKey";
         static readonly string value = "myValue";
         static readonly string index = "myIndex";
         static readonly string field = "myField";
         static readonly string alias = "myAlias";
+        public AuthenticationTests(RedisFixture redisFixture) : base(redisFixture) { }
 
-        string env0Host = "localhost:6379";
-
-        [Fact]
+        [TargetEnvironment("standalone-entraid-acl")]
         public void TestTokenBasedAuthentication()
         {
-
+            Assert.True(new FaultInjectorClient().TriggerActionAsync("enable_entraid", new Dictionary<string, object>()).Wait(5000),"Entraid could not be enabled this time!!!");
             // NOTE: ConnectionMultiplexer instances should be as long-lived as possible. Ideally a single ConnectionMultiplexer per cache is reused over the lifetime of the client application process.
             ConnectionMultiplexer? connectionMultiplexer = null;
-            StringWriter connectionLog = new();
+            // StringWriter connectionLog = new();
 
-            var configurationOptions = ConfigurationOptions.Parse($"{env0Host}").ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential()).Result!;
+            var configurationOptions = new ConfigurationOptions().ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential()).Result!;
             configurationOptions.Ssl = false;
             configurationOptions.AbortOnConnectFail = true; // Fail fast for the purposes of this sample. In production code, this should remain false to retry connections on startup
 
-            connectionMultiplexer = ConnectionMultiplexer.ConnectAsync(configurationOptions, connectionLog).Result;
+            connectionMultiplexer = redisFixture.GetConnectionById(configurationOptions, "standalone-entraid-acl");
 
             IDatabase db = connectionMultiplexer.GetDatabase();
 
@@ -53,7 +52,6 @@ public void TestTokenBasedAuthentication()
             SearchResult res1 = ft.Search(alias, new Query("*").ReturnFields(field));
             Assert.Equal(1, res1.TotalResults);
             Assert.Equal(value, res1.Documents[0][field]);
-
         }
     }
 }

tests/NRedisStack.Tests/TokenBasedAuthentication/FaultInjectorClient.cs

@@ -0,0 +1,112 @@
+using System.Text;
+using System.Text.Json;
+
+public class FaultInjectorClient
+{
+    private static readonly string BASE_URL;
+
+    static FaultInjectorClient()
+    {
+        BASE_URL = Environment.GetEnvironmentVariable("FAULT_INJECTION_API_URL") ?? "http://127.0.0.1:20324";
+    }
+
+    public class TriggerActionResponse
+    {
+        public string ActionId { get; }
+        private DateTime? LastRequestTime { get; set; }
+        private DateTime? CompletedAt { get; set; }
+        private DateTime? FirstRequestAt { get; set; }
+
+        public TriggerActionResponse(string actionId)
+        {
+            ActionId = actionId;
+        }
+
+        public async Task<bool> IsCompletedAsync(TimeSpan checkInterval, TimeSpan delayAfter, TimeSpan timeout)
+        {
+            if (CompletedAt.HasValue)
+            {
+                return DateTime.UtcNow - CompletedAt.Value >= delayAfter;
+            }
+
+            if (FirstRequestAt.HasValue && DateTime.UtcNow - FirstRequestAt.Value >= timeout)
+            {
+                throw new TimeoutException("Timeout");
+            }
+
+            if (!LastRequestTime.HasValue || DateTime.UtcNow - LastRequestTime.Value >= checkInterval)
+            {
+                LastRequestTime = DateTime.UtcNow;
+
+                if (!FirstRequestAt.HasValue)
+                {
+                    FirstRequestAt = LastRequestTime;
+                }
+
+                using var httpClient = GetHttpClient();
+                var request = new HttpRequestMessage(HttpMethod.Get, $"{BASE_URL}/action/{ActionId}");
+
+                try
+                {
+                    var response = await httpClient.SendAsync(request);
+                    var result = await response.Content.ReadAsStringAsync();
+
+
+                    if (result.Contains("success"))
+                    {
+                        CompletedAt = DateTime.UtcNow;
+                        return DateTime.UtcNow - CompletedAt.Value >= delayAfter;
+                    }
+                }
+                catch (HttpRequestException e)
+                {
+                    throw new Exception("Fault injection proxy error", e);
+                }
+            }
+            return false;
+        }
+    }
+
+    private static HttpClient GetHttpClient()
+    {
+        var httpClient = new HttpClient
+        {
+            Timeout = TimeSpan.FromMilliseconds(5000)
+        };
+        return httpClient;
+    }
+
+    public async Task<TriggerActionResponse> TriggerActionAsync(string actionType, Dictionary<string, object> parameters)
+    {
+        var payload = new Dictionary<string, object>
+    {
+      { "type", actionType },
+      { "parameters", parameters }
+    };
+
+        var jsonString = JsonSerializer.Serialize(payload, new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+        });
+
+        using var httpClient = GetHttpClient();
+        var request = new HttpRequestMessage(HttpMethod.Post, $"{BASE_URL}/action")
+        {
+            Content = new StringContent(jsonString, Encoding.UTF8, "application/json")
+        };
+
+        try
+        {
+            var response = await httpClient.SendAsync(request);
+            var result = await response.Content.ReadAsStringAsync();
+            return JsonSerializer.Deserialize<TriggerActionResponse>(result, new JsonSerializerOptions
+            {
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+            });
+        }
+        catch (HttpRequestException e)
+        {
+            throw;
+        }
+    }
+}