MockHost.cs

using System;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.Remoting.Messaging;
using System.Web;
using System.Web.Hosting;

namespace Standardikeskus.Tests
{
    public class MockHost
    {
        private string pdir;
        private string vdir;
        private string page = "/";

        public MockHost(string pdir, string vdir)
        {
            this.pdir = pdir;
            this.vdir = vdir;
        }

        private static HttpRuntime GetTheRuntimeInstance()
        {
            Type HttpRuntimeType = typeof(HttpRuntime);
            BindingFlags flags = BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Static;
            return HttpRuntimeType.InvokeMember(
                        "_theRuntime",
                        flags,
                        null,
                        null,
                        null) as HttpRuntime;
        }

        private static void SetHttpRuntimePath(HttpRuntime instance, string pdir, string vdir)
        {
            Type httpRuntimeType = typeof(HttpRuntime);

            BindingFlags flags = BindingFlags.NonPublic | BindingFlags.SetField | BindingFlags.Instance;

            httpRuntimeType.InvokeMember(
                    "_appDomainAppPath",
                    flags,
                    null,
                    instance,
                    new object[] { pdir }
                );

            HostingEnvironment en = new HostingEnvironment();
            FieldInfo _appPhysicalPath = typeof(HostingEnvironment).GetField("_appPhysicalPath", BindingFlags.Instance | BindingFlags.NonPublic);
            _appPhysicalPath.SetValue(en, pdir);

            FieldInfo _appVirtualPath = typeof(HostingEnvironment).GetField("_appVirtualPath", BindingFlags.Instance | BindingFlags.NonPublic);

            Type vtype = httpRuntimeType.Assembly.GetType("System.Web.VirtualPath");
            object virtualPath = vtype.InvokeMember("Create", BindingFlags.InvokeMethod, null, null, new object[] { vdir });
            _appVirtualPath.SetValue(en, virtualPath);

            FieldInfo fi = typeof(HostingEnvironment).GetField("_theHostingEnvironment", BindingFlags.NonPublic | BindingFlags.Static);
            fi.SetValue(null, en);

            httpRuntimeType.InvokeMember(
                    "_appDomainAppVPath",
                    flags,
                    null,
                    instance,
                    new object[] { virtualPath }
                );

        }

        public void Setup()
        {

            HttpRuntime instance = GetTheRuntimeInstance();

            //set call context for base folder
            SetCallContext(pdir, vdir);

            SetHttpRuntimePath(instance, pdir, vdir);

            SimpleWorkerRequest request = new SimpleWorkerRequest(vdir, pdir, page, null, new StringWriter());
            FieldInfo fInfo = request.GetType().GetField("_hasRuntimeInfo", BindingFlags.Instance | BindingFlags.NonPublic);
            fInfo.SetValue(request, true);
            HttpContext.Current = new HttpContext(request);

        }

        private static void SetCallContext(string pdir, string relativedir)
        {
            string rdir = relativedir;

            // remove the starting slash
            if (rdir[0] == '/')
            {
                rdir = rdir.Substring(1);
            }

            // change the virtual dir structure.
            rdir = rdir.Replace('/', '\\');

            string fdir = Path.Combine(pdir, rdir);
            DirectoryInfo fdirInfo = new DirectoryInfo(fdir);

            foreach (DirectoryInfo dir in fdirInfo.GetDirectories())
            {
                string sName = string.Format("{0}{1}", relativedir, dir.Name);

                CallContext.SetData(GetFixedMappingSlotName(sName), dir.FullName);
                SetCallContext(pdir, string.Format("{0}{1}/", relativedir, dir));
            }

            foreach (var fileInfo in fdirInfo.GetFiles())
            {
                string sName = string.Format("{0}{1}", relativedir, fileInfo.Name);

                CallContext.SetData(GetFixedMappingSlotName(sName), fileInfo.FullName);
            }
        }

        private static string GetFixedMappingSlotName(string virtualPathString)
        {
            return ("MapPath_" + virtualPathString.ToLowerInvariant().GetHashCode().ToString(CultureInfo.InvariantCulture));
        }

    }
}