internal virtual RazorSyntaxTree ParseDocument(string document, IEnumerable <DirectiveDescriptor> directives, bool designTime = false)
{
directives = directives ?? Array.Empty <DirectiveDescriptor>();
var source = TestRazorSourceDocument.Create(document, filePath: null);
var options = CreateParserOptions(directives, designTime);
var context = new ParserContext(source, options);
var codeParser = new CSharpCodeParser(directives, context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
markupParser.ParseDocument();
var root = context.Builder.Build();
var diagnostics = context.ErrorSink.Errors;
var codeDocument = RazorCodeDocument.Create(source);
var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options);
codeDocument.SetSyntaxTree(syntaxTree);
var defaultDirectivePass = new DefaultDirectiveSyntaxTreePass();
syntaxTree = defaultDirectivePass.Execute(codeDocument, syntaxTree);
return(syntaxTree);
}
internal virtual RazorSyntaxTree ParseDocument(RazorLanguageVersion version, string document, IEnumerable <DirectiveDescriptor> directives, bool designTime = false, RazorParserFeatureFlags featureFlags = null, string fileKind = null)
{
directives = directives ?? Array.Empty <DirectiveDescriptor>();
var source = TestRazorSourceDocument.Create(document, filePath: null, relativePath: null, normalizeNewLines: true);
var options = CreateParserOptions(version, directives, designTime, featureFlags, fileKind);
var context = new ParserContext(source, options);
var codeParser = new CSharpCodeParser(directives, context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
var root = markupParser.ParseDocument().CreateRed();
var diagnostics = context.ErrorSink.Errors;
var codeDocument = RazorCodeDocument.Create(source);
var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options);
codeDocument.SetSyntaxTree(syntaxTree);
var defaultDirectivePass = new DefaultDirectiveSyntaxTreePass();
syntaxTree = defaultDirectivePass.Execute(codeDocument, syntaxTree);
return(syntaxTree);
}
public void Indexer_ProvidesCharacterAccessToContent(int contentLength)
{
// Arrange
var content = new char[contentLength];
for (var i = 0; i < contentLength - 1; i++)
{
content[i] = 'a';
}
content[contentLength - 1] = 'b';
var contentString = new string(content);
var stream = TestRazorSourceDocument.CreateStreamContent(new string(content));
var reader = new StreamReader(stream, true);
var document = new LargeTextSourceDocument(reader, ChunkTestLength, Encoding.UTF8, "file.cshtml");
// Act
var output = new char[contentLength];
for (var i = 0; i < document.Length; i++)
{
output[i] = document[i];
}
var outputString = new string(output);
// Assert
Assert.Equal(contentLength, document.Length);
Assert.Equal(contentString, outputString);
}
internal virtual RazorSyntaxTree ParseCodeBlock(
string document,
IEnumerable <DirectiveDescriptor> directives,
bool designTime)
{
directives = directives ?? Array.Empty <DirectiveDescriptor>();
var source = TestRazorSourceDocument.Create(document, filePath: null);
var options = CreateParserOptions(directives, designTime);
var context = new ParserContext(source, options);
var parser = new CSharpCodeParser(directives, context);
parser.HtmlParser = new HtmlMarkupParser(context)
{
CodeParser = parser,
};
parser.ParseBlock();
var root = context.Builder.Build();
var diagnostics = context.ErrorSink.Errors;
return(RazorSyntaxTree.Create(root, source, diagnostics, options));
}
private static RazorCodeActionContext CreateRazorCodeActionContext(
CodeActionParams request,
SourceLocation location,
string filePath,
string text,
SourceSpan componentSourceSpan,
bool supportsFileCreation = true,
bool supportsCodeActionResolve = true)
{
var tagHelpers = Array.Empty <TagHelperDescriptor>();
var sourceDocument = TestRazorSourceDocument.Create(text, filePath: filePath, relativePath: filePath);
var projectEngine = RazorProjectEngine.Create(builder => builder.AddTagHelpers(tagHelpers));
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, FileKinds.Component, Array.Empty <RazorSourceDocument>(), tagHelpers);
var cSharpDocument = codeDocument.GetCSharpDocument();
var diagnosticDescriptor = new RazorDiagnosticDescriptor("RZ10012", () => "", RazorDiagnosticSeverity.Error);
var diagnostic = RazorDiagnostic.Create(diagnosticDescriptor, componentSourceSpan);
var cSharpDocumentWithDiagnostic = RazorCSharpDocument.Create(cSharpDocument.GeneratedCode, cSharpDocument.Options, new[] { diagnostic });
codeDocument.SetCSharpDocument(cSharpDocumentWithDiagnostic);
var documentSnapshot = Mock.Of <DocumentSnapshot>(document =>
document.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
document.GetTextAsync() == Task.FromResult(codeDocument.GetSourceText()) &&
document.Project.TagHelpers == tagHelpers, MockBehavior.Strict);
var sourceText = SourceText.From(text);
var context = new RazorCodeActionContext(request, documentSnapshot, codeDocument, location, sourceText, supportsFileCreation, supportsCodeActionResolve);
return(context);
}
private static RazorCodeActionContext CreateRazorCodeActionContext(CodeActionParams request, SourceLocation location, string filePath, string text, SourceSpan componentSourceSpan)
{
var shortComponent = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, "Fully.Qualified.Component", "TestAssembly");
shortComponent.TagMatchingRule(rule => rule.TagName = "Component");
var fullyQualifiedComponent = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, "Fully.Qualified.Component", "TestAssembly");
fullyQualifiedComponent.TagMatchingRule(rule => rule.TagName = "Fully.Qualified.Component");
var tagHelpers = new[] { shortComponent.Build(), fullyQualifiedComponent.Build() };
var sourceDocument = TestRazorSourceDocument.Create(text, filePath: filePath, relativePath: filePath);
var projectEngine = RazorProjectEngine.Create(builder => {
builder.AddTagHelpers(tagHelpers);
});
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, FileKinds.Component, Array.Empty <RazorSourceDocument>(), tagHelpers);
var cSharpDocument = codeDocument.GetCSharpDocument();
var diagnosticDescriptor = new RazorDiagnosticDescriptor("RZ10012", () => "", RazorDiagnosticSeverity.Error);
var diagnostic = RazorDiagnostic.Create(diagnosticDescriptor, componentSourceSpan);
var cSharpDocumentWithDiagnostic = RazorCSharpDocument.Create(cSharpDocument.GeneratedCode, cSharpDocument.Options, new[] { diagnostic });
codeDocument.SetCSharpDocument(cSharpDocumentWithDiagnostic);
var documentSnapshot = Mock.Of <DocumentSnapshot>(document =>
document.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
document.GetTextAsync() == Task.FromResult(codeDocument.GetSourceText()) &&
document.Project.TagHelpers == tagHelpers);
return(new RazorCodeActionContext(request, documentSnapshot, codeDocument, location));
}
public void OnDocumentStructureChanged_FiresForLatestTextBufferEdit()
{
// Arrange
var documentTracker = CreateDocumentTracker();
using (var parser = new DefaultVisualStudioRazorParser(
Dispatcher,
documentTracker,
Mock.Of <RazorTemplateEngineFactoryService>(),
new DefaultErrorReporter(),
Mock.Of <VisualStudioCompletionBroker>()))
{
var called = false;
parser.DocumentStructureChanged += (sender, e) => called = true;
var latestChange = new SourceChange(0, 0, string.Empty);
var latestSnapshot = documentTracker.TextBuffer.CurrentSnapshot;
parser._latestChangeReference = new DefaultVisualStudioRazorParser.ChangeReference(latestChange, latestSnapshot);
var codeDocument = TestRazorCodeDocument.CreateEmpty();
codeDocument.SetSyntaxTree(RazorSyntaxTree.Parse(TestRazorSourceDocument.Create()));
var args = new DocumentStructureChangedEventArgs(
latestChange,
latestSnapshot,
codeDocument);
// Act
parser.OnDocumentStructureChanged(args);
// Assert
Assert.True(called);
}
}
internal virtual RazorSyntaxTree ParseCodeBlock(
RazorLanguageVersion version,
string document,
IEnumerable <DirectiveDescriptor> directives,
bool designTime)
{
directives = directives ?? Array.Empty <DirectiveDescriptor>();
var source = TestRazorSourceDocument.Create(document, filePath: null, relativePath: null, normalizeNewLines: true);
var options = CreateParserOptions(version, directives, designTime);
var context = new ParserContext(source, options);
var codeParser = new CSharpCodeParser(directives, context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
var root = codeParser.ParseBlock().CreateRed();
var diagnostics = context.ErrorSink.Errors;
var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options);
return(syntaxTree);
}
public void Execute_ParsesImports()
{
// Arrange
var phase = new DefaultRazorParsingPhase();
var engine = RazorProjectEngine.CreateEmpty((builder) =>
{
builder.Phases.Add(phase);
builder.Features.Add(new DefaultRazorParserOptionsFeature(designTime: false, version: RazorLanguageVersion.Latest, fileKind: null));
builder.Features.Add(new MyParserOptionsFeature());
});
var imports = new[]
{
TestRazorSourceDocument.Create(),
TestRazorSourceDocument.Create(),
};
var codeDocument = TestRazorCodeDocument.Create(TestRazorSourceDocument.Create(), imports);
// Act
phase.Execute(codeDocument);
// Assert
Assert.Collection(
codeDocument.GetImportSyntaxTrees(),
t => { Assert.Same(t.Source, imports[0]); Assert.Equal("test", Assert.Single(t.Options.Directives).Directive); },
t => { Assert.Same(t.Source, imports[1]); Assert.Equal("test", Assert.Single(t.Options.Directives).Directive); });
}
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(
@"#line 1 ""test.cshtml""
if(@true){
#line default
#line hidden
Render Children
#line 1 ""test.cshtml""
}
#line default
#line hidden
",
csharp,
ignoreLineEndingDifferences: true);
}
public void WriteUsingDirective_WithSource_WritesContentWithLinePragmaAndMapping()
{
// Arrange
var writer = new DesignTimeNodeWriter();
var sourceDocument = TestRazorSourceDocument.Create("@using System;");
var context = TestCodeRenderingContext.CreateDesignTime();
var originalSpan = new SourceSpan("test.cshtml", 0, 0, 0, 6);
var generatedSpan = new SourceSpan(null, 21 + Environment.NewLine.Length, 1, 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(
@"#line 1 ""test.cshtml""
using System;
#line default
#line hidden
",
csharp,
ignoreLineEndingDifferences: true);
}
public void Lower_WithMultipleImports_SingleLineFileScopedSinglyOccurring()
{
// Arrange
var source = TestRazorSourceDocument.Create("<p>Hi!</p>");
var imports = new[]
{
TestRazorSourceDocument.Create("@test value1"),
TestRazorSourceDocument.Create("@test value2"),
};
var codeDocument = TestRazorCodeDocument.Create(source, imports);
// Act
var documentNode = Lower(codeDocument, b =>
{
b.AddDirective(DirectiveDescriptor.CreateDirective(
"test",
DirectiveKind.SingleLine,
builder =>
{
builder.AddMemberToken();
builder.Usage = DirectiveUsage.FileScopedSinglyOccurring;
}));
});
// Assert
Children(
documentNode,
n => Directive("test", n, c => DirectiveToken(DirectiveTokenKind.Member, "value2", c)),
n => Html("<p>Hi!</p>", n));
}
public void Parse_Persists_FilePath()
{
// Arrange
var filePath = "test.cshtml";
var source = TestRazorSourceDocument.Create("@if (true) { @if(false) { <div>@something.</div> } }", fileName: filePath);
// Act
var syntaxTree = RazorSyntaxTree.Parse(source);
// Assert
Assert.Empty(syntaxTree.Diagnostics);
Assert.NotNull(syntaxTree);
var spans = new List <SyntaxTreeNode>();
GetChildren(syntaxTree.Root);
Assert.All(spans, node => Assert.Equal(filePath, node.Start.FilePath));
void GetChildren(SyntaxTreeNode node)
{
if (node is Block block)
{
foreach (var child in block.Children)
{
GetChildren(child);
}
}
else
{
spans.Add(node);
}
}
}
public void CanParseStuff()
{
var parser = new RazorParser();
var sourceDocument = TestRazorSourceDocument.CreateResource("TestFiles/Source/BasicMarkup.cshtml", GetType());
var output = parser.Parse(sourceDocument);
Assert.NotNull(output);
}
private static RazorCodeDocument CreateCodeDocument(string text)
{
var sourceDocument = TestRazorSourceDocument.Create(text);
var projectEngine = RazorProjectEngine.Create(builder => { });
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, FileKinds.Legacy, Array.Empty <RazorSourceDocument>(), Array.Empty <TagHelperDescriptor>());
return(codeDocument);
}
public void Execute_HasRequiredInfo_AddsItemAndSourceChecksum()
{
// Arrange
var engine = CreateEngine();
var pass = new MetadataAttributePass()
{
Engine = engine,
};
var sourceDocument = TestRazorSourceDocument.Create("", new RazorSourceDocumentProperties(null, "Foo\\Bar.cshtml"));
var codeDocument = RazorCodeDocument.Create(sourceDocument);
var irDocument = new DocumentIntermediateNode()
{
DocumentKind = "test",
Options = RazorCodeGenerationOptions.Create((o) => { }),
};
var builder = IntermediateNodeBuilder.Create(irDocument);
var @namespace = new NamespaceDeclarationIntermediateNode
{
Annotations =
{
[CommonAnnotations.PrimaryNamespace] = CommonAnnotations.PrimaryNamespace,
},
Content = "Some.Namespace"
};
builder.Push(@namespace);
var @class = new ClassDeclarationIntermediateNode
{
Annotations =
{
[CommonAnnotations.PrimaryClass] = CommonAnnotations.PrimaryClass,
},
ClassName = "Test",
};
builder.Add(@class);
// Act
pass.Execute(codeDocument, irDocument);
// Assert
Assert.Equal(2, irDocument.Children.Count);
var item = Assert.IsType <RazorCompiledItemAttributeIntermediateNode>(irDocument.Children[0]);
Assert.Equal("/Foo/Bar.cshtml", item.Identifier);
Assert.Equal("test", item.Kind);
Assert.Equal("Some.Namespace.Test", item.TypeName);
Assert.Equal(2, @namespace.Children.Count);
var checksum = Assert.IsType <RazorSourceChecksumAttributeIntermediateNode>(@namespace.Children[0]);
Assert.NotNull(checksum.Checksum); // Not verifying the checksum here
Assert.Equal("SHA1", checksum.ChecksumAlgorithm);
Assert.Equal("/Foo/Bar.cshtml", checksum.Identifier);
}
private static RazorCodeDocument CreateComponentDocument(string text, params TagHelperDescriptor[] tagHelpers)
{
tagHelpers ??= Array.Empty <TagHelperDescriptor>();
var sourceDocument = TestRazorSourceDocument.Create(text);
var projectEngine = RazorProjectEngine.Create(builder => { });
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, FileKinds.Component, Array.Empty <RazorSourceDocument>(), tagHelpers);
return(codeDocument);
}
private static RazorCodeDocument CreateCodeDocument(string text)
{
var codeDocument = TestRazorCodeDocument.CreateEmpty();
var sourceDocument = TestRazorSourceDocument.Create(text);
var syntaxTree = RazorSyntaxTree.Parse(sourceDocument);
codeDocument.SetSyntaxTree(syntaxTree);
return(codeDocument);
}
private static RazorCodeDocument CreateCodeDocument(string text, IReadOnlyList <TagHelperDescriptor> tagHelpers = null)
{
tagHelpers ??= Array.Empty <TagHelperDescriptor>();
var sourceDocument = TestRazorSourceDocument.Create(text);
var projectEngine = RazorProjectEngine.Create(builder => { });
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, "mvc", Array.Empty <RazorSourceDocument>(), tagHelpers);
return(codeDocument);
}
public void Execute_SuppressMetadataSourceChecksumAttributes_DoesNotGenerateSourceChecksumAttributes()
{
// Arrange
var engine = CreateEngine();
var pass = new MetadataAttributePass()
{
Engine = engine,
};
var sourceDocument = TestRazorSourceDocument.Create("", new RazorSourceDocumentProperties(null, "Foo\\Bar.cshtml"));
var import = TestRazorSourceDocument.Create("@using System", new RazorSourceDocumentProperties(null, "Foo\\Import.cshtml"));
var codeDocument = RazorCodeDocument.Create(sourceDocument, new[] { import, });
var irDocument = new DocumentIntermediateNode()
{
DocumentKind = "test",
Options = RazorCodeGenerationOptions.Create(o => o.SuppressMetadataSourceChecksumAttributes = true),
};
var builder = IntermediateNodeBuilder.Create(irDocument);
var @namespace = new NamespaceDeclarationIntermediateNode
{
Annotations =
{
[CommonAnnotations.PrimaryNamespace] = CommonAnnotations.PrimaryNamespace,
},
Content = "Some.Namespace"
};
builder.Push(@namespace);
var @class = new ClassDeclarationIntermediateNode
{
Annotations =
{
[CommonAnnotations.PrimaryClass] = CommonAnnotations.PrimaryClass,
},
ClassName = "Test",
};
builder.Add(@class);
// Act
pass.Execute(codeDocument, irDocument);
// Assert
Assert.Equal(2, irDocument.Children.Count);
var item = Assert.IsType <RazorCompiledItemAttributeIntermediateNode>(irDocument.Children[0]);
Assert.Equal("/Foo/Bar.cshtml", item.Identifier);
Assert.Equal("test", item.Kind);
Assert.Equal("Some.Namespace.Test", item.TypeName);
var child = Assert.Single(@namespace.Children);
Assert.IsType <ClassDeclarationIntermediateNode>(child);
}
private static RazorSyntaxTree GetSyntaxTree(string text, string fileKind = null)
{
fileKind ??= FileKinds.Component;
var sourceDocument = TestRazorSourceDocument.Create(text);
var projectEngine = RazorProjectEngine.Create(builder => { });
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, fileKind, Array.Empty <RazorSourceDocument>(), Array.Empty <TagHelperDescriptor>());
var syntaxTree = codeDocument.GetSyntaxTree();
return(syntaxTree);
}
private static TestTokenizerBackedParser CreateContentTokenizer(string content)
{
var source = TestRazorSourceDocument.Create(content);
var options = RazorParserOptions.CreateDefault();
var context = new ParserContext(source, options);
var tokenizer = new TestTokenizerBackedParser(HtmlLanguageCharacteristics.Instance, context);
return(tokenizer);
}
internal static RazorCodeDocument CreateCodeDocument(string text, string filePath, params TagHelperDescriptor[] tagHelpers)
{
tagHelpers ??= Array.Empty <TagHelperDescriptor>();
var sourceDocument = TestRazorSourceDocument.Create(text, filePath: filePath, relativePath: filePath);
var projectEngine = RazorProjectEngine.Create(builder => { });
var fileKind = filePath.EndsWith(".razor", StringComparison.Ordinal) ? FileKinds.Component : FileKinds.Legacy;
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, fileKind, Array.Empty <RazorSourceDocument>(), tagHelpers);
return(codeDocument);
}
private static RazorCodeDocument CreateCodeDocument(string text)
{
var codeDocument = TestRazorCodeDocument.CreateEmpty();
var sourceDocument = TestRazorSourceDocument.Create(text);
var syntaxTree = RazorSyntaxTree.Parse(sourceDocument);
codeDocument.SetSyntaxTree(syntaxTree);
var tagHelperDocumentContext = TagHelperDocumentContext.Create(prefix: string.Empty, Enumerable.Empty<TagHelperDescriptor>());
codeDocument.SetTagHelperContext(tagHelperDocumentContext);
return codeDocument;
}
public void CodeDocumentRequest_Complete_CanBeCalledMultipleTimes()
{
// Arrange
var codeDocument = RazorCodeDocument.Create(TestRazorSourceDocument.Create());
var request = new DefaultVisualStudioRazorParser.CodeDocumentRequest(StringTextSnapshot.Empty, CancellationToken.None);
// Act & Assert
request.Complete(codeDocument);
request.Complete(codeDocument);
request.Complete(codeDocument);
}
internal static IReadOnlyList <ClassifiedSpanInternal> GetClassifiedSpans(Block root, string filePath)
{
// We don't care about the options and diagnostic here.
var syntaxTree = RazorSyntaxTree.Create(
root,
TestRazorSourceDocument.Create(filePath: filePath),
Array.Empty <RazorDiagnostic>(),
RazorParserOptions.CreateDefault());
return(syntaxTree.GetClassifiedSpans());
}
public void GetLineLength_Bigger()
{
// Arrange
var content = @"@addTagHelper, * Stuff
@* A comment *@";
var document = TestRazorSourceDocument.Create(content);
var collection = new DefaultRazorSourceLineCollection(document);
// Act & Assert
Assert.Throws <IndexOutOfRangeException>(() => collection.GetLineLength(40));
}
private static TextBufferCodeDocumentProvider CreateCodeDocumentProvider(string content)
{
var sourceDocument = TestRazorSourceDocument.Create(content);
var syntaxTree = RazorSyntaxTree.Parse(sourceDocument, RazorParserOptions.Create(opt => opt.Directives.Add(FunctionsDirective.Directive)));
var codeDocument = TestRazorCodeDocument.Create(content);
codeDocument.SetSyntaxTree(syntaxTree);
var codeDocumentProvider = Mock.Of <TextBufferCodeDocumentProvider>(provider => provider.TryGetFromBuffer(It.IsAny <ITextBuffer>(), out codeDocument), MockBehavior.Strict);
return(codeDocumentProvider);
}
public void Parse_CanParseEmptyDocument()
{
// Arrange
var source = TestRazorSourceDocument.Create(string.Empty);
// Act
var syntaxTree = RazorSyntaxTree.Parse(source);
// Assert
Assert.NotNull(syntaxTree);
Assert.Empty(syntaxTree.Diagnostics);
}
public void Execute_EscapesViewPathAndRouteWhenAddingAttributeToPage()
{
// Arrange
var expectedAttribute = "[assembly:global::Microsoft.AspNetCore.Mvc.Razor.Compilation.RazorViewAttribute(@\"/test/\"\"Index.cshtml\", typeof(SomeNamespace.SomeName))]";
var irDocument = new DocumentIntermediateNode
{
DocumentKind = MvcViewDocumentClassifierPass.MvcViewDocumentKind,
Options = RazorCodeGenerationOptions.CreateDefault(),
};
var builder = IntermediateNodeBuilder.Create(irDocument);
var @namespace = new NamespaceDeclarationIntermediateNode
{
Content = "SomeNamespace",
Annotations =
{
[CommonAnnotations.PrimaryNamespace] = CommonAnnotations.PrimaryNamespace
},
};
builder.Push(@namespace);
var @class = new ClassDeclarationIntermediateNode
{
ClassName = "SomeName",
Annotations =
{
[CommonAnnotations.PrimaryClass] = CommonAnnotations.PrimaryClass,
},
};
builder.Add(@class);
var pass = new AssemblyAttributeInjectionPass
{
Engine = RazorProjectEngine.Create().Engine,
};
var source = TestRazorSourceDocument.Create("test", new RazorSourceDocumentProperties(filePath: null, relativePath: "test\\\"Index.cshtml"));
var document = RazorCodeDocument.Create(source);
// Act
pass.Execute(document, irDocument);
// Assert
Assert.Collection(irDocument.Children,
node =>
{
var csharpCode = Assert.IsType <CSharpCodeIntermediateNode>(node);
var token = Assert.IsType <IntermediateToken>(Assert.Single(csharpCode.Children));
Assert.Equal(TokenKind.CSharp, token.Kind);
Assert.Equal(expectedAttribute, token.Content);
},
node => Assert.Same(@namespace, node));
}