private VirtualPathData GenerateUrlViaMock( object values )
        {
            //Arrange
            RouteCollection routeCollection = new RouteCollection();
            MvcApplication.RegisterRoutes( routeCollection );
            var mockHttpContext = new MockHttpContext().MakeMockHttpContext( null );
            RequestContext context = new RequestContext( mockHttpContext.Object, new RouteData() );

            //Act
            return routeCollection.GetVirtualPath( context, new RouteValueDictionary( values ) );
        }
Exemple #2
0
        public static VirtualPathData GenerateUrlViaMocks(RouteValueDictionary route)
        {
            // Arrange (get the routing config and test context)
            RouteCollection routeConfig = new RouteCollection();
            MvcApplication.RegisterRoutes(routeConfig);

            var mockContext = MakeMockHttpContext(null);
            RequestContext context = new RequestContext(mockContext.Object, new RouteData());

            // Act (generate a URL)
            return routeConfig.GetVirtualPath(context, route);
        }
        private string GetOutboundUrl(object routeValues)
        {
            RouteCollection routes = new RouteCollection();
            RouteConfig.RegisterRoutes(routes);
            var mockHttpContext = new Moq.Mock<HttpContextBase>();
            var mockRequest = new Moq.Mock<HttpRequestBase>();
            var fakeResponse = new FakeResponse();
            mockHttpContext.Setup(x => x.Request).Returns(mockRequest.Object);
            mockHttpContext.Setup(x => x.Response).Returns(fakeResponse);
            mockRequest.Setup(x => x.ApplicationPath).Returns("/");

            var ctx = new RequestContext(mockHttpContext.Object, new RouteData());
            return routes.GetVirtualPath(ctx, new RouteValueDictionary(routeValues)).VirtualPath;
        }
Exemple #4
0
        public void GetVirtualPathCanFillInSeparatedParametersWithDefaultValues()
        {
            var routes = new RouteCollection();
            routes.MapRoute("some-route", "{controller}/{language}-{locale}", new {language="en", locale="US"});

            var request = new Mock<HttpRequestBase>();
            request.Expect(req => req.AppRelativeCurrentExecutionFilePath).Returns("~/");
            request.Expect(req => req.ApplicationPath).Returns("");

            var httpContext = new Mock<HttpContextBase>();
            httpContext.Expect(http => http.Request).Returns(request.Object);

            var context = new RequestContext(httpContext.Object, new RouteData());

            VirtualPathData vpd = routes.GetVirtualPath(context, new RouteValueDictionary(new { controller = "Orders" }));
            Assert.IsNotNull(vpd, "Expected this to match our one route");
            Assert.AreEqual("/Orders/en-US", vpd.VirtualPath, "Expected the route to fill in the parameters using the defaults");
        }
		public void GetVirtualPath ()
		{
			var c = new RouteCollection ();
			c.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
			var hc = new HttpContextStub2 ("~/x/y", String.Empty, "apppath");
			// it tries to get HttpContextBase.Response, so set it.
			hc.SetResponse (new HttpResponseStub (2));
			var rd = c.GetRouteData (hc);
			Assert.IsNotNull (rd, "#1");
			
			var vpd = c.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
			Assert.IsNotNull (vpd, "#2");
			Assert.AreEqual ("apppath/x/y_modified", vpd.VirtualPath, "#3");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#4");
		}
		public void GetVirtualPathCheckVirtualPathToModify ()
		{
			var c = new RouteCollection ();
			c.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
			var hc = new HttpContextStub2 ("~/x/y", String.Empty, "apppath");
			// it tries to get HttpContextBase.Response, so set it.
			hc.SetResponse (new HttpResponseStub (1));
			var rd = c.GetRouteData (hc);
			try {
				var vpd = c.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
				Assert.Fail ("#1");
			} catch (ApplicationException ex) {
				Assert.AreEqual ("apppath/x/y", ex.Message, "#2");
			}
		}
		public void GetVirtualPathNoApplyAppPathModifier ()
		{
			var c = new RouteCollection ();
			c.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
			var hc = new HttpContextStub2 ("~/x/y", String.Empty, "apppath");
			// it tries to call HttpContextBase.Response.ApplyAppPathModifier() and then causes NIE.
			hc.SetResponse (new HttpResponseStub ());
			var rd = c.GetRouteData (hc);
			var vpd = c.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
		}
 public VirtualPathData GetVirtualPath(VirtualPathContext context) =>
 _routeCollection.GetVirtualPath(context);
        /// <summary>
        /// Generates an outbound url from the specified values.  Requires a delegate
        /// to populate a route collection with all possible routes.
        /// </summary>
        /// <param name="routeValues">The route values from which to generate the url</param>
        /// <param name="registerRoutes">Delegate to register all possible routes</param>
        /// <returns>The virtual path data object</returns>
        public static VirtualPathData GenerateOutboundVirtualPath(RouteValueDictionary routeValues, Action<RouteCollection> registerRoutes)
        {
            // Arrange (get the routing config and test context)
            RouteCollection routeConfig = new RouteCollection();
            registerRoutes(routeConfig);

            HttpContextBase mockHttp = MockHelpers.HttpContext(null).Object;
            RequestContext context = new RequestContext(mockHttp, new RouteData());

            // Act (generate a URL)
            return routeConfig.GetVirtualPath(context, routeValues);
        }
