public void TreesAreDifferentReturnsTrueIfTreeStructureIsDifferent()
{
var factory = SpanFactory.CreateCsHtml();
var original = new MarkupBlock(
factory.Markup("<p>"),
new ExpressionBlock(
factory.CodeTransition()),
factory.Markup("</p>"));
var modified = new MarkupBlock(
factory.Markup("<p>"),
new ExpressionBlock(
factory.CodeTransition("@"),
factory.Code("f")
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)),
factory.Markup("</p>"));
var oldBuffer = new StringTextBuffer("<p>@</p>");
var newBuffer = new StringTextBuffer("<p>@f</p>");
Assert.True(BackgroundParser.TreesAreDifferent(
original,
modified,
new[]
{
new TextChange(position: 4, oldLength: 0, oldBuffer: oldBuffer, newLength: 1, newBuffer: newBuffer)
}));
}
public void TreesAreDifferentReturnsFalseIfTreeStructureIsSame()
{
var factory = SpanFactory.CreateCsHtml();
Block original = new MarkupBlock(
factory.Markup("<p>"),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code("f")
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)),
factory.Markup("</p>"));
factory.Reset();
Block modified = new MarkupBlock(
factory.Markup("<p>"),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code("foo")
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)),
factory.Markup("</p>"));
original.LinkNodes();
modified.LinkNodes();
ITextBuffer oldBuffer = new StringTextBuffer("<p>@f</p>");
ITextBuffer newBuffer = new StringTextBuffer("<p>@foo</p>");
Assert.False(BackgroundParser.TreesAreDifferent(
original, modified, new[] {
new TextChange(position: 5, oldLength: 0, oldBuffer: oldBuffer, newLength: 2, newBuffer: newBuffer)
}));
}
public void Rewrite_Moves_Whitespace_Preceeding_ExpressionBlock_To_Parent_Block()
{
// Arrange
var factory = SpanFactory.CreateCsHtml();
var start = new MarkupBlock(
factory.Markup("test"),
new ExpressionBlock(
factory.Code(" ").AsExpression(),
factory.CodeTransition(SyntaxConstants.TransitionString),
factory.Code("foo").AsExpression()
),
factory.Markup("test")
);
var rewriter = new WhiteSpaceRewriter(new HtmlMarkupParser().BuildSpan);
var rewritingContext = new RewritingContext(start, new ErrorSink());
// Act
rewriter.Rewrite(rewritingContext);
factory.Reset();
// Assert
ParserTestBase.EvaluateParseTree(rewritingContext.SyntaxTree, new MarkupBlock(
factory.Markup("test"),
factory.Markup(" "),
new ExpressionBlock(
factory.CodeTransition(SyntaxConstants.TransitionString),
factory.Code("foo").AsExpression()
),
factory.Markup("test")
));
}
public void GetDescriptors_RemovesSpecifiedTagHelper()
{
// Arrange
var resolver = new TestTagHelperDescriptorResolver(
new Dictionary <string, IEnumerable <TagHelperDescriptor> >
{
{ "twoTagHelpers", new[] { PTagHelperDescriptor, DivTagHelperDescriptor } },
{ "singleTagHelper", new [] { PTagHelperDescriptor } }
});
var addOrRemoveTagHelperSpanVisitor = new AddOrRemoveTagHelperSpanVisitor(resolver);
var document = new MarkupBlock(
Factory.Code("\"twoTagHelpers\"").AsAddTagHelper("twoTagHelpers"),
Factory.Code("\"singleTagHelper\"").AsRemoveTagHelper("singleTagHelper"));
// Act
var descriptors = addOrRemoveTagHelperSpanVisitor.GetDescriptors(document);
// Assert
var descriptor = Assert.Single(descriptors);
Assert.Equal(DivTagHelperDescriptor, descriptor, TagHelperDescriptorComparer.Default);
Assert.Equal(2, resolver.Lookups.Count);
Assert.Contains("twoTagHelpers", resolver.Lookups);
Assert.Contains("singleTagHelper", resolver.Lookups);
}
public void GetDescriptors_LocatesTagHelperCodeGenerator_CreatesDirectiveDescriptors()
{
// Arrange
var resolver = new TestTagHelperDescriptorResolver();
var tagHelperDirectiveSpanVisitor = new TagHelperDirectiveSpanVisitor(resolver, new ParserErrorSink());
var document = new MarkupBlock(
Factory.Code("\"one\"").AsAddTagHelper("one"),
Factory.Code("\"two\"").AsRemoveTagHelper("two"),
Factory.Code("\"three\"").AsRemoveTagHelper("three"),
Factory.Code("\"four\"").AsTagHelperPrefixDirective("four"));
var expectedDescriptors = new TagHelperDirectiveDescriptor[]
{
new TagHelperDirectiveDescriptor("one", TagHelperDirectiveType.AddTagHelper),
new TagHelperDirectiveDescriptor("two", TagHelperDirectiveType.RemoveTagHelper),
new TagHelperDirectiveDescriptor("three", TagHelperDirectiveType.RemoveTagHelper),
new TagHelperDirectiveDescriptor("four", TagHelperDirectiveType.TagHelperPrefix),
};
// Act
tagHelperDirectiveSpanVisitor.GetDescriptors(document);
// Assert
Assert.Equal(
expectedDescriptors,
resolver.DirectiveDescriptors,
TagHelperDirectiveDescriptorComparer.Default);
}
public void ParseDocument_WithUnexpectedTransitionsInAttributeValue_Throws()
{
// Arrange
var expected = new MarkupBlock(
new MarkupTagBlock(
Factory.Markup("<span"),
new MarkupBlock(
new AttributeBlockChunkGenerator("foo", new LocationTagged <string>(" foo='", 5, 0, 5), new LocationTagged <string>("'", 14, 0, 14)),
Factory.Markup(" foo='").With(SpanChunkGenerator.Null),
new MarkupBlock(
new DynamicAttributeBlockChunkGenerator(new LocationTagged <string>(string.Empty, 11, 0, 11), 11, 0, 11),
new ExpressionBlock(
Factory.CodeTransition(),
Factory.EmptyCSharp().AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace))),
new MarkupBlock(
new DynamicAttributeBlockChunkGenerator(new LocationTagged <string>(" ", 12, 0, 12), 12, 0, 12),
Factory.Markup(" ").With(SpanChunkGenerator.Null),
new ExpressionBlock(
Factory.CodeTransition().Accepts(AcceptedCharacters.None).With(SpanChunkGenerator.Null),
Factory.EmptyCSharp().AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace))),
Factory.Markup("'").With(SpanChunkGenerator.Null)),
Factory.Markup(" />")));
var expectedErrors = new RazorError[]
{
new RazorError(@"A space or line break was encountered after the ""@"" character. Only valid identifiers, keywords, comments, ""("" and ""{"" are valid at the start of a code block and they must occur immediately following ""@"" with no space in between.", new SourceLocation(12, 0, 12)),
new RazorError(@"""' />"" is not valid at the start of a code block. Only identifiers, keywords, comments, ""("" and ""{"" are valid.", new SourceLocation(14, 0, 14)),
};
// Act & Assert
ParseDocumentTest("<span foo='@ @' />", expected, expectedErrors);
}
public void GetDescriptors_LocatesNestedRemoveTagHelperChunkGenerator()
{
// Arrange
var resolver = new TestTagHelperDescriptorResolver();
var tagHelperDirectiveSpanVisitor = new TagHelperDirectiveSpanVisitor(resolver, new ErrorSink());
var document = new MarkupBlock(
new DirectiveBlock(
Factory.CodeTransition(),
Factory.MetaCode(SyntaxConstants.CSharp.RemoveTagHelperKeyword + " ")
.Accepts(AcceptedCharacters.None),
Factory.Code("\"something\"").AsRemoveTagHelper("something"))
);
var expectedRegistration = new TagHelperDirectiveDescriptor
{
DirectiveText = "something",
DirectiveType = TagHelperDirectiveType.RemoveTagHelper
};
// Act
tagHelperDirectiveSpanVisitor.GetDescriptors(document);
// Assert
var directiveDescriptor = Assert.Single(resolver.DirectiveDescriptors);
Assert.Equal(expectedRegistration, directiveDescriptor, TagHelperDirectiveDescriptorComparer.Default);
}
public void GetDescriptors_LocatesTagHelperPrefixDirectiveCodeGenerator()
{
// Arrange
var resolver = new TestTagHelperDescriptorResolver();
var tagHelperDirectiveSpanVisitor = new TagHelperDirectiveSpanVisitor(resolver, new ParserErrorSink());
var document = new MarkupBlock(
new DirectiveBlock(
Factory.CodeTransition(),
Factory
.MetaCode(SyntaxConstants.CSharp.TagHelperPrefixKeyword + " ")
.Accepts(AcceptedCharacters.None),
Factory.Code("\"something\"").AsTagHelperPrefixDirective("something")));
var expectedDirectiveDescriptor =
new TagHelperDirectiveDescriptor("something", TagHelperDirectiveType.TagHelperPrefix);
// Act
tagHelperDirectiveSpanVisitor.GetDescriptors(document);
// Assert
var directiveDescriptor = Assert.Single(resolver.DirectiveDescriptors);
Assert.Equal(
expectedDirectiveDescriptor,
directiveDescriptor,
TagHelperDirectiveDescriptorComparer.Default);
}
public void GetDescriptors_LocatesNestedRemoveTagHelperCodeGenerator()
{
// Arrange
var resolver = new TestTagHelperDescriptorResolver(
new Dictionary <string, IEnumerable <TagHelperDescriptor> >
{
{ "something", new[] { PTagHelperDescriptor } }
});
var addOrRemoveTagHelperSpanVisitor = new AddOrRemoveTagHelperSpanVisitor(resolver);
var document = new MarkupBlock(
new DirectiveBlock(
Factory.CodeTransition(),
Factory.MetaCode(SyntaxConstants.CSharp.RemoveTagHelperKeyword + " ")
.Accepts(AcceptedCharacters.None),
Factory.Code("\"something\"").AsRemoveTagHelper("something"))
);
// Act
var descriptors = addOrRemoveTagHelperSpanVisitor.GetDescriptors(document);
// Assert
Assert.Empty(descriptors);
var lookup = Assert.Single(resolver.Lookups);
Assert.Equal("something", lookup);
}
public void TreesAreDifferentReturnsFalseForAddedContent(string content)
{
// Arrange
var factory = SpanFactory.CreateCsHtml();
var blockFactory = new BlockFactory(factory);
var original = new MarkupBlock(
blockFactory.MarkupTagBlock("<p>"),
blockFactory.TagHelperBlock(
tagName: "div",
tagMode: TagMode.StartTagAndEndTag,
start: new SourceLocation(3, 0, 3),
startTag: blockFactory.MarkupTagBlock("<div>"),
children: new SyntaxTreeNode[]
{
factory.Markup($"{Environment.NewLine}{Environment.NewLine}")
},
endTag: blockFactory.MarkupTagBlock("</div>")),
blockFactory.MarkupTagBlock("</p>"));
factory.Reset();
var modified = new MarkupBlock(
blockFactory.MarkupTagBlock("<p>"),
blockFactory.TagHelperBlock(
tagName: "div",
tagMode: TagMode.StartTagAndEndTag,
start: new SourceLocation(3, 0, 3),
startTag: blockFactory.MarkupTagBlock("<div>"),
children: new SyntaxTreeNode[]
{
factory.Markup($"{Environment.NewLine}{content}{Environment.NewLine}")
},
endTag: blockFactory.MarkupTagBlock("</div>")),
blockFactory.MarkupTagBlock("</p>"));
original.LinkNodes();
modified.LinkNodes();
var oldBuffer = new StringTextBuffer($"<p><div>{Environment.NewLine}{Environment.NewLine}</div></p>");
var newBuffer = new StringTextBuffer(
$"<p><div>{Environment.NewLine}{content}{Environment.NewLine}</div></p>");
// Act
var treesAreDifferent = BackgroundParser.TreesAreDifferent(
original,
modified,
new[]
{
new TextChange(
position: 8 + Environment.NewLine.Length,
oldLength: 0,
oldBuffer: oldBuffer,
newLength: content.Length,
newBuffer: newBuffer)
});
// Assert
Assert.False(treesAreDifferent);
}
public void GetDescriptors_RemoveTagHelperNotInDocument_DoesNotThrow()
{
// Arrange
var addOrRemoveTagHelperSpanVisitor = new AddOrRemoveTagHelperSpanVisitor(descriptorResolver: null);
var document = new MarkupBlock(Factory.Markup("Hello World"));
// Act & Assert
Assert.DoesNotThrow(() => addOrRemoveTagHelperSpanVisitor.GetDescriptors(document));
}
public void RunParseTreeRewriterTest(
string documentContent,
MarkupBlock expectedOutput,
IEnumerable <RazorError> errors,
params string[] tagNames)
{
var providerContext = BuildProviderContext(tagNames);
EvaluateData(providerContext, documentContent, expectedOutput, errors);
}
public void RunParseTreeRewriterTest(
string documentContent,
MarkupBlock expectedOutput,
IEnumerable<RazorError> errors,
params string[] tagNames)
{
var providerContext = BuildProviderContext(tagNames);
EvaluateData(providerContext, documentContent, expectedOutput, errors);
}
public void RunParseTreeRewriterTest(
string documentContent,
MarkupBlock expectedOutput,
params string[] tagNames)
{
RunParseTreeRewriterTest(
documentContent,
expectedOutput,
errors: Enumerable.Empty <RazorError>(),
tagNames: tagNames);
}
public void RunParseTreeRewriterTest(
string documentContent,
MarkupBlock expectedOutput,
params string[] tagNames)
{
RunParseTreeRewriterTest(
documentContent,
expectedOutput,
errors: Enumerable.Empty<RazorError>(),
tagNames: tagNames);
}
public void GetDescriptors_RemoveTagHelperNotInDocument_DoesNotThrow()
{
// Arrange
var tagHelperDirectiveSpanVisitor =
new TagHelperDirectiveSpanVisitor(
new TestTagHelperDescriptorResolver(),
new ErrorSink());
var document = new MarkupBlock(Factory.Markup("Hello World"));
// Act
var descriptors = tagHelperDirectiveSpanVisitor.GetDescriptors(document);
Assert.Empty(descriptors);
}
public void GetDescriptors_LocatesQuotedTagHelperDirectives_CreatesDirectiveDescriptors(
MarkupBlock document,
IEnumerable <TagHelperDirectiveDescriptor> expectedDescriptors)
{
// Arrange
var resolver = new TestTagHelperDescriptorResolver();
var tagHelperDirectiveSpanVisitor = new TagHelperDirectiveSpanVisitor(resolver, new ErrorSink());
// Act
tagHelperDirectiveSpanVisitor.GetDescriptors(document);
// Assert
Assert.Equal(
expectedDescriptors,
resolver.DirectiveDescriptors,
TagHelperDirectiveDescriptorComparer.Default);
}
public void EvaluateData(
TagHelperDescriptorProvider provider,
string documentContent,
MarkupBlock expectedOutput,
IEnumerable<RazorError> expectedErrors)
{
var errorSink = new ErrorSink();
var results = ParseDocument(documentContent, errorSink);
var rewritingContext = new RewritingContext(results.Document, errorSink);
new TagHelperParseTreeRewriter(provider).Rewrite(rewritingContext);
var rewritten = rewritingContext.SyntaxTree;
var actualErrors = errorSink.Errors.OrderBy(error => error.Location.AbsoluteIndex)
.ToList();
EvaluateRazorErrors(actualErrors, expectedErrors.ToList());
EvaluateParseTree(rewritten, expectedOutput);
}
public void GetDescriptors_RemoveTagHelperInDocument_ThrowsIfNullResolver()
{
// Arrange
var addOrRemoveTagHelperSpanVisitor = new AddOrRemoveTagHelperSpanVisitor(descriptorResolver: null);
var document = new MarkupBlock(
Factory.Code("\"something\"").AsRemoveTagHelper("something"));
var expectedMessage = "Cannot use directive 'removetaghelper' when a Microsoft.AspNet.Razor.TagHelpers." +
"ITagHelperDescriptorResolver has not been provided to the Microsoft.AspNet.Razor." +
"Parser.RazorParser.";
// Act & Assert
var ex = Assert.Throws <InvalidOperationException>(() =>
{
addOrRemoveTagHelperSpanVisitor.GetDescriptors(document);
});
Assert.Equal(expectedMessage, ex.Message);
}
public void LocateOwnerReturnsNullIfNoSpanReturnsTrueForOwnsSpan()
{
// Arrange
var factory = SpanFactory.CreateCsHtml();
Block block = new MarkupBlock(
factory.Markup("Foo "),
new StatementBlock(
factory.CodeTransition(),
factory.Code("bar").AsStatement()),
factory.Markup(" Baz"));
TextChange change = new TextChange(128, 1, new StringTextBuffer("Foo @bar Baz"), 1, new StringTextBuffer("Foo @bor Baz"));
// Act
Span actual = block.LocateOwner(change);
// Assert
Assert.Null(actual);
}
public void EvaluateData(
TagHelperDescriptorProvider provider,
string documentContent,
MarkupBlock expectedOutput,
IEnumerable <RazorError> expectedErrors)
{
var errorSink = new ErrorSink();
var results = ParseDocument(documentContent, errorSink);
var rewritingContext = new RewritingContext(results.Document, errorSink);
new TagHelperParseTreeRewriter(provider).Rewrite(rewritingContext);
var rewritten = rewritingContext.SyntaxTree;
var actualErrors = errorSink.Errors.OrderBy(error => error.Location.AbsoluteIndex)
.ToList();
EvaluateRazorErrors(actualErrors, expectedErrors.ToList());
EvaluateParseTree(rewritten, expectedOutput);
}
public void LocateOwnerReturnsNullIfChangeCrossesMultipleSpans()
{
// Arrange
var factory = SpanFactory.CreateCsHtml();
var block = new MarkupBlock(
factory.Markup("Foo "),
new StatementBlock(
factory.CodeTransition(),
factory.Code("bar").AsStatement()),
factory.Markup(" Baz"));
var change = new TextChange(4, 10, new StringTextBuffer("Foo @bar Baz"), 10, new StringTextBuffer("Foo @bor Baz"));
// Act
var actual = block.LocateOwner(change);
// Assert
Assert.Null(actual);
}
public void GetDescriptors_InvokesResolveForEachLookup()
{
// Arrange
var resolver = new Mock <ITagHelperDescriptorResolver>();
resolver.Setup(mock => mock.Resolve(It.IsAny <string>())).Returns(Enumerable.Empty <TagHelperDescriptor>());
var addOrRemoveTagHelperSpanVisitor = new AddOrRemoveTagHelperSpanVisitor(resolver.Object);
var document = new MarkupBlock(
Factory.Code("\"one\"").AsAddTagHelper("one"),
Factory.Code("\"two\"").AsRemoveTagHelper("two"),
Factory.Code("\"three\"").AsRemoveTagHelper("three"));
// Act
var descriptors = addOrRemoveTagHelperSpanVisitor.GetDescriptors(document);
// Assert
Assert.Empty(descriptors);
resolver.Verify(mock => mock.Resolve(It.IsAny <string>()), Times.Exactly(3));
}
public void LocateOwnerReturnsSpanWhichReturnsTrueForOwnsSpan()
{
// Arrange
Span expected = new CodeSpan(new SourceLocation(5, 0, 5), "bar");
Block block = new MarkupBlock(new SyntaxTreeNode[] {
new MarkupSpan(SourceLocation.Zero, "Foo "),
new StatementBlock(new SyntaxTreeNode[] {
new TransitionSpan(new SourceLocation(4, 0, 4), "@"),
expected,
}),
new MarkupSpan(new SourceLocation(8, 0, 8), " Baz")
});
TextChange change = new TextChange(6, 1, new StringTextBuffer("Foo @bar Baz"), 1, new StringTextBuffer("Foo @bor Baz"));
// Act
Span actual = block.LocateOwner(change);
// Assert
Assert.AreSame(expected, actual);
}
public void GetDescriptors_RemovesAddedTagHelpers()
{
// Arrange
var resolver = new TestTagHelperDescriptorResolver(
new Dictionary <string, IEnumerable <TagHelperDescriptor> >
{
{ "twoTagHelpers", new[] { PTagHelperDescriptor, DivTagHelperDescriptor } }
});
var addOrRemoveTagHelperSpanVisitor = new AddOrRemoveTagHelperSpanVisitor(resolver);
var document = new MarkupBlock(
Factory.Code("\"twoTagHelpers\"").AsAddTagHelper("twoTagHelpers"),
Factory.Code("\"twoTagHelpers\"").AsRemoveTagHelper("twoTagHelpers"));
// Act
var descriptors = addOrRemoveTagHelperSpanVisitor.GetDescriptors(document);
// Assert
Assert.Empty(descriptors);
Assert.Equal(Enumerable.Repeat("twoTagHelpers", 2), resolver.Lookups);
}
public void GetDescriptors_CanOverrideResolutionContext()
{
// Arrange
var resolver = new TestTagHelperDescriptorResolver();
var expectedInitialDirectiveDescriptors = new TagHelperDirectiveDescriptor[]
{
new TagHelperDirectiveDescriptor("one", TagHelperDirectiveType.AddTagHelper),
new TagHelperDirectiveDescriptor("two", TagHelperDirectiveType.RemoveTagHelper),
new TagHelperDirectiveDescriptor("three", TagHelperDirectiveType.RemoveTagHelper),
new TagHelperDirectiveDescriptor("four", TagHelperDirectiveType.TagHelperPrefix),
};
var expectedEndDirectiveDescriptors = new TagHelperDirectiveDescriptor[]
{
new TagHelperDirectiveDescriptor("custom", TagHelperDirectiveType.AddTagHelper)
};
var tagHelperDirectiveSpanVisitor = new CustomTagHelperDirectiveSpanVisitor(
resolver,
(descriptors, errorSink) =>
{
Assert.Equal(
expectedInitialDirectiveDescriptors,
descriptors,
TagHelperDirectiveDescriptorComparer.Default);
return(new TagHelperDescriptorResolutionContext(expectedEndDirectiveDescriptors, errorSink));
});
var document = new MarkupBlock(
Factory.Code("\"one\"").AsAddTagHelper("one"),
Factory.Code("\"two\"").AsRemoveTagHelper("two"),
Factory.Code("\"three\"").AsRemoveTagHelper("three"),
Factory.Code("\"four\"").AsTagHelperPrefixDirective("four"));
// Act
tagHelperDirectiveSpanVisitor.GetDescriptors(document);
// Assert
Assert.Equal(expectedEndDirectiveDescriptors,
resolver.DirectiveDescriptors,
TagHelperDirectiveDescriptorComparer.Default);
}
public void GetDescriptors_InvokesResolveOnceForAllDirectives()
{
// Arrange
var resolver = new Mock <ITagHelperDescriptorResolver>();
resolver.Setup(mock => mock.Resolve(It.IsAny <TagHelperDescriptorResolutionContext>()))
.Returns(Enumerable.Empty <TagHelperDescriptor>());
var addOrRemoveTagHelperSpanVisitor = new AddOrRemoveTagHelperSpanVisitor(
resolver.Object,
new ParserErrorSink());
var document = new MarkupBlock(
Factory.Code("\"one\"").AsAddTagHelper("one"),
Factory.Code("\"two\"").AsRemoveTagHelper("two"),
Factory.Code("\"three\"").AsRemoveTagHelper("three"));
// Act
addOrRemoveTagHelperSpanVisitor.GetDescriptors(document);
// Assert
resolver.Verify(mock => mock.Resolve(It.IsAny <TagHelperDescriptorResolutionContext>()), Times.Once);
}
public void HtmlCommentSupportsMultipleDashes(string documentContent, MarkupBlock expectedOutput)
{
ParseBlockTest(documentContent, expectedOutput);
}
public void Rewrite_RecoversWhenRequiredAttributeMismatchAndRestrictedChildren()
{
// Arrange
var factory = CreateDefaultSpanFactory();
var blockFactory = new BlockFactory(factory);
var documentContent = "<strong required><strong></strong></strong>";
var expectedErrors = new[] {
new RazorError(
RazorResources.FormatTagHelperParseTreeRewriter_InvalidNestedTag("strong", "strong", "br"),
absoluteIndex: 18,
lineIndex: 0,
columnIndex: 18,
length: 6)
};
var expectedOutput = new MarkupBlock(
new MarkupTagHelperBlock("strong",
new List<TagHelperAttributeNode>
{
new TagHelperAttributeNode("required", null, HtmlAttributeValueStyle.Minimized)
},
blockFactory.MarkupTagBlock("<strong>"),
blockFactory.MarkupTagBlock("</strong>")));
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "strong",
TypeName = "StrongTagHelper",
AssemblyName = "SomeAssembly",
RequiredAttributes = new[] { new TagHelperRequiredAttributeDescriptor { Name = "required" } },
AllowedChildren = new[] { "br" }
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors);
}
public void TagHelperParseTreeRewriter_UnderstandsTagHelpersInHtmlTypedScriptTags(
string documentContent,
MarkupBlock expectedOutput)
{
RunParseTreeRewriterTest(documentContent, expectedOutput, "p", "input");
}
public void TagHelperParseTreeRewriter_DoesNotRewriteSpecialTagTagHelpers(
string documentContent,
MarkupBlock expectedOutput)
{
RunParseTreeRewriterTest(documentContent, expectedOutput, "!--", "?xml", "![CDATA[", "!DOCTYPE");
}
public void Rewrite_AllowsTagHelperElementOptOutHTML(
string documentContent,
MarkupBlock expectedOutput,
RazorError[] expectedErrors)
{
RunParseTreeRewriterTest(documentContent, expectedOutput, expectedErrors, "strong", "p");
}
public void Rewrite_AllowsCompatibleTagStructures(
string documentContent,
TagStructure structure1,
TagStructure structure2,
MarkupBlock expectedOutput)
{
// Arrange
var factory = CreateDefaultSpanFactory();
var blockFactory = new BlockFactory(factory);
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper1",
AssemblyName = "SomeAssembly",
TagStructure = structure1
},
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper2",
AssemblyName = "SomeAssembly",
TagStructure = structure2
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors: new RazorError[0]);
}
private void RunSimpleWrappedMarkupTest(string prefix, string markup, string suffix, MarkupBlock expectedMarkup, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
{
ParseBlockTest(prefix + markup + suffix,
new StatementBlock(
Factory.Code(prefix).AsStatement(),
expectedMarkup,
Factory.Code(suffix).AsStatement().Accepts(acceptedCharacters)
));
}
private void RunSimpleWrappedMarkupTest(string prefix, string markup, string suffix, MarkupBlock expectedMarkup, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
{
ParseBlockTest(prefix + markup + suffix,
new StatementBlock(
Factory.Code(prefix).AsStatement(),
expectedMarkup,
Factory.Code(suffix).AsStatement().Accepts(acceptedCharacters)
));
}
public void Rewrite_UnderstandsMinimizedAttributes(
string documentContent,
MarkupBlock expectedOutput,
RazorError[] expectedErrors)
{
// Arrange
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper1",
AssemblyName = "SomeAssembly",
Attributes = new[]
{
new TagHelperAttributeDescriptor
{
Name = "bound-required-string",
PropertyName = "BoundRequiredString",
TypeName = typeof(string).FullName,
IsStringProperty = true
}
},
RequiredAttributes = new[]
{
new TagHelperRequiredAttributeDescriptor { Name = "unbound-required" }
}
},
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper1",
AssemblyName = "SomeAssembly",
Attributes = new[]
{
new TagHelperAttributeDescriptor
{
Name = "bound-required-string",
PropertyName = "BoundRequiredString",
TypeName = typeof(string).FullName,
IsStringProperty = true
}
},
RequiredAttributes = new[]
{
new TagHelperRequiredAttributeDescriptor { Name = "bound-required-string" }
}
},
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper2",
AssemblyName = "SomeAssembly",
Attributes = new[]
{
new TagHelperAttributeDescriptor
{
Name = "bound-required-int",
PropertyName = "BoundRequiredInt",
TypeName = typeof(int).FullName
}
},
RequiredAttributes = new[]
{
new TagHelperRequiredAttributeDescriptor { Name = "bound-required-int" }
}
},
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper3",
AssemblyName = "SomeAssembly",
Attributes = new[]
{
new TagHelperAttributeDescriptor
{
Name = "int-dictionary",
PropertyName ="DictionaryOfIntProperty",
TypeName = typeof(IDictionary<string, int>).FullName
},
new TagHelperAttributeDescriptor
{
Name = "string-dictionary",
PropertyName = "DictionaryOfStringProperty",
TypeName = typeof(IDictionary<string, string>).FullName
},
new TagHelperAttributeDescriptor
{
Name = "int-prefix-",
PropertyName = "DictionaryOfIntProperty",
TypeName = typeof(int).FullName,
IsIndexer = true
},
new TagHelperAttributeDescriptor
{
Name = "string-prefix-",
PropertyName = "DictionaryOfStringProperty",
TypeName = typeof(string).FullName,
IsIndexer = true,
IsStringProperty = true
}
}
},
new TagHelperDescriptor
{
TagName = "p",
TypeName = "PTagHelper",
AssemblyName = "SomeAssembly",
Attributes = new[]
{
new TagHelperAttributeDescriptor
{
Name = "bound-string",
PropertyName = "BoundRequiredString",
TypeName = typeof(string).FullName,
IsStringProperty = true
},
new TagHelperAttributeDescriptor
{
Name = "bound-int",
PropertyName = "BoundRequiredString",
TypeName = typeof(int).FullName
}
}
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors);
}
private static StatementBlock CreateStatementBlock(MarkupBlock block)
{
var factory = CreateDefaultSpanFactory();
return new StatementBlock(
factory.MetaCode("{").Accepts(AcceptedCharacters.None),
block,
factory.EmptyCSharp().AsStatement(),
factory.MetaCode("}").Accepts(AcceptedCharacters.None));
}
public void Rewrite_CanHandleStartTagOnlyTagTagMode()
{
// Arrange
var documentContent = "<input>";
var expectedOutput = new MarkupBlock(new MarkupTagHelperBlock("input", TagMode.StartTagOnly));
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper",
AssemblyName = "SomeAssembly",
TagStructure = TagStructure.WithoutEndTag
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors: new RazorError[0]);
}
public void TagHelperParseTreeRewriter_DoesNotRewriteTextTagTransitionTagHelpers(
string documentContent,
MarkupBlock expectedOutput)
{
RunParseTreeRewriterTest(documentContent, expectedOutput, "p", "text");
}
public void Rewrite_CreatesErrorForWithoutEndTagTagStructureForEndTags()
{
// Arrange
var factory = CreateDefaultSpanFactory();
var blockFactory = new BlockFactory(factory);
var expectedError = new RazorError(
RazorResources.FormatTagHelperParseTreeRewriter_EndTagTagHelperMustNotHaveAnEndTag(
"input",
"InputTagHelper",
TagStructure.WithoutEndTag),
absoluteIndex: 2,
lineIndex: 0,
columnIndex: 2,
length: 5);
var documentContent = "</input>";
var expectedOutput = new MarkupBlock(blockFactory.MarkupTagBlock("</input>"));
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper",
AssemblyName = "SomeAssembly",
TagStructure = TagStructure.WithoutEndTag
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors: new[] { expectedError });
}
public void TagHelperParseTreeRewriter_RewritesNestedTagHelperTagBlocks(
string documentContent,
MarkupBlock expectedOutput)
{
RunParseTreeRewriterTest(documentContent, expectedOutput, "p", "div");
}
public void Rewrite_CreatesErrorForInconsistentTagStructures()
{
// Arrange
var factory = CreateDefaultSpanFactory();
var blockFactory = new BlockFactory(factory);
var expectedError = new RazorError(
RazorResources.FormatTagHelperParseTreeRewriter_InconsistentTagStructure(
"InputTagHelper1",
"InputTagHelper2",
"input",
nameof(TagHelperDescriptor.TagStructure)),
absoluteIndex: 0,
lineIndex: 0,
columnIndex: 0,
length: 7);
var documentContent = "<input>";
var expectedOutput = new MarkupBlock(new MarkupTagHelperBlock("input", TagMode.StartTagOnly));
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper1",
AssemblyName = "SomeAssembly",
TagStructure = TagStructure.WithoutEndTag
},
new TagHelperDescriptor
{
TagName = "input",
TypeName = "InputTagHelper2",
AssemblyName = "SomeAssembly",
TagStructure = TagStructure.NormalOrSelfClosing
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors: new[] { expectedError });
}
public void Rewrite_CanHandleInvalidChildrenWithWhitespace()
{
// Arrange
var factory = CreateDefaultSpanFactory();
var blockFactory = new BlockFactory(factory);
var documentContent = $"<p>{Environment.NewLine} <strong>{Environment.NewLine} Hello" +
$"{Environment.NewLine} </strong>{Environment.NewLine}</p>";
var newLineLength = Environment.NewLine.Length;
var expectedErrors = new[] {
new RazorError(
RazorResources.FormatTagHelperParseTreeRewriter_InvalidNestedTag("strong", "p", "br"),
absoluteIndex: 8 + newLineLength,
lineIndex: 1,
columnIndex: 5,
length: 6),
};
var expectedOutput = new MarkupBlock(
new MarkupTagHelperBlock("p",
factory.Markup(Environment.NewLine + " "),
blockFactory.MarkupTagBlock("<strong>"),
factory.Markup(Environment.NewLine + " Hello" + Environment.NewLine + " "),
blockFactory.MarkupTagBlock("</strong>"),
factory.Markup(Environment.NewLine)));
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "p",
TypeName = "PTagHelper",
AssemblyName = "SomeAssembly",
AllowedChildren = new[] { "br" },
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors);
}
public void Rewrite_RequiredAttributeDescriptorsCreateMalformedTagHelperBlocksCorrectly(
string documentContent,
MarkupBlock expectedOutput,
RazorError[] expectedErrors)
{
// Arrange
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "p",
TypeName = "pTagHelper",
AssemblyName = "SomeAssembly",
RequiredAttributes = new[] { new TagHelperRequiredAttributeDescriptor { Name = "class" } }
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors);
}
public void Rewrite_CanHandleMultipleTagHelpersWithAllowedChildren()
{
// Arrange
var factory = CreateDefaultSpanFactory();
var documentContent = "<p><strong>Hello World</strong><br></p>";
var expectedOutput = new MarkupBlock(
new MarkupTagHelperBlock("p",
new MarkupTagHelperBlock("strong",
factory.Markup("Hello World")),
new MarkupTagHelperBlock("br", TagMode.StartTagOnly)));
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "p",
TypeName = "PTagHelper1",
AssemblyName = "SomeAssembly",
AllowedChildren = new[] { "strong" }
},
new TagHelperDescriptor
{
TagName = "p",
TypeName = "PTagHelper2",
AssemblyName = "SomeAssembly",
AllowedChildren = new[] { "br" }
},
new TagHelperDescriptor
{
TagName = "strong",
TypeName = "StrongTagHelper",
AssemblyName = "SomeAssembly"
},
new TagHelperDescriptor
{
TagName = "br",
TypeName = "BRTagHelper",
AssemblyName = "SomeAssembly",
TagStructure = TagStructure.WithoutEndTag
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors: new RazorError[0]);
}
public void Rewrite_AllowsPrefixedTagHelpers(
string documentContent,
MarkupBlock expectedOutput,
IEnumerable<TagHelperDescriptor> availableDescriptors)
{
// Arrange
var descriptorProvider = new TagHelperDescriptorProvider(availableDescriptors);
// Act & Assert
EvaluateData(
descriptorProvider,
documentContent,
expectedOutput,
expectedErrors: Enumerable.Empty<RazorError>());
}
public void ParseDocument_WithUnexpectedTransitionsInAttributeValue_Throws()
{
// Arrange
var expected = new MarkupBlock(
new MarkupTagBlock(
Factory.Markup("<span"),
new MarkupBlock(
new AttributeBlockChunkGenerator("foo", new LocationTagged<string>(" foo='", 5, 0, 5), new LocationTagged<string>("'", 14, 0, 14)),
Factory.Markup(" foo='").With(SpanChunkGenerator.Null),
new MarkupBlock(
new DynamicAttributeBlockChunkGenerator(new LocationTagged<string>(string.Empty, 11, 0, 11), 11, 0, 11),
new ExpressionBlock(
Factory.CodeTransition(),
Factory.EmptyCSharp().AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace))),
new MarkupBlock(
new DynamicAttributeBlockChunkGenerator(new LocationTagged<string>(" ", 12, 0, 12), 12, 0, 12),
Factory.Markup(" ").With(SpanChunkGenerator.Null),
new ExpressionBlock(
Factory.CodeTransition().Accepts(AcceptedCharacters.None).With(SpanChunkGenerator.Null),
Factory.EmptyCSharp().AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace))),
Factory.Markup("'").With(SpanChunkGenerator.Null)),
Factory.Markup(" />")));
var expectedErrors = new RazorError[]
{
new RazorError(
@"A space or line break was encountered after the ""@"" character. Only valid identifiers, keywords, comments, ""("" and ""{"" are valid at the start of a code block and they must occur immediately following ""@"" with no space in between.",
new SourceLocation(12, 0, 12),
length: 1),
new RazorError(
@"""' />"" is not valid at the start of a code block. Only identifiers, keywords, comments, ""("" and ""{"" are valid.",
new SourceLocation(14, 0, 14),
length: 4),
};
// Act & Assert
ParseDocumentTest("<span foo='@ @' />", expected, expectedErrors);
}
public void Rewrite_AllowsTagHelperElementOptForIncompleteTextTagInCSharpBlock(
string documentContent,
MarkupBlock expectedOutput,
RazorError[] expectedErrors)
{
RunParseTreeRewriterTest(documentContent, expectedOutput, expectedErrors, "text");
}
public void HtmlCommentSupportsMultipleDashes(string documentContent, MarkupBlock expectedOutput)
{
ParseBlockTest(documentContent, expectedOutput);
}
public void Rewrite_AllowsTagHelperElementOptForIncompleteHTML(
string documentContent,
MarkupBlock expectedOutput)
{
RunParseTreeRewriterTest(documentContent, expectedOutput, new RazorError[0], "strong", "p");
}
public void Rewrite_CreatesErrorForMalformedTagHelper(
string documentContent,
MarkupBlock expectedOutput,
RazorError[] expectedErrors)
{
RunParseTreeRewriterTest(documentContent, expectedOutput, expectedErrors, "strong", "p");
}
public void Rewrite_UnderstandsNestedRequiredParent(string documentContent, MarkupBlock expectedOutput)
{
// Arrange
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "strong",
TypeName = "StrongTagHelper",
AssemblyName = "SomeAssembly",
RequiredParent = "p",
},
new TagHelperDescriptor
{
TagName = "strong",
TypeName = "StrongTagHelper",
AssemblyName = "SomeAssembly",
RequiredParent = "div",
},
new TagHelperDescriptor
{
TagName = "p",
TypeName = "PTagHelper",
AssemblyName = "SomeAssembly"
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors: new RazorError[0]);
}
public void Rewrite_UnderstandsAllowedChildren(
string documentContent,
IEnumerable<string> allowedChildren,
MarkupBlock expectedOutput,
RazorError[] expectedErrors)
{
// Arrange
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "p",
TypeName = "PTagHelper",
AssemblyName = "SomeAssembly",
AllowedChildren = allowedChildren
},
new TagHelperDescriptor
{
TagName = "strong",
TypeName = "StrongTagHelper",
AssemblyName = "SomeAssembly",
AllowedChildren = allowedChildren
},
new TagHelperDescriptor
{
TagName = "br",
TypeName = "BRTagHelper",
AssemblyName = "SomeAssembly",
TagStructure = TagStructure.WithoutEndTag
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors);
}
public void Rewrite_UnderstandsTagHelperPrefixAndAllowedChildren()
{
// Arrange
var documentContent = "<th:p><th:strong></th:strong></th:p>";
var expectedOutput = new MarkupBlock(
new MarkupTagHelperBlock("th:p",
new MarkupTagHelperBlock("th:strong")));
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "p",
TypeName = "PTagHelper",
AssemblyName = "SomeAssembly",
AllowedChildren = new[] { "strong" },
Prefix = "th:"
},
new TagHelperDescriptor
{
TagName = "strong",
TypeName = "StrongTagHelper",
AssemblyName = "SomeAssembly",
Prefix = "th:"
}
};
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
// Act & Assert
EvaluateData(
descriptorProvider,
documentContent,
expectedOutput,
expectedErrors: Enumerable.Empty<RazorError>());
}
public void Rewrite_UnderstandsNullTagNameWithAllowedChildrenForCatchAllWithPrefix()
{
// Arrange
var documentContent = "<th:p></</th:p>";
var descriptors = new TagHelperDescriptor[]
{
new TagHelperDescriptor
{
TagName = "p",
TypeName = "PTagHelper",
AssemblyName = "SomeAssembly",
AllowedChildren = new[] { "custom" },
Prefix = "th:",
},
new TagHelperDescriptor
{
TagName = "*",
TypeName = "CatchAllTagHelper",
AssemblyName = "SomeAssembly",
Prefix = "th:",
}
};
var expectedOutput = new MarkupBlock(
new MarkupTagHelperBlock("th:p",
BlockFactory.MarkupTagBlock("</")));
var descriptorProvider = new TagHelperDescriptorProvider(descriptors);
var expectedErrors = new[]
{
new RazorError(
RazorResources.FormatTagHelperParseTreeRewriter_CannotHaveNonTagContent("th:p", "custom"),
absoluteIndex: 6,
lineIndex: 0,
columnIndex: 6,
length: 2)
};
// Act & Assert
EvaluateData(descriptorProvider, documentContent, expectedOutput, expectedErrors);
}
public void Rewrite_GeneratesExpectedOutputForUnboundDataDashAttributes(
string documentContent,
MarkupBlock expectedOutput)
{
// Act & Assert
RunParseTreeRewriterTest(documentContent, expectedOutput, Enumerable.Empty<RazorError>(), "input");
}
