|
public SendAsync ( |
||
| request | ||
| cancellationToken | ||
| Résultat | Task |
|
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 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 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 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);
}
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 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);
}
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 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;
}
}
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 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 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 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 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);
}
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 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 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);
}
}
/// <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 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 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 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"));
}
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 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!"));
}
public void SendAsync_RemovesRouteParameterOptionalValuesThatAreNotPresent()
{
var config = new HttpConfiguration();
var request = CreateRequest(config, "http://localhost/api/controllerName");
var dispatcher = new HttpRoutingDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
invoker.SendAsync(request, CancellationToken.None).WaitUntilCompleted();
Assert.False(request.GetRouteData().Values.ContainsKey("id"));
}
public void GetProducts()
{
HttpConfiguration config = GetTestConfiguration();
HttpServer server = GetTestCatalogServer(config);
HttpMessageInvoker invoker = new HttpMessageInvoker(server);
HttpRequestMessage request = TestHelpers.CreateTestMessage(TestConstants.CatalogUrl + "GetProducts", HttpMethod.Get, config);
HttpResponseMessage response = invoker.SendAsync(request, CancellationToken.None).Result;
Product[] products = response.Content.ReadAsAsync<IQueryable<Product>>().Result.ToArray();
Assert.Equal(9, products.Length);
}
public void SendAsync_Returns404WhenNoMatchingRoute()
{
var config = new HttpConfiguration();
var request = CreateRequest(config, "http://localhost/noMatch");
var dispatcher = new HttpRoutingDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
var responseTask = invoker.SendAsync(request, CancellationToken.None);
responseTask.WaitUntilCompleted();
Assert.Equal(HttpStatusCode.NotFound, responseTask.Result.StatusCode);
}
public void SendAsync_CallsDefaultHandlerWhenRouteHandlerIsNull()
{
var mockHandler = new Mock<HttpMessageHandler>();
var config = new HttpConfiguration();
var request = CreateRequest(config, "http://localhost/api/controllerName", routeHandler: null);
var dispatcher = new HttpRoutingDispatcher(config, defaultHandler: mockHandler.Object);
var invoker = new HttpMessageInvoker(dispatcher);
invoker.SendAsync(request, CancellationToken.None);
mockHandler.Protected().Verify("SendAsync", Times.Once(), request, CancellationToken.None);
}
public async void WhenCalledShouldLogTheRequestUrl()
{
var mockLogger = new Mock<ILoggingService>();
var handler = new LoggingHandler
{
LoggingService = mockLogger.Object
};
var invoker = new HttpMessageInvoker(handler);
var result = await invoker.SendAsync(new HttpRequestMessage(HttpMethod.Get, new Uri("http://test.com/resource")), CancellationToken.None);
mockLogger.Verify(x => x.Log("http://test.com/resource"), Times.Once);
}
public void SendAsync_CallsControllerSelectorToGetControllerDescriptor()
{
var mockSelector = new Mock<IHttpControllerSelector>();
var config = new HttpConfiguration();
config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
var request = CreateRequest(config, "http://localhost/api/foo");
var dispatcher = new HttpControllerDispatcher(config);
var invoker = new HttpMessageInvoker(dispatcher);
invoker.SendAsync(request, CancellationToken.None).WaitUntilCompleted();
mockSelector.Verify(s => s.SelectController(request), Times.Once());
}
/// <summary>
/// Tests for a particular HTTP response message.
/// </summary>
/// <returns>HTTP response message test builder.</returns>
public IHttpHandlerResponseMessageTestBuilder ShouldReturnHttpResponseMessage()
{
var serverHandler = new ServerHttpMessageHandler(this.client, this.disposeServer);
using (var invoker = new HttpMessageInvoker(serverHandler, true))
{
var httpResponseMessage = invoker.SendAsync(this.httpRequestMessage, CancellationToken.None).Result;
if (this.disposeServer && this.server != null)
{
this.server.Dispose();
}
return new HttpHandlerResponseMessageTestBuilder(serverHandler, httpResponseMessage);
}
}
public async Task ResubmitRequestWorks()
{
int requestCount = 1;
var handler = new ClientHandler(env =>
{
var context = new DefaultHttpContext((IFeatureCollection)env);
int read = context.Request.Body.Read(new byte[100], 0, 100);
Assert.Equal(11, read);
context.Response.Headers["TestHeader"] = "TestValue:" + requestCount++;
return Task.FromResult(0);
}, PathString.Empty);
HttpMessageInvoker invoker = new HttpMessageInvoker(handler);
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Post, "https://example.com/");
message.Content = new StringContent("Hello World");
HttpResponseMessage response = await invoker.SendAsync(message, CancellationToken.None);
Assert.Equal("TestValue:1", response.Headers.GetValues("TestHeader").First());
response = await invoker.SendAsync(message, CancellationToken.None);
Assert.Equal("TestValue:2", response.Headers.GetValues("TestHeader").First());
}
/// <summary>
/// Invokes the single.
/// </summary>
/// <returns></returns>
public async Task <HttpResponseMessage> InvokeSingle()
{
var invoker = new HttpMessageInvoker(this.Handler);
return(await invoker.SendAsync(Messages.First(), new CancellationToken()));
}
