public static void InstanceContextMode_PerCall()
{
PerCallInstanceContextSimpleServiceAndBehavior.ClearCounts();
var services = new ServiceCollection();
services.AddTransient <PerCallInstanceContextSimpleServiceAndBehavior>();
string serviceAddress = "http://localhost/dummy";
var serviceDispatcher = TestHelper.BuildDispatcher <PerCallInstanceContextSimpleServiceAndBehavior>(services, serviceAddress);
IChannel mockChannel = new MockReplyChannel(services.BuildServiceProvider());
var dispatcher = serviceDispatcher.CreateServiceChannelDispatcher(mockChannel);
// Instance created as part of service startup to probe if type is availale in DI
Assert.Equal(1, PerCallInstanceContextSimpleServiceAndBehavior.CreationCount);
// Instance not disposed as it implements IServiceBehavior and is added to service behaviors
Assert.Equal(0, PerCallInstanceContextSimpleServiceAndBehavior.DisposalCount);
Assert.Equal(1, PerCallInstanceContextSimpleServiceAndBehavior.AddBindingParametersCallCount);
Assert.Equal(1, PerCallInstanceContextSimpleServiceAndBehavior.ApplyDispatchBehaviorCount);
Assert.Equal(1, PerCallInstanceContextSimpleServiceAndBehavior.ValidateCallCount);
PerCallInstanceContextSimpleServiceAndBehavior.ClearCounts();
var requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
Assert.Equal(2, PerCallInstanceContextSimpleServiceAndBehavior.CreationCount);
Assert.Equal(2, PerCallInstanceContextSimpleServiceAndBehavior.DisposalCount);
}
public static void InstanceContextMode_PerSession_WithBehavior_NoInjection()
{
PerSessionInstanceContextSimpleServiceAndBehavior.ClearCounts();
var services = new ServiceCollection();
string serviceAddress = "http://localhost/dummy";
var serviceDispatcher = TestHelper.BuildDispatcher <PerSessionInstanceContextSimpleServiceAndBehavior>(services, serviceAddress);
IChannel mockChannel = new MockReplySessionChannel(services.BuildServiceProvider());
var dispatcher = serviceDispatcher.CreateServiceChannelDispatcher(mockChannel);
// Instance created as part of service startup as it implements IServiceBehavior
Assert.Equal(1, PerSessionInstanceContextSimpleServiceAndBehavior.CreationCount);
// Instance not disposed as it implements IServiceBehavior and is added to service behaviors
Assert.Equal(0, PerSessionInstanceContextSimpleServiceAndBehavior.DisposalCount);
Assert.Equal(1, PerSessionInstanceContextSimpleServiceAndBehavior.AddBindingParametersCallCount);
Assert.Equal(1, PerSessionInstanceContextSimpleServiceAndBehavior.ApplyDispatchBehaviorCount);
Assert.Equal(1, PerSessionInstanceContextSimpleServiceAndBehavior.ValidateCallCount);
PerSessionInstanceContextSimpleServiceAndBehavior.ClearCounts();
var requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
// Close channel/session by sending null request context
dispatcher.DispatchAsync(null, CancellationToken.None).Wait();
Assert.Equal(1, PerSessionInstanceContextSimpleServiceAndBehavior.CreationCount);
Assert.Equal(1, PerSessionInstanceContextSimpleServiceAndBehavior.DisposalCount);
}
public async Task BeforeRequestAsyncTest()
{
var apiAction = new DefaultApiActionDescriptor(typeof(IMyApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, new
{
name = "laojiu",
birthDay = DateTime.Parse("2010-10-10")
});
context.HttpContext.RequestMessage.RequestUri = new Uri("http://www.webapi.com/");
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var attr = new JsonContentAttribute()
{
CharSet = "utf-16"
};
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
var body = await context.HttpContext.RequestMessage.Content.ReadAsUtf8ByteArrayAsync();
var options = context.HttpContext.HttpApiOptions.JsonSerializeOptions;
using var buffer = new RecyclableBufferWriter <byte>();
JsonBufferSerializer.Serialize(buffer, context.Arguments[0], options);
var target = buffer.WrittenSpan.ToArray();
Assert.True(body.SequenceEqual(target));
}
public static void InstanceContextMode_Single()
{
SingleInstanceContextSimpleService.ClearCounts();
var services = new ServiceCollection();
var serviceInstance = new SingleInstanceContextSimpleService();
services.AddSingleton(serviceInstance);
string serviceAddress = "http://localhost/dummy";
var serviceDispatcher = TestHelper.BuildDispatcher <SingleInstanceContextSimpleService>(services, serviceAddress);
IChannel mockChannel = new MockReplyChannel(services.BuildServiceProvider());
var dispatcher = serviceDispatcher.CreateServiceChannelDispatcher(mockChannel);
Assert.Equal(1, SingleInstanceContextSimpleService.AddBindingParametersCallCount);
Assert.Equal(1, SingleInstanceContextSimpleService.ApplyDispatchBehaviorCount);
Assert.Equal(1, SingleInstanceContextSimpleService.ValidateCallCount);
var requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
Assert.Equal(1, SingleInstanceContextSimpleService.CreationCount);
Assert.Equal(0, SingleInstanceContextSimpleService.DisposalCount);
Assert.Equal(2, serviceInstance.CallCount);
}
public static void InstanceContextMode_PerSession_NoInjection()
{
PerSessionInstanceContextSimpleService.ClearCounts();
var services = new ServiceCollection();
string serviceAddress = "http://localhost/dummy";
var serviceDispatcher = TestHelper.BuildDispatcher <PerSessionInstanceContextSimpleService>(services, serviceAddress);
IChannel mockChannel = new MockReplySessionChannel(services.BuildServiceProvider());
var dispatcher = serviceDispatcher.CreateServiceChannelDispatcher(mockChannel);
// Instance shouldn't be created as part of service startup to as type isn't available in DI
Assert.Equal(0, PerSessionInstanceContextSimpleService.CreationCount);
Assert.Equal(0, PerSessionInstanceContextSimpleService.DisposalCount);
var requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
// Close channel/session by sending null request context
dispatcher.DispatchAsync(null, CancellationToken.None).Wait();
Assert.Equal(1, PerSessionInstanceContextSimpleService.CreationCount);
Assert.Equal(1, PerSessionInstanceContextSimpleService.DisposalCount);
}
public async Task OnRequestAsyncRelativeTest()
{
var apiAction = new ApiActionDescriptor(typeof(IMyApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, "http://www.baidu.com");
var attr = new UriAttribute();
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
Assert.True(context.HttpContext.RequestMessage.RequestUri == new Uri("http://www.baidu.com"));
context.Arguments[0] = "/login";
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
Assert.True(context.HttpContext.RequestMessage.RequestUri == new Uri("http://www.baidu.com/login"));
context.Arguments[0] = "/login/login2";
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
Assert.True(context.HttpContext.RequestMessage.RequestUri == new Uri("http://www.baidu.com/login/login2"));
context.Arguments[0] = "login3";
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
Assert.True(context.HttpContext.RequestMessage.RequestUri == new Uri("http://www.baidu.com/login/login3"));
}
public async Task OnRequestAsyncTest()
{
var apiAction = new DefaultApiActionDescriptor(typeof(IMyApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, new
{
@class = 123,
xx_yy = "xxyy"
});
var attr = new HeadersAttribute();
context.HttpContext.RequestMessage.Headers.Clear();
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
context.HttpContext.RequestMessage.Headers.TryGetValues("xx-yy", out IEnumerable <string> values);
Assert.Equal("xxyy", values.FirstOrDefault());
context.HttpContext.RequestMessage.Headers.TryGetValues("class", out IEnumerable <string> cValues);
Assert.Equal("123", cValues.FirstOrDefault());
attr.UnderlineToMinus = false;
context.HttpContext.RequestMessage.Headers.Clear();
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
context.HttpContext.RequestMessage.Headers.TryGetValues("xx_yy", out IEnumerable <string> values2);
Assert.Equal("xxyy", values2.FirstOrDefault());
}
public async Task OnRequestAsyncTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, string.Empty);
context.HttpContext.RequestMessage.RequestUri = new Uri("http://www.webapi.com/");
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var attr = new HttpPutAttribute();
await attr.OnRequestAsync(context);
Assert.True(context.HttpContext.RequestMessage.Method == HttpMethod.Put);
var attr2 = new HttpPutAttribute("/login");
await attr2.OnRequestAsync(context);
Assert.True(context.HttpContext.RequestMessage.Method == HttpMethod.Put);
Assert.True(context.HttpContext.RequestMessage.RequestUri == new Uri("http://www.webapi.com/login"));
var attr3 = new HttpPutAttribute("http://www.baidu.com");
await attr3.OnRequestAsync(context);
Assert.True(context.HttpContext.RequestMessage.Method == HttpMethod.Put);
Assert.True(context.HttpContext.RequestMessage.RequestUri == new Uri("http://www.baidu.com"));
}
public static void BuildDispatcherWithConfiguration_Singleton_Not_WellKnown()
{
string serviceAddress = "http://localhost/dummy";
var services = new ServiceCollection();
services.AddServiceModelServices();
var serverAddressesFeature = new ServerAddressesFeature();
serverAddressesFeature.Addresses.Add(serviceAddress);
IServer server = new MockServer();
server.Features.Set <IServerAddressesFeature>(serverAddressesFeature);
services.AddSingleton(server);
var serviceProvider = services.BuildServiceProvider();
var serviceBuilder = serviceProvider.GetRequiredService <IServiceBuilder>();
serviceBuilder.AddService <SimpleSingletonService>();
var binding = new CustomBinding("BindingName", "BindingNS");
binding.Elements.Add(new MockTransportBindingElement());
serviceBuilder.AddServiceEndpoint <SimpleSingletonService, ISimpleService>(binding, serviceAddress);
var dispatcherBuilder = serviceProvider.GetRequiredService <IDispatcherBuilder>();
var dispatchers = dispatcherBuilder.BuildDispatchers(typeof(SimpleSingletonService));
Assert.Single(dispatchers);
var dispatcher = dispatchers[0];
Assert.Equal("foo", dispatcher.Binding.Scheme);
Assert.Equal(serviceAddress, dispatcher.BaseAddress.ToString());
var requestContext = TestRequestContext.Create(serviceAddress);
IChannel mockChannel = new MockReplyChannel(serviceProvider);
dispatcher.DispatchAsync(requestContext, mockChannel, CancellationToken.None).Wait();
requestContext.ValidateReply();
}
public async Task OnRequestAsync_Parameter_Timespan_Test()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, 5);
var attr = new TimeoutAttribute();
var parameterContext = new ApiParameterContext(context, 0);
await attr.OnRequestAsync(parameterContext, () => Task.CompletedTask);
await Task.Delay(20);
var canceled = context.CancellationTokens[0].IsCancellationRequested;
Assert.True(canceled);
context.Arguments[0] = Guid.NewGuid();
await Assert.ThrowsAsync <HttpApiInvalidOperationException>(()
=> attr.OnRequestAsync(parameterContext, () => Task.CompletedTask));
context.Arguments[0] = null;
await attr.OnRequestAsync(parameterContext, () => Task.CompletedTask);
Assert.True(context.CancellationTokens.Count == 1);
}
public void DisposeHttpEndpointContextDisposesParent()
{
bool disposed = false;
var requestContext = new TestRequestContext(); // TODO: kinda just tests the test...
requestContext.OnDispose += delegate { disposed = true; };
requestContext.Dispose();
Assert.True(disposed);
}
public static void BuildDispatcherAndCallService(ServiceCollection services)
{
string serviceAddress = "http://localhost/dummy";
var serviceDispatcher = BuildDispatcher <SimpleService>(services, serviceAddress);
IChannel mockChannel = new MockReplyChannel(services.BuildServiceProvider());
var dispatcher = serviceDispatcher.CreateServiceChannelDispatcher(mockChannel);
var requestContext = TestRequestContext.Create(serviceAddress);
dispatcher.DispatchAsync(requestContext, CancellationToken.None).Wait();
}
public async Task OnRequestAsync()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, string.Empty);
var attr = new HeaderAttribute("MyHeader", "laojiu");
await attr.OnRequestAsync(context);
context.HttpContext.RequestMessage.Headers.TryGetValues("MyHeader", out IEnumerable <string> values);
Assert.Equal("laojiu", values.First());
}
public async Task OnRequestAsync()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, "value");
var basicAuth = new BasicAuth("laojiu", "123456");
await basicAuth.OnRequestAsync(new ApiParameterContext(context, 0));
var auth = Convert.ToBase64String(Encoding.ASCII.GetBytes("laojiu:123456"));
Assert.True(context.HttpContext.RequestMessage.Headers.Authorization.Parameter == auth);
}
public async Task OnRequestAsyncTest()
{
var apiAction = new DefaultApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, string.Empty);
var attr = new BasicAuthAttribute("laojiu", "123456");
await attr.OnRequestAsync(context);
var auth = Convert.ToBase64String(Encoding.ASCII.GetBytes("laojiu:123456"));
Assert.True(context.HttpContext.RequestMessage.Headers.Authorization.Scheme == "Basic");
Assert.True(context.HttpContext.RequestMessage.Headers.Authorization.Parameter == auth);
}
public void Should_Make_RequestBus_Context_Available_To_Handler()
{
var sut = IocHelper.GetRequestBus(sc =>
{
sc.AddTransient <IRequestBusContextWriter, RequestContextWriter>();
sc.AddTransient <IRequestHandler <TestRequestContext, None>, TestRequestContextHandler>();
});
var request = new TestRequestContext();
sut.Send(request);
request.MsgInContext.ShouldBe("Hello World!");
}
public async Task OnRequestAsync()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, 10);
var attr = new TimeoutAttribute(50);
await attr.OnRequestAsync(context);
await Task.Delay(100);
var canceled = context.CancellationTokens[0].IsCancellationRequested;
Assert.True(canceled);
}
public async Task OnRequestAsync()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, string.Empty);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var attr = new FormDataTextAttribute("value", "laojiu");
await attr.OnRequestAsync(context);
var body = await context.HttpContext.RequestMessage.Content.ReadAsStringAsync();
Assert.Contains(get("value", "laojiu"), body);
}
public async Task OnRequestAsyncTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, string.Empty);
Assert.Throws <ArgumentNullException>(() => new HttpHostAttribute(null));
Assert.Throws <UriFormatException>(() => new HttpHostAttribute("/"));
context.HttpContext.RequestMessage.RequestUri = null;
var attr = new HttpHostAttribute("http://www.webapiclient.com");
await attr.OnRequestAsync(context);
Assert.True(context.HttpContext.RequestMessage.RequestUri == new Uri("http://www.webapiclient.com"));
}
public async Task StringResultTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("StringAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
context.HttpContext.ResponseMessage.Content = new StringContent("laojiu", Encoding.UTF8);
var attr = new RawReturnAttribute();
await attr.OnResponseAsync(responseContext);
Assert.True(responseContext.Result?.ToString() == "laojiu");
}
public async Task OnRequestAsync()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, "value");
context.HttpContext.RequestMessage.RequestUri = new Uri("http://www.webapi.com/");
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
IApiParameter formField = new FormField("laojiu");
await formField.OnRequestAsync(new ApiParameterContext(context, 0));
var body = await context.HttpContext.RequestMessage.Content.ReadAsStringAsync();
Assert.Equal("value=laojiu", body);
}
public async Task OnRequestAsync_Parameter()
{
var apiAction = new DefaultApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var parameterContext = new ApiParameterContext(context, 0);
var attr = new FormFieldAttribute();
await attr.OnRequestAsync(parameterContext);
var body = await context.HttpContext.RequestMessage.Content.ReadAsStringAsync();
Assert.Equal("value=laojiu", body);
}
public async Task OnRequestAsyncTest()
{
var apiAction = new DefaultApiActionDescriptor(typeof(IMyApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, new StringContent("laojiu"));
context.HttpContext.RequestMessage.RequestUri = new Uri("http://www.mywebapi.com");
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var attr = new HttpContentTypeAttribute();
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
var body = await context.HttpContext.RequestMessage.Content.ReadAsStringAsync();
Assert.True(body == "laojiu");
}
public async Task OnRequestAsync_Parameter_Double_Test()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, 1);
var attr = new TimeoutAttribute();
var parameterContext = new ApiParameterContext(context, 0);
await attr.OnRequestAsync(parameterContext, () => Task.CompletedTask);
await Task.Delay(20);
var canceled = context.CancellationTokens[0].IsCancellationRequested;
Assert.True(canceled);
}
public async Task ByteArrayResultTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("ByteArrayAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
context.HttpContext.ResponseMessage.Content = new StringContent("laojiu", Encoding.UTF8);
var attr = new RawTypeReturnAttribute();
await attr.OnResponseAsync(responseContext, () => Task.CompletedTask);
var text = Encoding.UTF8.GetString((byte[])responseContext.Result);
Assert.True(text == "laojiu");
}
public async Task EnsureSuccessStatusCodeTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("JsonXmlAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
context.HttpContext.ResponseMessage.StatusCode = System.Net.HttpStatusCode.InternalServerError;
var attr = new JsonReturnAttribute()
{
EnsureSuccessStatusCode = true
};
await attr.OnResponseAsync(responseContext, () => Task.CompletedTask);
Assert.IsType <HttpStatusFailureException>(responseContext.Exception);
}
public async Task EnsureSuccessStatusCodeTest()
{
var apiAction = new DefaultApiActionDescriptor(typeof(ITestApi).GetMethod("JsonXmlAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
context.HttpContext.ResponseMessage.Content = new JsonContent();
context.HttpContext.ResponseMessage.StatusCode = System.Net.HttpStatusCode.InternalServerError;
await Assert.ThrowsAsync <ApiResponseStatusException>(async() =>
{
var attr = new JsonReturnAttribute()
{
EnsureSuccessStatusCode = true
};
await attr.OnResponseAsync(responseContext);
});
}
public async Task XmlResultTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("JsonXmlAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var model = new TestModel();
var xml = context.HttpContext.Services.GetRequiredService <IXmlFormatter>().Serialize(model, Encoding.UTF8);
context.HttpContext.ResponseMessage.Content = new XmlContent(xml, Encoding.UTF8);
var attr = new XmlReturnAttribute();
await attr.OnResponseAsync(responseContext, () => Task.CompletedTask);
var result = responseContext.Result as TestModel;
Assert.True(model.Name == result.Name && model.Age == result.Age);
}
public async Task OnRequestAsyncTest()
{
var apiAction = new DefaultApiActionDescriptor(typeof(IMyApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, new
{
name = "laojiu",
birthDay = DateTime.Parse("2010-10-10")
});
context.HttpContext.RequestMessage.RequestUri = new Uri("http://www.webapi.com/");
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var attr = new PathQueryAttribute();
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
var birthday = KeyValueSerializer.Serialize("time", DateTime.Parse("2010-10-10"), null)[0].Value;
var target = new Uri("http://www.webapi.com?name=laojiu&birthDay=" + Uri.EscapeDataString(birthday));
Assert.True(context.HttpContext.RequestMessage.RequestUri == target);
}
public async Task OnRequestAsyncTest()
{
var apiAction = new ApiActionDescriptor(typeof(IMyApi).GetMethod("PostAsync"));
var context = new TestRequestContext(apiAction, new
{
name = "laojiu",
birthDay = DateTime.Parse("2010-10-10")
});
context.HttpContext.RequestMessage.RequestUri = new Uri("http://www.webapi.com/");
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var attr = new PathQueryAttribute();
await attr.OnRequestAsync(new ApiParameterContext(context, 0));
var birthday = context.HttpContext.Services.GetService <IKeyValueFormatter>().Serialize("time", DateTime.Parse("2010-10-10"), null)[0].Value;
var target = new Uri("http://www.webapi.com?name=laojiu&birthDay=" + HttpUtility.UrlEncode(birthday, Encoding.GetEncoding(attr.Encoding)));
Assert.True(context.HttpContext.RequestMessage.RequestUri == target);
}