Exemple #10
0
		public void GetVirtualPath7 ()
		{
			var c = new RouteCollection ();

			c.Add (new MyRoute ("{table}/{action}.aspx", new MyRouteHandler ()) {
				Constraints = new RouteValueDictionary (new { action = "List|Details|Edit|Insert" }),
			});

			var req = new FakeHttpWorkerRequest ();
			var ctx = new HttpContext (req);
			HttpContext.Current = ctx;
			var rd = new RouteData ();
			var hc = new HttpContextWrapper (ctx);

			var vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary {
				{"Table", "FooTable"},
				{"Action", "Details"}
			});

			Assert.IsNotNull (vp, "#A1");
			Assert.AreEqual ("/FooTable/Details.aspx", vp.VirtualPath, "#A1-1");

			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary {
				{"Table", "FooTable"},
				{"Action", String.Empty}
			});

			Assert.IsNull (vp, "#B1");

			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary {
				{"Table", "FooTable"},
				{"Action", null}
			});

			Assert.IsNull (vp, "#C1");
		}
Exemple #11
0
		public void GetVirtualPath4 ()
		{
			var c = new RouteCollection ();

			c.Add (new MyRoute ("blog/{user}/{action}", new MyRouteHandler ()) {
					Defaults = new RouteValueDictionary {
							{ "controller", "blog" },
							{ "user", "admin" }
						}
				}
			);

			c.Add (new MyRoute ("forum/{user}/{action}", new MyRouteHandler ()) {
					Defaults = new RouteValueDictionary {
							{ "controller", "forum" },
							{ "user", "admin" }
						}
				}
			);

			var hc = new HttpContextStub2 ("~/forum/admin/Index", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (3));
			var rd = c.GetRouteData (hc);
			Assert.IsNotNull (rd, "#1");

			var vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { action="Index", controller="forum"}));
			Assert.IsNotNull (vp, "#2");
			Assert.AreEqual ("/forum/admin/Index", vp.VirtualPath, "#2-1");
			
			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { action="Index", controller="blah"}));
			Assert.IsNull (vp, "#3");
		}
        internal static string GenerateUrl(string routeName, string actionName, string controllerName, RouteValueDictionary routeValues, RouteCollection routeCollection, RequestContext requestContext, bool includeImplicitMvcValues) {
            RouteValueDictionary mergedRouteValues = RouteValuesHelpers.MergeRouteValues(actionName, controllerName, requestContext.RouteData.Values, routeValues, includeImplicitMvcValues);

            VirtualPathData vpd = routeCollection.GetVirtualPath(requestContext, routeName, mergedRouteValues);
            if (vpd == null) {
                return null;
            }

            string modifiedUrl = PathHelpers.GenerateClientUrl(requestContext.HttpContext, vpd.VirtualPath);
            return modifiedUrl;
        }
 private string GenerateUrl(RouteCollection routeCollection, RouteValueDictionary routeValueDictionary)
 {
     var requestContext = _urlHelper.RequestContext;
     var virtualPathForArea = routeCollection.GetVirtualPath(requestContext, null,
         routeValueDictionary ?? new RouteValueDictionary());
     return virtualPathForArea == null ? null : GenerateClientUrl(requestContext.HttpContext, virtualPathForArea.VirtualPath);
 }
