CompositeExpression is working

Author: darrelmiller

src/Microsoft.OpenApi/Expressions/CompositeExpression.cs

@@ -2,22 +2,44 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 namespace Microsoft.OpenApi.Expressions
 {
+    /// <summary>
+    /// String literal with embedded expressions
+    /// </summary>
     public class CompositeExpression : RuntimeExpression
     {
         private string template;
+        private Regex expressionPattern = new Regex("{(?<exp>[^}]+)");
+        /// <summary>
+        /// Expressions embedded into string literal
+        /// </summary>
+        public List<RuntimeExpression> ContainedExpressions = new List<RuntimeExpression>();
 
+        /// <summary>
+        /// Create a composite expression from a string literal with an embedded expression
+        /// </summary>
+        /// <param name="expression"></param>
         public CompositeExpression(string expression)
         {
             template = expression;
 
             // Extract subexpressions and convert to RuntimeExpressions
+            var matches = expressionPattern.Matches(expression);
 
+            foreach (var item in matches.Cast<Match>())
+            {
+                var value = item.Groups["exp"].Captures.Cast<Capture>().First().Value;
+                ContainedExpressions.Add(RuntimeExpression.Build(value));
+            }
         }
 
+        /// <summary>
+        /// Return original string literal with embedded expression
+        /// </summary>
         public override string Expression => template;
     }
 }

test/Microsoft.OpenApi.Tests/Expressions/RuntimeExpressionTests.cs

@@ -5,6 +5,7 @@
 using Microsoft.OpenApi.Expressions;
 using Microsoft.OpenApi.Properties;
 using System;
+using System.Linq;
 using Xunit;
 
 namespace Microsoft.OpenApi.Tests.Writers
@@ -171,5 +172,60 @@ public void CompareRuntimeExpressionWorks(string expression)
             Assert.NotSame(runtimeExpression1, runtimeExpression2);
             Assert.Equal(runtimeExpression1, runtimeExpression2);
         }
+
+
+        [Fact]
+        public void CompositeRuntimeExpressionContainsExpression()
+        {
+            // Arrange
+            string expression = "This is a composite expression {$url} yay";
+
+            // Act
+            var runtimeExpression = RuntimeExpression.Build(expression);
+
+            // Assert
+            Assert.NotNull(runtimeExpression);
+            var response = Assert.IsType<CompositeExpression>(runtimeExpression);
+            Assert.Equal(expression, response.Expression);
+
+            var compositeExpression = runtimeExpression as CompositeExpression;
+            Assert.Single(compositeExpression.ContainedExpressions);
+
+        }
+
+        [Fact]
+        public void CompositeRuntimeExpressionContainsMultipleExpressions()
+        {
+            // Arrange
+            string expression = "This is a composite expression {$url} yay and {$request.header.foo}";
+
+            // Act
+            var runtimeExpression = RuntimeExpression.Build(expression);
+
+            // Assert
+            Assert.NotNull(runtimeExpression);
+            var response = Assert.IsType<CompositeExpression>(runtimeExpression);
+            Assert.Equal(expression, response.Expression);
+
+            var compositeExpression = runtimeExpression as CompositeExpression;
+            Assert.Equal(2,compositeExpression.ContainedExpressions.Count);
+
+            Assert.IsType<UrlExpression>(compositeExpression.ContainedExpressions.First());
+            Assert.IsType<RequestExpression>(compositeExpression.ContainedExpressions.Last());
+        }
+
+        [Theory]
+        [InlineData("This is a composite expression  yay and {} and {$sddsd}")]
+        [InlineData("This is a composite expression {url} yay and {} and {$url}")]
+        public void CompositeRuntimeExpressionContainsInvalidExpressions(string expression)
+        {
+            // Arrange
+
+            // Act
+            Action test = () => RuntimeExpression.Build(expression);
+
+            // Assert
+            Assert.Throws<OpenApiException>(test);
+        }
     }
 }