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!"));
}