Exemple #14
0
        public void RequestUrlPrefixAdjustsMatchingAndPathGeneration()
        {
            var settings = new ShellSettings {
                RequestUrlPrefix = "~/foo"
            };

            var builder = new ContainerBuilder();

            builder.RegisterType <ShellRoute>().InstancePerDependency();
            builder.RegisterAutoMocking();
            builder.Register(ctx => settings);

            var container = builder.Build();

            container.Mock <IRunningShellTable>()
            .Setup(x => x.Match(It.IsAny <HttpContextBase>()))
            .Returns(settings);


            var shellRouteFactory = container.Resolve <Func <RouteBase, ShellRoute> >();

            var helloRoute = shellRouteFactory(new Route(
                                                   "hello",
                                                   new RouteValueDictionary {
                { "controller", "foo" }, { "action", "bar" }
            },
                                                   new MvcRouteHandler()));

            var tagsRoute = shellRouteFactory(new Route(
                                                  "tags/{tagName}",
                                                  new RouteValueDictionary {
                { "controller", "tags" }, { "action", "show" }
            },
                                                  new MvcRouteHandler()));

            var defaultRoute = shellRouteFactory(new Route(
                                                     "{controller}/{action}",
                                                     new RouteValueDictionary {
                { "controller", "home" }, { "action", "index" }
            },
                                                     new MvcRouteHandler()));

            var routes = new RouteCollection {
                helloRoute, tagsRoute, defaultRoute
            };

            var helloRouteData = routes.GetRouteData(new StubHttpContext("~/Foo/Hello"));

            Assert.That(helloRouteData, Is.Not.Null);
            Assert.That(helloRouteData.Values.Count(), Is.EqualTo(2));
            Assert.That(helloRouteData.GetRequiredString("controller"), Is.EqualTo("foo"));
            Assert.That(helloRouteData.GetRequiredString("action"), Is.EqualTo("bar"));

            var tagsRouteData = routes.GetRouteData(new StubHttpContext("~/Foo/Tags/my-tag-name"));

            Assert.That(tagsRouteData, Is.Not.Null);
            Assert.That(tagsRouteData.Values.Count(), Is.EqualTo(3));
            Assert.That(tagsRouteData.GetRequiredString("controller"), Is.EqualTo("tags"));
            Assert.That(tagsRouteData.GetRequiredString("action"), Is.EqualTo("show"));
            Assert.That(tagsRouteData.GetRequiredString("tagName"), Is.EqualTo("my-tag-name"));

            var defaultRouteData = routes.GetRouteData(new StubHttpContext("~/Foo/Alpha/Beta"));

            Assert.That(defaultRouteData, Is.Not.Null);
            Assert.That(defaultRouteData.Values.Count(), Is.EqualTo(2));
            Assert.That(defaultRouteData.GetRequiredString("controller"), Is.EqualTo("Alpha"));
            Assert.That(defaultRouteData.GetRequiredString("action"), Is.EqualTo("Beta"));

            var defaultRouteData2 = routes.GetRouteData(new StubHttpContext("~/Foo/Alpha"));

            Assert.That(defaultRouteData2, Is.Not.Null);
            Assert.That(defaultRouteData2.Values.Count(), Is.EqualTo(2));
            Assert.That(defaultRouteData2.GetRequiredString("controller"), Is.EqualTo("Alpha"));
            Assert.That(defaultRouteData2.GetRequiredString("action"), Is.EqualTo("index"));

            var defaultRouteData3 = routes.GetRouteData(new StubHttpContext("~/Foo/"));

            Assert.That(defaultRouteData3, Is.Not.Null);
            Assert.That(defaultRouteData3.Values.Count(), Is.EqualTo(2));
            Assert.That(defaultRouteData3.GetRequiredString("controller"), Is.EqualTo("home"));
            Assert.That(defaultRouteData3.GetRequiredString("action"), Is.EqualTo("index"));

            var defaultRouteData4 = routes.GetRouteData(new StubHttpContext("~/Foo"));

            Assert.That(defaultRouteData4, Is.Not.Null);
            Assert.That(defaultRouteData4.Values.Count(), Is.EqualTo(2));
            Assert.That(defaultRouteData4.GetRequiredString("controller"), Is.EqualTo("home"));
            Assert.That(defaultRouteData4.GetRequiredString("action"), Is.EqualTo("index"));

            var requestContext   = new RequestContext(new StubHttpContext("~/Foo/Alpha/Beta"), defaultRouteData);
            var helloVirtualPath = routes.GetVirtualPath(requestContext, helloRouteData.Values);

            Assert.That(helloVirtualPath, Is.Not.Null);
            Assert.That(helloVirtualPath.VirtualPath, Is.EqualTo("~/foo/hello"));

            var defaultVirtualPath4 = routes.GetVirtualPath(requestContext, defaultRouteData4.Values);

            Assert.That(defaultVirtualPath4, Is.Not.Null);
            Assert.That(defaultVirtualPath4.VirtualPath, Is.EqualTo("~/foo/"));
        }
		public void GetVirtualPath8 ()
		{
			var routes = new RouteCollection();

			routes.Add (new MyRoute ("login", new MyRouteHandler ()) {
				Defaults = new RouteValueDictionary (new { controller = "Home", action = "LogOn" })
			});

			routes.Add (new MyRoute ("{site}/{controller}/{action}", new MyRouteHandler ())	{
				Defaults = new RouteValueDictionary (new { site = "_", controller = "Home", action = "Index" }),
				Constraints = new RouteValueDictionary ( new { site = "_?[0-9A-Za-z-]*" })
			});

			routes.Add (new MyRoute ("{*path}", new MyRouteHandler ()) {
				Defaults = new RouteValueDictionary (new { controller = "Error", action = "NotFound" }),
			});

			var hc = new HttpContextStub2 ("~/login", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (3));
			var rd = routes.GetRouteData (hc);
			var rvs = new RouteValueDictionary () {
				{ "controller", "Home" },
				{ "action" , "Index" }
			};
			var vpd = routes.GetVirtualPath (new RequestContext (hc, rd), rvs);
			Assert.IsNotNull (vpd, "#A1");
			Assert.AreEqual ("/", vpd.VirtualPath, "#A2");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#A3");

			hc = new HttpContextStub2 ("~/login", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (3));
			rd = routes.GetRouteData (hc);
			rvs = new RouteValueDictionary () {
				{ "controller", "Home" }
			};
			vpd = routes.GetVirtualPath (new RequestContext (hc, rd), rvs);
			Assert.IsNotNull (vpd, "#B1");
			Assert.AreEqual ("/login", vpd.VirtualPath, "#B2");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#B3");

			hc = new HttpContextStub2 ("~/login", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (3));
			rd = routes.GetRouteData (hc);
			rvs = new RouteValueDictionary () {
				{ "action" , "Index" }
			};
			vpd = routes.GetVirtualPath (new RequestContext (hc, rd), rvs);
			Assert.IsNotNull (vpd, "#C1");
			Assert.AreEqual ("/", vpd.VirtualPath, "#C2");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#C3");

			hc = new HttpContextStub2 ("~/", String.Empty, String.Empty);
			rd = routes.GetRouteData (hc);
			Assert.IsNotNull (rd, "#D1");
		}
