How to unit test static method which is used in the razor view?

Question

Let's say I have a static class with the following extension method which retrieves the file from the Cache or reads it from disk and puts it in the Cache if it is not there + makes some changes to the content (e.g., add tags or attributes):

public static class Foo
{
  public static DoSomething(this HtmlHelper helper, string url, List<string> parameters)
  {
     string content = String.Empty;
     var cache = HttpContext.Current.Cache[url];

     if (cache == null)
     {
       string absolute_path = WebPages.HelperPage.Server.MapPath(url);
       content = File.ReadAllText(absolute_path);
       HttpContext.Current.Cache.Add(url, content, ...);
     }
     else
     {
       content = cache.ToString();
     }

     //make a few changes to content (e.g., add some tags or attributes)
     content = makeChangesToContent(content, parameters);

     return MvcHtmlString.Create(content);
  }
}

This method is used in the razor view like this:

   @Html.DoSomething("/path/to/file", new List<string>(){"param1", "param2"});

To make this code testable I have to remove all the dependencies from the method. But since it is static and used in the razor view I'm not sure how to do it right.

The only one option came to my mind is to use Shims to fake external dependencies with some fake methods. But the unit test code looks a bit heavy and it takes around 200ms to run it.

Here is a quick example of the unit test:

[Test]
public void DoSomething_Should_Return_FileContent_From_Cache_When_It_Is_There()
{
    string relativeFilePath = "/some/path";
    string fileContent = "content";
    string cachedKey = String.Empty;
    object cachedValue = null;

    using (ShimsContext.Create())
    {
        //Arrange
        System.Web.Fakes.ShimHttpContext.CurrentGet = () =>
        {
            var httpContext = new System.Web.Fakes.ShimHttpContext();

            httpContext.CacheGet = () =>
            {
                var cache = new System.Web.Caching.Fakes.ShimCache();

                cache.ItemGetString = (key) =>
                {
                    cachedKey = key;
                    cachedValue = fileContent;

                    return fileContent;
                };

                return cache;
            };

            return httpContext;
        };

        //Act
        var result = helper.DoSomething(relativeFilePath, new List<string>(){"param1", "param2"});

        //Assert
        Assert.IsTrue(cachedKey.Equals(relativeFilePath));
        Assert.IsTrue(cachedValue.Equals(fileContent));
    }

Is it correct way to test it? Are there any better options? From you experience, what is the best approach to test such static methods?

Answer 1

Your method does too much, I'd split it up:

public class GetFileController
{
  public string GetFileContent(string url)
  {
    //Read file from disk & return content
  }

  public string GetCachedFileContent(string url, Cache cache)
  {
    if(!cache.ContainsUrl)
      cache[url] =  GetFileContent(url);
    return cache[url];
  }
}

public class MakeChangesController()
{
  public string DoChanges(){}
}

You can then mock out the filereading and test your do changes without having to read from disk.

Answer 2

HtmlHelpers are supposed to be for outputting Html for a view.

Here's a good explanation Why do we use HTML helper in ASP.NET MVC?

The helper you wrote really looks like it should be in a controller action. something like

public class ScratchController : Controller
{
    private readonly IProvideFilePath _pathProvider;
    private readonly IProvideCacheSupport _cacheProvider;
    public ScratchController(IProvideFilePath pathProvider, IProvideCacheSupport cacheProvider)
    {
        _pathProvider = pathProvider;
        _cacheProvider = cacheProvider;
    }

    [HttpPost]
    public FileResult Index(string url, List<string> parameters)
    {
        var fileContent = _cacheProvider.GetItem(url) as string;  
        if (string.IsNullOrWhiteSpace(fileContent))
        {
            var filePath = _pathProvider.MapPath(url);

            fileContent = File.ReadAllText(filePath);
            _cacheProvider.AddItem(url, fileContent);
        }

        fileContent = makeChangesToContent(fileContent, parameters);

        return Content(fileContent);
    }
}

where the IProviderFilePath fronts a class that wraps the Server.MapPath calls and IProvideCacheSupport fronts a class that wraps calls to Cache. that way you can mock both.