public void Benchmark_Razor_vs_Markdown()
        {
            var iterations = 10000;
            var razorFormat = RazorFormat.Instance;
            var markdownFmt = MarkdownFormat.Instance;
            var dto = new RockstarsResponse { Results = Rockstar.SeedData.ToList() };

            "Warm up MVC Razor...".Print();
            var mockReq = new MockHttpRequest { OperationName = "RockstarsRazor" };
            var mockRes = new MockHttpResponse(mockReq);
            razorFormat.ProcessRequest(mockReq, mockRes, dto);
            mockRes.ReadAsString().Print();

            "Warm up Markdown Razor...".Print();
            mockReq = new MockHttpRequest { OperationName = "RockstarsMark" };
            mockRes = new MockHttpResponse(mockReq);
            markdownFmt.ProcessRequest(mockReq, mockRes, dto);
            mockRes.ReadAsString().Print();

            "\n\nRunning for {0} times...".Fmt(iterations).Print();
            CompareRuns(iterations,
                "MVC Razor", () => {
                    mockReq = new MockHttpRequest { OperationName = "RockstarsRazor" };
                    mockRes = new MockHttpResponse(mockReq);
                    razorFormat.ProcessRequest(mockReq, mockRes, dto);
                },
                "Markdown Razor", () => {
                    mockReq = new MockHttpRequest { OperationName = "RockstarsMark" };
                    mockRes = new MockHttpResponse(mockReq);
                    markdownFmt.ProcessRequest(mockReq, mockRes, dto);
                });
        }

        public void Can_mock_uploading_files()
        {
            using (new BasicAppHost
            {
                ConfigureAppHost = host => host.VirtualFiles = new InMemoryVirtualPathProvider(host),
            }.Init())
            {
                var ms = new MemoryStream("mocked".ToUtf8Bytes());
                var httpFile = new HttpFile
                {
                    ContentType = "application/x-msaccess",
                    FileName = "C:\\path\\to\\file.txt",
                    InputStream = ms,
                    ContentLength = ms.ToArray().Length,
                };
                var mockReq = new MockHttpRequest
                {
                    Files = new IHttpFile[] { httpFile },
                };
                //Mock Session
                mockReq.Items[Keywords.Session] = new AuthUserSession { Id = "sess-id" };

                var service = new UploadFileService
                {
                    Request = mockReq
                };

                service.Any(new MockUploadFile());

                var files = HostContext.VirtualFiles.GetAllFiles().ToList();
                Assert.That(files[0].ReadAllText(), Is.EqualTo("mocked"));
            }
        }

 /// <summary>Creates a request.</summary>
 ///
 /// <param name="userHostAddress">The user host address.</param>
 ///
 /// <returns>The new request.</returns>
 public IHttpRequest CreateRequest(string userHostAddress)
 {
     var httpReq = new MockHttpRequest("test", HttpMethods.Get, ContentType.Json, "/", null, null, null) {
         UserHostAddress = userHostAddress
     };
     return httpReq;
 }

        public void GetRequestCorrelationId_ReturnsRequestFromHeader(string header)
        {
            var request = new MockHttpRequest();
            request.Headers.Add("x-mac-requestid", header);

            var value = request.GetRequestCorrelationId();
            value.Should().Be(header);
        }

        public void ProcessRequest_CallsGetLimits()
        {
            var mockHttpRequest = new MockHttpRequest();
            A.CallTo(() => limitProvider.GetLimits(mockHttpRequest)).Returns(null);

            var feature = GetSut();
            feature.ProcessRequest(mockHttpRequest, new MockHttpResponse(), null);

            A.CallTo(() => limitProvider.GetLimits(mockHttpRequest)).MustHaveHappened();
        }

 /// <summary>
 /// Mock a controller context
 /// </summary>
 public MockControllerContext(
         IController ControllerToSet,
         MockPrincipal PrincipalToSet,
         MockIdentity IdentityToSet,
         MockHttpRequest RequestToSet,
         MockHttpResponse ResponseToSet,
         MockHttpSessionState SessionStateToSet)
     : base(new MockHttpContext(PrincipalToSet, RequestToSet, ResponseToSet, SessionStateToSet), new RouteData(), (ControllerBase)ControllerToSet)
 {
 }

        public void IsMatch_ExactTextRuleInversedWithNonMatchingString_ReturnsTrue()
        {
            var request = new MockHttpRequest
            {
                HttpMethod = "GET"
            };

            var rule = new HttpMethodRule("not:POST");
            Assert.IsTrue(rule.IsMatch(request));
        }

        public HealthCheckServiceTests(AppHostFixture fixture)
        {
            this.fixture = fixture;
            this.fixture.Host.Container.RegisterAutoWired<HealthCheckService>();
            consulFeature = fixture.Host.GetPlugin<ConsulFeature>();

            var mockHttpRequest = new MockHttpRequest("Heartbeat", "GET", "json", "heartbeat", null, null, null);

            service = new HealthCheckService { Request = mockHttpRequest };
        }

 /// <summary>
 /// Constructor
 /// </summary>       
 /// <param name="PrincipalToSet">Principal</param>
 /// <param name="RequestToSet">Request to mock</param>
 /// <param name="ResponseToSet">Response to mock</param>
 /// <param name="SessionStateToSet">Mocked session state</param>
 public MockHttpContext(MockPrincipal PrincipalToSet,
                        MockHttpRequest RequestToSet,
                        MockHttpResponse ResponseToSet,
                        MockHttpSessionState SessionStateToSet)
 {
     Principal = PrincipalToSet;
     MockedSessionState = SessionStateToSet;
     MockedHttpResponse = ResponseToSet;
     MockedHttpRequest = RequestToSet;
 }

        public void GetConsumerId_ReturnsUserId_IfAuthenticated(string userAuthId)
        {
            MockHttpRequest request = new MockHttpRequest();
            var authSession = SetupAuthenticatedSession(userAuthId, request);

            var keyGenerator = GetGenerator();
            var consumerId = keyGenerator.GetConsumerId(request);

            consumerId.Should().Be(authSession.UserAuthId.ToLower());
        }

 private static string GetRazorInstanceHtml()
 {
     var razorFormat = RazorFormat.Instance;
     var mockReq = new MockHttpRequest { OperationName = "RazorInstance" };
     var mockRes = new MockHttpResponse();
     var dto = new RockstarsResponse { Results = Rockstar.SeedData.ToList() };
     razorFormat.ProcessRequest(mockReq, mockRes, dto);
     var html = mockRes.ReadAsString();
     return html;
 }

        public void IsMatch_ExactTextRuleInversedWithNonMatchingString_ReturnsTrue()
        {
            var request = new MockHttpRequest
            {
                RawUrl = "/passed/"
            };

            var rule = new UrlRule("not:/failed/");
            Assert.IsTrue(rule.IsMatch(request));
        }

        public void GetConfigKeysForRequest_ReturnsCorrectNumberOfKeys()
        {
            MockHttpRequest request = new MockHttpRequest();
            SetupAuthenticatedSession("123", request);

            var keyGenerator = GetGenerator();
            var keys = keyGenerator.GetConfigKeysForRequest(request);

            keys.Count().Should().Be(3);
        }

        public void GetRequestCorrelationId_UsesHeaderNameFromFeature(string header)
        {
            string defaultHeaderName = RateLimitFeature.CorrelationIdHeader;

            const string headerName = "sunkilmoon";
            RateLimitFeature.CorrelationIdHeader = headerName;

            var request = new MockHttpRequest();
            request.Headers.Add(headerName, header);

            var value = request.GetRequestCorrelationId();
            value.Should().Be(header);

            RateLimitFeature.CorrelationIdHeader = defaultHeaderName;
        }

        public void Does_process_Markdown_pages()
        {
            var markdownHandler = new MarkdownHandler("/AppData/NoTemplate/Static")
            {
                MarkdownFormat = markdownFormat,
            };
            var httpReq = new MockHttpRequest { QueryString = PclExportClient.Instance.NewNameValueCollection() };
            var httpRes = new MockHttpResponse();
            markdownHandler.ProcessRequestAsync(httpReq, httpRes, "Static").Wait();

            var expectedHtml = markdownFormat.Transform(
                File.ReadAllText("~/AppData/NoTemplate/Static.md".MapProjectPath()));

            httpRes.Close();
            Assert.That(httpRes.Contents, Is.EqualTo(expectedHtml));
        }

        public void Can_deserialize_TestRequest_QueryStringSerializer_output()
        {
            // Setup
            new BasicAppHost(new Container(), typeof(TestService).Assembly).Init();
            var restPath = new RestPath(typeof(TestRequest), "/service", "GET");
            var restHandler = new RestHandler { RestPath = restPath };

            var requestString = "ListOfA={ListOfB:[{Property:prop1},{Property:prop2}]}";
            NameValueCollection queryString = HttpUtility.ParseQueryString(requestString);
            var httpReq = new MockHttpRequest("service", "GET", "application/json", "service", queryString, new MemoryStream(), new NameValueCollection());

            var request2 = (TestRequest)restHandler.CreateRequest(httpReq, "service");

            Assert.That(request2.ListOfA.Count, Is.EqualTo(1));
            Assert.That(request2.ListOfA.First().ListOfB.Count, Is.EqualTo(2));
        }

        private static void CanOptimizeResult(string contentType, IPlugin pluginFormat)
        {
            using (var appHost = new BasicAppHost().Init())
            {
                var dto = new TestDto { Name = "test" };

                var httpReq = new MockHttpRequest();
                httpReq.Headers.Add(HttpHeaders.AcceptEncoding, "gzip,deflate,sdch");
                httpReq.ResponseContentType = contentType;

                if (pluginFormat != null) pluginFormat.Register(appHost);

                object result = httpReq.ToOptimizedResult(dto);
                Assert.IsNotNull(result);
                Assert.IsTrue(result is CompressedResult);
            }
        }

        public string GetHtml(object dto, string format)
        {
            var httpReq = new MockHttpRequest
            {
                Headers = PclExportClient.Instance.NewNameValueCollection(),
                OperationName = "OperationName",
                QueryString = PclExportClient.Instance.NewNameValueCollection(),
            };
            httpReq.QueryString.Add("format", format);
            using (var ms = new MemoryStream())
            {
                var httpRes = new HttpResponseStreamWrapper(ms, httpReq);
                appHost.ViewEngines[0].ProcessRequest(httpReq, httpRes, dto);

                var utf8Bytes = ms.ToArray();
                var html = utf8Bytes.FromUtf8Bytes();
                return html;
            }
        }

        private static void CanOptimizeResult(string contentType, IPlugin pluginFormat)
        {
            var dto = new TestDto {Name = "test"};

            var httpReq = new MockHttpRequest();
            httpReq.Headers.Add(HttpHeaders.AcceptEncoding, "gzip,deflate,sdch");
            httpReq.ResponseContentType = contentType;
            var httpRes = new ViewTests.MockHttpResponse();

            var httpRequestContext = new HttpRequestContext(httpReq, httpRes, dto);

            var appHost = new TestAppHost();
            if (pluginFormat != null) pluginFormat.Register(appHost);

            EndpointHost.ContentTypeFilter = appHost.ContentTypeFilters;

            object result = httpRequestContext.ToOptimizedResult(dto);
            Assert.IsNotNull(result);
            Assert.IsTrue(result is CompressedResult);
        }

        public void Can_send_ResponseText_test_with_StatusDescription()
        {
            var mockRequest = new MockHttpRequest { ContentType = MimeTypes.Json };
            var mockResponse = mockRequest.Response;

            var customStatus = "Custom Status Description";

            var httpResult = new HttpResult(System.Net.HttpStatusCode.Accepted, customStatus)
            {
                RequestContext = mockRequest
            };

            var reponseWasAutoHandled = mockResponse.WriteToResponse(httpResult, MimeTypes.Html);

            Assert.That(reponseWasAutoHandled.Result, Is.True);

            var statusDesc = mockResponse.StatusDescription;
            Assert.That(mockResponse.StatusCode, Is.EqualTo((int)System.Net.HttpStatusCode.Accepted));
            Assert.That(statusDesc, Is.EqualTo(customStatus));
        }