这是模拟HttpContextBase，HttpRequestBase和HttpResponseBase进行单元测试Cookie的正确方法吗？

Question

Given the following class to write and read cookies:

public static class CookieManager
{
    #region Methods

    /// <summary>
    ///     Writes a new cookie on the.
    /// </summary>
    /// <param name="response">The <see cref="HttpResponseBase"/> that is used to write the cookies.</param>
    /// <param name="name">The name of the cookie.</param>
    /// <param name="value">The value of the cookie.</param>
    public static void Write(HttpResponseBase response, string name, string value)
    {
        var applicationCookie = new HttpCookie(name) { Value = value, Expires = DateTime.Now.AddYears(1) };
        response.Cookies.Add(applicationCookie);
    }

    /// <summary>
    ///     Reads a cookie.
    /// </summary>
    /// <param name="request">The <see cref="HttpRequestBase"/> that is used to read cookies.</param>
    /// <param name="name">The name of the cookie to read.</param>
    /// <param name="defaultValue">The value to return when the cookie does not exists.</param>
    /// <returns>The value of the cookie if it's exists, otherwise the defautValue.</returns>
    public static string Read(HttpRequestBase request, string name, string defaultValue)
    {
        if (request.Cookies[name] != null)
        {
            return request.Cookies[name].Value;
        }

        return defaultValue;
    }

    /// <summary>
    ///     Check if a cookie does exists.
    /// </summary>
    /// <param name="request">The <see cref="HttpRequestBase"/> that is used to read cookies.</param>
    /// <param name="name">The name of the cookie.</param>
    /// <returns><see langword="true" /> when the cookie does exists, otherwise <see langword="false" />.</returns>
    public static bool Exists(HttpRequestBase request, string name)
    {
        if (request.Cookies[name] != null)
        {
            return true;
        }

        return false;
    }

    #endregion
}

Now, I do have a unit test and I want to test my CookieManager. Here's the unit test:

/// <summary>
///     Checks if the repository of the logs does contain an entry.
/// </summary>
[TestMethod]
public void then_the_cookie_should_be_present_in_the_cookiecollection()
{
    var context = new Mock<HttpContextBase>();
    var request = new Mock<HttpRequestBase>();
    var response = new Mock<HttpResponseBase>();

    response.SetupGet(x => x.Cookies).Returns(new HttpCookieCollection());
    request.SetupGet(x => x.Cookies).Returns(response.Object.Cookies);
    context.SetupGet(x => x.Request).Returns(request.Object);
    context.SetupGet(x => x.Response).Returns(response.Object);

    CookieManager.Write(response.Object, "CookieName", "CookieValue");
    var cookie = CookieManager.Read(request.Object, "CookieName", "Default");

    Assert.AreEqual("CookieValue", cookie, "The value retrieved from the cookie is incorrect.");
}

I know that this test is working, but I want to make sure that it's the correct way of testing or if there is any better solution.

I know CodeReview, but I do think the question is best placed here. If not, my aplogies.

Answer 1

Testing against HttpContextBase is hard as it is closely coupled to the web framework. So the HttpContextBase class can be thought as Humble Object Pattern . This means that you don't necessarily need to test the logic in HttpContextBase.

To make HttpContextBase humble, you need to extract abstraction from logic of HttpContextBase as the following.

public interface ICookies
{
    string this[string name]{ get; set; }
}

And then, you can create the humble class, which isn't under test.

public class Cookies : ICookies
{
    public string this[string name]
    {
        get
        {
            var cookie = HttpContext.Current.Request.Cookies[name];
            if (cookie == null)
                throw new KeyNotFoundException();
            return cookie.Value;
        }
        set
        {
            var cookie = HttpContext.Current.Request.Cookies[name];
            if (cookie == null)
                throw new KeyNotFoundException();
            cookie.Value = value;
        }
    }
}

Your target class will be changed as below.

public static class CookieManager
{
    public static void Write(ICookies cookies, string name, string value)
    {
        ...
    }

    ...
}

This would not be the best, but if I fall into your case, I will do like this.