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 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_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_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_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 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_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_ignore_case_of_maxforwards_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "12" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.MaxForwards.ShouldEqual(12); }
public void Should_return_null_ifunmodifiedsince_is_invalid() { // Given var expectedValues = new[] { "Bad Date" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "If-Unmodified-Since", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.IfUnmodifiedSince.ShouldBeNull(); }
public void Should_return_maxforwards_headers_when_available() { // Given var expectedValues = new[] { "12" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "Max-Forwards", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.MaxForwards.ShouldEqual(12); }
public void Should_ignore_case_of_authorization_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Authorization.ShouldBeSameAs(expectedValues[0]); }
public async Task <ActionResult> GetContextData( [FromQuery] Guid id, [FromQuery] DateTimeOffset?ifModifiedSinceOverride, [FromServices] GetContextDataHandler getContextDataHandler) { var requestDict = new RequestHeaders(Request.Headers); var result = await getContextDataHandler.Get( Request.GetUserName(), ifModifiedSinceOverride ?? requestDict.IfModifiedSince, id); return(result.UnwrapFile()); }
public void Should_return_useragent_headers_when_available() { // Given var expectedValues = new[] { "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.815.0 Safari/535.1" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "User-Agent", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.UserAgent.ShouldBeSameAs(expectedValues[0]); }
public void Should_ignore_case_of_accept_language_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "en-US", "sv-SE" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders).AcceptLanguage.ToList(); // Then headers.Count.ShouldEqual(2); }
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 static string BuildRequest <T>(RequestHeaders header, T message, string key = null) { var sb = new StringBuilder(); sb.Append(header); sb.Append(Constants.RequestDelimiter); if (key != null) { sb.Append(key); sb.Append(Constants.RequestDelimiter); } sb.Append(Serializer.Serialize(message)); return(sb.ToString()); }
public void Should_return_host_headers_when_available() { // Given var expectedValues = new[] { "en.wikipedia.org" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "Host", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Host.ShouldBeSameAs(expectedValues[0]); }
public static void AddHeaders(this HttpRequestMessage message, RequestHeaders headers) { var headerParameters = headers.Parameters.Where(x => !RequestContent.ContentHeaders.Contains(x.Name)); headerParameters.ForEach(x => AddHeader(x, message.Headers)); void AddHeader(Parameter parameter, HttpHeaders httpHeaders) { var parameterStringValue = parameter.Value !.ToString(); httpHeaders.Remove(parameter.Name !); httpHeaders.TryAddWithoutValidation(parameter.Name !, parameterStringValue); } }
private void AddRequestHeader(string name, string value) { string[] existing; if (!RequestHeaders.TryGetValue(name, out existing) || existing == null || existing.Length == 0) { RequestHeaders[name] = new[] { value }; } else { RequestHeaders[name] = existing.Concat(new[] { value }).ToArray(); } }
private void PreprocessRequestHeader(HttpContext httpContext, ref int currentPort) { RequestHeaders requestHeader = new RequestHeaders(httpContext.Request.Headers); if (requestHeader.IfNoneMatch != null) { HostConnectionData connectionData; if (GetHostConnectionData(_applicationPath, out connectionData)) { currentPort = BrowserLinkMiddleWareUtil.FilterRequestHeader(requestHeader, connectionData.ConnectionString); } } }
async Task <InternalResponse> ExecuteInternal(RestRequest request, CancellationToken cancellationToken) { Ensure.NotNull(request, nameof(request)); using var requestContent = new RequestContent(this, request); if (Authenticator != null) { await Authenticator.Authenticate(this, request).ConfigureAwait(false); } var httpMethod = AsHttpMethod(request.Method); var url = BuildUri(request); var message = new HttpRequestMessage(httpMethod, url) { Content = requestContent.BuildContent() }; message.Headers.Host = Options.BaseHost; message.Headers.CacheControl = Options.CachePolicy; using var timeoutCts = new CancellationTokenSource(request.Timeout > 0 ? request.Timeout : int.MaxValue); using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, cancellationToken); var ct = cts.Token; try { var headers = new RequestHeaders() .AddHeaders(request.Parameters) .AddHeaders(DefaultParameters) .AddAcceptHeader(AcceptedContentTypes); message.AddHeaders(headers); if (request.OnBeforeRequest != null) { await request.OnBeforeRequest(message).ConfigureAwait(false); } var responseMessage = await HttpClient.SendAsync(message, request.CompletionOption, ct).ConfigureAwait(false); if (request.OnAfterRequest != null) { await request.OnAfterRequest(responseMessage).ConfigureAwait(false); } return(new InternalResponse(responseMessage, url, null, timeoutCts.Token)); } catch (Exception ex) { return(new InternalResponse(null, url, ex, timeoutCts.Token)); } }
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_ifnonematch_headers_when_available() { // Given var expectedValues = new[] { "xyzzy", "c3piozzzz" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "If-None-Match", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.IfNoneMatch.ShouldBeSameAs(expectedValues); }
public void Should_ignore_case_of_referer_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "http://nancyfx.org" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Referrer.ShouldBeSameAs(expectedValues[0]); }
public void Should_ignore_case_of_cache_control_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "public", "max-age=123445" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.CacheControl.ShouldBeSameAs(expectedValues); }
public void Should_ignore_case_of_useragent_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.815.0 Safari/535.1" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.UserAgent.ShouldBeSameAs(expectedValues[0]); }
public void Should_ignore_case_of_connection_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "closed" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Connection.ShouldBeSameAs(expectedValues[0]); }
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_return_accept_charset_headers_when_available() { // Given var expectedValues = new[] { "utf-8", "iso-8859-5" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "Accept-Charset", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.AcceptCharset.ShouldBeSameAs(expectedValues); }
public void Should_return_cache_control_headers_when_available() { // Given var expectedValues = new[] { "public", "max-age=123445" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "Cache-Control", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.CacheControl.ShouldBeSameAs(expectedValues); }
public override bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action) { var requestHeaders = new RequestHeaders(routeContext.HttpContext.Request.Headers); var actionConstrains = action.ActionConstraints .Where(constraintMetadata => constraintMetadata.GetType() == typeof(ProducesConstraintAttribute)) .Cast <ProducesConstraintAttribute>(); var any = actionConstrains.Any(constraintAttribute => constraintAttribute.ContentTypes.Any( producesType => requestHeaders.Accept?.Any(acceptFromHeader => acceptFromHeader.MediaType.Value == producesType) ?? false) ); return(any); }
public void Should_return_connection_headers_when_available() { // Given var expectedValues = new[] { "closed" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "Connection", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Connection.ShouldBeSameAs(expectedValues[0]); }
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_ignore_case_of_ifrange_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "737060cd8c284d8af7ad3082f209582d" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.IfRange.ShouldEqual(expectedValues[0]); }
public void Should_ignore_case_of_host_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "en.wikipedia.org" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Host.ShouldBeSameAs(expectedValues[0]); }
public void Should_ignore_case_of_ifnonematch_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "xyzzy", "c3piozzzz" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.IfNoneMatch.ShouldBeSameAs(expectedValues); }
public void Should_return_ifrange_header_when_available() { // Given var expectedValues = new[] { "737060cd8c284d8af7ad3082f209582d" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "If-Range", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.IfRange.ShouldEqual(expectedValues[0]); }
public void Should_return_authorization_headers_when_available() { // Given var expectedValues = new[] { "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" }; var rawHeaders = new Dictionary <string, IEnumerable <string> > { { "Authorization", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Authorization.ShouldBeSameAs(expectedValues[0]); }
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); }
public void Should_return_maxforwards_headers_when_available() { // Given var expectedValues = new[] { "12" }; var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "Max-Forwards", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.MaxForwards.ShouldEqual(12); }
public void Should_ignore_case_of_accept_language_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "en-US", "sv-SE" }; var rawHeaders = new Dictionary<string, IEnumerable<string>> { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.AcceptLanguage.ShouldBeSameAs(expectedValues); }
public void Should_return_ifunmodifiedsince_when_available() { // Given var expectedDate = new DateTime(2011, 11, 15, 8, 12, 31); var expectedValues = new[] { "Tue, 15 Nov 2011 08:12:31 GMT" }; var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "If-Unmodified-Since", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.IfUnmodifiedSince.ShouldEqual(expectedDate); }
public void Should_return_zero_when_maxforwards_headers_are_not_available() { // Given var rawHeaders = new Dictionary<string, IEnumerable<string>>(); // When var headers = new RequestHeaders(rawHeaders); // Then headers.MaxForwards.ShouldEqual(0); }
public void Should_return_host_headers_when_available() { // Given var expectedValues = new[] { "en.wikipedia.org" }; var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "Host", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Host.ShouldBeSameAs(expectedValues[0]); }
public void Should_return_useragent_headers_when_available() { // Given var expectedValues = new[] { "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.815.0 Safari/535.1" }; var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "User-Agent", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.UserAgent.ShouldBeSameAs(expectedValues[0]); }
public void Should_return_zero_when_content_length_headers_are_not_available() { // Given var rawHeaders = new Dictionary<string, IEnumerable<string>>(); // When var headers = new RequestHeaders(rawHeaders); // Then headers.ContentLength.ShouldEqual(0L); }
public void Should_return_ifnonematch_headers_when_available() { // Given var expectedValues = new[] { "xyzzy", "c3piozzzz" }; var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "If-None-Match", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.IfNoneMatch.ShouldBeSameAs(expectedValues); }
public void Should_ignore_case_of_authorization_header_name_when_retrieving_values(string headerName) { // Given var expectedValues = new[] { "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" }; var rawHeaders = new Dictionary<string, IEnumerable<string>> { { headerName, expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.Authorization.ShouldBeSameAs(expectedValues[0]); }
public void Should_return_ifrange_header_when_available() { // Given var expectedValues = new[] { "737060cd8c284d8af7ad3082f209582d" }; var rawHeaders = new Dictionary<string, IEnumerable<string>> { { "If-Range", expectedValues } }; // When var headers = new RequestHeaders(rawHeaders); // Then headers.IfRange.ShouldEqual(expectedValues[0]); }