public void PostProcessGeneratedCodeAddsStaticApplicationInstanceProperty()
{
// Arrange
WebCodeRazorHost host = new WebCodeRazorHost("Foo.cshtml");
CodeGeneratorContext context =
CodeGeneratorContext.Create(
host,
() => new CSharpCodeWriter(),
"TestClass",
"TestNamespace",
"Foo.cshtml",
shouldGenerateLinePragmas: true);
// Act
host.PostProcessGeneratedCode(context);
// Assert
CodeMemberProperty appInstance = context.GeneratedClass
.Members
.OfType <CodeMemberProperty>()
.Where(p => p.Name.Equals("ApplicationInstance"))
.SingleOrDefault();
Assert.NotNull(appInstance);
Assert.True(appInstance.Attributes.HasFlag(MemberAttributes.Static));
}
private static CodeGeneratorContext CreateContext()
{
return(CodeGeneratorContext.Create(new MvcRazorHost(new TestFileSystem()),
"MyClass",
"MyNamespace",
string.Empty,
shouldGenerateLinePragmas: true));
}
private static Mock <ChunkVisitor <CodeWriter> > CreateVisitor()
{
var context = CodeGeneratorContext.Create(new RazorEngineHost(new CSharpRazorCodeLanguage()),
"myclass",
"myns",
string.Empty,
shouldGenerateLinePragmas: false);
var writer = Mock.Of <CodeWriter>();
return(new Mock <ChunkVisitor <CodeWriter> >(writer, context));
}
public void PostProcessGeneratedCodeAddsApplicationInstanceProperty()
{
string expectedPropertyCode =
Environment.NewLine
+ "protected Foo.Bar ApplicationInstance {"
+ Environment.NewLine
+ " get {"
+ Environment.NewLine
+ " return ((Foo.Bar)(Context.ApplicationInstance));"
+ Environment.NewLine
+ " }"
+ Environment.NewLine
+ "}"
+ Environment.NewLine;
// Arrange
WebPageRazorHost host = new WebPageRazorHost("Foo.cshtml")
{
GlobalAsaxTypeName = "Foo.Bar"
};
CodeGeneratorContext context = CodeGeneratorContext.Create(
host,
() => new CSharpCodeWriter(),
"TestClass",
"TestNs",
"TestFile.cshtml",
shouldGenerateLinePragmas: true
);
// Act
host.PostProcessGeneratedCode(context);
// Assert
CodeMemberProperty property = context.GeneratedClass.Members[0] as CodeMemberProperty;
Assert.NotNull(property);
CSharpCodeProvider provider = new CSharpCodeProvider();
StringBuilder builder = new StringBuilder();
using (StringWriter writer = new StringWriter(builder))
{
provider.GenerateCodeFromMember(property, writer, new CodeGeneratorOptions());
}
Assert.Equal(expectedPropertyCode, builder.ToString());
}
public void CreateCodeBuilder_ReturnsNewCSharpCodeBuilder()
{
// Arrange
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language);
var context = CodeGeneratorContext.Create(host,
"myclass",
"myns",
string.Empty,
shouldGenerateLinePragmas: false);
// Act
var generator = language.CreateCodeBuilder(context);
// Assert
Assert.IsType <CSharpCodeBuilder>(generator);
}
public void PostProcessGeneratedCodeRemovesExecuteMethod()
{
// Arrange
WebCodeRazorHost host = new WebCodeRazorHost("Foo.cshtml");
CodeGeneratorContext context = CodeGeneratorContext.Create(
host,
() => new CSharpCodeWriter(),
"TestClass",
"TestNamespace",
"TestFile.cshtml",
shouldGenerateLinePragmas: true);
// Act
host.PostProcessGeneratedCode(context);
// Assert
Assert.Equal(0, context.GeneratedClass.Members.OfType <CodeMemberMethod>().Count());
}
public void PostProcessGeneratedCodeAddsGlobalImports()
{
// Arrange
WebPageRazorHost.AddGlobalImport("Foo.Bar");
WebPageRazorHost host = new WebPageRazorHost("Foo.cshtml");
CodeGeneratorContext context = CodeGeneratorContext.Create(
host,
() => new CSharpCodeWriter(),
"TestClass",
"TestNs",
"TestFile.cshtml",
shouldGenerateLinePragmas: true);
// Act
host.PostProcessGeneratedCode(context);
// Assert
Assert.True(context.Namespace.Imports.OfType <CodeNamespaceImport>().Any(import => String.Equals("Foo.Bar", import.Namespace)));
}
public void CodeTreeWithUsings()
{
var syntaxTreeNode = new Mock <Span>(new SpanBuilder());
var language = new CSharpRazorCodeLanguage();
var host = new RazorEngineHost(language);
var context = CodeGeneratorContext.Create(host, "TestClass", "TestNamespace", "Foo.cs", shouldGenerateLinePragmas: false);
context.CodeTreeBuilder.AddUsingChunk("FakeNamespace1", syntaxTreeNode.Object);
context.CodeTreeBuilder.AddUsingChunk("FakeNamespace2.SubNamespace", syntaxTreeNode.Object);
var codeBuilder = language.CreateCodeBuilder(context);
// Act
var result = codeBuilder.Build();
BaselineWriter.WriteBaseline(@"test\Microsoft.AspNet.Razor.Test\TestFiles\CodeGenerator\CS\Output\CSharpCodeBuilder.cs", result.Code);
var expectedOutput = TestFile.Create("TestFiles/CodeGenerator/CS/Output/CSharpCodeBuilder.cs").ReadAllText();
// Assert
Assert.Equal(expectedOutput, result.Code);
}
public void CreateCodeBuilder_PassesCodeGeneratorThroughDecorateMethodOnHost()
{
// Arrange
var mockHost = new Mock <RazorEngineHost>(new CSharpRazorCodeLanguage())
{
CallBase = true
};
var context = CodeGeneratorContext.Create(mockHost.Object,
"different-class",
"different-ns",
string.Empty,
shouldGenerateLinePragmas: true);
var expected = new CSharpCodeBuilder(context);
mockHost.Setup(h => h.DecorateCodeBuilder(It.IsAny <CSharpCodeBuilder>(), context))
.Returns(expected);
var engine = new RazorTemplateEngine(mockHost.Object);
// Act
var actual = engine.CreateCodeBuilder(context);
// Assert
Assert.Equal(expected, actual);
}