Exemple #16
0
		public void GetVirtualPath2 ()
		{
			var c = new RouteCollection ();
			
			c.Add ("Summary",
			       new MyRoute ("summary/{action}-{type}/{page}", new MyRouteHandler ()) { Defaults = new RouteValueDictionary (new { controller = "Summary", action = "Index", page = 1}) }
			);
			       
			c.Add ("Apis",
			       new MyRoute ("apis/{apiname}", new MyRouteHandler ()) { Defaults = new RouteValueDictionary (new { controller = "Apis", action = "Index" }) }
			);
							    
			c.Add ("Single Report",
			       new MyRoute ("report/{guid}", new MyRouteHandler ()) { Defaults = new RouteValueDictionary (new { controller = "Reports", action = "SingleReport" }) }
			);
			
			c.Add ("Reports",
			       new MyRoute ("reports/{page}", new MyRouteHandler ()) { Defaults = new RouteValueDictionary (new { controller = "Reports", action = "Index", page = 1 }) }
			);

			c.Add ("Default",
			       new MyRoute ("{controller}/{action}", new MyRouteHandler ()) { Defaults = new RouteValueDictionary (new { controller = "Home", action = "Index"}) }
			);

			var hc = new HttpContextStub2 ("~/Home/About", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (2));
			var rd = c.GetRouteData (hc);
			var vpd = c.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
			Assert.IsNotNull (vpd, "#A1");
			Assert.AreEqual ("/Home/About_modified", vpd.VirtualPath, "#A2");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#A3");

			hc = new HttpContextStub2 ("~/Home/Index", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (2));
			rd = c.GetRouteData (hc);
			vpd = c.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
			Assert.IsNotNull (vpd, "#B1");
			Assert.AreEqual ("/_modified", vpd.VirtualPath, "#B2");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#B3");

			hc = new HttpContextStub2 ("~/Account/LogOn", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (2));
			rd = c.GetRouteData (hc);
			vpd = c.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
			Assert.IsNotNull (vpd, "#C1");
			Assert.AreEqual ("/Account/LogOn_modified", vpd.VirtualPath, "#C2");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#C3");

			hc = new HttpContextStub2 ("~/", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (3));
			rd = c.GetRouteData (hc);
			vpd = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { controller = "home" }) );
			Assert.IsNotNull (vpd, "#D1");
			Assert.AreEqual ("/", vpd.VirtualPath, "#D2");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#D3");

			hc = new HttpContextStub2 ("~/", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (3));
			rd = c.GetRouteData (hc);
			vpd = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { controller = "Home" }) );
			Assert.IsNotNull (vpd, "#E1");
			Assert.AreEqual ("/", vpd.VirtualPath, "#E2");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#E3");
		}
