Add comprehensive tests and update AstVisitor/AstRewriter

Co-authored-by: sebastienros <1165805+sebastienros@users.noreply.github.com>

Author: Copilot

Fluid.Tests/CaseStatementTests.cs

@@ -311,5 +311,106 @@ public async Task CaseEvaluateMultipleMatchingBlocks()
 
             Assert.Equal("foobarbar", output);
         }
+
+        [Fact]
+        public async Task CaseWithOrSeparatedWhenExpression()
+        {
+            var parser = new FluidParser();
+            var template = "{% case title %}{% when 'foo' %}foo{% when 'bar' or 'Hello' %}bar{% endcase %}";
+            
+            var result = parser.Parse(template);
+            var context = new TemplateContext();
+            context.SetValue("title", "Hello");
+            var output = await result.RenderAsync(context);
+            
+            Assert.Equal("bar", output);
+        }
+
+        [Fact]
+        public async Task CaseWithCommaSeparatedWhenExpression()
+        {
+            var parser = new FluidParser();
+            var template = "{% case title %}{% when 'foo' %}foo{% when 'bar', 'Hello' %}bar{% endcase %}";
+            
+            var result = parser.Parse(template);
+            var context = new TemplateContext();
+            context.SetValue("title", "Hello");
+            var output = await result.RenderAsync(context);
+            
+            Assert.Equal("bar", output);
+        }
+
+        [Fact]
+        public async Task CaseMixOrAndCommaSeparatedWhenExpression()
+        {
+            var parser = new FluidParser();
+            var template = "{% case title %}{% when 'foo' %}foo{% when 'bar' or 'Hello', 'Hello' %}bar{% endcase %}";
+            
+            var result = parser.Parse(template);
+            var context = new TemplateContext();
+            context.SetValue("title", "Hello");
+            var output = await result.RenderAsync(context);
+            
+            // Both 'bar' or 'Hello' and 'Hello' match, so bar is output twice
+            Assert.Equal("barbar", output);
+        }
+
+        [Fact]
+        public async Task CaseNoWhensOnlyElse()
+        {
+            var parser = new FluidParser();
+            var template = "{% case title %}{% else %}bar{% endcase %}";
+            
+            var result = parser.Parse(template);
+            var context = new TemplateContext();
+            context.SetValue("title", "Hello");
+            var output = await result.RenderAsync(context);
+            
+            Assert.Equal("bar", output);
+        }
+
+        [Fact]
+        public async Task CaseNoWhensNoElse()
+        {
+            var parser = new FluidParser();
+            var template = "{% case title %}{% endcase %}";
+            
+            var result = parser.Parse(template);
+            var context = new TemplateContext();
+            context.SetValue("title", "Hello");
+            var output = await result.RenderAsync(context);
+            
+            Assert.Equal("", output);
+        }
+
+        [Fact]
+        public async Task CaseWhenExpressionUsingIdentifier()
+        {
+            var parser = new FluidParser();
+            var template = "{% case title %}{% when other %}foo{% when 'goodbye' %}bar{% endcase %}";
+            
+            var result = parser.Parse(template);
+            var context = new TemplateContext();
+            context.SetValue("title", "Hello");
+            context.SetValue("other", "Hello");
+            var output = await result.RenderAsync(context);
+            
+            Assert.Equal("foo", output);
+        }
+
+        [Fact]
+        public async Task CaseTagsInsideWhenBlock()
+        {
+            var parser = new FluidParser();
+            var template = "{% case title %}{% when other %}{% if true %}foo{% endif %}{% when 'goodbye' %}bar{% endcase %}";
+            
+            var result = parser.Parse(template);
+            var context = new TemplateContext();
+            context.SetValue("title", "Hello");
+            context.SetValue("other", "Hello");
+            var output = await result.RenderAsync(context);
+            
+            Assert.Equal("foo", output);
+        }
     }
 }

Fluid/Ast/AstRewriter.cs

@@ -276,11 +276,66 @@ protected internal override Statement VisitCaptureStatement(CaptureStatement cap
 
         protected internal override Statement VisitCaseStatement(CaseStatement caseStatement)
         {
-            if (TryRewriteExpression(caseStatement.Expression, out var newExpression)
+            // Handle new block-based structure
+            if (caseStatement.Blocks.Count > 0)
+            {
+                var hasChanges = false;
+                var newBlocks = new List<CaseBlock>();
+                
+                if (TryRewriteExpression(caseStatement.Expression, out var newExpression))
+                {
+                    hasChanges = true;
+                }
+                else
+                {
+                    newExpression = caseStatement.Expression;
+                }
+
+                foreach (var block in caseStatement.Blocks)
+                {
+                    if (block is WhenBlock whenBlock)
+                    {
+                        var optionsChanged = TryRewriteExpressions(whenBlock.Options, out var newOptions);
+                        var statementsChanged = TryRewriteStatements(whenBlock.Statements, out var newStatements);
+                        
+                        if (optionsChanged || statementsChanged)
+                        {
+                            hasChanges = true;
+                            newBlocks.Add(new WhenBlock(newOptions.ToArray(), newStatements.ToArray()));
+                        }
+                        else
+                        {
+                            newBlocks.Add(block);
+                        }
+                    }
+                    else if (block is ElseBlock elseBlock)
+                    {
+                        if (TryRewriteStatements(elseBlock.Statements, out var newStatements))
+                        {
+                            hasChanges = true;
+                            newBlocks.Add(new ElseBlock(newStatements.ToArray()));
+                        }
+                        else
+                        {
+                            newBlocks.Add(block);
+                        }
+                    }
+                }
+
+                if (hasChanges)
+                {
+                    return new CaseStatement(newExpression, newBlocks.ToArray());
+                }
+
+                return caseStatement;
+            }
+            
+            // Handle old structure for backward compatibility
+            if (TryRewriteExpression(caseStatement.Expression, out var newExpression2)
                 | TryRewriteStatement(caseStatement.Else, out var newElseStatement)
                 | TryRewriteStatements(caseStatement.Whens, out var newWhenStatements))
             {
-                return new CaseStatement(newExpression, newElseStatement, newWhenStatements.ToArray());
+                return new CaseStatement(newExpression2, newElseStatement, newWhenStatements.ToArray());
             }
 
             return caseStatement;

Fluid/Ast/AstVisitor.cs

@@ -204,12 +204,41 @@ protected internal virtual Statement VisitCaseStatement(CaseStatement caseStatem
 
             Visit(caseStatement.Expression);
 
-            foreach (var statement in caseStatement.Whens)
+            // Visit new block-based structure if present
+            if (caseStatement.Blocks.Count > 0)
             {
-                Visit(statement);
+                foreach (var block in caseStatement.Blocks)
+                {
+                    if (block is WhenBlock whenBlock)
+                    {
+                        foreach (var option in whenBlock.Options)
+                        {
+                            Visit(option);
+                        }
+                        foreach (var statement in whenBlock.Statements)
+                        {
+                            Visit(statement);
+                        }
+                    }
+                    else if (block is ElseBlock elseBlock)
+                    {
+                        foreach (var statement in elseBlock.Statements)
+                        {
+                            Visit(statement);
+                        }
+                    }
+                }
             }
+            else
+            {
+                // Visit old structure for backward compatibility
+                foreach (var statement in caseStatement.Whens)
+                {
+                    Visit(statement);
+                }
 
-            Visit(caseStatement.Else);
+                Visit(caseStatement.Else);
+            }
 
             return caseStatement;
         }