Modify tests to allow new content mode design for runtime components.

- Added a new internal ctor for TagHelperExecutionContext since it's used in multiple tests to allow for less friction testing.

#221

Author: N. Taylor Mullen

src/Microsoft.AspNet.Razor.Runtime/TagHelpers/TagHelperExecutionContext.cs

@@ -19,6 +19,18 @@ public class TagHelperExecutionContext
         private readonly Func<TextWriter> _endWritingScope;
         private string _childContent;
 
+        /// <summary>
+        /// Internal for testing purposes only.
+        /// </summary>
+        internal TagHelperExecutionContext(string tagName)
+            : this(tagName,
+                   uniqueId: string.Empty,
+                   executeChildContentAsync: async () => await Task.FromResult(result: true),
+                   startWritingScope: () => { },
+                   endWritingScope: () => new StringWriter())
+        {
+        }
+
         /// <summary>
         /// Instantiates a new <see cref="TagHelperExecutionContext"/>.
         /// </summary>

src/Microsoft.AspNet.Razor.Runtime/TagHelpers/TagHelperOutput.cs

@@ -24,12 +24,6 @@ internal TagHelperOutput(string tagName)
             Attributes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         }
 
-        // Internal for testing
-        internal TagHelperOutput(string tagName, [NotNull] IDictionary<string, string> attributes)
-            : this(tagName, attributes, string.Empty)
-        {
-        }
-
         /// <summary>
         /// Instantiates a new instance of <see cref="TagHelperOutput"/>.
         /// </summary>

test/Microsoft.AspNet.Razor.Runtime.Test/TagHelpers/TagHelperExecutionContextTest.cs