Exemple #17
0
		public void GetVirtualPath3 ()
		{
			var c = new RouteCollection ();

			c.Add ("todo-route",
			       new MyRoute ("todo/{action}", new MyRouteHandler ()) { Defaults = new RouteValueDictionary (new {controller = "todo", action="list", page=0}) }
			);

			c.Add ("another-route",
			       new MyRoute ("{controller}/{action}", new MyRouteHandler ()) { Defaults = new RouteValueDictionary (new {controller = "home", action="list", page=0}) }
			);

			var hc = new HttpContextStub2 ("~/home/list", String.Empty, String.Empty);
			hc.SetResponse (new HttpResponseStub (3));
			var rd = c.GetRouteData (hc);
			Assert.IsNotNull (rd, "#1");
			Assert.AreEqual (3, rd.Values.Count, "#1-1");
			Assert.AreEqual ("home", rd.Values["controller"], "#1-2");
			Assert.AreEqual ("list", rd.Values["action"], "#1-3");
			Assert.AreEqual (0, rd.Values["page"], "#1-4");
			
			var vp = c.GetVirtualPath (new RequestContext (hc, rd), "todo-route", new RouteValueDictionary ());
			Assert.IsNotNull (vp, "#2");
			Assert.AreEqual ("/todo", vp.VirtualPath, "#2-1");

			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary ());
			Assert.IsNotNull (vp, "#3");
			Assert.AreEqual ("/todo", vp.VirtualPath, "#3-1");

			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { controller = "home" }));
			Assert.IsNotNull (vp, "#4");
			Assert.AreEqual ("/", vp.VirtualPath, "#4-1");

			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary (new { controller = "home", extra="stuff" }));
			Assert.IsNotNull (vp, "#5");
			Assert.AreEqual ("/?extra=stuff", vp.VirtualPath, "#5-1");
		}
        public void GetVirtualPath2()
        {
            var c = new RouteCollection();

            c.Add("Summary",
                  new MyRoute("summary/{action}-{type}/{page}", new MyRouteHandler())
            {
                Defaults = new RouteValueDictionary(new { controller = "Summary", action = "Index", page = 1 })
            }
                  );

            c.Add("Apis",
                  new MyRoute("apis/{apiname}", new MyRouteHandler())
            {
                Defaults = new RouteValueDictionary(new { controller = "Apis", action = "Index" })
            }
                  );

            c.Add("Single Report",
                  new MyRoute("report/{guid}", new MyRouteHandler())
            {
                Defaults = new RouteValueDictionary(new { controller = "Reports", action = "SingleReport" })
            }
                  );

            c.Add("Reports",
                  new MyRoute("reports/{page}", new MyRouteHandler())
            {
                Defaults = new RouteValueDictionary(new { controller = "Reports", action = "Index", page = 1 })
            }
                  );

            c.Add("Default",
                  new MyRoute("{controller}/{action}", new MyRouteHandler())
            {
                Defaults = new RouteValueDictionary(new { controller = "Home", action = "Index" })
            }
                  );

            var hc = new HttpContextStub2("~/Home/About", String.Empty, String.Empty);

            hc.SetResponse(new HttpResponseStub(2));
            var rd  = c.GetRouteData(hc);
            var vpd = c.GetVirtualPath(new RequestContext(hc, rd), rd.Values);

            Assert.IsNotNull(vpd, "#A1");
            Assert.AreEqual("/Home/About_modified", vpd.VirtualPath, "#A2");
            Assert.AreEqual(0, vpd.DataTokens.Count, "#A3");

            hc = new HttpContextStub2("~/Home/Index", String.Empty, String.Empty);
            hc.SetResponse(new HttpResponseStub(2));
            rd  = c.GetRouteData(hc);
            vpd = c.GetVirtualPath(new RequestContext(hc, rd), rd.Values);
            Assert.IsNotNull(vpd, "#B1");
            Assert.AreEqual("/_modified", vpd.VirtualPath, "#B2");
            Assert.AreEqual(0, vpd.DataTokens.Count, "#B3");

            hc = new HttpContextStub2("~/Account/LogOn", String.Empty, String.Empty);
            hc.SetResponse(new HttpResponseStub(2));
            rd  = c.GetRouteData(hc);
            vpd = c.GetVirtualPath(new RequestContext(hc, rd), rd.Values);
            Assert.IsNotNull(vpd, "#C1");
            Assert.AreEqual("/Account/LogOn_modified", vpd.VirtualPath, "#C2");
            Assert.AreEqual(0, vpd.DataTokens.Count, "#C3");

            hc = new HttpContextStub2("~/", String.Empty, String.Empty);
            hc.SetResponse(new HttpResponseStub(3));
            rd  = c.GetRouteData(hc);
            vpd = c.GetVirtualPath(new RequestContext(hc, rd), new RouteValueDictionary(new { controller = "home" }));
            Assert.IsNotNull(vpd, "#D1");
            Assert.AreEqual("/", vpd.VirtualPath, "#D2");
            Assert.AreEqual(0, vpd.DataTokens.Count, "#D3");

            hc = new HttpContextStub2("~/", String.Empty, String.Empty);
            hc.SetResponse(new HttpResponseStub(3));
            rd  = c.GetRouteData(hc);
            vpd = c.GetVirtualPath(new RequestContext(hc, rd), new RouteValueDictionary(new { controller = "Home" }));
            Assert.IsNotNull(vpd, "#E1");
            Assert.AreEqual("/", vpd.VirtualPath, "#E2");
            Assert.AreEqual(0, vpd.DataTokens.Count, "#E3");
        }
