public void PostMapRequestHandlerNoPath ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("foo/bar", new MyRouteHandler ()));
// ... huh? no NIE? what does it do then?
m.PostMapRequestHandler (new HttpContextStub2 ("~/foo/bar", null));
}
public void SetRouteCollectionNull ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new Route (null, null));
Assert.IsNotNull (m.RouteCollection, "#1");
Assert.AreEqual (RouteTable.Routes, m.RouteCollection, "#1-2");
m.RouteCollection = null;
Assert.IsNotNull (m.RouteCollection, "#2");
Assert.AreEqual (RouteTable.Routes, m.RouteCollection, "#2-2");
}
/// <summary>
/// Rewrites to the correct Umbraco handler, either WebForms or Mvc
/// </summary>
/// <param name="context"></param>
/// <param name="pcr"> </param>
private static void RewriteToUmbracoHandler(HttpContextBase context, PublishedContentRequest pcr)
{
// NOTE: we do not want to use TransferRequest even though many docs say it is better with IIS7, turns out this is
// not what we need. The purpose of TransferRequest is to ensure that .net processes all of the rules for the newly
// rewritten url, but this is not what we want!
// read: http://forums.iis.net/t/1146511.aspx
string query = pcr.Uri.Query.TrimStart(new[] { '?' });
string rewritePath;
if (pcr.RenderingEngine == RenderingEngine.Unknown)
{
// Unkwnown means that no template was found. Default to Mvc because Mvc supports hijacking
// routes which sometimes doesn't require a template since the developer may want full control
// over the rendering. Can't do it in WebForms, so Mvc it is. And Mvc will also handle what to
// do if no template or hijacked route is exist.
pcr.RenderingEngine = RenderingEngine.Mvc;
}
switch (pcr.RenderingEngine)
{
case RenderingEngine.Mvc:
// GlobalSettings.Path has already been through IOHelper.ResolveUrl() so it begins with / and vdir (if any)
rewritePath = GlobalSettings.Path.TrimEnd(new[] { '/' }) + "/RenderMvc";
// rewrite the path to the path of the handler (i.e. /umbraco/RenderMvc)
context.RewritePath(rewritePath, "", query, false);
//if it is MVC we need to do something special, we are not using TransferRequest as this will
//require us to rewrite the path with query strings and then reparse the query strings, this would
//also mean that we need to handle IIS 7 vs pre-IIS 7 differently. Instead we are just going to create
//an instance of the UrlRoutingModule and call it's PostResolveRequestCache method. This does:
// * Looks up the route based on the new rewritten URL
// * Creates the RequestContext with all route parameters and then executes the correct handler that matches the route
//we also cannot re-create this functionality because the setter for the HttpContext.Request.RequestContext is internal
//so really, this is pretty much the only way without using Server.TransferRequest and if we did that, we'd have to rethink
//a bunch of things!
var urlRouting = new UrlRoutingModule();
urlRouting.PostResolveRequestCache(context);
break;
case RenderingEngine.WebForms:
rewritePath = "~/default.aspx";
// rewrite the path to the path of the handler (i.e. default.aspx)
context.RewritePath(rewritePath, "", query, false);
break;
default:
throw new Exception("Invalid RenderingEngine.");
}
}
public void PostResolveRequestCacheNullHttpHandler ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("foo/bar", new NullRouteHandler ()));
m.PostResolveRequestCache (new HttpContextStub2 ("~/foo/bar", null));
}
public void PostMapRequestHandlerNoMatch ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute (null, null));
m.PostMapRequestHandler (new HttpContextStub2 ());
}
public void Pipeline3 ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
#if NET_4_0
var hc = new HttpContextStub5 ("~/x/y", String.Empty, "apppath");
#else
var hc = new HttpContextStub2 ("~/x/y", String.Empty, "apppath");
#endif
hc.SetResponse (new HttpResponseStub (2));
#if NET_4_0
Assert.IsNull (m.RouteCollection.GetRouteData (hc), "#0");
#else
Assert.IsNotNull (m.RouteCollection.GetRouteData (hc), "#0");
m.PostResolveRequestCache (hc);
try {
m.PostMapRequestHandler (hc);
Assert.Fail ("#1");
} catch (ApplicationException ex) {
Assert.AreEqual ("~/UrlRouting.axd", ex.Message, "#2");
}
#endif
}
public void Pipeline1 ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
var hc = new HttpContextStub3 ("~/x/y", "z", "apppath", false);
hc.SetResponse (new HttpResponseStub (2));
m.PostResolveRequestCache (hc);
Assert.AreEqual ("~/UrlRouting.axd", hc.RewrittenPath, "#1");
// It tries to set Handler and causes NIE
m.PostMapRequestHandler (hc);
}
/// <summary>
/// Rewrites to the default back office page.
/// </summary>
/// <param name="context"></param>
private static void RewriteToBackOfficeHandler(HttpContextBase context)
{
// GlobalSettings.Path has already been through IOHelper.ResolveUrl() so it begins with / and vdir (if any)
var rewritePath = GlobalSettings.Path.TrimEnd(new[] { '/' }) + "/Default";
// rewrite the path to the path of the handler (i.e. /umbraco/RenderMvc)
context.RewritePath(rewritePath, "", "", false);
//if it is MVC we need to do something special, we are not using TransferRequest as this will
//require us to rewrite the path with query strings and then reparse the query strings, this would
//also mean that we need to handle IIS 7 vs pre-IIS 7 differently. Instead we are just going to create
//an instance of the UrlRoutingModule and call it's PostResolveRequestCache method. This does:
// * Looks up the route based on the new rewritten URL
// * Creates the RequestContext with all route parameters and then executes the correct handler that matches the route
//we also cannot re-create this functionality because the setter for the HttpContext.Request.RequestContext is internal
//so really, this is pretty much the only way without using Server.TransferRequest and if we did that, we'd have to rethink
//a bunch of things!
var urlRouting = new UrlRoutingModule();
urlRouting.PostResolveRequestCache(context);
}
public void PostResolveRequestCacheStopRoutingHttpHandler ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("foo/bar", new StopRoutingHandler ()));
var hc = new HttpContextStub3 ("~/foo/bar", String.Empty, "apppath", false);
m.PostResolveRequestCache (hc);
Assert.IsNull (hc.RewrittenPath, "StopRoutingHandler should stop before the path is rewritten");
}
public void PostResolveRequestCachePathToExistingFile ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("~/{foo}/{bar}", new MyRouteHandler ()));
var hc = new HttpContextStub2 ("~/hoge/fuga", String.Empty, ".");
// it tries to get HttpContextBase.Response, so set it.
hc.SetResponse (new HttpResponseStub (3));
try {
m.PostResolveRequestCache (hc);
Assert.Fail ("#1");
} catch (ApplicationException ex) {
Assert.AreEqual ("~/UrlRouting.axd", ex.Message, "#2");
}
}
public void PostResolveRequestCache ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
#if NET_4_0
var hc = new HttpContextStub4 ("~/x/y", "z", "apppath", false);
#else
var hc = new HttpContextStub3 ("~/x/y", "z", "apppath", false);
#endif
hc.SetResponse (new HttpResponseStub (2));
m.PostResolveRequestCache (hc);
#if NET_4_0
Assert.AreEqual (null, hc.RewrittenPath, "#1");
#else
Assert.AreEqual ("~/UrlRouting.axd", hc.RewrittenPath, "#1");
#endif
// it internally stores the handler
}
public void PostResolveRequestCacheModifiedPath ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
var hc = new HttpContextStub2 ("~/x/y", "z", "apppath");
hc.SetResponse (new HttpResponseStub (2));
try {
m.PostResolveRequestCache (hc);
Assert.Fail ("#1");
} catch (ApplicationException ex) {
Assert.AreEqual ("~/UrlRouting.axd", ex.Message, "#2");
}
}
public void PostResolveRequestCacheNoPath ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("foo/bar", new MyRouteHandler ()));
// it tries to get HttpContextBase.Request.Path and causes NIE.
m.PostResolveRequestCache (new HttpContextStub2 ("~/foo/bar", null));
}
public virtual void PostResolveRequestCache(HttpContextBase context)
{
var request = context.Request;
if (request == null || _routes.Count == 0)
return;
var path = request.AppRelativeCurrentExecutionFilePath.TrimStart('~').TrimEnd('/');
var method = request.HttpMethod.EmptyNull();
foreach (var route in _routes)
{
if (route.PathPattern.IsMatch(path) && route.HttpMethodPattern.IsMatch(method))
{
var module = new UrlRoutingModule();
module.PostResolveRequestCache(context);
return;
}
}
}
public void Pipeline2 ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
#if NET_4_0
var hc = new HttpContextStub4 ("~/x/y", "z", "apppath", true);
#else
var hc = new HttpContextStub3 ("~/x/y", "z", "apppath", true);
#endif
hc.HttpHandler = new MyHttpHandler ();
hc.SetResponse (new HttpResponseStub (2));
m.PostResolveRequestCache (hc);
#if NET_4_0
Assert.AreEqual (null, hc.RewrittenPath, "#1");
#else
Assert.AreEqual ("~/UrlRouting.axd", hc.RewrittenPath, "#1");
#endif
// It tries to set Handler and causes NIE
m.PostMapRequestHandler (hc);
}
/// <summary>
/// Rewrites to the correct Umbraco handler, either WebForms or Mvc
/// </summary>
/// <param name="context"></param>
/// <param name="currentQuery"></param>
/// <param name="engine"> </param>
private void RewriteToUmbracoHandler(HttpContext context, string currentQuery, RenderingEngine engine)
{
//NOTE: We do not want to use TransferRequest even though many docs say it is better with IIS7, turns out this is
//not what we need. The purpose of TransferRequest is to ensure that .net processes all of the rules for the newly
//rewritten url, but this is not what we want!
// http://forums.iis.net/t/1146511.aspx
string rewritePath;
switch (engine)
{
case RenderingEngine.Mvc:
//the Path is normally ~/umbraco but we need to remove the start ~/ of it and if someone modifies this
//then we should be rendering the MVC stuff in that location.
rewritePath = "~/"
+ GlobalSettings.Path.TrimStart(new[] { '~', '/' }).TrimEnd(new[] { '/' })
+ "/RenderMvc";
// we rewrite the path to the path of the handler (i.e. default.aspx or /umbraco/RenderMvc )
context.RewritePath(rewritePath, "", currentQuery.TrimStart(new[] { '?' }), false);
//if it is MVC we need to do something special, we are not using TransferRequest as this will
//require us to rewrite the path with query strings and then reparse the query strings, this would
//also mean that we need to handle IIS 7 vs pre-IIS 7 differently. Instead we are just going to create
//an instance of the UrlRoutingModule and call it's PostResolveRequestCache method. This does:
// * Looks up the route based on the new rewritten URL
// * Creates the RequestContext with all route parameters and then executes the correct handler that matches the route
//we also cannot re-create this functionality because the setter for the HttpContext.Request.RequestContext is internal
//so really, this is pretty much the only way without using Server.TransferRequest and if we did that, we'd have to rethink
//a bunch of things!
var urlRouting = new UrlRoutingModule();
urlRouting.PostResolveRequestCache(new HttpContextWrapper(context));
break;
case RenderingEngine.WebForms:
default:
rewritePath = "~/default.aspx";
// rewrite the path to the path of the handler (i.e. default.aspx or /umbraco/RenderMvc )
context.RewritePath(rewritePath, "", currentQuery.TrimStart(new[] { '?' }), false);
break;
}
}
public void Pipeline3 ()
{
var m = new UrlRoutingModule ();
RouteTable.Routes.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
var hc = new HttpContextStub5 ("~/x/y", String.Empty, "apppath");
hc.SetResponse (new HttpResponseStub (2));
Assert.IsNull (m.RouteCollection.GetRouteData (hc), "#0");
}
