public RequestInfo(Verb method, HttpUrl url, Stream body, IClaimBasedIdentity identity, HeaderCollection headers) { if (method == null) { throw new ArgumentNullException("method"); } if (url == null) { throw new ArgumentNullException("url"); } if (body == null) { throw new ArgumentNullException("body"); } if (identity == null) { throw new ArgumentNullException("identity"); } Method = method; Url = url; Body = new UnclosableStream(_stream = body); _identity = identity; Headers = headers ?? new HeaderCollection(); }
private static IApiDocumentation GetApiDocumentation(HttpUrl url) { string contentType; var responseStream = new UnclosableStream(GetResponse(Method, url, out contentType)); var container = UrsaConfigurationSection.InitializeComponentProvider(); container.Register<IHttpServerConfiguration>(new StaticHttpServerConfiguration((Uri)url)); var headers = new HeaderCollection(); if (!String.IsNullOrEmpty(contentType)) { ((IDictionary<string, string>)headers)[Header.Accept] = contentType; ((IDictionary<string, string>)headers)[Header.ContentType] = contentType; } var apiDocumentationId = url.WithFragment(String.Empty); var httpRequest = new RequestInfo(Verb.Parse(Method), apiDocumentationId, responseStream, new BasicClaimBasedIdentity(), headers); var converterProvider = container.Resolve<IConverterProvider>(); var converter = converterProvider.FindBestInputConverter<IApiDocumentation>(httpRequest); if (converter == null) { throw new NotSupportedException(String.Format("Content type of '{0}' is not supported.", contentType)); } converter.ConvertTo<IApiDocumentation>(httpRequest); return _container.Resolve<IEntityContext>().Load<IApiDocumentation>((Uri)apiDocumentationId); }
public void it_should_remove_a_header() { HeaderCollection headers = new HeaderCollection(); headers.Add(new Header("Header1", new[] { new HeaderValue("Value1", new HeaderParameter("Parameter1", "ParameterValue1")) })); headers.Remove("Header1"); headers.Count.Should().Be(0); }
public void it_should_serialize_the_headers_to_its_string_representation() { HeaderCollection headers = new HeaderCollection(); headers.Add(new Header("Header1", new[] { new HeaderValue("Value1", new HeaderParameter("Parameter1", "ParameterValue1")) })); headers.Add(new Header("Header2", new[] { new HeaderValue("Value2", new HeaderParameter("Parameter2", "ParameterValue2")) })); string expected = String.Format("{0}\r\n{1}\r\n\r\n", headers["Header1"], headers["Header2"]); headers.ToString().Should().Be(expected); }
public void it_should_set_a_header() { HeaderCollection headers = new HeaderCollection(); headers.Set(new Header("Header1", new[] { new HeaderValue("Value1", new HeaderParameter("Parameter1", "ParameterValue1")) })); headers.Set(new Header("Header1", "Value2")); headers.Count.Should().Be(1); headers["Header1"].Values.Count.Should().Be(1); headers["Header1"].Values.First().Parameters.Count.Should().Be(0); }
public void it_should_get_a_header_by_its_name() { HeaderCollection headers = new HeaderCollection(); headers.Add(new Header("Header1", new[] { new HeaderValue("Value1", new HeaderParameter("Parameter1", "ParameterValue1")) })); Header header = headers["Header1"]; header.Should().NotBeNull(); header.Name.Should().Be("Header1"); }
public void it_should_add_a_header() { HeaderCollection headers = new HeaderCollection(); headers.Add(new Header("Header1", new List<HeaderValue>(new[] { new HeaderValue("Value1", new HeaderParameter("Parameter1", "ParameterValue1")) }))); headers.Add("Header1", "Value2"); headers.Count.Should().Be(1); headers["Header1"].Values.Count.Should().Be(2); headers["Header1"].Values.First().Parameters.Count.Should().Be(1); }
/// <summary>Tries to parse a given string as a <see cref="HeaderCollection" />.</summary> /// <param name="headers">String to be parsed.</param> /// <param name="headersCollection">Resulting collection of headers if parsing was successful; otherwise <b>null</b>.</param> /// <returns><b>true</b> if the parsing was successful; otherwise <b>false</b>.</returns> public static bool TryParse(string headers, out HeaderCollection headersCollection) { bool result = false; headersCollection = null; try { headersCollection = Parse(headers); result = true; } catch { } return result; }
public ResponseInfo(Encoding encoding, RequestInfo request, HeaderCollection headers) { if (encoding == null) { throw new ArgumentNullException("encoding"); } if (request == null) { throw new ArgumentNullException("request"); } Encoding = encoding; Request = request; _headers = headers ?? new HeaderCollection(); }
public ResponseInfo(Encoding encoding, RequestInfo request, params Header[] headers) { if (encoding == null) { throw new ArgumentNullException("encoding"); } if (request == null) { throw new ArgumentNullException("request"); } Encoding = encoding; Request = request; _headers = new HeaderCollection(); headers.ForEach(header => _headers.Add(header)); }
protected ObjectResponseInfo(Encoding encoding, RequestInfo request, HeaderCollection headers) : base(encoding, request, headers) { }
private async Task HandleRequest(IOwinContext context) { var headers = new HeaderCollection(); context.Request.Headers.ForEach(header => headers[header.Key] = new Header(header.Key, header.Value)); var requestInfo = new RequestInfo( Verb.Parse(context.Request.Method), (HttpUrl)UrlParser.Parse(context.Request.Uri.AbsoluteUri.TrimEnd('/')), context.Request.Body, new OwinPrincipal(context.Authentication.User), headers); System.Runtime.Remoting.Messaging.CallContext.HostContext = requestInfo; ResponseInfo response; try { response = await _requestHandler.HandleRequestAsync(requestInfo); } finally { System.Runtime.Remoting.Messaging.CallContext.HostContext = null; } if ((IsResponseNoMatchingRouteFoundException(response)) && (Next != null)) { await Next.Invoke(context); return; } context.Response.StatusCode = (int)response.Status; foreach (var header in response.Headers) { switch (header.Name) { case Header.ContentLength: context.Response.ContentLength = response.Body.Length; break; default: context.Response.Headers.Add(header.Name, header.Values.Select(headerValue => headerValue.ToString()).ToArray()); break; } } response.Body.CopyTo(context.Response.Body); }
protected ObjectResponseInfo(Encoding encoding, RequestInfo request, HeaderCollection headers) : base(encoding, request, headers) { }
/// <summary>Parses a given string as a <see cref="HeaderCollection" />.</summary> /// <param name="headers">String to be parsed.</param> /// <returns>Instance of the <see cref="HeaderCollection" />.</returns> public static HeaderCollection Parse(string headers) { if (headers == null) { throw new ArgumentNullException("headers"); } if (headers.Length == 0) { throw new ArgumentOutOfRangeException("headers"); } HeaderCollection result = new HeaderCollection(); var matches = Header.Matches(headers); foreach (Match match in matches) { result.Add(Http.Header.Parse(match.Value)); } return result; }
/// <summary>Calls the ReST service using specified HTTP verb.</summary> /// <param name="verb">The HTTP verb.</param> /// <param name="url">Relative URL of the service to call.</param> /// <param name="accept">Enumeration of accepted media types.</param> /// <param name="contentType">Enumeration of possible content type media types.</param> /// <param name="responseType">Type of the response.</param> /// <param name="uriArguments">The URI template arguments.</param> /// <param name="bodyArguments">The body arguments.</param> /// <returns>Result of the call.</returns> protected object Call(Verb verb, string url, IEnumerable <string> accept, IEnumerable <string> contentType, Type responseType, IDictionary <string, object> uriArguments, params object[] bodyArguments) { var callUrl = BuildUrl(url, uriArguments); var validAccept = (!accept.Any() ? _converterProvider.SupportedMediaTypes : _converterProvider.SupportedMediaTypes.Join(accept, outer => outer, inner => inner, (outer, inner) => inner)); var accepted = (validAccept.Any() ? validAccept : new[] { "*/*" }); WebRequest request = _webRequestProvider.CreateRequest((Uri)callUrl, new Dictionary <string, string>() { { Header.Accept, String.Join(", ", accepted) } }); if ((!String.IsNullOrEmpty(CredentialCache.DefaultNetworkCredentials.UserName)) && (!String.IsNullOrEmpty(CredentialCache.DefaultNetworkCredentials.Password))) { var credentials = new CredentialCache(); credentials.Add(new Uri(callUrl.Authority), _authenticationScheme, new NetworkCredential(CredentialCache.DefaultNetworkCredentials.UserName, CredentialCache.DefaultNetworkCredentials.Password)); request.Credentials = credentials; request.PreAuthenticate = true; } request.Method = verb.ToString(); if ((bodyArguments != null) && (bodyArguments.Length > 0)) { FillRequestBody(verb, callUrl, request, contentType, accepted, bodyArguments); } var response = (HttpWebResponse)request.GetResponse(); ParseContentRange(response, uriArguments); if (responseType == null) { return(null); } RequestInfo fakeRequest = new RequestInfo(verb, callUrl, response.GetResponseStream(), new BasicClaimBasedIdentity(), HeaderCollection.Parse(response.Headers.ToString())); var result = _resultBinder.BindResults(responseType, fakeRequest); return(result.FirstOrDefault(responseType.IsInstanceOfType)); }
public ResponseInfo(RequestInfo request, HeaderCollection headers) : this(Encoding.UTF8, request, headers) { }
public void it_should_merge_headers() { var headers1 = new HeaderCollection(new Header("test1")); var headers2 = new HeaderCollection(new Header("test2")); headers1.Merge(headers2); headers1.Should().ContainKey("test2"); }
public MultiObjectResponseInfo(Encoding encoding, RequestInfo request, IEnumerable<object> values, IConverterProvider converterProvider, HeaderCollection headers) : base(encoding, request, headers) { Initialize(encoding, request, values, converterProvider); }
public MultiObjectResponseInfo(RequestInfo request, IEnumerable<object> values, IConverterProvider converterProvider, HeaderCollection headers) : this(Encoding.UTF8, request, values, converterProvider, headers) { }
public void it_should_bind_arguments_for_Upload_method_correctly() { string fileName = "test.txt"; byte[] data = new byte[] { 1, 2 }; _fromQueryStringBinder.Setup(instance => instance.GetArgumentValue(It.IsAny<ArgumentBindingContext>())) .Returns<ArgumentBindingContext>(context => (context.Index == 0 ? (object)fileName : (object)data)); var method = ControllerType.GetMethod("Upload"); string body = String.Format( "--test\r\nContentType: text/plain\r\nContent-Lenght: {0}\r\nContent-Disposition: form-data; name=\"filename\"\r\n\r\n{1}\r\n" + "--test\r\nContentType: text/plain\r\nContent-Length: {2}\r\nContent-Disposition: form-data; name=\"data\"\r\n\r\n{3}\r\n" + "--test--", fileName.Length + 2, fileName, System.Convert.ToBase64String(data).Length + 2, System.Convert.ToBase64String(data)); var headers = new HeaderCollection(); headers.ContentType = "multipart/form-data; boundary=\"test\""; headers.ContentLength = body.Length; var arguments = BindArguments("/api/test/upload", method, Verb.POST); arguments.Length.Should().Be(method.GetParameters().Length); arguments[0].Should().Be(fileName); ((byte[])arguments[1]).Should().BeEquivalentTo(data); }
public void it_should_set_and_get_named_headers_correctly() { var collection = new HeaderCollection(); foreach (var namedHeader in collection.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance) .Where(property => (property.CanRead) && (property.CanWrite) && (property.Name != "Item"))) { var value = (namedHeader.PropertyType == typeof(string) ? (object)"test" : 1); namedHeader.SetValue(collection, value); namedHeader.GetValue(collection).Should().Be(value); } }
public void it_should_bind_arguments_for_Modulo_method_correctly() { _fromQueryStringBinder.Setup(instance => instance.GetArgumentValue(It.IsAny<ArgumentBindingContext>())) .Returns<ArgumentBindingContext>(context => (context.Index == 0 ? 1 : 2)); var method = ControllerType.GetMethod("PostModulo"); var body = "--test\r\nContent-Type: text/plain\r\nContent-Length:3\r\n\r\n1\r\n" + "--test\r\nContent-Type: text/plain\r\nContent-Length:3\r\n\r\n2\r\n--test--"; var headers = new HeaderCollection(); headers.ContentLength = body.Length; ((IDictionary<string, string>)headers)["Content-Type"] = "multipart/mixed; boundary=\"test\""; var arguments = BindArguments("/api/test/modulo", method, Verb.POST); arguments.Length.Should().Be(method.GetParameters().Length); arguments[0].Should().Be(1); arguments[1].Should().Be(2); }
public ResponseInfo(RequestInfo request, HeaderCollection headers) : this(Encoding.UTF8, request, headers) { }
public RequestInfo(Verb method, HttpUrl url, Stream body, IClaimBasedIdentity identity, HeaderCollection headers) { if (method == null) { throw new ArgumentNullException("method"); } if (url == null) { throw new ArgumentNullException("url"); } if (body == null) { throw new ArgumentNullException("body"); } if (identity == null) { throw new ArgumentNullException("identity"); } Method = method; Url = url; Body = new UnclosableStream(_stream = body); _identity = identity; Headers = headers ?? new HeaderCollection(); }
/// <summary>Merges headers.</summary> /// <param name="headers">Headers to be merged.</param> public void Merge(HeaderCollection headers) { if (headers == null) { return; } foreach (var header in headers) { Add(header); } }
public void it_should_do_nothing_when_no_headers_is_being_merged() { var headers = new HeaderCollection(); headers.Merge(null); headers.Should().HaveCount(0); }