using System;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Threading;
using System.Web;
using System.Web.Hosting;
using System.Web.SessionState;

public sealed class MockHttpContext
{
    // NOTE: This code is based on the following article:
    // http://righteousindignation.gotdns.org/blog/archive/2004/04/13/149.aspx
    private const string ContextKeyAspSession = "AspSession";
    private const string ThreadDataKeyAppPath = ".appPath";
    private const string ThreadDataKeyAppPathValue = "c:\\inetpub\\wwwroot\\webapp\\";
    private const string ThreadDataKeyAppVPath = ".appVPath";
    private const string ThreadDataKeyAppVPathValue = "/webapp";
    private const string WorkerRequestPage = "default.aspx";

    private HttpContext context = null;

    private MockHttpContext()
        : base()
    {
    }

    public MockHttpContext(bool isSecure)
        : this()
    {
        Thread.GetDomain().SetData(
            MockHttpContext.ThreadDataKeyAppPath, MockHttpContext.ThreadDataKeyAppPathValue);
        Thread.GetDomain().SetData(
            MockHttpContext.ThreadDataKeyAppVPath, MockHttpContext.ThreadDataKeyAppVPathValue);
        SimpleWorkerRequest request = new WorkerRequest(MockHttpContext.WorkerRequestPage,
            string.Empty, new StringWriter(), isSecure);
        this.context = new HttpContext(request);

        HttpSessionStateContainer container = new HttpSessionStateContainer(
            Guid.NewGuid().ToString("N"), new SessionStateItemCollection(), new HttpStaticObjectsCollection(),
            5, true, HttpCookieMode.AutoDetect, SessionStateMode.InProc, false);

        HttpSessionState state = Activator.CreateInstance(
             typeof(HttpSessionState),
             BindingFlags.Public | BindingFlags.NonPublic |
             BindingFlags.Instance | BindingFlags.CreateInstance,
             null,
             new object[] { container }, CultureInfo.CurrentCulture) as HttpSessionState;
        this.context.Items[ContextKeyAspSession] = state;
    }

    public HttpContext Context
    {
        get
        {
            return this.context;
        }
    }

    private class WorkerRequest : SimpleWorkerRequest
    {
        private bool isSecure = false;

        public WorkerRequest(string page, string query, TextWriter output, bool isSecure)
            : base(page, query, output)
        {
            this.isSecure = isSecure;
        }

        public override bool IsSecure()
        {
            return this.isSecure;
        }
    }
}

Related posts:

1. Redirecting using strong types in an asp.net web application project Update, I recommend also reading the following post after you...

Related posts brought to you by Yet Another Related Posts Plugin.

Last night I was at the first meeting of the local alt.net book club, we’re currently going through a book called the art of unit testing. What I took from reading the first chapter and the discussion we had at the meeting was that you test your code already, your tests can be improved and unit testing will improve it. My first mistake was to confuse what unit testing was. I thought it was just automated testing. I had used a unit testing framework and that’s all that I had learnt from doing so. However once you start reading up on the best practices of testing you hear a different story.

Unit testing is testing a piece of logic as a unit isolated from all dependancies. That’s not the offical definition, it’s only designed to cover the bit that I msised. When you unit test a piece of code, you shouldn’t call other parts of your code. If necessary you should fake, mock or stub the rest of your logic in order to isolate that code properly. When you get the result of that test, you’ll then know whether that unit of logic is working or not.

Alternatively you could all it to call other units of logic and then you’ll know either that all is well or something somewhere in your code is broken. Which is fine if you have a small project that will never grow, because then you’ll only lose a small amount of time hunting down bugs gradually increasing as your grasp of the project slips over time. However if you have a large project you could easily lose days, it’s even worse when you have a whole team full of people that every time there is a failed test, the whole project doesn’t work and no one can proceed.

That’s what I took away from it, I’d recommend book clubs as a pain free way to get through technical books and I shall be using unit testing next chance I get.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.