ControllerHelper

ControllerHelper.cs

namespace Web.Tests.TestHelpers
{
    using System;
    using System.IO;
    using System.Linq;
    using System.Security.Principal;
    using System.Web;
    using System.Web.Mvc;
    using System.Web.Routing;

    using Moq;

    using Web.AppStart;
    
    public static class ControllerHelper
    {
        public static T MakeAjax<T>(this T controller) where T : Controller
        {
            var hasMockedContext = true;

            var request = Mock.Get(controller.ControllerContext.HttpContext.Request);

            if (request == null)
            {
                request = new Mock<HttpRequestBase>();
                hasMockedContext = false;
            }

            // IsAjaxRequest() is static extension method and cannot be mocked
            // request.Setup(x => x.IsAjaxRequest()).Returns(true /* or false */);
            // use this
            request.SetupGet(x => x.Headers).Returns(
                new System.Net.WebHeaderCollection 
                {
                    { "X-Requested-With", "XMLHttpRequest" } 
                });

            if (!hasMockedContext)
            {
                var context = new Mock<HttpContextBase>();
                context.SetupGet(x => x.Request).Returns(request.Object);
                controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
            }

            return controller;
        }

        public static T MakeNonAjax<T>(this T controller) where T : Controller
        {
            var request = new Mock<HttpRequestBase>();

            // Not working - IsAjaxRequest() is static extension method and cannot be mocked
            // request.Setup(x => x.IsAjaxRequest()).Returns(true /* or false */);
            // use this
            request.SetupGet(x => x.Headers).Returns(new System.Net.WebHeaderCollection());            

            var context = new Mock<HttpContextBase>();
            context.SetupGet(x => x.Request).Returns(request.Object);

            controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);

            return controller;
        }
        
        public static T WithUrlReferrer<T>(this T controller, Uri url) where T : Controller
        {
            RouteTable.Routes.Clear();
            Routing.Start();

            var request = new Mock<HttpRequestBase>();
            var name = string.Empty;
            
            if (controller.User != null)
            {
                name = controller.User.Identity.Name;
            }

            request.SetupGet(x => x.Headers).Returns(new System.Net.WebHeaderCollection());
            request.Setup(x => x.IsAuthenticated).Returns(true);
            request.SetupGet(x => x.Url).Returns(url);
            request.SetupGet(x => x.UrlReferrer).Returns(url);
            request.Setup(x => x.ApplicationPath).Returns("/");
            request.Setup(c => c.AppRelativeCurrentExecutionFilePath).Returns("~/");
            request.Setup(c => c.PathInfo).Returns(string.Empty);

            var response = new Mock<HttpResponseBase>();
            response.Setup(r => r.ApplyAppPathModifier(It.IsAny<string>())).Returns((string s) => s);

            var context = new Mock<HttpContextBase>();
            context.SetupGet(x => x.Request).Returns(request.Object);
            context.Setup(x => x.Response).Returns(response.Object);
            context.Setup(x => x.Server.MapPath(It.IsAny<string>())).Returns(string.Empty);

            if (!string.IsNullOrWhiteSpace(name))
            {
                context.SetupGet(x => x.User.Identity.Name).Returns(name);
            }

            var routeData = new RouteData();
            controller.ControllerContext = new ControllerContext(context.Object, routeData, controller);
            controller.Url = new UrlHelper(new RequestContext(controller.HttpContext, routeData), RouteTable.Routes);
            
            return controller;
        }

