public Request(string method, Url url, IHttpUtility httpUtility, RequestStream body = null, IDictionary<string, IEnumerable<string>> headers = null, string ip = null)
        {
            method.ArgumentNullOrEmptyCheck("method");
            url.ArgumentNullCheck("url");
            url.Path.ArgumentNullOrEmptyCheck("url.Path");
            url.Scheme.ArgumentNullOrEmptyCheck("url.Scheme");
            httpUtility.ArgumentNullCheck("httpUtility");

            this.httpUtility = httpUtility;

            Items = new Dictionary<string, object>();

            UserHostAddress = ip;

            Url = url;

            Method = method;

            Query = url.Query.AsQueryDictionary(httpUtility);

            Body = body ?? RequestStream.FromStream(new MemoryStream());

            Headers = new RequestHeaders(headers ?? new Dictionary<string, IEnumerable<string>>());

            ParseFormData();
        }

        public void Should_return_empty_enumerable_when_accept_headers_are_not_available()
        {
            // Given
            var rawHeaders = new Dictionary<string, IEnumerable<string>>();

            // When
            var headers = new RequestHeaders(rawHeaders);
            
            // Then
            headers.Accept.ShouldHaveCount(0);
        }

        public void SetUp()
        {
            httpRequest = new StubCurrentHttpRequest();

            var container = StructureMapContainerFacility.GetBasicFubuContainer();
            theHeaderValues = httpRequest.Headers;

            container.Inject<ICurrentHttpRequest>(httpRequest);

            theHeaders = container.GetInstance<RequestHeaders>();
        }

        public void SetUp()
        {
            var container = StructureMapContainerFacility.GetBasicFubuContainer();
            theHeaderValues = new KeyValues();

            theRequest = new RequestData();
            theRequest.AddValues(RequestDataSource.Header, theHeaderValues);

            container.Inject<IRequestData>(theRequest);

            theHeaders = container.GetInstance<RequestHeaders>();
        }

        public void Should_ignore_case_of_accept_charset_header_name_when_retrieving_values(string headerName)
        {
            // Given
            var expectedValues = new[] { "utf-8", "iso-8859-5" };
            var rawHeaders = new Dictionary<string, IEnumerable<string>> { { headerName, expectedValues } };

            // When
            var headers = new RequestHeaders(rawHeaders);

            // Then
            headers.AcceptCharset.ShouldBeSameAs(expectedValues);
        }

        public void Should_be_null_when_date_headers_are_invalid()
        {
            // Given
            var expectedValues = new[] { "Bad Date Header" };
            var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "Date", expectedValues } };

            // When
            var headers = new RequestHeaders(rawHeaders);

            // Then
            headers.Date.ShouldBeNull();
        }

        public void Should_ignore_case_of_accept_encoding_header_name_when_retrieving_values(string headerName)
        {
            // Given
            var expectedValues = new[] { "compress", "sdch" };
            var rawHeaders = new Dictionary<string, IEnumerable<string>> { { headerName, expectedValues } };

            // When
            var headers = new RequestHeaders(rawHeaders);

            // Then
            headers.AcceptEncoding.ShouldBeSameAs(expectedValues);
        }

        public void Should_ignore_case_of_accept_header_name_when_retrieving_values(string headerName)
        {
            // Given
            var expectedValues = new[] { "text/plain", "text/ninja" };
            var rawHeaders = new Dictionary<string, IEnumerable<string>> { { headerName, expectedValues } };

            // When
            var headers = new RequestHeaders(rawHeaders);

            // Then
            headers.Accept.ShouldBeSameAs(expectedValues);
        }

        public void Should_header_values_when_available_using_indexer()
        {
            // Given
            var expectedValues = new[] { "fakeValue1", "fakeValue2" };
            var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "some-header", expectedValues } };
            var headers = new RequestHeaders(rawHeaders);

            // When
            var result = headers["some-header"];

            // Then
            result.ShouldBeSameAs(expectedValues);
        }

        public void Should_default_accept_language_header_values_to_quality_one_if_not_explicitly_defined()
        {
            // Given
            var values = new[] { "en-US" };
            var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "Accept-Language", values } };

            // When
            var headers = new RequestHeaders(rawHeaders).AcceptLanguage.ToList();

            // Then
            headers.Count.ShouldEqual(1);
            headers[0].Item1.ShouldEqual("en-US");
            headers[0].Item2.ShouldEqual(1m);
        }

        public void Should_allow_accept_authorization_to_be_overwritten()
        {
            // Given
            var rawHeaders =
                new Dictionary<string, IEnumerable<string>> { { "Authorization", new[] { "Basic 12345LDKJDFJDDSFDFvfdf==" } } };

            var headers =
                new RequestHeaders(rawHeaders) { Authorization = "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" };

            // When
            var values = headers.Authorization;

            // Then
            values.ShouldEqual("Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==");
        }

 public PomonaRequest(string url,
                      string relativePath,
                      HttpMethod method = HttpMethod.Get,
                      RequestHeaders headers = null,
                      Stream body = null,
                      DynamicDictionary query = null)
 {
     if (url == null)
         throw new ArgumentNullException(nameof(url));
     Method = method;
     Url = url;
     RelativePath = relativePath;
     Body = body;
     this.headers = headers;
     Query = query ?? new DynamicDictionary();
 }

        public void Should_return_all_accept_headers_when_multiple_are_available()
        {
            // Given
            var rawHeaders = 
                new Dictionary<string, IEnumerable<string>>
                {
                    { "Accept", new[] { "text/plain", "text/ninja" } }
                };

            // When
            var headers = new RequestHeaders(rawHeaders).Accept.ToList();

            // Then
            headers.ShouldHaveCount(2);
            headers[0].Item1.ShouldEqual("text/plain");
            headers[1].Item1.ShouldEqual("text/ninja");
        }

        public void Should_return_all_header_names_when_keys_are_retrieved()
        {
            // Given
            var rawHeaders = 
                new Dictionary<string, IEnumerable<string>>
                {
                    {"accept", null},
                    {"charset", null}
                };

            var headers = new RequestHeaders(rawHeaders);

            // When
            var keys = headers.Keys.ToList();

            // Then
            keys.ShouldHaveCount(2);
            keys.First().ShouldEqual("accept");
            keys.Last().ShouldEqual("charset");
        }

        public void Should_allow_accept_encoding_headers_to_be_overwritten()
        {
            // Given
            var expectedValues = new[] {
                "compress",
                "gzip",
            };

            var rawHeaders =
                new Dictionary<string, IEnumerable<string>> { { "Accept-Encoding", new[] { "sdch" } } };

            var headers =
                new RequestHeaders(rawHeaders) { AcceptEncoding = expectedValues };

            // When
            var values = headers.AcceptEncoding.ToList();

            // Then
            values[0].ShouldEqual("compress");
            values[1].ShouldEqual("gzip");
        }

        public void Should_return_all_header_values_when_values_are_retrieved()
        {
            // Given
            var rawHeaders =
                new Dictionary<string, IEnumerable<string>>
                {
                    {"accept", new[] {"text/plain", "text/html"}},
                    {"charset", new[] {"utf-8"}}
                };

            var headers = new RequestHeaders(rawHeaders);

            // When
            var values = headers.Values.ToList();

            // Then
            values.ShouldHaveCount(2);
            values.First().ShouldHaveCount(2);
            values.First().First().ShouldEqual("text/plain");
            values.First().Last().ShouldEqual("text/html");
            values.Last().First().ShouldEqual("utf-8");
        }

        public void Should_allow_accept_charset_headers_to_be_overwritten()
        {
            // Given
            var expectedValues = new[] {
                new Tuple<string, decimal>("utf-8", 0.7m),
                new Tuple<string, decimal>("iso-8859-5", 0.3m),
            };

            var rawHeaders =
                new Dictionary<string, IEnumerable<string>> { { "Accept-Charset", new[] { "utf-7" } } };

            var headers =
                new RequestHeaders(rawHeaders) { AcceptCharset = expectedValues };

            // When
            var values = headers.AcceptCharset.ToList();

            // Then
            values[0].Item1.ShouldEqual("utf-8");
            values[0].Item2.ShouldEqual(0.7m);
            values[1].Item1.ShouldEqual("iso-8859-5");
            values[1].Item2.ShouldEqual(0.3m);
        }

        public SpecialEmbeddedFileResponse(Assembly assembly, string zipFilePath, string resourcePath, RequestHeaders requestHeaders = null, bool disableRequestCompression = false)
        {
            _disableRequestCompression = disableRequestCompression;

            // Generate the etag for the zip file and use it for optionally returning HTTP Not-Modified
            var zipFileEtag = "zip" + File.GetLastWriteTime(zipFilePath).Ticks.ToString("G");
            if (requestHeaders != null && (requestHeaders.IfMatch.Any(x => x == zipFileEtag) || requestHeaders.IfNoneMatch.Any(x => x == zipFileEtag)))
            {
                StatusCode = HttpStatusCode.NotModified;
                this.WithHeader("ETag", zipFileEtag);
                return;
            }

            var content = GetFileFromZip(zipFilePath, resourcePath);
            if (content != null)
            {
                Contents = content;
                if (_disableRequestCompression == false)
                    Headers["Content-Encoding"] = "gzip";
                this.WithHeader("ETag", zipFileEtag);
            }
            else
            {
                // Potentially fall back to loading the requested file if it was embedded as a resource
                var fileContent = assembly.GetManifestResourceStream(resourcePath);
                if (fileContent == null)
                {
                    StatusCode = HttpStatusCode.NotFound;
                    return;
                }
                Contents = GetFileContent(fileContent);
            }
            
            ContentType = MimeTypes.GetMimeType(Path.GetFileName(resourcePath));
            StatusCode = HttpStatusCode.OK;
        }

        public void Should_return_referer_headers_when_available()
        {
            // Given
            var expectedValues = new[] { "http://nancyfx.org" };
            var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "Referer", expectedValues } };

            // When
            var headers = new RequestHeaders(rawHeaders);

            // Then
            headers.Referrer.ShouldBeSameAs(expectedValues[0]);
        }

        public void Should_return_min_date_when_ifunmodifiedsince_headers_are_not_available()
        {
            // Given
            var rawHeaders = new Dictionary<string, IEnumerable<string>>();

            // When
            var headers = new RequestHeaders(rawHeaders);

            // Then
            headers.IfUnmodifiedSince.ShouldEqual(DateTime.MinValue);
        }