@@ -1,14 +1,75 @@
 // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace Microsoft.AspNet.Razor.Runtime.TagHelpers
 {
     public class TagHelperExecutionContextTest
     {
+        [Fact]
+        public async Task GetChildContentAsync_CachesValue()
+        {
+            // Arrange
+            var writer = new StringWriter();
+            var expectedContent = string.Empty;
+            var executionContext = new TagHelperExecutionContext(
+                "p",
+                uniqueId: string.Empty,
+                executeChildContentAsync: () =>
+                {
+                    if (string.IsNullOrEmpty(expectedContent))
+                    {
+                        expectedContent = "Hello from child content: " + Guid.NewGuid().ToString();
+                    }
+
+                    writer.Write(expectedContent);
+
+                    return Task.FromResult(result: true);
+                },
+                startWritingScope: () => { },
+                endWritingScope: () => writer);
+
+            // Act
+            var content1 = await executionContext.GetChildContentAsync();
+            var content2 = await executionContext.GetChildContentAsync();
+
+            // Assert
+            Assert.Equal(expectedContent, content1);
+            Assert.Equal(expectedContent, content2);
+        }
+
+        [Fact]
+        public async Task ExecuteChildContentAsync_IsNotMemoized()
+        {
+            // Arrange
+            var childContentExecutionCount = 0;
+            var executionContext = new TagHelperExecutionContext(
+                "p",
+                uniqueId: string.Empty,
+                executeChildContentAsync: () =>
+                {
+                    childContentExecutionCount++;
+
+                    return Task.FromResult(result: true);
+                },
+                startWritingScope: () => { },
+                endWritingScope: () => new StringWriter());
+
+            // Act
+            await executionContext.ExecuteChildContentAsync();
+            await executionContext.ExecuteChildContentAsync();
+            await executionContext.ExecuteChildContentAsync();
+
+            // Assert
+            Assert.Equal(3, childContentExecutionCount);
+        }
+
         public static TheoryData<string, string> DictionaryCaseTestingData
         {
             get

test/Microsoft.AspNet.Razor.Runtime.Test/TagHelpers/TagHelperOutputTest.cs

@@ -9,17 +9,17 @@ namespace Microsoft.AspNet.Razor.Runtime.TagHelpers
     public class TagHelperOutputTest
     {
         [Fact]
-        public void TagName_CannotSetToNullInCtor()
+        public void TagName_CanSetToNullInCtor()
         {
             // Arrange & Act
             var tagHelperOutput = new TagHelperOutput(null);
 
             // Assert
-            Assert.Empty(tagHelperOutput.TagName);
+            Assert.Null(tagHelperOutput.TagName);
         }
 
         [Fact]
-        public void TagName_CannotSetToNull()
+        public void TagName_CanSetToNull()
         {
             // Arrange
             var tagHelperOutput = new TagHelperOutput("p");
@@ -28,11 +28,11 @@ public void TagName_CannotSetToNull()
             tagHelperOutput.TagName = null;
 
             // Assert
-            Assert.Empty(tagHelperOutput.TagName);
+            Assert.Null(tagHelperOutput.TagName);
         }
 
         [Fact]
-        public void Content_CannotSetToNull()
+        public void Content_CanSetToNull()
         {
             // Arrange
             var tagHelperOutput = new TagHelperOutput("p");
@@ -41,7 +41,33 @@ public void Content_CannotSetToNull()
             tagHelperOutput.Content = null;
 
             // Assert
-            Assert.Empty(tagHelperOutput.Content);
+            Assert.Null(tagHelperOutput.Content);
+        }
+
+        [Fact]
+        public void PreContent_CanSetToNull()
+        {
+            // Arrange
+            var tagHelperOutput = new TagHelperOutput("p");
+
+            // Act
+            tagHelperOutput.PreContent = null;
+
+            // Assert
+            Assert.Null(tagHelperOutput.PreContent);
+        }
+
+        [Fact]
+        public void PostContent_CanSetToNull()
+        {
+            // Arrange
+            var tagHelperOutput = new TagHelperOutput("p");
+
+            // Act
+            tagHelperOutput.PostContent = null;
+
+            // Assert
+            Assert.Null(tagHelperOutput.PostContent);
         }
 
         [Fact]
@@ -146,6 +172,39 @@ public void GenerateEndTag_ReturnsNothingIfWhitespaceTagName()
             Assert.Empty(output);
         }
 
+        [Fact]
+        public void GeneratePreContent_ReturnsPreContent()
+        {
+            // Arrange
+            var tagHelperOutput = new TagHelperOutput("p");
+
+            tagHelperOutput.PreContent = "Hello World";
+
+            // Act
+            var output = tagHelperOutput.GeneratePreContent();
+
+            // Assert
+            Assert.Equal("Hello World", output);
+        }
+
+        [Fact]
+        public void GeneratePreContent_ReturnsNothingIfSelfClosing()
+        {
+            // Arrange
+            var tagHelperOutput = new TagHelperOutput("p")
+            {
+                SelfClosing = true
+            };
+
+            tagHelperOutput.PreContent = "Hello World";
+
+            // Act
+            var output = tagHelperOutput.GeneratePreContent();
+
+            // Assert
+            Assert.Empty(output);
+        }
+
         [Fact]
         public void GenerateContent_ReturnsContent()
         {
@@ -180,6 +239,39 @@ public void GenerateContent_ReturnsNothingIfSelfClosing()
             Assert.Empty(output);
         }
 
+        [Fact]
+        public void GeneratePostContent_ReturnsPreContent()
+        {
+            // Arrange
+            var tagHelperOutput = new TagHelperOutput("p");
+
+            tagHelperOutput.PostContent = "Hello World";
+
+            // Act
+            var output = tagHelperOutput.GeneratePostContent();
+
+            // Assert
+            Assert.Equal("Hello World", output);
+        }
+
+        [Fact]
+        public void GeneratePostContent_ReturnsNothingIfSelfClosing()
+        {
+            // Arrange
+            var tagHelperOutput = new TagHelperOutput("p")
+            {
+                SelfClosing = true
+            };
+
+            tagHelperOutput.PostContent = "Hello World";
+
+            // Act
+            var output = tagHelperOutput.GeneratePostContent();
+
+            // Assert
+            Assert.Empty(output);
+        }
+
         [Fact]
         public void GenerateEndTag_ReturnsEndTag()
         {
@@ -209,6 +301,56 @@ public void GenerateEndTag_ReturnsNothingIfSelfClosing()
             Assert.Empty(output);
         }
 
+        [Fact]
+        public void SupressOutput_Sets_TagName_Content_PreContent_PostContent_ToNull()
+        {
+            // Arrange
+            var tagHelperOutput = new TagHelperOutput("p")
+            {
+                PreContent = "Pre Content",
+                Content = "Content",
+                PostContent = "Post Content"
+            };
+
+            // Act
+            tagHelperOutput.SupressOutput();
+
+            // Assert
+            Assert.Null(tagHelperOutput.TagName);
+            Assert.Null(tagHelperOutput.PreContent);
+            Assert.Null(tagHelperOutput.Content);
+            Assert.Null(tagHelperOutput.PostContent);
+        }
+
+        [Fact]
+        public void SupressOutput_PreventsTagOutput()
+        {
+            // Arrange
+            var tagHelperOutput = new TagHelperOutput("p",
+                attributes: new Dictionary<string, string>
+                {
+                    { "class", "btn" },
+                    { "something", "   spaced    " }
+                })
+            {
+                PreContent = "Pre Content",
+                Content = "Content",
+                PostContent = "Post Content"
+            };
+
+            // Act
+            tagHelperOutput.SupressOutput();
+
+            var output = tagHelperOutput.GenerateStartTag() +
+                         tagHelperOutput.GeneratePreContent() +
+                         tagHelperOutput.GenerateContent() +
+                         tagHelperOutput.GeneratePostContent() +
+                         tagHelperOutput.GenerateEndTag();
+
+            // Assert
+            Assert.Empty(output);
+        }
+
         [Theory]
         [InlineData("class", "ClASs")]
         [InlineData("CLaSs", "class")]

test/Microsoft.AspNet.Razor.Runtime.Test/TagHelpers/TagHelperRunnerTest.cs

@@ -66,23 +66,6 @@ public async Task RunAsync_AllowsDataRetrievalFromTagHelperContext()
             Assert.Equal("True", output.Attributes["foo"]);
         }
 
-        [Fact]
-        public async Task RunAsync_WithContentSetsOutputsContent()
-        {
-            // Arrange
-            var runner = new TagHelperRunner();
-            var executionContext = new TagHelperExecutionContext("p");
-            var tagHelper = new ExecutableTagHelper();
-            var contentWriter = new StringWriter(new StringBuilder("Hello World"));
-
-            // Act
-            executionContext.Add(tagHelper);
-            var output = await runner.RunAsync(executionContext, contentWriter);
-
-            // Assert
-            Assert.Equal(output.Content, "Hello World");
-        }
-
         private class ExecutableTagHelper : TagHelper
         {
             public bool Processed { get; set; }