public void ByPostShouldReturnCorrectResponse() { var controller = typeof(CategoriesController); var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; var httpServer = new HttpServer(config); var httpInvoker = new HttpMessageInvoker(httpServer); using (httpInvoker) { var request = new HttpRequestMessage { RequestUri = new Uri("http://test.com/api/categories/1"), Method = HttpMethod.Get }; var result = httpInvoker.SendAsync(request, CancellationToken.None).Result; Assert.IsNotNull(result); } }
public HttpCrowDispatcher(HttpConfiguration configuration, HttpMessageHandler handler, IEnumerable<string> filteredUrl) : base() { _configuration = configuration; _messageInvoker = new HttpMessageInvoker(handler); _filteredUrl = filteredUrl ?? new List<string>(); }
public void TestWebApiCanInitialize() { HttpServer server = null; string controllerResponse = string.Empty; Host host = HostFactory.New(configurator => { configurator.UseTestHost(); configurator.Service<SampleService>(s => { s.ConstructUsing(settings => new SampleService()); s.WhenStarted((service, control) => service.Start()); s.AfterStartingService(() => { using (var client = new HttpMessageInvoker(server)) using (var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Api/Test")) using (var response = client.SendAsync(request, CancellationToken.None).Result) controllerResponse = response.Content.ReadAsStringAsync().Result; }); s.WhenStopped((service, control) => service.Stop()); s.WebApiEndpoint(api => { //Use an in-memory server instead of the SelfHost server. api.ServerFactory = uri => new HttpServer(new HttpConfiguration()); api.ConfigureRoutes(Configure); server = api.Build(); }); }); }); host.Run(); Assert.AreEqual("42", controllerResponse); }
/// <summary> /// Sends the ChangeSet request. /// </summary> /// <param name="invoker">The invoker.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A <see cref="ChangeSetResponseItem"/>.</returns> public override async Task<ODataBatchResponseItem> SendRequestAsync(HttpMessageInvoker invoker, CancellationToken cancellationToken) { if (invoker == null) { throw Error.ArgumentNull("invoker"); } cancellationToken.ThrowIfCancellationRequested(); Dictionary<string, string> contentIdToLocationMapping = new Dictionary<string, string>(); List<HttpResponseMessage> responses = new List<HttpResponseMessage>(); try { foreach (HttpRequestMessage request in Requests) { responses.Add(await SendMessageAsync(invoker, request, cancellationToken, contentIdToLocationMapping)); } } catch { foreach (HttpResponseMessage response in responses) { if (response != null) { response.Dispose(); } } throw; } return new ChangeSetResponseItem(responses); }
private static async void CallAsyncMethod() { var expected = new HttpResponseMessage(); var handler = new AsyncClass() { InnerHandler = new EchoHandler(expected) }; var invoker = new HttpMessageInvoker(handler, false); var actual = await invoker.SendAsync(new HttpRequestMessage(), new CancellationToken()); }
public static void RunTest(string controllerName, string routeSuffix, HttpRequestMessage request, Action<HttpResponseMessage> assert, Action<HttpConfiguration> configurer = null) { // Arrange HttpConfiguration config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always }; config.Routes.MapHttpRoute("Default", "{controller}" + routeSuffix, new { controller = controllerName }); if (configurer != null) { configurer(config); } HttpServer server = new HttpServer(config); HttpMessageInvoker invoker = new HttpMessageInvoker(server); HttpResponseMessage response = null; try { // Act response = invoker.SendAsync(request, CancellationToken.None).Result; // Assert assert(response); } finally { request.Dispose(); if (response != null) { response.Dispose(); } } }
public void Should_reject_an_invalid_request() { var request = new HttpRequestMessage(HttpMethod.Post, "http://myApi/api/somePath"); request.Headers.Date = new DateTimeOffset(DateTime.UtcNow); request.Content = new StringContent("{'A':'b'}"); request.Headers.Authorization = new AuthenticationHeaderValue(Configuration.AuthenticationScheme, string.Format("{0}:{1}", "1234", "bad hash value")); request.Content.Headers.ContentMD5 = Encoding.UTF8.GetBytes("anotherBadHash"); var innerhandler = new FakeInnerHandler { Message = new HttpResponseMessage(HttpStatusCode.OK) }; var client = new HttpMessageInvoker(new HmacAuthenticationHandler( new ApiKeyRepository(), new CanonicalRepresentationBuilder(), new HmacSignatureCalculator()) { InnerHandler = innerhandler }); var message = client.SendAsync(request, new CancellationToken(false)).Result; Assert.AreEqual(message.StatusCode, HttpStatusCode.Unauthorized); }
public static async Task<HttpResponseMessage> GetResponse( string requestUri, HttpMethod httpMethod, HttpContent requestContent, Action<HttpConfiguration, HttpServer> registerOData, IEnumerable<KeyValuePair<string, string>> headers = null) { using (HttpConfiguration config = new HttpConfiguration()) { using (HttpServer server = new HttpServer(config)) using (HttpMessageInvoker client = new HttpMessageInvoker(server)) { registerOData(config, server); HttpRequestMessage request = new HttpRequestMessage(httpMethod, requestUri); try { request.Content = requestContent; if (headers != null) { foreach (var header in headers) { request.Headers.Add(header.Key, header.Value); } } return await client.SendAsync(request, CancellationToken.None); } finally { request.DisposeRequestResources(); request.Dispose(); } } } }
public void IndexShouldNotThrow() { var controller = typeof(ChatController); var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}", defaults: new { id = RouteParameter.Optional } ); var httpServer = new HttpServer(config); var httpInvoker = new HttpMessageInvoker(httpServer); using (httpInvoker) { var request = new HttpRequestMessage { RequestUri = new Uri("http://test.com/api/Chat/Index"), Method= HttpMethod.Get }; var result=httpInvoker.SendAsync(request, CancellationToken.None).Result; } }
internal static Task<HttpResponseMessage> InvokeAsync( this DelegatingHandler handler, HttpRequestMessage request, CancellationToken cancellationToken = default(CancellationToken)) { handler.InnerHandler = new DummyHandler(); var invoker = new HttpMessageInvoker(handler); return invoker.SendAsync(request, cancellationToken); }
public async Task http_post() { //arrange var httpConfig = new HttpConfiguration(); WebApiConfig.Register(httpConfig); var url = "http://localhost/api/default"; //act using (var httpServer = new HttpServer(httpConfig)) using (var client = new HttpMessageInvoker(httpServer)) { using (var request = new HttpRequestMessage(HttpMethod.Post, url)) { request.Content = new ObjectContent<string>("Johnny", new JsonMediaTypeFormatter()); using (var response = await client.SendAsync(request, CancellationToken.None)) { var output = await response.Content.ReadAsAsync<string>(); //assert Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); Assert.AreEqual("Hello Johnny!", output); } } } }
public void Test_不是聖誕節的時候_應回傳BadRequest() { // arrange // Step1: 初始化 fakeInnerHandler, 拿來接在欲測試的 messageHandler 後面 // 預計的回傳值可以隨便自訂 var fakeInnerHandler = new FakeInnerHandler { Message = new HttpResponseMessage(System.Net.HttpStatusCode.OK) { Content = new StringContent("Fake inner handler response") } }; // Step2: 初始化測試目標,並將 fakeInnerHandler assign 給 InnerHandler 的 property var target = new XmasMessageHandler() { InnerHandler = fakeInnerHandler }; // Step3: MessageHandler 的單元測試,需要透過HttpMessageInvoker來模擬 client 端送 request 進來 HttpMessageInvoker client = new HttpMessageInvoker(target); var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/Fake"); httpRequestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration()); // act // Step4: 呼叫HttpMessageInvoker的 SendAsync ,就會先呼叫 target, // 當正常執行時,會先呼叫 target 的 SendAsync(), 穿過 target 後,再呼叫 InnerHandler 的 SendAsync() var actual = client.SendAsync(httpRequestMessage, new CancellationToken()).Result; // assert // Step5: 驗證回傳的 StatusCode 是否為 BadRequest Assert.AreEqual(HttpStatusCode.BadRequest, actual.StatusCode); }
/// <summary> /// Sends a single OData batch request. /// </summary> /// <param name="invoker">The invoker.</param> /// <param name="request">The request.</param> /// <param name="cancellationToken">The token to monitor for cancellation requests.</param> /// <param name="contentIdToLocationMapping">The Content-ID to Location mapping.</param> /// <returns></returns> public static async Task<HttpResponseMessage> SendMessageAsync(HttpMessageInvoker invoker, HttpRequestMessage request, CancellationToken cancellationToken, Dictionary<string, string> contentIdToLocationMapping) { if (invoker == null) { throw Error.ArgumentNull("invoker"); } if (request == null) { throw Error.ArgumentNull("request"); } if (contentIdToLocationMapping != null) { string resolvedRequestUrl = ContentIdHelpers.ResolveContentId(request.RequestUri.OriginalString, contentIdToLocationMapping); request.RequestUri = new Uri(resolvedRequestUrl); request.SetODataContentIdMapping(contentIdToLocationMapping); } HttpResponseMessage response = await invoker.SendAsync(request, cancellationToken); ContentIdHelpers.CopyContentIdToResponse(request, response); if (contentIdToLocationMapping != null) { ContentIdHelpers.AddLocationHeaderToMapping(response, contentIdToLocationMapping); } return response; }
public void GetList_ReturnsListWithHeaders_Always() { // Arrange var config = new HttpConfiguration(); config.Routes.MapHttpRoute( "Default", "{controller}/{action}", new { controller = "Test", action = "Get" }); var server = new HttpServer(config); using (var client = new HttpMessageInvoker(server)) { // Act using (var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Test?page=2&per_page=2")) using (var response = client.SendAsync(request, CancellationToken.None).Result) { // Assert Assert.IsNotNull(response); Assert.AreEqual(response.StatusCode, HttpStatusCode.OK); Assert.AreEqual(response.Headers.GetValues("X-Total-Page-Count").Single(), "7"); Assert.AreEqual(response.Headers.GetValues("X-Total-Count").Single(), "2"); Assert.AreEqual(response.Headers.GetValues("X-Current-Page").Single(), "2"); Assert.AreEqual(response.Headers.GetValues("Link").Single(), "<http://localhost/Test/?page=1&per_page=2>; rel=\"first\", <http://localhost/Test/?page=1&per_page=2>; rel=\"previous\", <http://localhost/Test/?page=3&per_page=2>; rel=\"next\", <http://localhost/Test/?page=7&per_page=2>; rel=\"last\""); } } }
public void SendAsync_CallsControllerExecuteAsyncWithPopulatedControllerContext() { HttpControllerContext calledContext = null; var mockSelector = new Mock<IHttpControllerSelector>(); var mockDescriptor = new Mock<HttpControllerDescriptor>(); var mockController = new Mock<IHttpController>(); var config = new HttpConfiguration(); config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object); var request = CreateRequest(config, "http://localhost/api/foo"); mockSelector.Setup(s => s.SelectController(request)) .Returns(mockDescriptor.Object); mockDescriptor.Setup(d => d.CreateController(request)) .Returns(mockController.Object); mockDescriptor.Object.Initialize(config); mockController.Setup(c => c.ExecuteAsync(It.IsAny<HttpControllerContext>(), CancellationToken.None)) .Callback((HttpControllerContext ctxt, CancellationToken token) => { calledContext = ctxt; }); var dispatcher = new HttpControllerDispatcher(config); var invoker = new HttpMessageInvoker(dispatcher); invoker.SendAsync(request, CancellationToken.None).WaitUntilCompleted(); Assert.NotNull(calledContext); Assert.Same(mockController.Object, calledContext.Controller); Assert.Same(mockDescriptor.Object, calledContext.ControllerDescriptor); Assert.Same(config, calledContext.Configuration); Assert.Same(request, calledContext.Request); Assert.Same(request.GetRouteData(), calledContext.RouteData); }
public void ShouldGenerateAuthHeader() { var credential = new HawkCredential { Id = "123", Algorithm = "sha256", Key = "werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn", User = "******" }; var nonce = "123456"; var date = DateTime.UtcNow; var ts = Hawk.ConvertToUnixTimestamp(date).ToString(); var handler = new HawkClientMessageHandler(new DummyHttpMessageHandler(), credential, "hello", date, nonce); var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com:8080/resource/4?filter=a"); var invoker = new HttpMessageInvoker(handler); invoker.SendAsync(request, new CancellationToken()); var mac = Hawk.CalculateMac(request.Headers.Host, request.Method.ToString(), request.RequestUri, "hello", ts, nonce, credential, "header"); var parameter = string.Format("id=\"{0}\", ts=\"{1}\", nonce=\"{2}\", mac=\"{3}\", ext=\"{4}\"", credential.Id, ts, nonce, mac, "hello"); Assert.IsNotNull(request.Headers.Authorization); Assert.AreEqual("Hawk", request.Headers.Authorization.Scheme); Assert.AreEqual(parameter, request.Headers.Authorization.Parameter); }
public void SendAsync_Preflight_ReturnsAllowMethodsAndAllowHeaders(string requestedMethod, string expectedOrigin, string requestedHeaders) { HttpConfiguration config = new HttpConfiguration(); config.Routes.MapHttpRoute("default", "{controller}"); HttpServer server = new HttpServer(config); CorsMessageHandler corsHandler = new CorsMessageHandler(config); corsHandler.InnerHandler = server; HttpMessageInvoker invoker = new HttpMessageInvoker(corsHandler); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample"); request.SetConfiguration(config); request.Headers.Add(CorsConstants.Origin, "http://localhost"); request.Headers.Add(CorsConstants.AccessControlRequestMethod, requestedMethod); request.Headers.Add(CorsConstants.AccessControlRequestHeaders, requestedHeaders); HttpResponseMessage response = invoker.SendAsync(request, CancellationToken.None).Result; string origin = response.Headers.GetValues(CorsConstants.AccessControlAllowOrigin).FirstOrDefault(); string allowMethod = response.Headers.GetValues(CorsConstants.AccessControlAllowMethods).FirstOrDefault(); string[] allowHeaders = response.Headers.GetValues(CorsConstants.AccessControlAllowHeaders).FirstOrDefault().Split(','); string[] requestedHeaderArray = requestedHeaders.Split(','); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(expectedOrigin, origin); Assert.Equal(requestedMethod, allowMethod); foreach (string requestedHeader in requestedHeaderArray) { Assert.Contains(requestedHeader, allowHeaders); } }
public void ByProjectShouldReturnCorrectResponse() { // Required by the HttpServer to find controller in another assembly var controller = typeof(CommitsController); var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always; var httpServer = new HttpServer(config); var httpInvoker = new HttpMessageInvoker(httpServer); using (httpInvoker) { var request = new HttpRequestMessage { RequestUri = new Uri("http://test.com/api/Commits/ByProject/1"), Method = HttpMethod.Get }; var result = httpInvoker.SendAsync(request, CancellationToken.None).Result; Assert.IsNotNull(result); Assert.AreEqual(HttpStatusCode.OK, result.StatusCode); } }
public void ChatHistoryShouldReturnNotFoundIfNoUsername() { var controller = typeof(MessageController); var config = new HttpConfiguration(); config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); var httpServer = new HttpServer(config); var httpInvoker = new HttpMessageInvoker(httpServer); using (httpInvoker) { var request = new HttpRequestMessage { RequestUri = new Uri("http://test.com/api/Message/History"), Method = HttpMethod.Get }; var result = httpInvoker.SendAsync(request, CancellationToken.None).Result; Assert.AreEqual(HttpStatusCode.NotFound, result.StatusCode); } }
public void ShouldFailOnInvalidCredentials() { var handler = new HawkMessageHandler(new DummyHttpMessageHandler(), (id) => { return new HawkCredential { Key = "werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn", User = "******" }; }); var invoker = new HttpMessageInvoker(handler); var ts = Hawk.ConvertToUnixTimestamp(DateTime.Now).ToString(); var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com:8080/resource/4?filter=a"); request.Headers.Authorization = new AuthenticationHeaderValue("Hawk", "id = \"456\", ts = \"" + ts + "\", nonce=\"k3j4h2\", mac = \"qrP6b5tiS2CO330rpjUEym/USBM=\", ext = \"hello\""); request.Headers.Host = "localhost"; var response = invoker.SendAsync(request, new CancellationToken()) .Result; Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode); Assert.AreEqual("Invalid credentials", response.ReasonPhrase); }
public static Task<HttpResponseMessage> SendAsync(this HttpMessageHandler handler, HttpRequestMessage request, CancellationToken cancellationToken) { using (HttpMessageInvoker invoker = new HttpMessageInvoker(handler, disposeHandler: false)) { return invoker.SendAsync(request, cancellationToken); } }
public RegexRouteHandler(HttpConfiguration configuration) { if(configuration == null) { throw new ArgumentNullException("configuration"); } m_DefaultInvoker = new HttpMessageInvoker(new HttpControllerDispatcher(configuration)); }
private static HttpResponseMessage GetResponse(HttpConfiguration configuration, HttpResponseMessage initialResponse) { configuration.AddFiveLevelsOfMediaType(); var handler = new DummyMessageHandler() { Response = initialResponse }; var httpServer = new HttpServer(configuration, handler); var invoker = new HttpMessageInvoker(httpServer); return invoker.SendAsync(new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/ddd"), CancellationToken.None).Result; }
public Http2SessionHandler(bool do11Handshake, HttpMessageHandler fallbackHandler, IConnectionResolver connectionResolver) { // TODO: Will we need a connection resolver that understands proxies? _connectionResolver = connectionResolver; _secureConnectionResolver = new SslConnectionResolver(_connectionResolver); _do11Handshake = do11Handshake; _11fallbackInvoker = new HttpMessageInvoker(fallbackHandler, disposeHandler: false); _fallbackTo11 = false; }
public InMemoryServer() { var config = new HttpConfiguration(); HttpServerConfiguration.Configure(config); // ReSharper disable once PossibleNullReferenceException Container = (config.DependencyResolver as MyDependencyResolver).GetContainer() as SimpleIocContainer; var server = new HttpServer(config); messageInvoker = new HttpMessageInvoker(new InMemoryHttpContentSerializationHandler(server)); }
/// <summary> /// Initializes a new instance of the <see cref="HttpBatchHandler"/> class. /// </summary> /// <param name="httpServer">The <see cref="HttpServer"/> for handling the individual batch requests.</param> protected HttpBatchHandler(HttpServer httpServer) { if (httpServer == null) { throw Error.ArgumentNull("httpServer"); } Invoker = new HttpMessageInvoker(httpServer); }
public void InvokeMethodThrowsExceptionIfRequestNull() { var handler = new DependencyScopeHandler(); var invoker = new HttpMessageInvoker(handler); var exception = Assert.Throws<ArgumentNullException>(() => invoker.SendAsync(null, new CancellationToken())); Assert.That(exception.ParamName, Is.EqualTo("request")); }
/// <summary> /// Sends the Operation request. /// </summary> /// <param name="invoker">The invoker.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A <see cref="OperationResponseItem"/>.</returns> public override async Task<ODataBatchResponseItem> SendRequestAsync(HttpMessageInvoker invoker, CancellationToken cancellationToken) { if (invoker == null) { throw Error.ArgumentNull("invoker"); } HttpResponseMessage response = await SendMessageAsync(invoker, Request, cancellationToken, null); return new OperationResponseItem(response); }
/// <summary> /// Starts singleton global instance of the HTTP server. /// </summary> /// <param name="httpConfiguration">HTTP configuration to use for the requests.</param> public static void StartGlobal(HttpConfiguration httpConfiguration) { if (GlobalIsStarted) { StopGlobal(); } GlobalServer = new HttpServer(httpConfiguration); GlobalClient = new HttpMessageInvoker(GlobalServer, true); }
public async void ShouldAppendCustomHeader() { var invoker = new HttpMessageInvoker(_headerAppenderHandler); var result = await invoker.SendAsync(new HttpRequestMessage(HttpMethod.Get, new Uri("http://localhost/api/test/")), CancellationToken.None); Assert.That(result.Headers.Contains("X-WebAPI-Header"), Is.True); Assert.That(result.Content.ReadAsStringAsync().Result, Is.EqualTo("Unit testing message handlers!")); }