Unit Testing ASP.NET (not MVC) - How do I get past "Request is not Available in this context."?

I've been struggling with similar problems recently and what was really helpful is the Moles framework from Microsoft Research - http://research.microsoft.com/en-us/projects/moles/. It allows you to fake anything from BCL including HttpContext.Current.

There is a very similar problem to the one you have encountered which is described in the book "Working Effectively with Legacy Code" by Michael Feathers. In particular, the refactoring is called "Adapt Parameter".

The "problem" with your code is that it is directly coupled to the HttpRequest, specifically Request.Path. So the overall approach is you want to decouple your code from HttpRequest.

Similarly to what is suggested above, here is another way to do the decoupling following the idea in Michael Feather's book. I haven't tried compiling this, so please excuse any typos or syntax errors.

public interface ParameterSource
{
    public string Path {get; }
}

public class FakeParameterSource : ParameterSource
{
   public string Value;
   public string Path { get { return Value } }
}

public class RealParameterSource : ParameterSource
{
   private HttpRequest request;
   public RealParameterSource(HttpRequest aRequest)
   {
     request = aRequest;
   }
   public string Path { get { return request.Path } }
}

Now here's the important part of what you need to change (and here's one way of doing it):

// small rename
protected string GetPageName(ParameterSource source) 
{ 
   return Path.GetFileName(source.Path).Substring(0, Path.GetFileName(source.Path).Length - 5);
}

Above the injection happens at the method level. You could do it via a constructor or a property too.

Your test code could now be something like:

protected Change SetupApproval(string changeDescription) 
{
    ParameterSource p = new FakeParameterSource { Value = "mypath" }; 
    Change change = Change.GetInstance(); 
    change.Description = changeDescription; 
    change.DateOfChange = DateTime.Now; 
    change.Page = GetPageName(p); //  now uses the value in the parameter source
    return change; 
} 

I hope you get the idea and find this useful

The key to testing methods that use HttpContext is to use HttpContextBase. HttpContextBase is an abstract class which makes it easily mockable. Unfortunately HttpContext does not implement HttpContextBase so you need to use HttpContextWrapper to wrap the real HttpContext to HttpContextBase. This article has a good and simple explanation: http://splinter.com.au/httpcontext-vs-httpcontextbase-vs-httpcontext

Your question doesn't say where the example code is located. If it's all in the code-behind you are going to have a difficult time trying to test that. Instead of having logic in code-behind, you should look into Model-View-Presenter(MVP) -pattern. There are frameworks for the MVP, but it is also quite easy to do it yourself.

In MVP presenters contain all the logic and pages code-behind only implements View-interface containing properties which can be bound to the UI. All dependencies can be injected to presenter making it easy to test.

I agree with @Alex Taylor (sorry, I can't comment): the best way of unit testing a (non-MVC) web app is to make sure the bits don't rely on the whole environment being present; that's why it's called unit testing, after all. So you could replace PageName with this:

protected string PageName
{
    get 
    {
        return GetPageName(Request.Path);
    }
}

protected static string GetPageName(string path)
{
    return Path.GetFileNameWithoutExtension(path);
}

And with this you can unit test GetPageName, and be confident that PageName works as expected.

Remember, there's no point trying to unit test Request.Path, because that has an expected behaviour (or 'contract') that it should fulfil. If you're not sure what Request.Path will return in different circumstances, you should check the documentation instead of adding unit tests.