        public static T WithDocumentCacheParameters<T>(this T controller, string fileName, string documentType, Guid applicationId, Guid addressId, string addressType) where T : Controller
        {
            RouteTable.Routes.Clear();
            Routing.Start();

            var request = new Mock<HttpRequestBase>();
            var name = string.Empty;

            if (controller.User != null)
            {
                name = controller.User.Identity.Name;
            }

            request.SetupGet(x => x.Headers).Returns(new System.Net.WebHeaderCollection());
            request.Setup(x => x.IsAuthenticated).Returns(true);
            request.Setup(x => x.ApplicationPath).Returns("/");
            request.SetupGet(x => x["qqfile"]).Returns(fileName);
            request.SetupGet(x => x["documentType"]).Returns(documentType);
            request.SetupGet(x => x["applicationId"]).Returns(applicationId.ToString());
            request.SetupGet(x => x["addressId"]).Returns(addressId.ToString());
            request.SetupGet(x => x["addressType"]).Returns(addressType);

            request.SetupGet(x => x.InputStream).Returns(new MemoryStream(new byte[] { 12, 12 }));
            request.SetupGet(x => x.ContentType).Returns("content/type");

            var response = new Mock<HttpResponseBase>();
            response.Setup(r => r.ApplyAppPathModifier(It.IsAny<string>())).Returns((string s) => s);

            var context = new Mock<HttpContextBase>();
            context.SetupGet(x => x.Request).Returns(request.Object);
            context.Setup(x => x.Response).Returns(response.Object);
            context.Setup(x => x.Server.MapPath(It.IsAny<string>())).Returns(string.Empty);

            if (!string.IsNullOrWhiteSpace(name))
            {
                context.SetupGet(x => x.User.Identity.Name).Returns(name);
            }

            controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
            controller.Url = new UrlHelper(new RequestContext(controller.HttpContext, new RouteData()), RouteTable.Routes);

            return controller;
        }

        public static T WithUrl<T>(this T controller, Uri url) where T : Controller
        {
            var request = new Mock<HttpRequestBase>();
            var name = string.Empty;

            if (controller.User != null)
            {
                name = controller.User.Identity.Name;
            }

            request.SetupGet(x => x.Headers).Returns(new System.Net.WebHeaderCollection());
            request.Setup(x => x.IsAuthenticated).Returns(true);
            request.SetupGet(x => x.Url).Returns(url);

            var context = new Mock<HttpContextBase>();
            context.SetupGet(x => x.Request).Returns(request.Object);
            context.Setup(x => x.Server.MapPath(It.IsAny<string>())).Returns(string.Empty);

            if (!string.IsNullOrWhiteSpace(name))
            {
                context.SetupGet(x => x.User.Identity.Name).Returns(name);
            }

            var routeData = new RouteData();
            controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
            controller.Url = new UrlHelper(new RequestContext(controller.HttpContext, routeData), RouteTable.Routes);

            return controller;
        }

        public static T WithUserAndPermissions<T>(this T controller, string username, params string[] permissions) where T : Controller
        {
            var request = new Mock<HttpRequestBase>();

            request.SetupGet(x => x.Headers).Returns(new System.Net.WebHeaderCollection());
            request.Setup(x => x.IsAuthenticated).Returns(true);

            var context = new Mock<HttpContextBase>();
            var principal = new Mock<IPrincipal>();
            var identity = new Mock<IIdentity>();

            identity.SetupGet(x => x.Name).Returns(username);
            principal.SetupGet(x => x.Identity).Returns(identity.Object);

            foreach (var permission in permissions)
            {
                principal.Setup(x => x.IsInRole(permission)).Returns(true);
            }
            
            context.SetupGet(x => x.User).Returns(principal.Object);
            context.Setup(x => x.Server.MapPath(It.IsAny<string>())).Returns(string.Empty);
            context.SetupGet(x => x.Request).Returns(request.Object);

            var routeData = new RouteData();
            controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
            controller.Url = new UrlHelper(new RequestContext(controller.HttpContext, routeData), RouteTable.Routes);

            return controller;
        }

        public static T WithUserAndUrl<T>(this T controller, string username, string url) where T : Controller
        {
            RouteTable.Routes.Clear();
            Routing.Start();

            var request = new Mock<HttpRequestBase>();

            request.SetupGet(x => x.Headers).Returns(new System.Net.WebHeaderCollection());
            request.Setup(x => x.IsAuthenticated).Returns(true);
            request.SetupGet(x => x.Url).Returns(new Uri(url));
            request.SetupGet(x => x.UrlReferrer).Returns(new Uri(url));

            var context = new Mock<HttpContextBase>();
            var principal = new Mock<IPrincipal>();
            var identity = new Mock<IIdentity>();
            var httpResponse = new Mock<HttpResponseBase>();

            httpResponse.Setup(r => r.ApplyAppPathModifier(It.IsAny<string>())).Returns((string s) => s);

            identity.SetupGet(x => x.Name).Returns(username);
            principal.SetupGet(x => x.Identity).Returns(identity.Object);

            context.SetupGet(x => x.User).Returns(principal.Object);
            context.Setup(x => x.Server.MapPath(It.IsAny<string>())).Returns(string.Empty);
            context.Setup(x => x.Response).Returns(httpResponse.Object);
            context.SetupGet(x => x.Request).Returns(request.Object);

            var routeData = new RouteData();
            controller.ControllerContext = new ControllerContext(context.Object, new RouteData(), controller);
            controller.Url = new UrlHelper(new RequestContext(controller.HttpContext, routeData), RouteTable.Routes);

            return controller;
        }

