public void CanGetLocalPathCorrectly(string url, string appPath, string expectedLocalPath)
        {
            HttpSimulator simulator = new HttpSimulator(appPath, @"c:\inetpub\wwwroot\AppPath\");

            simulator.SimulateRequest(new Uri(url));
            Assert.AreEqual(expectedLocalPath, HttpContext.Current.Request.Path);
            Assert.AreEqual(expectedLocalPath, HttpContext.Current.Request.Url.LocalPath);
        }
		public void CanDispose()
		{
			using (HttpSimulator simulator = new HttpSimulator())
			{
				simulator.SimulateRequest();
				Assert.IsNotNull(HttpContext.Current);
			}
			Assert.IsNull(HttpContext.Current);
		}
        public void CanGetResponse()
        {
            HttpSimulator simulator = new HttpSimulator();

            simulator.SimulateRequest();
            HttpContext.Current.Response.Write("Hello World!");
            HttpContext.Current.Response.Flush();
            Assert.AreEqual("Hello World!", simulator.ResponseText);
        }
 public void CanDispose()
 {
     using (HttpSimulator simulator = new HttpSimulator())
     {
         simulator.SimulateRequest();
         Assert.IsNotNull(HttpContext.Current);
     }
     Assert.IsNull(HttpContext.Current);
 }
		public void CanSetApplicationPathCorrectly(string url, string appPath, string expectedAppPath)
		{
			HttpSimulator simulator = new HttpSimulator(appPath, @"c:\inetpub\wwwroot\site1\test");
			Assert.AreEqual(expectedAppPath, simulator.ApplicationPath);
			simulator.SimulateRequest(new Uri(url));
			Assert.AreEqual(expectedAppPath, HttpContext.Current.Request.ApplicationPath);
			Assert.AreEqual(expectedAppPath, HttpRuntime.AppDomainAppVirtualPath);
			Assert.AreEqual(expectedAppPath, HostingEnvironment.ApplicationVirtualPath);
		}
        public void CanSetApplicationPathCorrectly(string url, string appPath, string expectedAppPath)
        {
            HttpSimulator simulator = new HttpSimulator(appPath, @"c:\inetpub\wwwroot\site1\test");

            Assert.AreEqual(expectedAppPath, simulator.ApplicationPath);
            simulator.SimulateRequest(new Uri(url));
            Assert.AreEqual(expectedAppPath, HttpContext.Current.Request.ApplicationPath);
            Assert.AreEqual(expectedAppPath, HttpRuntime.AppDomainAppVirtualPath);
            Assert.AreEqual(expectedAppPath, HostingEnvironment.ApplicationVirtualPath);
        }
        public void CanGetReferer()
        {
            HttpSimulator simulator = new HttpSimulator();

            simulator.SetReferer(new Uri("http://example.com/Blah.aspx")).SimulateRequest();
            Assert.AreEqual(new Uri("http://example.com/Blah.aspx"), HttpContext.Current.Request.UrlReferrer);

            simulator = new HttpSimulator();
            simulator.SimulateRequest().SetReferer(new Uri("http://x.example.com/Blah.aspx"));
            Assert.AreEqual(new Uri("http://x.example.com/Blah.aspx"), HttpContext.Current.Request.UrlReferrer);
        }
        public void CanGetQueryString()
        {
            HttpSimulator simulator = new HttpSimulator();

            simulator.SimulateRequest(new Uri("http://localhost/Test.aspx?param1=value1&param2=value2&param3=value3"));
            for (int i = 1; i <= 3; i++)
            {
                Assert.AreEqual("value" + i,
                                HttpContext.Current.Request.QueryString["param" + i],
                                "Could not find query string field 'param{0}'",
                                i);
            }

            simulator.SimulateRequest(
                new Uri("http://localhost/Test.aspx?param1=new-value1&param2=new-value2&param3=new-value3&param4=new-value4"));
            for (int i = 1; i <= 4; i++)
            {
                Assert.AreEqual("new-value" + i,
                                HttpContext.Current.Request.QueryString["param" + i],
                                "Could not find query string field 'param{0}'",
                                i);
            }

            simulator.SimulateRequest(new Uri("http://localhost/Test.aspx?"));
            Assert.AreEqual(string.Empty, HttpContext.Current.Request.QueryString.ToString());
            Assert.AreEqual(0, HttpContext.Current.Request.QueryString.Count);

            simulator.SimulateRequest(new Uri("http://localhost/Test.aspx"));
            Assert.AreEqual(string.Empty, HttpContext.Current.Request.QueryString.ToString());
            Assert.AreEqual(0, HttpContext.Current.Request.QueryString.Count);

            simulator.SimulateRequest(new Uri("http://localhost/Test.aspx?param-name"));
            Assert.AreEqual("param-name", HttpContext.Current.Request.QueryString.ToString());
            Assert.AreEqual(1, HttpContext.Current.Request.QueryString.Count);
            Assert.IsNull(HttpContext.Current.Request.QueryString["param-name"]);
        }
        public void CanSetAppPhysicalPathCorrectly(string url,
                                                   string appPath,
                                                   string appPhysicalPath,
                                                   string expectedPhysicalAppPath,
                                                   string expectedPhysicalPath)
        {
            HttpSimulator simulator = new HttpSimulator(appPath, appPhysicalPath);

            Assert.AreEqual(expectedPhysicalAppPath, simulator.PhysicalApplicationPath);
            simulator.SimulateRequest(new Uri(url), HttpVerb.GET);

            Assert.AreEqual(expectedPhysicalPath, simulator.PhysicalPath);
            Assert.AreEqual(expectedPhysicalAppPath, HttpRuntime.AppDomainAppPath);
            Assert.AreEqual(expectedPhysicalAppPath, HostingEnvironment.ApplicationPhysicalPath);
            Assert.AreEqual(expectedPhysicalPath, HttpContext.Current.Request.PhysicalPath);
        }
        public void CanSimulateRequest(string url,
                                       string appPath,
                                       string physicalPath,
                                       string expectedHost,
                                       int expectedPort,
                                       string expectedAppPath,
                                       string expectedLocalPath,
                                       string expectedPhysicalPath)
        {
            HttpSimulator simulator = new HttpSimulator(appPath, physicalPath);

            simulator.SimulateRequest(new Uri(url));

            Assert.AreEqual(expectedHost, HttpContext.Current.Request.Url.Host);
            Assert.AreEqual(expectedPort, HttpContext.Current.Request.Url.Port);
            Assert.AreEqual(expectedAppPath, HttpContext.Current.Request.ApplicationPath);
            Assert.AreEqual(expectedPhysicalPath, HttpContext.Current.Request.PhysicalApplicationPath);
            Assert.AreEqual(expectedLocalPath, HttpContext.Current.Request.Url.LocalPath);
        }
        public void CanMapPath(string virtualPath, string appPath, string expectedMapPath)
        {
            Uri           url       = new Uri("http://localhost/Test/Test.aspx");
            HttpSimulator simulator = new HttpSimulator(appPath, @"c:\inetpub\wwwroot\");

            simulator.SimulateRequest(url);

            //Create a virtual path object.
            object vpath =
                ReflectionHelper.Instantiate(
                    "System.Web.VirtualPath, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
                    new[] { typeof(string) },
                    virtualPath);

            Assert.IsNotNull(vpath);

            HostingEnvironment environment = HttpSimulatorTester.CallGetEnvironment();

            string vpathString = ReflectionHelper.InvokeProperty <string>(vpath, "VirtualPathString");
            object appVirtPath = ReflectionHelper.GetPrivateInstanceFieldValue <object>("_appVirtualPath", environment);

            Assert.IsNotNull(appVirtPath);
            Console.WriteLine("VPATH: " + vpath);
            Console.WriteLine("App-VPATH: " + appVirtPath);

            Console.WriteLine("vpath.VirtualPathString == '{0}'", vpathString);

            string mapping = ReflectionHelper.InvokeNonPublicMethod <string>(typeof(HostingEnvironment),
                                                                             "GetVirtualPathToFileMapping",
                                                                             vpath);

            Console.WriteLine("GetVirtualPathToFileMapping: --->{0}<---", (mapping ?? "{NULL}"));

            object o = ReflectionHelper.GetPrivateInstanceFieldValue <object>("_configMapPath", environment);

            Console.WriteLine("_configMapPath: {0}", o ?? "{null}");

            string mappedPath = ReflectionHelper.InvokeNonPublicMethod <string>(environment, "MapPathActual", vpath, false);

            Console.WriteLine("MAPPED: " + mappedPath);
            Assert.AreEqual(expectedMapPath, HttpContext.Current.Request.MapPath(virtualPath));
        }
        public void CanSimulateFormPost()
        {
            using (HttpSimulator simulator = new HttpSimulator())
            {
                NameValueCollection form = new NameValueCollection();
                form.Add("Test1", "Value1");
                form.Add("Test2", "Value2");
                simulator.SimulateRequest(new Uri("http://localhost/Test.aspx"), form);

                Assert.AreEqual("Value1", HttpContext.Current.Request.Form["Test1"]);
                Assert.AreEqual("Value2", HttpContext.Current.Request.Form["Test2"]);
            }

            using (HttpSimulator simulator = new HttpSimulator())
            {
                simulator.SetFormVariable("Test1", "Value1").SetFormVariable("Test2", "Value2").SimulateRequest(
                    new Uri("http://localhost/Test.aspx"));

                Assert.AreEqual("Value1", HttpContext.Current.Request.Form["Test1"]);
                Assert.AreEqual("Value2", HttpContext.Current.Request.Form["Test2"]);
            }
        }
		public void CanGetQueryString()
		{
			HttpSimulator simulator = new HttpSimulator();
			simulator.SimulateRequest(new Uri("http://localhost/Test.aspx?param1=value1&param2=value2&param3=value3"));
			for (int i = 1; i <= 3; i++)
			{
				Assert.AreEqual("value" + i,
				                HttpContext.Current.Request.QueryString["param" + i],
				                "Could not find query string field 'param{0}'",
				                i);
			}

			simulator.SimulateRequest(
				new Uri("http://localhost/Test.aspx?param1=new-value1&param2=new-value2&param3=new-value3&param4=new-value4"));
			for (int i = 1; i <= 4; i++)
			{
				Assert.AreEqual("new-value" + i,
				                HttpContext.Current.Request.QueryString["param" + i],
				                "Could not find query string field 'param{0}'",
				                i);
			}

			simulator.SimulateRequest(new Uri("http://localhost/Test.aspx?"));
			Assert.AreEqual(string.Empty, HttpContext.Current.Request.QueryString.ToString());
			Assert.AreEqual(0, HttpContext.Current.Request.QueryString.Count);

			simulator.SimulateRequest(new Uri("http://localhost/Test.aspx"));
			Assert.AreEqual(string.Empty, HttpContext.Current.Request.QueryString.ToString());
			Assert.AreEqual(0, HttpContext.Current.Request.QueryString.Count);

			simulator.SimulateRequest(new Uri("http://localhost/Test.aspx?param-name"));
			Assert.AreEqual("param-name", HttpContext.Current.Request.QueryString.ToString());
			Assert.AreEqual(1, HttpContext.Current.Request.QueryString.Count);
			Assert.IsNull(HttpContext.Current.Request.QueryString["param-name"]);
		}
		public void CanGetResponse()
		{
			HttpSimulator simulator = new HttpSimulator();
			simulator.SimulateRequest();
			HttpContext.Current.Response.Write("Hello World!");
			HttpContext.Current.Response.Flush();
			Assert.AreEqual("Hello World!", simulator.ResponseText);
		}
		public void CanGetReferer()
		{
			HttpSimulator simulator = new HttpSimulator();
			simulator.SetReferer(new Uri("http://example.com/Blah.aspx")).SimulateRequest();
			Assert.AreEqual(new Uri("http://example.com/Blah.aspx"), HttpContext.Current.Request.UrlReferrer);

			simulator = new HttpSimulator();
			simulator.SimulateRequest().SetReferer(new Uri("http://x.example.com/Blah.aspx"));
			Assert.AreEqual(new Uri("http://x.example.com/Blah.aspx"), HttpContext.Current.Request.UrlReferrer);
		}
		public void CanGetLocalPathCorrectly(string url, string appPath, string expectedLocalPath)
		{
			HttpSimulator simulator = new HttpSimulator(appPath, @"c:\inetpub\wwwroot\AppPath\");
			simulator.SimulateRequest(new Uri(url));
			Assert.AreEqual(expectedLocalPath, HttpContext.Current.Request.Path);
			Assert.AreEqual(expectedLocalPath, HttpContext.Current.Request.Url.LocalPath);
		}
		public void CanSimulateRequest(string url,
		                               string appPath,
		                               string physicalPath,
		                               string expectedHost,
		                               int expectedPort,
		                               string expectedAppPath,
		                               string expectedLocalPath,
		                               string expectedPhysicalPath)
		{
			HttpSimulator simulator = new HttpSimulator(appPath, physicalPath);
			simulator.SimulateRequest(new Uri(url));

			Assert.AreEqual(expectedHost, HttpContext.Current.Request.Url.Host);
			Assert.AreEqual(expectedPort, HttpContext.Current.Request.Url.Port);
			Assert.AreEqual(expectedAppPath, HttpContext.Current.Request.ApplicationPath);
			Assert.AreEqual(expectedPhysicalPath, HttpContext.Current.Request.PhysicalApplicationPath);
			Assert.AreEqual(expectedLocalPath, HttpContext.Current.Request.Url.LocalPath);
		}
		public void CanMapPath(string virtualPath, string appPath, string expectedMapPath)
		{
			Uri url = new Uri("http://localhost/Test/Test.aspx");
			HttpSimulator simulator = new HttpSimulator(appPath, @"c:\inetpub\wwwroot\");
			simulator.SimulateRequest(url);

			//Create a virtual path object.
			object vpath =
				ReflectionHelper.Instantiate(
					"System.Web.VirtualPath, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
					new[] { typeof(string) },
					virtualPath);
			Assert.IsNotNull(vpath);

			HostingEnvironment environment = HttpSimulatorTester.CallGetEnvironment();

			string vpathString = ReflectionHelper.InvokeProperty<string>(vpath, "VirtualPathString");
			object appVirtPath = ReflectionHelper.GetPrivateInstanceFieldValue<object>("_appVirtualPath", environment);
			Assert.IsNotNull(appVirtPath);
			Console.WriteLine("VPATH: " + vpath);
			Console.WriteLine("App-VPATH: " + appVirtPath);

			Console.WriteLine("vpath.VirtualPathString == '{0}'", vpathString);

			string mapping = ReflectionHelper.InvokeNonPublicMethod<string>(typeof(HostingEnvironment),
			                                                                "GetVirtualPathToFileMapping",
			                                                                vpath);
			Console.WriteLine("GetVirtualPathToFileMapping: --->{0}<---", (mapping ?? "{NULL}"));

			object o = ReflectionHelper.GetPrivateInstanceFieldValue<object>("_configMapPath", environment);
			Console.WriteLine("_configMapPath: {0}", o ?? "{null}");

			string mappedPath = ReflectionHelper.InvokeNonPublicMethod<string>(environment, "MapPathActual", vpath, false);
			Console.WriteLine("MAPPED: " + mappedPath);
			Assert.AreEqual(expectedMapPath, HttpContext.Current.Request.MapPath(virtualPath));
		}
		public void CanSimulateFormPost()
		{
			using (HttpSimulator simulator = new HttpSimulator())
			{
				NameValueCollection form = new NameValueCollection();
				form.Add("Test1", "Value1");
				form.Add("Test2", "Value2");
				simulator.SimulateRequest(new Uri("http://localhost/Test.aspx"), form);

				Assert.AreEqual("Value1", HttpContext.Current.Request.Form["Test1"]);
				Assert.AreEqual("Value2", HttpContext.Current.Request.Form["Test2"]);
			}

			using (HttpSimulator simulator = new HttpSimulator())
			{
				simulator.SetFormVariable("Test1", "Value1").SetFormVariable("Test2", "Value2").SimulateRequest(
					new Uri("http://localhost/Test.aspx"));

				Assert.AreEqual("Value1", HttpContext.Current.Request.Form["Test1"]);
				Assert.AreEqual("Value2", HttpContext.Current.Request.Form["Test2"]);
			}
		}
		public void CanSetAppPhysicalPathCorrectly(string url,
		                                           string appPath,
		                                           string appPhysicalPath,
		                                           string expectedPhysicalAppPath,
		                                           string expectedPhysicalPath)
		{
			HttpSimulator simulator = new HttpSimulator(appPath, appPhysicalPath);
			Assert.AreEqual(expectedPhysicalAppPath, simulator.PhysicalApplicationPath);
			simulator.SimulateRequest(new Uri(url), HttpVerb.GET);

			Assert.AreEqual(expectedPhysicalPath, simulator.PhysicalPath);
			Assert.AreEqual(expectedPhysicalAppPath, HttpRuntime.AppDomainAppPath);
			Assert.AreEqual(expectedPhysicalAppPath, HostingEnvironment.ApplicationPhysicalPath);
			Assert.AreEqual(expectedPhysicalPath, HttpContext.Current.Request.PhysicalPath);
		}