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]);
}
