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);
}
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 GetLocation_Negative()
{
// Arrange
var content = @"@addTagHelper, * Stuff
@* A comment *@";
var document = TestRazorSourceDocument.Create(content);
var collection = new DefaultRazorSourceLineCollection(document);
// Act & Assert
Assert.Throws <IndexOutOfRangeException>(() => collection.GetLocation(-1));
}
internal static IReadOnlyList <TagHelperSpanInternal> GetTagHelperSpans(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.GetTagHelperSpans());
}
public void AtValidContentKind_ReturnsFalseAtMarkup()
{
// Arrange
var syntaxTree = RazorSyntaxTree.Parse(TestRazorSourceDocument.Create("<p></p>"));
var changePosition = 2;
// Act
var result = BraceSmartIndenter.AtValidContentKind(changePosition, syntaxTree);
// Assert
Assert.False(result);
}
public void Create()
{
// Arrange
var source = TestRazorSourceDocument.Create();
// Act
var code = RazorCodeDocument.Create(source);
// Assert
Assert.Same(source, code.Source);
Assert.NotNull(code.Items);
}
public void TryComputeNamespace_RelativePathLongerThanFilePath_ReturnsNull()
{
// Arrange
var sourceDocument = TestRazorSourceDocument.Create(filePath: "C:\\Hello\\Test.cshtml", relativePath: "Some\\invalid\\relative\\path\\Test.cshtml");
var codeDocument = TestRazorCodeDocument.Create(sourceDocument, Array.Empty <RazorSourceDocument>());
// Act
codeDocument.TryComputeNamespace(fallbackToRootNamespace: true, out var @namespace);
// Assert
Assert.Null(@namespace);
}
public void TryComputeNamespace_FilePathNull_ReturnsNull()
{
// Arrange
var sourceDocument = TestRazorSourceDocument.Create(filePath: null, relativePath: "Test.cshtml");
var codeDocument = TestRazorCodeDocument.Create(sourceDocument, Array.Empty <RazorSourceDocument>());
// Act
codeDocument.TryComputeNamespace(fallbackToRootNamespace: true, out var @namespace);
// Assert
Assert.Null(@namespace);
}
public void AtValidContentKind_ReturnsTrueAtCode()
{
// Arrange
var syntaxTree = RazorSyntaxTree.Parse(TestRazorSourceDocument.Create("@{}"));
var changePosition = 2;
// Act
var result = BraceSmartIndenter.AtValidContentKind(changePosition, syntaxTree);
// Assert
Assert.True(result);
}
private static RazorSyntaxTree GetSyntaxTree(string content)
{
var syntaxTree = RazorSyntaxTree.Parse(
TestRazorSourceDocument.Create(content),
RazorParserOptions.Create(options =>
{
options.Directives.Add(FunctionsDirective.Directive);
options.Directives.Add(SectionDirective.Directive);
}));
return(syntaxTree);
}
public void MapDirectives_HandlesDuplicates()
{
// Arrange
var source = TestRazorSourceDocument.Create();
var options = RazorParserOptions.CreateDefault();
var context = new ParserContext(source, options);
var parser = new CSharpCodeParser(context);
// Act & Assert (Does not throw)
parser.MapDirectives((b, t) => { }, "test");
parser.MapDirectives((b, t) => { }, "test");
}
public void AtApplicableRazorBlock_AtMarkup_ReturnsFalse()
{
// Arrange
var syntaxTree = RazorSyntaxTree.Parse(TestRazorSourceDocument.Create("<p></p>"));
var changePosition = 2;
// Act
var result = BraceSmartIndenter.AtApplicableRazorBlock(changePosition, syntaxTree);
// Assert
Assert.False(result);
}
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 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 AtApplicableRazorBlock_WhenNoOwner_ReturnsFalse()
{
// Arrange
var syntaxTree = RazorSyntaxTree.Parse(TestRazorSourceDocument.Create("@DateTime.Now"));
var changePosition = 14; // 1 after the end of the content
// Act
var result = BraceSmartIndenter.AtApplicableRazorBlock(changePosition, syntaxTree);
// Assert
Assert.False(result);
}
public void AtApplicableRazorBlock_AtExplicitCodeBlocksCode_ReturnsTrue()
{
// Arrange
var syntaxTree = RazorSyntaxTree.Parse(TestRazorSourceDocument.Create("@{}"));
var changePosition = 2;
// Act
var result = BraceSmartIndenter.AtApplicableRazorBlock(changePosition, syntaxTree);
// Assert
Assert.True(result);
}
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));
}
public void Create_ProcessDesignTime_AlwaysGeneratesEmptyGeneratedCSharp()
{
// Arrange
var factory = new ProjectEngineFactory_Unsupported();
var engine = factory.Create(UnsupportedRazorConfiguration.Instance, RazorProjectFileSystem.Empty, (_) => { });
var sourceDocument = TestRazorSourceDocument.Create("<strong>Hello World!</strong>", RazorSourceDocumentProperties.Default);
// Act
var codeDocument = engine.ProcessDesignTime(sourceDocument, "test", Array.Empty <RazorSourceDocument>(), Array.Empty <TagHelperDescriptor>());
// Assert
Assert.Equal(UnsupportedCSharpLoweringPhase.UnsupportedDisclaimer, codeDocument.GetCSharpDocument().GeneratedCode);
}
public void Create_WithImports_AllowsNull()
{
// Arrange
var source = TestRazorSourceDocument.Create();
// Act
var code = RazorCodeDocument.Create(source, imports: null);
// Assert
Assert.Same(source, code.Source);
Assert.NotNull(code.Items);
Assert.Empty(code.Imports);
}
public void Ctor_AllowsNullForImports()
{
// Arrange
var source = TestRazorSourceDocument.Create();
// Act
var code = new DefaultRazorCodeDocument(source, imports: null);
// Assert
Assert.Same(source, code.Source);
Assert.NotNull(code.Items);
Assert.Empty(code.Imports);
}
public void AtApplicableRazorBlock_AtMetacode_ReturnsTrue()
{
// Arrange
var parseOptions = RazorParserOptions.Create(options => options.Directives.Add(FunctionsDirective.Directive));
var syntaxTree = RazorSyntaxTree.Parse(TestRazorSourceDocument.Create("@functions {}"), parseOptions);
var changePosition = 12;
// Act
var result = BraceSmartIndenter.AtApplicableRazorBlock(changePosition, syntaxTree);
// Assert
Assert.True(result);
}
public void BuildEngine_CallProcess()
{
// Arrange
var engine = RazorEngine.Create();
var document = RazorCodeDocument.Create(TestRazorSourceDocument.Create());
// Act
engine.Process(document);
// Assert
Assert.NotNull(document.GetSyntaxTree());
Assert.NotNull(document.GetDocumentIntermediateNode());
}
private static RazorSyntaxTree CreateSyntaxTree(string text, params DirectiveDescriptor[] directives)
{
var sourceDocument = TestRazorSourceDocument.Create(text);
var options = RazorParserOptions.Create(builder =>
{
foreach (var directive in directives)
{
builder.Directives.Add(directive);
}
});
var syntaxTree = RazorSyntaxTree.Parse(sourceDocument, options);
return(syntaxTree);
}
private void VerifyPartialParseTree(TestParserManager manager, string content, string expectedCode = null)
{
if (expectedCode != null)
{
// Verify if the syntax tree represents the expected input.
var syntaxTreeContent = manager.PartialParsingSyntaxTreeRoot.ToFullString();
Assert.Contains(expectedCode, syntaxTreeContent, StringComparison.Ordinal);
}
var sourceDocument = TestRazorSourceDocument.Create(content);
var syntaxTree = RazorSyntaxTree.Create(manager.PartialParsingSyntaxTreeRoot, sourceDocument, manager.CurrentSyntaxTree.Diagnostics, manager.CurrentSyntaxTree.Options);
BaselineTest(syntaxTree);
}
public async Task CodeDocumentRequest_Complete_FinishesTask()
{
// Arrange
var codeDocument = RazorCodeDocument.Create(TestRazorSourceDocument.Create());
var request = new DefaultVisualStudioRazorParser.CodeDocumentRequest(StringTextSnapshot.Empty, CancellationToken.None);
// Act
request.Complete(codeDocument);
// Assert
Assert.True(request.Task.IsCompleted);
var resolvedSyntaxTree = await request.Task;
Assert.Same(codeDocument, resolvedSyntaxTree);
}
public void CodeDocumentRequest_CancelToCompleteNoops()
{
// Arrange
var codeDocument = RazorCodeDocument.Create(TestRazorSourceDocument.Create());
var request = new DefaultVisualStudioRazorParser.CodeDocumentRequest(StringTextSnapshot.Empty, CancellationToken.None);
// Act - 1
request.Cancel();
// Assert - 1
Assert.True(request.Task.IsCanceled);
// Act & Assert - 2
request.Complete(codeDocument);
}
public void Execute_FunctionsAndComponentCodeDirective_AddsStatementsToClassLevel()
{
// Arrange
var projectEngine = CreateProjectEngine(b => b.AddDirective(ComponentCodeDirective.Directive));
var pass = new FunctionsDirectivePass()
{
Engine = projectEngine.Engine,
};
var sourceDocument = TestRazorSourceDocument.Create(@"
@functions { var value1 = true; }
@code { var value2 = true; }
@functions { var value3 = true; }");
var codeDocument = RazorCodeDocument.Create(sourceDocument);
codeDocument.SetFileKind(FileKinds.Component);
var irDocument = Lower(codeDocument, projectEngine);
// Act
pass.Execute(codeDocument, irDocument);
// Assert
Children(
irDocument,
node => Assert.IsType <NamespaceDeclarationIntermediateNode>(node));
var @namespace = irDocument.Children[0];
Children(
@namespace,
node => Assert.IsType <ClassDeclarationIntermediateNode>(node));
var @class = @namespace.Children[0];
Children(
@class,
node => Assert.IsType <MethodDeclarationIntermediateNode>(node),
node => CSharpCode(" var value1 = true; ", node),
node => CSharpCode(" var value2 = true; ", node),
node => CSharpCode(" var value3 = true; ", node));
var method = @class.Children[0];
Children(
method,
node => Assert.IsType <HtmlContentIntermediateNode>(node));
}
public void GetLocation_AtStart()
{
// Arrange
var content = @"@addTaghelper, * Stuff
@* A comment *@";
var document = TestRazorSourceDocument.Create(content);
var collection = new DefaultRazorSourceLineCollection(document);
// Act
var location = collection.GetLocation(0);
// Assert
var expected = new SourceLocation("test.cshtml", 0, 0, 0);
Assert.Equal(expected, location);
}
public void GetLineLength_AtEnd()
{
// Arrange
var content = @"@addTagHelper, * Stuff
@* A comment *@";
var document = TestRazorSourceDocument.Create(content);
var collection = new DefaultRazorSourceLineCollection(document);
// Act
var lineLength = collection.GetLineLength(1);
// Assert
var expectedLineLength = 15;
Assert.Equal(expectedLineLength, lineLength);
}
private RazorCodeDocument GetCodeDocument(string source)
{
var taghelper = TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly")
.BoundAttributeDescriptor(attr => attr.Name("show").TypeName("System.Boolean"))
.BoundAttributeDescriptor(attr => attr.Name("id").TypeName("System.Int32"))
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("taghelper"))
.TypeName("TestTagHelper")
.Build();
var engine = CreateProjectEngine();
var sourceDocument = TestRazorSourceDocument.Create(source, normalizeNewLines: true);
var importDocument = TestRazorSourceDocument.Create("@addTagHelper *, TestAssembly", filePath: "import.cshtml", relativePath: "import.cshtml");
var codeDocument = engine.ProcessDesignTime(sourceDocument, FileKinds.Legacy, importSources: new [] { importDocument }, new [] { taghelper });
return(codeDocument);
}