        public static T WithUser<T>(this T controller, string name) where T : Controller
        {            
            return WithUserAndPermissions(controller, name);
        }

        public static T WithInvalidModelState<T>(this T controller) where T : Controller
        {
            controller.ModelState.AddModelError("key", "error message");
            return controller;
        }

        public static T WithUrlHelper<T>(this T controller) where T : Controller
        {
            RouteTable.Routes.Clear();
            Routing.Start();

            var request = new Mock<HttpRequestBase>();
            var response = new Mock<HttpResponseBase>();

            request.SetupGet(x => x.Headers).Returns(new System.Net.WebHeaderCollection());
            request.SetupGet(x => x.ApplicationPath).Returns("/");
            request.SetupGet(x => x.Url).Returns(new Uri("http://localhost/", UriKind.Absolute));
            request.SetupGet(x => x.ServerVariables).Returns(new System.Collections.Specialized.NameValueCollection());
            request.SetupGet(x => x.Files).Returns(new Func<HttpFileCollectionBase>(() => null));

            response.Setup(x => x.ApplyAppPathModifier(It.IsAny<string>())).Returns((string s) => s);

            var context = new Mock<HttpContextBase>();
            context.SetupGet(x => x.Request).Returns(request.Object);
            context.SetupGet(x => x.Response).Returns(response.Object);
            context.Setup(x => x.Server.MapPath(It.IsAny<string>())).Returns(string.Empty);
            
            var routeData = new RouteData();
            controller.ControllerContext = new ControllerContext(context.Object, routeData, controller);            
            controller.Url = new UrlHelper(new RequestContext(controller.HttpContext, routeData), RouteTable.Routes);
            return controller;
        }

        public static T WithRoute<T>(this T controller, string route, string url, string urlReferrer = "") where T : Controller
        {
            RouteTable.Routes.Clear();
            Routing.Start();

            var context = Mock.Get(controller.ControllerContext.HttpContext) ?? new Mock<HttpContextBase>();
            var request = Mock.Get(controller.ControllerContext.HttpContext.Request) ?? new Mock<HttpRequestBase>();
            var response = new Mock<HttpResponseBase>();
            
            request.SetupGet(x => x.Url).Returns(new Uri(url, UriKind.Absolute));
            request.SetupGet(x => x.UrlReferrer).Returns(new Uri(string.IsNullOrEmpty(urlReferrer) ? url : urlReferrer, UriKind.RelativeOrAbsolute));
            request.SetupGet(x => x.ApplicationPath).Returns("/");
            request.SetupGet(x => x.ServerVariables).Returns(new System.Collections.Specialized.NameValueCollection());

            response.Setup(x => x.ApplyAppPathModifier(It.IsAny<string>())).Returns((string s) => s);

            context.SetupGet(x => x.Request).Returns(request.Object);
            context.SetupGet(x => x.Response).Returns(response.Object);
            context.Setup(x => x.Server.MapPath(It.IsAny<string>())).Returns(string.Empty);

            var routeData = new RouteData { Route = RouteTable.Routes[route] };
            var requestContext = new Mock<RequestContext>(controller.HttpContext, routeData);

            requestContext.Setup(x => x.RouteData).Returns(routeData);

            controller.ControllerContext = new ControllerContext(context.Object, routeData, controller);
            controller.Url = new UrlHelper(requestContext.Object, RouteTable.Routes);

            return controller;
        }
    }
}