Exemple #19
0
		public void GetVirtualPath6 ()
		{
			var c = new RouteCollection ();

			c.Add (new MyRoute ("reports/{year}/{month}/{day}", new MyRouteHandler ()) {
					Defaults = new RouteValueDictionary {
							{ "day", 1 }
						}
				}
			);

			var hc = new HttpContextStub2 ("~/reports/2009/05", String.Empty, "/myapp");
			hc.SetResponse (new HttpResponseStub (3));
			var rd = c.GetRouteData (hc);
			Assert.IsNotNull (rd, "#1");

			var vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary {
					{ "year", 2007 },
					{ "month", 1 },
					{ "day", 12 },
				}
			);
			Assert.IsNotNull (vp, "#2");
			Assert.AreEqual ("/myapp/reports/2007/1/12", vp.VirtualPath, "#2-1");
			
			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary {
					{ "year", 2007 },
					{ "month", 1 }
				}
			);
			Assert.IsNotNull (vp, "#3");
			Assert.AreEqual ("/myapp/reports/2007/1", vp.VirtualPath, "#3-1");

			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary {
					{ "year", 2007 },
					{ "month", 1 },
					{ "day", 12 },
					{ "category", 123 }
				}
			);
			Assert.IsNotNull (vp, "#4");
			Assert.AreEqual ("/myapp/reports/2007/1/12?category=123", vp.VirtualPath, "#4-1");
			
			vp = c.GetVirtualPath (new RequestContext (hc, rd), new RouteValueDictionary {
					{ "year", 2007 },
				}
			);
			Assert.IsNull (vp, "#5");
		}
        public void GetVirtualPath8()
        {
            var routes = new RouteCollection();

            routes.Add(new MyRoute("login", new MyRouteHandler())
            {
                Defaults = new RouteValueDictionary(new { controller = "Home", action = "LogOn" })
            });

            routes.Add(new MyRoute("{site}/{controller}/{action}", new MyRouteHandler())
            {
                Defaults    = new RouteValueDictionary(new { site = "_", controller = "Home", action = "Index" }),
                Constraints = new RouteValueDictionary(new { site = "_?[0-9A-Za-z-]*" })
            });

            routes.Add(new MyRoute("{*path}", new MyRouteHandler())
            {
                Defaults = new RouteValueDictionary(new { controller = "Error", action = "NotFound" }),
            });

            var hc = new HttpContextStub2("~/login", String.Empty, String.Empty);

            hc.SetResponse(new HttpResponseStub(3));
            var rd  = routes.GetRouteData(hc);
            var rvs = new RouteValueDictionary()
            {
                { "controller", "Home" },
                { "action", "Index" }
            };
            var vpd = routes.GetVirtualPath(new RequestContext(hc, rd), rvs);

            Assert.IsNotNull(vpd, "#A1");
            Assert.AreEqual("/", vpd.VirtualPath, "#A2");
            Assert.AreEqual(0, vpd.DataTokens.Count, "#A3");

            hc = new HttpContextStub2("~/login", String.Empty, String.Empty);
            hc.SetResponse(new HttpResponseStub(3));
            rd  = routes.GetRouteData(hc);
            rvs = new RouteValueDictionary()
            {
                { "controller", "Home" }
            };
            vpd = routes.GetVirtualPath(new RequestContext(hc, rd), rvs);
            Assert.IsNotNull(vpd, "#B1");
            Assert.AreEqual("/login", vpd.VirtualPath, "#B2");
            Assert.AreEqual(0, vpd.DataTokens.Count, "#B3");

            hc = new HttpContextStub2("~/login", String.Empty, String.Empty);
            hc.SetResponse(new HttpResponseStub(3));
            rd  = routes.GetRouteData(hc);
            rvs = new RouteValueDictionary()
            {
                { "action", "Index" }
            };
            vpd = routes.GetVirtualPath(new RequestContext(hc, rd), rvs);
            Assert.IsNotNull(vpd, "#C1");
            Assert.AreEqual("/", vpd.VirtualPath, "#C2");
            Assert.AreEqual(0, vpd.DataTokens.Count, "#C3");

            hc = new HttpContextStub2("~/", String.Empty, String.Empty);
            rd = routes.GetRouteData(hc);
            Assert.IsNotNull(rd, "#D1");
        }
