Fix test to work with TH rewriters.

- Added understanding to the ParserTestBase for TagHelperBlock's
- Added a helper class MarkupTagHelperBlock to make building test TagHelpers easier.
- Fixed some existing tests that "new"d up the RazorParser and didn't obide by the new contract (to provide optimizers).

#71

test/Microsoft.AspNet.Razor.Test/Framework/BlockTypes.cs

@@ -2,8 +2,10 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.AspNet.Razor.Generator;
 using Microsoft.AspNet.Razor.Parser.SyntaxTree;
+using Microsoft.AspNet.Razor.Parser.TagHelpers;
 
 namespace Microsoft.AspNet.Razor.Test.Framework
 {
@@ -174,6 +176,33 @@ public MarkupBlock(IEnumerable<SyntaxTreeNode> children)
         }
     }
 
+    public class MarkupTagHelperBlock : TagHelperBlock
+    {
+        public MarkupTagHelperBlock(string tagName)
+            : this(tagName, new Dictionary<string, SyntaxTreeNode>())
+        {
+        }
+
+        public MarkupTagHelperBlock(string tagName, 
+                                    IDictionary<string, SyntaxTreeNode> attributes)
+            : this(tagName, attributes, new SyntaxTreeNode[0])
+        {
+        }
+
+        public MarkupTagHelperBlock(string tagName,
+                                    params SyntaxTreeNode[] children)
+            : this(tagName, new Dictionary<string, SyntaxTreeNode>(), children)
+        {
+        }
+
+        public MarkupTagHelperBlock(string tagName,
+                                    IDictionary<string, SyntaxTreeNode> attributes,
+                                    params SyntaxTreeNode[] children)
+            : base(new TagHelperBlockBuilder(tagName, attributes, children))
+        {
+        }
+    }
+
     public class SectionBlock : Block
     {
         private const BlockType ThisBlockType = BlockType.Section;

test/Microsoft.AspNet.Razor.Test/Framework/ParserTestBase.cs

@@ -11,6 +11,7 @@
 using Microsoft.AspNet.Razor.Generator;
 using Microsoft.AspNet.Razor.Parser;
 using Microsoft.AspNet.Razor.Parser.SyntaxTree;
+using Microsoft.AspNet.Razor.Parser.TagHelpers;
 using Microsoft.AspNet.Razor.Text;
 using Xunit;
 
@@ -291,6 +292,22 @@ private static void EvaluateSyntaxTreeNode(ErrorCollector collector, SyntaxTreeN
             }
         }
 
+        private static void EvaluateTagHelperAttribute(ErrorCollector collector,
+                                                       KeyValuePair<string, SyntaxTreeNode> actual,
+                                                       KeyValuePair<string, SyntaxTreeNode> expected)
+        {
+            if (actual.Key != expected.Key)
+            {
+                collector.AddError("{0} - FAILED :: Attribute names do not match", expected.Key);
+            }
+            else
+            {
+                collector.AddMessage("{0} - PASSED :: Attribute names match", expected.Key);
+            }
+
+            EvaluateSyntaxTreeNode(collector, actual.Value, expected.Value);
+        }
+
         private static void EvaluateSpan(ErrorCollector collector, Span actual, Span expected)
         {
             if (!Equals(expected, actual))
@@ -311,11 +328,16 @@ private static void EvaluateBlock(ErrorCollector collector, Block actual, Block
             }
             else
             {
+                if (actual is TagHelperBlock)
+                {
+                    EvaluateTagHelperBlock(collector, actual as TagHelperBlock, expected as TagHelperBlock);
+                }
+
                 AddPassedMessage(collector, expected);
                 using (collector.Indent())
                 {
-                    IEnumerator<SyntaxTreeNode> expectedNodes = expected.Children.GetEnumerator();
-                    IEnumerator<SyntaxTreeNode> actualNodes = actual.Children.GetEnumerator();
+                    var expectedNodes = expected.Children.GetEnumerator();
+                    var actualNodes = actual.Children.GetEnumerator();
                     while (expectedNodes.MoveNext())
                     {
                         if (!actualNodes.MoveNext())
@@ -335,6 +357,35 @@ private static void EvaluateBlock(ErrorCollector collector, Block actual, Block
             }
         }
 
+        private static void EvaluateTagHelperBlock(ErrorCollector collector, TagHelperBlock actual, TagHelperBlock expected)
+        {
+            if (expected == null)
+            {
+                AddMismatchError(collector, actual, expected);
+            }
+            else
+            {
+                IEnumerator<KeyValuePair<string, SyntaxTreeNode>> expectedAttributes = expected.Attributes.GetEnumerator();
+                IEnumerator<KeyValuePair<string, SyntaxTreeNode>> actualAttributes = actual.Attributes.GetEnumerator();
+
+                while (expectedAttributes.MoveNext())
+                {
+                    if (!actualAttributes.MoveNext())
+                    {
+                        collector.AddError("{0} - FAILED :: No more attributes on this node", expectedAttributes.Current);
+                    }
+                    else
+                    {
+                        EvaluateTagHelperAttribute(collector, actualAttributes.Current, expectedAttributes.Current);
+                    }
+                }
+                while (actualAttributes.MoveNext())
+                {
+                    collector.AddError("End of Attributes - FAILED :: Found Attribute: {0}", actualAttributes.Current.Key);
+                }
+            }
+        }
+
         private static void AddPassedMessage(ErrorCollector collector, SyntaxTreeNode expected)
         {
             collector.AddMessage("{0} - PASSED", expected);

test/Microsoft.AspNet.Razor.Test/Parser/BlockTest.cs

@@ -28,24 +28,6 @@ public void ConstructorWithBlockBuilderSetsParent()
             Assert.Same(block, span.Parent);
         }
 
-        [Fact]
-        public void ConstructorCopiesBasicValuesFromBlockBuilder()
-        {
-            // Arrange
-            BlockBuilder builder = new BlockBuilder()
-            {
-                Name = "Foo",
-                Type = BlockType.Helper
-            };
-
-            // Act
-            Block actual = builder.Build();
-
-            // Assert
-            Assert.Equal("Foo", actual.Name);
-            Assert.Equal(BlockType.Helper, actual.Type);
-        }
-
         [Fact]
         public void ConstructorTransfersInstanceOfCodeGeneratorFromBlockBuilder()
         {