How can I test code that depends on display templates?

Created a workaround. It's ugly and violates best practices, but it works.

1) Add extension class for extension method class:

public static class MyExtensionMethods
{
    static MyExtensionMethods()
    {
        Renderer = (html, model) =>
        {
            // this is the default implementation that will be used by MVC runtime
            var viewDataContainer = new ViewDataContainer<INode>(model);
            var modelHtmlHelper = new HtmlHelper<INode>(html.ViewContext, viewDataContainer);

            return modelHtmlHelper.DisplayFor(node => node, "TemplateName");
        };
    }

    public static Func<HtmlHelper, INode, MvcHtmlString> Renderer { get; set; }

    public static MvcHtmlString Menu(this HtmlHelper html)
    {
        var model = new Model();
        return Renderer(html, model);
    }
}

      

        
        
        
      

    

2) Use a self-driving Razor engine to execute the template:

using System;
using System.CodeDom.Compiler;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web.Razor;
using Microsoft.CSharp;

namespace YourNamespace.Specifications.SpecUtils
{
    public sealed class InMemoryRazorEngine
    {
        public static ExecutionResult Execute<TModel>(string razorTemplate, TModel model, params Assembly[] referenceAssemblies)
        {
            var razorEngineHost = new RazorEngineHost(new CSharpRazorCodeLanguage());
            razorEngineHost.DefaultNamespace = "RazorOutput";
            razorEngineHost.DefaultClassName = "Template";
            razorEngineHost.NamespaceImports.Add("System");
            razorEngineHost.DefaultBaseClass = typeof(RazorTemplateBase<TModel>).FullName;

            var razorTemplateEngine = new RazorTemplateEngine(razorEngineHost);

            using (var template = new StringReader(razorTemplate))
            {
                var generatorResult = razorTemplateEngine.GenerateCode(template);

                var compilerParameters = new CompilerParameters();
                compilerParameters.GenerateInMemory = true;
                compilerParameters.ReferencedAssemblies.Add(typeof(InMemoryRazorEngine).Assembly.Location);
                if (referenceAssemblies != null)
                {
                    foreach (var referenceAssembly in referenceAssemblies)
                    {
                        compilerParameters.ReferencedAssemblies.Add(referenceAssembly.Location);
                    }
                }

                var codeProvider = new CSharpCodeProvider();
                var compilerResult = codeProvider.CompileAssemblyFromDom(compilerParameters, generatorResult.GeneratedCode);

                var compiledTemplateType = compilerResult.CompiledAssembly.GetExportedTypes().Single();
                var compiledTemplate = Activator.CreateInstance(compiledTemplateType);

                var modelProperty = compiledTemplateType.GetProperty("Model");
                modelProperty.SetValue(compiledTemplate, model, null);

                var executeMethod = compiledTemplateType.GetMethod("Execute");
                executeMethod.Invoke(compiledTemplate, null);

                var builderProperty = compiledTemplateType.GetProperty("OutputBuilder");
                var outputBuilder = (StringBuilder)builderProperty.GetValue(compiledTemplate, null);
                var runtimeResult = outputBuilder.ToString();

                return new ExecutionResult(generatorResult, compilerResult, runtimeResult);
            }
        }

        #region Nested type: ExecutionResult

        public sealed class ExecutionResult
        {
            public ExecutionResult(GeneratorResults generatorResult, CompilerResults compilerResult, string runtimeResult)
            {
                GeneratorResult = generatorResult;
                CompilerResult = compilerResult;
                RuntimeResult = runtimeResult;
            }

            public GeneratorResults GeneratorResult { get; private set; }
            public CompilerResults CompilerResult { get; private set; }
            public string RuntimeResult { get; private set; }
        }

        #endregion

        #region Nested type: RazorTemplateBase

        public abstract class RazorTemplateBase<TModel>
        {
            protected RazorTemplateBase()
            {
                OutputBuilder = new StringBuilder();
            }

            public TModel Model { get; set; }
            public StringBuilder OutputBuilder { get; private set; }

            public abstract void Execute();

            public virtual void Write(object value)
            {
                OutputBuilder.Append(value);
            }

            public virtual void WriteLiteral(object value)
            {
                OutputBuilder.Append(value);
            }
        }

        #endregion
    }
}

      

        
        
        
      

    

3) Override the default Renderer extension method in your test

public class when_extension_method_is_used
{
    static MvcHtmlString output;

    Because of = () =>
    {    
        var htmlHelper = new HtmlHelper(new ViewContext(), new ViewPage());

        MyExtensionMethods.Renderer = (html, model) =>
        {
            const string template = "<blink>@Model</blink>";

            var executionResult = InMemoryRazorEngine.Execute(template, model);
            return new MvcHtmlString(executionResult.RuntimeResult);
        };

        output = htmlHelper.MyMethod();
    };

    It should_just_work =
        () => output.ToString().ShouldEqual("<blink>make UX experts cry!</blink>");
    }
}

      

        
        
        
      

    

Notes:

• And in three easy steps you can test the logic of your extension methods
• I have executed enough code for my tests to work (namely @Model). If you want richer API support in views, you will have to extendRazorTemplateBase