Exemple #21
0
		public void GetVirtualPathToExistingFile ()
		{
			var c = new RouteCollection ();
			c.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
			var hc = new HttpContextStub2 ("~/Test/test.html", String.Empty, ".");
			// it tries to get HttpContextBase.Response, so set it.
			hc.SetResponse (new HttpResponseStub (3));
			var rd = c.GetRouteData (hc);
			var vpd = c.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
			Assert.AreEqual ("./Test/test.html", vpd.VirtualPath, "#1");
			Assert.AreEqual (0, vpd.DataTokens.Count, "#2");
		}
Exemple #22
0
        /// <inheritdoc/>
        public override IHttpVirtualPathData GetVirtualPath(
            HttpRequestMessage request,
            string name,
            IDictionary <string, object> values
            )
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpContextBase httpContextBase = request.GetHttpContext();

            if (httpContextBase == null)
            {
                httpContextBase = new HttpRequestMessageContextWrapper(VirtualPathRoot, request);
            }

            if (httpContextBase.GetHttpRequestMessage() == null)
            {
                httpContextBase.SetHttpRequestMessage(request);
            }

            IHttpRouteData routeData = request.GetRouteData();

            if (routeData == null)
            {
                return(null);
            }

            RequestContext requestContext = new RequestContext(
                httpContextBase,
                routeData.ToRouteData()
                );
            RouteValueDictionary routeValues =
                values != null ? new RouteValueDictionary(values) : new RouteValueDictionary();
            VirtualPathData virtualPathData = _routeCollection.GetVirtualPath(
                requestContext,
                name,
                routeValues
                );

            if (virtualPathData != null)
            {
                // If the route is not an HttpWebRoute, try getting a virtual path without the httproute key in the route value dictionary
                // This ensures that httproute isn't picked up by non-WebAPI routes that might pollute the virtual path with httproute
                if (!(virtualPathData.Route is HttpWebRoute))
                {
                    if (routeValues.Remove(HttpWebRoute.HttpRouteKey))
                    {
                        VirtualPathData virtualPathDataWithoutHttpRouteValue =
                            _routeCollection.GetVirtualPath(requestContext, name, routeValues);
                        if (virtualPathDataWithoutHttpRouteValue != null)
                        {
                            virtualPathData = virtualPathDataWithoutHttpRouteValue;
                        }
                    }
                }

                return(new HostedHttpVirtualPathData(virtualPathData, routeData.Route));
            }

            return(null);
        }
