public void WriteTagHelperProperty_DesignTime_NonStringIndexer_RendersCorrectly()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension()
            {
                DesignTime = true
            };
            var context = TestCodeRenderingContext.CreateDesignTime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new DefaultTagHelperPropertyIntermediateNode()
            {
                AttributeName      = "foo-bound",
                AttributeStructure = AttributeStructure.DoubleQuotes,
                BoundAttribute     = IntIndexerTagHelper.BoundAttributes.Single(),
                FieldName          = "__InputTagHelper",
                IsIndexerNameMatch = true,
                PropertyName       = "IntIndexer",
                TagHelper          = IntIndexerTagHelper,
                Source             = Span,
                Children           =
                {
                    new CSharpExpressionIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.CSharp, Content = "32",
                      } },
                    }
                }
            };

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperProperty(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"#line 3 ""test.cshtml""
__InputTagHelper.IntIndexer[""bound""] = 32;

#line default
#line hidden
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
Exemple #2
0
        public void WriteTagHelperProperty_Runtime_NonStringProperty_RendersCorrectly()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateRuntime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new DefaultTagHelperPropertyIntermediateNode()
            {
                AttributeName      = "bound",
                AttributeStructure = AttributeStructure.DoubleQuotes,
                BoundAttribute     = IntPropertyTagHelper.BoundAttributes.Single(),
                FieldName          = "__InputTagHelper",
                IsIndexerNameMatch = false,
                PropertyName       = "IntProp",
                TagHelper          = IntPropertyTagHelper,
                Source             = Span,
                Children           =
                {
                    new CSharpExpressionIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.CSharp, Content = "32",
                      } },
                    }
                },
            };

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperProperty(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"#line 3 ""test.cshtml""
__InputTagHelper.IntProp = 32;

#line default
#line hidden
__tagHelperExecutionContext.AddTagHelperAttribute(""bound"", __InputTagHelper.IntProp, global::Microsoft.AspNetCore.Razor.TagHelpers.HtmlAttributeValueStyle.DoubleQuotes);
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
    public void WriteCSharpExpression_WithSource_WritesPadding()
    {
        // Arrange
        var codeWriter = new CodeWriter();
        var writer     = new RuntimeNodeWriter()
        {
            WriteCSharpExpressionMethod = "Test",
        };
        var context = TestCodeRenderingContext.CreateRuntime();

        var node = new CSharpExpressionIntermediateNode()
        {
            Source = new SourceSpan("test.cshtml", 8, 0, 8, 3, 0, 11),
        };
        var builder = IntermediateNodeBuilder.Create(node);

        builder.Add(new IntermediateToken()
        {
            Content = "i",
            Kind    = TokenKind.CSharp,
        });
        builder.Add(new MyExtensionIntermediateNode());
        builder.Add(new IntermediateToken()
        {
            Content = "++",
            Kind    = TokenKind.CSharp,
        });

        // Act
        writer.WriteCSharpExpression(context, node);

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"
#nullable restore
#line (1,9)-(1,12) 5 ""test.cshtml""
Test(iRender Children
++);

#line default
#line hidden
#nullable disable
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
Exemple #4
0
        public void WriteTagHelperHtmlAttribute_DesignTime_WritesNothing()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension()
            {
                DesignTime = true
            };
            var context = TestCodeRenderingContext.CreateDesignTime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new DefaultTagHelperHtmlAttributeIntermediateNode()
            {
                AttributeName      = "name",
                AttributeStructure = AttributeStructure.DoubleQuotes,
                Children           =
                {
                    new HtmlAttributeValueIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.Html, Content = "Blah-"
                      } }
                    },
                    new CSharpCodeAttributeValueIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.CSharp, Content = "\"Foo\"",
                      } },
                    }
                }
            };

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperHtmlAttribute(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"Render Children
Render Children
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
        public void WriteTagHelperProperty_Runtime_NonStringIndexer_RendersCorrectly_WithoutLocation()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateRuntime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new DefaultTagHelperPropertyIntermediateNode()
            {
                AttributeName      = "foo-bound",
                AttributeStructure = AttributeStructure.DoubleQuotes,
                BoundAttribute     = IntIndexerTagHelper.BoundAttributes.Single(),
                FieldName          = "__InputTagHelper",
                IsIndexerNameMatch = true,
                PropertyName       = "IntIndexer",
                TagHelper          = IntIndexerTagHelper,
                Children           =
                {
                    new CSharpExpressionIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.CSharp, Content = "32",
                      } },
                    }
                }
            };

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperProperty(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"if (__InputTagHelper.IntIndexer == null)
{
    throw new InvalidOperationException(InvalidTagHelperIndexerAssignment(""foo-bound"", ""InputTagHelper"", ""IntIndexer""));
}
__InputTagHelper.IntIndexer[""bound""] = 32;
__tagHelperExecutionContext.AddTagHelperAttribute(""foo-bound"", __InputTagHelper.IntIndexer[""bound""], global::Microsoft.AspNetCore.Razor.TagHelpers.HtmlAttributeValueStyle.DoubleQuotes);
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
        public void WriteTagHelperProperty_Runtime_StringProperty_HtmlContent_RendersCorrectly()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateRuntime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new DefaultTagHelperPropertyIntermediateNode()
            {
                AttributeName      = "bound",
                AttributeStructure = AttributeStructure.DoubleQuotes,
                BoundAttribute     = StringPropertyTagHelper.BoundAttributes.Single(),
                FieldName          = "__InputTagHelper",
                IsIndexerNameMatch = false,
                PropertyName       = "StringProp",
                TagHelper          = StringPropertyTagHelper,
                Children           =
                {
                    new HtmlContentIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.Html, Content = "\"value\"",
                      } },
                    }
                }
            };

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperProperty(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            // The attribute value is not rendered inline because we are not using the preallocated writer.
            Assert.Equal(
                @"BeginWriteTagHelperAttribute();
Render Children
__tagHelperStringValueBuffer = EndWriteTagHelperAttribute();
__InputTagHelper.StringProp = __tagHelperStringValueBuffer;
__tagHelperExecutionContext.AddTagHelperAttribute(""bound"", __InputTagHelper.StringProp, global::Microsoft.AspNetCore.Razor.TagHelpers.HtmlAttributeValueStyle.DoubleQuotes);
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
        public void WriteDesignTimeDirective_WithStringToken_WritesLambda()
        {
            // Arrange
            var extension = new DesignTimeDirectiveTargetExtension();
            var context   = TestCodeRenderingContext.CreateDesignTime();

            var node  = new DesignTimeDirectiveIntermediateNode();
            var token = new DirectiveTokenIntermediateNode()
            {
                Source         = new SourceSpan("test.cshtml", 0, 0, 0, 5),
                Content        = "Value",
                DirectiveToken = DirectiveTokenDescriptor.CreateToken(DirectiveTokenKind.String),
            };
            var tokenWithQuotedContent = new DirectiveTokenIntermediateNode()
            {
                Source         = new SourceSpan("test.cshtml", 0, 0, 0, 5),
                Content        = "\"Value\"",
                DirectiveToken = DirectiveTokenDescriptor.CreateToken(DirectiveTokenKind.String),
            };

            node.Children.Add(token);
            node.Children.Add(tokenWithQuotedContent);

            // Act
            extension.WriteDesignTimeDirective(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"#pragma warning disable 219
private void __RazorDirectiveTokenHelpers__() {
((System.Action)(() => {
global::System.Object __typeHelper = ""Value"";
}
))();
((System.Action)(() => {
global::System.Object __typeHelper = ""Value"";
}
))();
}
#pragma warning restore 219
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
        public void WriteTagHelperHtmlAttribute_Runtime_DynamicAttribute_RendersCorrectly()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateRuntime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new DefaultTagHelperHtmlAttributeIntermediateNode()
            {
                AttributeName      = "name",
                AttributeStructure = AttributeStructure.DoubleQuotes,
                Children           =
                {
                    new HtmlAttributeValueIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.Html, Content = "Blah-"
                      } }
                    },
                    new CSharpCodeAttributeValueIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.CSharp, Content = "\"Foo\"",
                      } },
                    }
                }
            };

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperHtmlAttribute(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"BeginAddHtmlAttributeValues(__tagHelperExecutionContext, ""name"", 2, global::Microsoft.AspNetCore.Razor.TagHelpers.HtmlAttributeValueStyle.DoubleQuotes);
Render Children
Render Children
EndAddHtmlAttributeValues(__tagHelperExecutionContext);
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
Exemple #9
0
        [Fact] // We don't actually assign the expression result at design time, we just use string.Empty as a placeholder.
        public void WriteTagHelperProperty_DesignTime_StringProperty_NonHtmlContent_RendersCorrectly()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension()
            {
                DesignTime = true
            };
            var context = TestCodeRenderingContext.CreateDesignTime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new DefaultTagHelperPropertyIntermediateNode()
            {
                AttributeName      = "bound",
                AttributeStructure = AttributeStructure.DoubleQuotes,
                BoundAttribute     = StringPropertyTagHelper.BoundAttributes.Single(),
                FieldName          = "__InputTagHelper",
                IsIndexerNameMatch = false,
                PropertyName       = "StringProp",
                TagHelper          = StringPropertyTagHelper,
                Children           =
                {
                    new CSharpExpressionIntermediateNode()
                    {
                        Children ={ new IntermediateToken                {
                          Kind = TokenKind.CSharp, Content = "\"3+5\"",
                      } },
                    }
                }
            };

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperProperty(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"Render Children
__InputTagHelper.StringProp = string.Empty;
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
Exemple #10
0
        public void WriteTagHelperProperty_DesignTime_NonStringProperty_SecondUseOfAttribute()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension()
            {
                DesignTime = true
            };
            var context = TestCodeRenderingContext.CreateDesignTime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node1         = new DefaultTagHelperPropertyIntermediateNode()
            {
                // We only look at the attribute name here.
                AttributeName = "bound",
                FieldName     = "__OtherTagHelper",
                PropertyName  = "IntProp",
            };
            var node2 = new DefaultTagHelperPropertyIntermediateNode()
            {
                AttributeName      = "bound",
                AttributeStructure = AttributeStructure.DoubleQuotes,
                BoundAttribute     = IntPropertyTagHelper.BoundAttributes.Single(),
                FieldName          = "__InputTagHelper",
                IsIndexerNameMatch = false,
                PropertyName       = "IntProp",
                TagHelper          = IntPropertyTagHelper,
                Source             = Span,
            };

            tagHelperNode.Children.Add(node1);
            tagHelperNode.Children.Add(node2);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperProperty(context, node2);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"__InputTagHelper.IntProp = __OtherTagHelper.IntProp;
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
Exemple #11
0
        public void WriteTagHelperProperty_RendersCorrectly()
        {
            // Arrange
            var extension = new PreallocatedAttributeTargetExtension();
            var context   = TestCodeRenderingContext.CreateRuntime();

            var tagHelperBuilder = new DefaultTagHelperDescriptorBuilder(TagHelperConventions.DefaultKind, "FooTagHelper", "Test");

            tagHelperBuilder.TypeName("FooTagHelper");

            var builder = new DefaultBoundAttributeDescriptorBuilder(tagHelperBuilder, TagHelperConventions.DefaultKind);

            builder
            .Name("Foo")
            .TypeName("System.String")
            .PropertyName("FooProp");

            var descriptor = builder.Build();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new PreallocatedTagHelperPropertyIntermediateNode()
            {
                AttributeName  = descriptor.Name,
                BoundAttribute = descriptor,
                FieldName      = "__FooTagHelper",
                PropertyName   = "FooProp",
                VariableName   = "_tagHelper1",
            };

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperProperty(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"__FooTagHelper.FooProp = (string)_tagHelper1.Value;
__tagHelperExecutionContext.AddTagHelperAttribute(_tagHelper1);
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
        public void WriteTagHelperRuntime_DesignTime_WritesNothing()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateDesignTime();

            var node = new DefaultTagHelperRuntimeIntermediateNode();

            // Act
            extension.WriteTagHelperRuntime(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"",
                csharp,
                ignoreLineEndingDifferences: true);
        }
    public void WriteHtmlLiteral_WithinMaxSize_WritesSingleLiteral()
    {
        // Arrange
        var codeWriter = new CodeWriter();
        var writer     = new RuntimeNodeWriter();
        var context    = TestCodeRenderingContext.CreateRuntime();

        // Act
        writer.WriteHtmlLiteral(context, maxStringLiteralLength: 6, "Hello");

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"WriteLiteral(""Hello"");
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
Exemple #14
0
        public void InjectDirectiveTargetExtension_WritesProperty()
        {
            // Arrange
            var context = TestCodeRenderingContext.CreateRuntime();
            var target  = new InjectTargetExtension();
            var node    = new InjectIntermediateNode()
            {
                TypeName   = "PropertyType",
                MemberName = "PropertyName",
            };

            // Act
            target.WriteInjectProperty(context, node);

            // Assert
            Assert.Equal(
                "[global::Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute]" + Environment.NewLine +
                "public PropertyType PropertyName { get; private set; }" + Environment.NewLine,
                context.CodeWriter.GenerateCode());
        }
    public void WriteHtmlLiteral_GreaterThanMaxSize_SingleEmojisSplit()
    {
        // Arrange
        var codeWriter = new CodeWriter();
        var writer     = new RuntimeNodeWriter();
        var context    = TestCodeRenderingContext.CreateRuntime();

        // Act
        writer.WriteHtmlLiteral(context, maxStringLiteralLength: 2, " 👦");

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"WriteLiteral("" "");
WriteLiteral(""👦"");
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
Exemple #16
0
        public void WriteDesignTimeDirective_WithNamespaceToken_WritesLambda()
        {
            // Arrange
            var extension = new DesignTimeDirectiveTargetExtension();
            var context   = TestCodeRenderingContext.CreateDesignTime();

            var node  = new DesignTimeDirectiveIntermediateNode();
            var token = new DirectiveTokenIntermediateNode()
            {
                Source         = new SourceSpan("test.cshtml", 0, 0, 0, 5),
                Content        = "System.Collections.Generic",
                DirectiveToken = DirectiveTokenDescriptor.CreateToken(DirectiveTokenKind.Namespace),
            };

            node.Children.Add(token);

            // Act
            extension.WriteDesignTimeDirective(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"#pragma warning disable 219
private void __RazorDirectiveTokenHelpers__() {
((System.Action)(() => {
#nullable restore
#line 1 ""test.cshtml""
global::System.Object __typeHelper = nameof(System.Collections.Generic);

#line default
#line hidden
#nullable disable
}
))();
}
#pragma warning restore 219
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
        public void RenderTagHelperAttributeInline_NonStringIndexerMatch_TemplateInAttribute_Errors()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateRuntime();
            var node      = new DefaultTagHelperPropertyIntermediateNode()
            {
                BoundAttribute     = IntIndexerTagHelper.BoundAttributes.Single(),
                IsIndexerNameMatch = true,
            };
            var expectedLocation   = new SourceSpan(100, 10);
            var expectedDiagnostic = RazorDiagnosticFactory.CreateTagHelper_InlineMarkupBlocksNotSupportedInAttributes(expectedLocation, "System.Int32");

            // Act
            extension.RenderTagHelperAttributeInline(context, node, new TemplateIntermediateNode(), expectedLocation);

            // Assert
            var diagnostic = Assert.Single(context.Diagnostics);

            Assert.Equal(expectedDiagnostic, diagnostic);
        }
    public void EndWriterScope_RendersCorrectly()
    {
        // Arrange
        var writer = new RuntimeNodeWriter()
        {
            PopWriterMethod = "TestPopWriter"
        };
        var context = TestCodeRenderingContext.CreateRuntime();

        // Act
        writer.EndWriterScope(context);

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"TestPopWriter();
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
    public void BeginWriterScope_UsesSpecifiedWriter_RendersCorrectly()
    {
        // Arrange
        var writer = new RuntimeNodeWriter()
        {
            PushWriterMethod = "TestPushWriter"
        };
        var context = TestCodeRenderingContext.CreateRuntime();

        // Act
        writer.BeginWriterScope(context, "MyWriter");

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"TestPushWriter(MyWriter);
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
        public void WriteTagHelperRuntime_Runtime_DeclaresRequiredFields()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateRuntime();

            var node = new DefaultTagHelperRuntimeIntermediateNode();

            // Act
            extension.WriteTagHelperRuntime(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"#line hidden
#pragma warning disable 0649
private global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperExecutionContext __tagHelperExecutionContext;
#pragma warning restore 0649
private global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperRunner __tagHelperRunner = new global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperRunner();
#pragma warning disable 0169
private string __tagHelperStringValueBuffer;
#pragma warning restore 0169
private global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperScopeManager __backed__tagHelperScopeManager = null;
private global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperScopeManager __tagHelperScopeManager
{
    get
    {
        if (__backed__tagHelperScopeManager == null)
        {
            __backed__tagHelperScopeManager = new global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperScopeManager(StartTagHelperWritingScope, EndTagHelperWritingScope);
        }
        return __backed__tagHelperScopeManager;
    }
}
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
        public void WriteTemplate_WritesTemplateCode()
        {
            // Arrange
            var node = new TemplateIntermediateNode()
            {
                Children =
                {
                    new CSharpExpressionIntermediateNode()
                }
            };
            var extension = new TemplateTargetExtension()
            {
                TemplateTypeName = "global::TestTemplate"
            };

            var nodeWriter = new RuntimeNodeWriter()
            {
                PushWriterMethod = "TestPushWriter",
                PopWriterMethod  = "TestPopWriter"
            };

            var context = TestCodeRenderingContext.CreateRuntime(nodeWriter: nodeWriter);

            // Act
            extension.WriteTemplate(context, node);

            // Assert
            var expected = @"item => new global::TestTemplate(async(__razor_template_writer) => {
    TestPushWriter(__razor_template_writer);
    Render Children
    TestPopWriter();
}
)";

            var output = context.CodeWriter.GenerateCode();

            Assert.Equal(expected, output);
        }
Exemple #22
0
    public void WriteCSharpCodeAttributeValue_WithExpression_RendersCorrectly()
    {
        var writer         = new DesignTimeNodeWriter();
        var content        = "<input checked=\"hello-world @if(@true){ @false }\" />";
        var sourceDocument = TestRazorSourceDocument.Create(content);
        var codeDocument   = RazorCodeDocument.Create(sourceDocument);
        var documentNode   = Lower(codeDocument);
        var node           = documentNode.Children.OfType <HtmlAttributeIntermediateNode>().Single().Children[1] as CSharpCodeAttributeValueIntermediateNode;

        var context = TestCodeRenderingContext.CreateDesignTime(source: sourceDocument);

        // Act
        writer.WriteCSharpCodeAttributeValue(context, node);

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"
#nullable restore
#line 1 ""test.cshtml""
                             if(@true){ 

#line default
#line hidden
#nullable disable
Render Children
#nullable restore
#line 1 ""test.cshtml""
                                               }

#line default
#line hidden
#nullable disable
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
    public void WriteCSharpCode_WritesPadding_WithSource()
    {
        // Arrange
        var codeWriter = new CodeWriter();
        var writer     = new RuntimeNodeWriter();
        var context    = TestCodeRenderingContext.CreateRuntime();

        var node = new CSharpCodeIntermediateNode()
        {
            Source = new SourceSpan("test.cshtml", 0, 0, 0, 17),
        };

        IntermediateNodeBuilder.Create(node)
        .Add(new IntermediateToken()
        {
            Kind    = TokenKind.CSharp,
            Content = "    if (true) { }",
        });

        // Act
        writer.WriteCSharpCode(context, node);

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"
#nullable restore
#line 1 ""test.cshtml""
    if (true) { }

#line default
#line hidden
#nullable disable
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
    public void WriteCSharpExpression_WithExtensionNode_WritesPadding()
    {
        // Arrange
        var codeWriter = new CodeWriter();
        var writer     = new RuntimeNodeWriter()
        {
            WriteCSharpExpressionMethod = "Test",
        };
        var context = TestCodeRenderingContext.CreateRuntime();

        var node    = new CSharpExpressionIntermediateNode();
        var builder = IntermediateNodeBuilder.Create(node);

        builder.Add(new IntermediateToken()
        {
            Content = "i",
            Kind    = TokenKind.CSharp,
        });
        builder.Add(new MyExtensionIntermediateNode());
        builder.Add(new IntermediateToken()
        {
            Content = "++",
            Kind    = TokenKind.CSharp,
        });

        // Act
        writer.WriteCSharpExpression(context, node);

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"Test(iRender Children
++);
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
        public void WriteDesignTimeDirective_NoChildren_WritesEmptyMethod_WithPragma()
        {
            // Arrange
            var extension = new DesignTimeDirectiveTargetExtension();
            var context   = TestCodeRenderingContext.CreateDesignTime();

            var node = new DesignTimeDirectiveIntermediateNode();

            // Act
            extension.WriteDesignTimeDirective(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"#pragma warning disable 219
private void __RazorDirectiveTokenHelpers__() {
}
#pragma warning restore 219
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
Exemple #26
0
    public void WriteUsingDirective_NoSource_WritesContent()
    {
        // Arrange
        var writer  = new DesignTimeNodeWriter();
        var context = TestCodeRenderingContext.CreateDesignTime();

        var node = new UsingDirectiveIntermediateNode()
        {
            Content = "System",
        };

        // Act
        writer.WriteUsingDirective(context, node);

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"using System;
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
Exemple #27
0
    public void WriteCSharpExpression_WritesLinePragma_WithSource()
    {
        // Arrange
        var writer  = new DesignTimeNodeWriter();
        var context = TestCodeRenderingContext.CreateDesignTime();

        var node = new CSharpExpressionIntermediateNode()
        {
            Source = new SourceSpan("test.cshtml", 0, 0, 0, 3),
        };
        var builder = IntermediateNodeBuilder.Create(node);

        builder.Add(new IntermediateToken()
        {
            Content = "i++",
            Kind    = TokenKind.CSharp,
        });

        // Act
        writer.WriteCSharpExpression(context, node);

        // Assert
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"
#nullable restore
#line 1 ""test.cshtml""
__o = i++;

#line default
#line hidden
#nullable disable
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
Exemple #28
0
    public void WriteUsingDirective_WithSource_WritesContentWithLinePragmaAndMapping()
    {
        // Arrange
        var writer  = new DesignTimeNodeWriter();
        var context = TestCodeRenderingContext.CreateDesignTime();

        var originalSpan          = new SourceSpan("test.cshtml", 0, 0, 0, 6);
        var generatedSpan         = new SourceSpan(null, 38 + Environment.NewLine.Length * 3, 3, 0, 6);
        var expectedSourceMapping = new SourceMapping(originalSpan, generatedSpan);
        var node = new UsingDirectiveIntermediateNode()
        {
            Content = "System",
            Source  = originalSpan,
        };

        // Act
        writer.WriteUsingDirective(context, node);

        // Assert
        var mapping = Assert.Single(((DefaultCodeRenderingContext)context).SourceMappings);

        Assert.Equal(expectedSourceMapping, mapping);
        var csharp = context.CodeWriter.GenerateCode();

        Assert.Equal(
            @"
#nullable restore
#line 1 ""test.cshtml""
using System;

#line default
#line hidden
#nullable disable
",
            csharp,
            ignoreLineEndingDifferences: true);
    }
        public void WriteTagHelperExecute_DesignTime_RendersAsyncCode()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateDesignTime();

            var tagHelperNode = new TagHelperIntermediateNode();
            var node          = new DefaultTagHelperExecuteIntermediateNode();

            tagHelperNode.Children.Add(node);
            Push(context, tagHelperNode);

            // Act
            extension.WriteTagHelperExecute(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"await __tagHelperRunner.RunAsync(__tagHelperExecutionContext);
",
                csharp,
                ignoreLineEndingDifferences: true);
        }
        public void WriteTagHelperRuntime_DesignTime_RendersPreRequisites()
        {
            // Arrange
            var extension = new DefaultTagHelperTargetExtension();
            var context   = TestCodeRenderingContext.CreateDesignTime();

            var node = new DefaultTagHelperRuntimeIntermediateNode();

            // Act
            extension.WriteTagHelperRuntime(context, node);

            // Assert
            var csharp = context.CodeWriter.GenerateCode();

            Assert.Equal(
                @"#line hidden
#pragma warning disable 0649
private global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperExecutionContext __tagHelperExecutionContext;
#pragma warning restore 0649
private global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperRunner __tagHelperRunner = new global::Microsoft.AspNetCore.Razor.Runtime.TagHelpers.TagHelperRunner();
",
                csharp,
                ignoreLineEndingDifferences: true);
        }