fix: Address issues when evaluating the context in the InMemoryProvider

src/OpenFeature/Providers/Memory/Flag.cs

@@ -36,41 +36,52 @@ public Flag(Dictionary<string, T> variants, string defaultVariant, Func<Evaluati
 
     internal ResolutionDetails<T> Evaluate(string flagKey, T _, EvaluationContext? evaluationContext)
     {
-        T? value;
         if (this._contextEvaluator == null)
         {
-            if (this._variants.TryGetValue(this._defaultVariant, out value))
-            {
-                return new ResolutionDetails<T>(
-                    flagKey,
-                    value,
-                    variant: this._defaultVariant,
-                    reason: Reason.Static,
-                    flagMetadata: this._flagMetadata
-                );
-            }
-            else
-            {
-                throw new GeneralException($"variant {this._defaultVariant} not found");
-            }
+            return this.EvaluateDefaultVariant(flagKey);
+        }
+
+        string variant;
+        try
+        {
+            variant = this._contextEvaluator.Invoke(evaluationContext ?? EvaluationContext.Empty);
+        }
+        catch (Exception)
+        {
+            return this.EvaluateDefaultVariant(flagKey, Reason.Default);
+        }
+
+        if (!this._variants.TryGetValue(variant, out var value))
+        {
+            return this.EvaluateDefaultVariant(flagKey, Reason.Default);
+        }
+        else
+        {
+            return new ResolutionDetails<T>(
+                flagKey,
+                value,
+                variant: variant,
+                reason: Reason.TargetingMatch,
+                flagMetadata: this._flagMetadata
+            );
+        }
+    }
+
+    private ResolutionDetails<T> EvaluateDefaultVariant(string flagKey, string reason = Reason.Static)
+    {
+        if (this._variants.TryGetValue(this._defaultVariant, out var value))
+        {
+            return new ResolutionDetails<T>(
+                flagKey,
+                value,
+                variant: this._defaultVariant,
+                reason: reason,
+                flagMetadata: this._flagMetadata
+            );
         }
         else
         {
-            var variant = this._contextEvaluator.Invoke(evaluationContext ?? EvaluationContext.Empty);
-            if (!this._variants.TryGetValue(variant, out value))
-            {
-                throw new GeneralException($"variant {variant} not found");
-            }
-            else
-            {
-                return new ResolutionDetails<T>(
-                    flagKey,
-                    value,
-                    variant: variant,
-                    reason: Reason.TargetingMatch,
-                    flagMetadata: this._flagMetadata
-                );
-            }
+            throw new GeneralException($"variant {this._defaultVariant} not found");
         }
     }
 }

test/OpenFeature.Tests/Providers/Memory/InMemoryProviderTests.cs

@@ -98,6 +98,18 @@ public InMemoryProviderTests()
                         return "missing";
                     }
                 )
+            },
+            {
+                "evaluator-throws-flag", new Flag<bool>(
+                    variants: new Dictionary<string, bool>(){
+                        { "on", true },
+                        { "off", false }
+                    },
+                    defaultVariant: "on",
+                    (context) => {
+                        throw new Exception("Cannot evaluate flag at the moment.");
+                    }
+                )
             }
         });
 
@@ -198,9 +210,25 @@ public async Task MissingDefaultVariant_ShouldThrow()
     }
 
     [Fact]
-    public async Task MissingEvaluatedVariant_ShouldThrow()
+    public async Task MissingEvaluatedVariant_ReturnsDefaultVariant()
     {
-        await Assert.ThrowsAsync<GeneralException>(() => this.commonProvider.ResolveBooleanValueAsync("invalid-evaluator-flag", false, EvaluationContext.Empty));
+        // Act
+        var result = await this.commonProvider.ResolveBooleanValueAsync("invalid-evaluator-flag", false, EvaluationContext.Empty);
+
+        // Assert
+        Assert.True(result.Value);
+        Assert.Equal(Reason.Default, result.Reason);
+    }
+
+    [Fact]
+    public async Task ContextEvaluatorThrows_ReturnsDefaultVariant()
+    {
+        // Act
+        var result = await this.commonProvider.ResolveBooleanValueAsync("evaluator-throws-flag", false, EvaluationContext.Empty);
+
+        // Assert
+        Assert.True(result.Value);
+        Assert.Equal(Reason.Default, result.Reason);
     }
 
     [Fact]