Exemple #23
0
        public void RequestUrlPrefixAdjustsMatchingAndPathGeneration() {
            var settings = new ShellSettings { RequestUrlPrefix = "~/foo" };

            var builder = new ContainerBuilder();
            builder.RegisterType<ShellRoute>().InstancePerDependency();
            builder.RegisterAutoMocking();
            builder.Register(ctx => settings);

            var container = builder.Build();
            container.Mock<IRunningShellTable>()
                .Setup(x => x.Match(It.IsAny<HttpContextBase>()))
                .Returns(settings);


            var shellRouteFactory = container.Resolve<Func<RouteBase, ShellRoute>>();

            var helloRoute = shellRouteFactory(new Route(
                "hello",
                new RouteValueDictionary { { "controller", "foo" }, { "action", "bar" } },
                new MvcRouteHandler()));

            var tagsRoute = shellRouteFactory(new Route(
                "tags/{tagName}",
                new RouteValueDictionary { { "controller", "tags" }, { "action", "show" } },
                new MvcRouteHandler()));

            var defaultRoute = shellRouteFactory(new Route(
                "{controller}/{action}",
                new RouteValueDictionary { { "controller", "home" }, { "action", "index" } },
                new MvcRouteHandler()));

            var routes = new RouteCollection { helloRoute, tagsRoute, defaultRoute };

            var helloRouteData = routes.GetRouteData(new StubHttpContext("~/Foo/Hello"));
            Assert.That(helloRouteData, Is.Not.Null);
            Assert.That(helloRouteData.Values.Count(), Is.EqualTo(2));
            Assert.That(helloRouteData.GetRequiredString("controller"), Is.EqualTo("foo"));
            Assert.That(helloRouteData.GetRequiredString("action"), Is.EqualTo("bar"));

            var tagsRouteData = routes.GetRouteData(new StubHttpContext("~/Foo/Tags/my-tag-name"));
            Assert.That(tagsRouteData, Is.Not.Null);
            Assert.That(tagsRouteData.Values.Count(), Is.EqualTo(3));
            Assert.That(tagsRouteData.GetRequiredString("controller"), Is.EqualTo("tags"));
            Assert.That(tagsRouteData.GetRequiredString("action"), Is.EqualTo("show"));
            Assert.That(tagsRouteData.GetRequiredString("tagName"), Is.EqualTo("my-tag-name"));

            var defaultRouteData = routes.GetRouteData(new StubHttpContext("~/Foo/Alpha/Beta"));
            Assert.That(defaultRouteData, Is.Not.Null);
            Assert.That(defaultRouteData.Values.Count(), Is.EqualTo(2));
            Assert.That(defaultRouteData.GetRequiredString("controller"), Is.EqualTo("Alpha"));
            Assert.That(defaultRouteData.GetRequiredString("action"), Is.EqualTo("Beta"));

            var defaultRouteData2 = routes.GetRouteData(new StubHttpContext("~/Foo/Alpha"));
            Assert.That(defaultRouteData2, Is.Not.Null);
            Assert.That(defaultRouteData2.Values.Count(), Is.EqualTo(2));
            Assert.That(defaultRouteData2.GetRequiredString("controller"), Is.EqualTo("Alpha"));
            Assert.That(defaultRouteData2.GetRequiredString("action"), Is.EqualTo("index"));

            var defaultRouteData3 = routes.GetRouteData(new StubHttpContext("~/Foo/"));
            Assert.That(defaultRouteData3, Is.Not.Null);
            Assert.That(defaultRouteData3.Values.Count(), Is.EqualTo(2));
            Assert.That(defaultRouteData3.GetRequiredString("controller"), Is.EqualTo("home"));
            Assert.That(defaultRouteData3.GetRequiredString("action"), Is.EqualTo("index"));

            var defaultRouteData4 = routes.GetRouteData(new StubHttpContext("~/Foo"));
            Assert.That(defaultRouteData4, Is.Not.Null);
            Assert.That(defaultRouteData4.Values.Count(), Is.EqualTo(2));
            Assert.That(defaultRouteData4.GetRequiredString("controller"), Is.EqualTo("home"));
            Assert.That(defaultRouteData4.GetRequiredString("action"), Is.EqualTo("index"));

            var requestContext = new RequestContext(new StubHttpContext("~/Foo/Alpha/Beta"), defaultRouteData);
            var helloVirtualPath = routes.GetVirtualPath(requestContext, helloRouteData.Values);
            Assert.That(helloVirtualPath, Is.Not.Null);
            Assert.That(helloVirtualPath.VirtualPath, Is.EqualTo("~/foo/hello"));

            var defaultVirtualPath4 = routes.GetVirtualPath(requestContext, defaultRouteData4.Values);
            Assert.That(defaultVirtualPath4, Is.Not.Null);
            Assert.That(defaultVirtualPath4.VirtualPath, Is.EqualTo("~/foo/"));
        }
Exemple #24
0
		public void GetVirtualPathNoApplicationPath ()
		{
			var c = new RouteCollection ();
			c.Add (new MyRoute ("{foo}/{bar}", new MyRouteHandler ()));
			var hc = new HttpContextStub2 ("~/x/y", String.Empty);
			var rd = c.GetRouteData (hc);
			// it tries to get HttpContextBase.Request.ApplicationPath and then throws NIE.
			var vpd = c.GetVirtualPath (new RequestContext (hc, rd), rd.Values);
		}