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) )); }
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 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"); }