public void ResolvedServiceGetResponseEncoder()
{
ServiceCollection services = new ServiceCollection();
services
.WithService("Test", "/")
.WithEndpoint("{action}")
.Post<Payload>((Payload p) => { });
ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo");
EncodingLookupResult result = service.GetResponseEncoder("gzip");
Assert.IsNotNull(result);
Assert.AreEqual(EncodingType.Empty, result.EncodingType);
Assert.AreEqual(new IdentityEncoding(), result.Encoding);
result = service.GetResponseEncoder("gzip, *");
Assert.IsNotNull(result);
Assert.AreEqual(EncodingType.Empty, result.EncodingType);
Assert.AreEqual(new IdentityEncoding(), result.Encoding);
services.WithHostEncoding(new GzipDeflateEncoding());
service = new ServiceResolver(services).Find(MethodType.Post, "foo");
result = service.GetResponseEncoder("gzip, *");
Assert.IsNotNull(result);
Assert.AreEqual(EncodingType.Parse("gzip"), result.EncodingType);
Assert.AreEqual(new GzipDeflateEncoding(), result.Encoding);
result = service.GetResponseEncoder("gzip;q=0");
Assert.IsNotNull(result);
Assert.AreEqual(EncodingType.Empty, result.EncodingType);
Assert.AreEqual(new IdentityEncoding(), result.Encoding);
}
public void ServiceCollectionErrorService()
{
ServiceCollection services = new ServiceCollection();
services.WithService("Test", "/");
services
.ErrorService((ex) => true)
.ErrorService((ex, req, res) => true)
.ErrorService<string>((ex, req, res) => true);
Assert.AreEqual(3, services.First().Pipeline.ErrorActions.Count);
}
public void ServiceCollectionBeforeService()
{
ServiceCollection services = new ServiceCollection();
services.WithService("Test", "/");
services
.BeforeService(() => true)
.BeforeService((req, res) => true)
.BeforeService<string>((req, res) => true);
Assert.AreEqual(3, services.First().Pipeline.BeforeActions.Count);
}
public void ServiceResolverFind()
{
ServiceCollection services = new ServiceCollection();
services
.WithService("Test", "/")
.WithEndpoint("foo/{param}/bar")
.Get(() => { });
ServiceResolver resolver = new ServiceResolver(services);
Assert.IsNotNull(resolver.Find(MethodType.Get, "foo/baz/bar"));
Assert.IsNull(resolver.Find(MethodType.Post, "foo/baz/bar"));
}
public void ServiceResolverFindRouteTypes()
{
ServiceCollection services = new ServiceCollection();
services
.WithService("Test", "/")
.WithEndpoint("foo/{param}/bar", new { param = typeof(Guid) })
.Get(() => { });
ServiceResolver resolver = new ServiceResolver(services);
Assert.IsNotNull(resolver.Find(MethodType.Get, "foo/D118CE6F-36BE-4DB4-B0E7-D426809B22FE/bar"));
Assert.IsNull(resolver.Find(MethodType.Get, "foo/42/bar"));
}
public void ServiceResolverExistsForAnyMethodType()
{
ServiceCollection services = new ServiceCollection();
services
.WithService("Test", "/")
.WithEndpoint("foo/{param}/bar")
.Get(() => { });
ServiceResolver resolver = new ServiceResolver(services);
Assert.IsTrue(resolver.ExistsForAnyMethodType("foo/baz/bar"));
Assert.IsFalse(resolver.ExistsForAnyMethodType("foo/bar"));
}
public void ServiceResolverFindRoutePatterns()
{
ServiceCollection services = new ServiceCollection();
services
.WithService("Test", "/")
.WithEndpoint("foo/{param}/bar", null, new { param = @"^\d+$" })
.Get(() => { });
ServiceResolver resolver = new ServiceResolver(services);
Assert.IsNotNull(resolver.Find(MethodType.Get, "foo/42/bar"));
Assert.IsNull(resolver.Find(MethodType.Get, "foo/baz/bar"));
}
public void MethodCollectionBeforeEndpoint()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
MethodCollection methods = endpoints.WithEndpoint("endpoint/route") as MethodCollection;
methods
.BeforeEndpoint(() => true)
.BeforeEndpoint((req, res) => true)
.BeforeEndpoint<string>((req, res) => true);
Assert.AreEqual(3, endpoints.First().Pipeline.BeforeActions.Count);
}
public void ServiceCollectionWithEndpoint()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
services.WithEndpoint("accounts/{id}");
Assert.AreEqual(1, endpoints.Count());
Assert.AreEqual(0, endpoints.First().ParameterTypes.Count);
services.WithEndpoint("foo/{id}/bar", new { id = typeof(long) });
Assert.AreEqual(2, endpoints.Count());
Assert.IsTrue(endpoints.Last().ParameterTypes.ContainsKey("id"));
Assert.AreEqual(typeof(long), endpoints.Last().ParameterTypes["id"]);
}
public void EndpointCollectionErrorEndpoint()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
endpoints.WithEndpoint("endpoint/route");
endpoints
.ErrorEndpoint((ex) => true)
.ErrorEndpoint((ex, req, res) => true)
.ErrorEndpoint<string>((ex, req, res) => true);
Assert.AreEqual(3, endpoints.First().Pipeline.ErrorActions.Count);
}
public void EndpointCollectionAfterService()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
endpoints.WithEndpoint("endpoint/route");
endpoints
.AfterService(() => true)
.AfterService((req, res) => true)
.AfterService<string>((req, res) => true);
Assert.AreEqual(3, services.First().Pipeline.AfterActions.Count);
}
public void ResolvedServiceGetRequestDeserializer()
{
ServiceCollection services = new ServiceCollection();
services
.WithService("Test", "/")
.WithEndpoint("{action}")
.Post<Payload>((Payload p) => { });
ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo");
FormatLookupResult result = service.GetRequestDeserializer("application/json");
Assert.IsNull(result);
result = service.GetRequestDeserializer(string.Empty);
Assert.IsNotNull(result);
Assert.AreEqual(MediaType.Empty, result.MediaType);
Assert.AreEqual(new PlainTextFormat(), result.Format);
services.WithHostFormat(new JsonFormat());
service = new ServiceResolver(services).Find(MethodType.Post, "foo");
result = service.GetRequestDeserializer("application/json");
Assert.IsNotNull(result);
Assert.AreEqual(MediaType.Parse("application/json"), result.MediaType);
Assert.AreEqual(new JsonFormat(), result.Format);
}
public void MethodCollectionWithServiceFormat()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
MethodCollection methods = endpoints.WithEndpoint("endpoint/route") as MethodCollection;
methods.WithServiceFormat(new PlainTextFormat());
Assert.AreEqual(1, services.First().Pipeline.Formats.Count);
}
public void MethodCollectionWithServiceEncoding()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
MethodCollection methods = endpoints.WithEndpoint("endpoint/route") as MethodCollection;
methods.WithServiceEncoding(new GzipDeflateEncoding());
Assert.AreEqual(1, services.First().Pipeline.Encodings.Count);
}
public void MethodCollectionWithService()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
MethodCollection methods = endpoints.WithEndpoint("endpoint/route") as MethodCollection;
methods.WithService("Test1", "/api");
Assert.AreEqual(2, services.Count);
}
public void EndpointCollectionWithHostEncoding()
{
ServiceCollection services = new ServiceCollection();
int count = services.Pipeline.Encodings.Count;
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
endpoints.WithHostEncoding(new GzipDeflateEncoding());
Assert.AreEqual(count + 1, services.Pipeline.Encodings.Count);
}
public void MethodCollectionDelete()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
MethodCollection methods = endpoints.WithEndpoint("endpoint/route") as MethodCollection;
methods.Delete(() => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Delete, methods.CurrentMethod.MethodType);
methods.Clear();
Assert.AreEqual(0, methods.Count);
methods.Delete((req) => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Delete, methods.CurrentMethod.MethodType);
methods.Clear();
Assert.AreEqual(0, methods.Count);
methods.Delete((req, res) => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Delete, methods.CurrentMethod.MethodType);
}
public void EndpointCollectionWithService()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
endpoints.WithEndpoint("endpoint/route");
endpoints.WithService("Test2", "/api");
Assert.AreEqual(2, services.Count);
}
public void EndpointCollectionWithoutBeforeEndpoint()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
endpoints.WithEndpoint("endpoint/route");
endpoints
.WithoutBeforeEndpoint(() => true)
.WithoutBeforeEndpoint((req, res) => true)
.WithoutBeforeEndpoint<string>((req, res) => true);
Assert.AreEqual(3, endpoints.First().Pipeline.ExcludeBeforeActions.Count);
}
public void EndpointCollectionWithHostFormat()
{
ServiceCollection services = new ServiceCollection();
int count = services.Pipeline.Formats.Count;
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
endpoints.WithHostFormat(new PlainTextFormat());
Assert.AreEqual(count + 1, services.Pipeline.Formats.Count);
}
public void ResolvedServiceInvokeErrorActionsNoContinue()
{
Payload payload = new Payload()
{
Date = DateTime.UtcNow,
Number = 42,
Text = "Hello, world!"
};
ServiceCollection services = new ServiceCollection();
services
.WithService("Test", "/")
.WithEndpoint("{action}")
.Post<Payload>((Payload p) => { })
.ErrorService<Payload>(
(ex, req, resp) =>
{
Assert.AreEqual(payload, req.RequestObject);
return false;
})
.ErrorService(
ex =>
{
Assert.Fail();
return true;
});
IDictionary<string, object> routeValues = new Dictionary<string, object>();
routeValues["action"] = "foo";
using (IRequestMessage request = new RequestMessage<Payload>("Test", routeValues, new Uri("http://example.com/foo"), payload))
{
using (IResponseMessage response = new ResponseMessage())
{
ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo");
InvokeActionsResult result = service.InvokeErrorActions(request, response, new Exception[0]);
Assert.IsFalse(result.Continue);
Assert.IsTrue(result.Success);
Assert.AreEqual(1, result.Results.Count);
}
}
}
public void ServiceCollectionWithServiceFormat()
{
ServiceCollection services = new ServiceCollection();
services.WithService("Test", "/");
services.WithServiceFormat(new PlainTextFormat());
Assert.AreEqual(1, services.First().Pipeline.Formats.Count);
}
public void ResolvedServiceReadRequestMissingFormat()
{
ServiceCollection services = new ServiceCollection();
services
.WithService("Test", "/")
.WithEndpoint("{action}")
.Post<Payload>((Payload p) => { });
ResolvedService service = new ServiceResolver(services).Find(MethodType.Post, "foo");
using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes("{\"date\":\"2012-09-22T18:46:00Z\",\"number\":42,\"text\":\"Hello, world!\"}")))
{
using (RequestMessage request = new RequestMessage<Payload>(service.Name, service.RouteValues, new Uri("http://example.com/foo")))
{
ReadRequestResult result = service.ReadRequest(request, (int)stream.Length, null, "application/json", stream);
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
Assert.IsNull(result.Exception);
Assert.AreEqual(StatusCode.UnsupportedMediaType, result.StatusCode);
Assert.IsNull(result.RequestObject);
}
}
}
public void MethodCollectionWithoutErrorMethod()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
MethodCollection methods = endpoints.WithEndpoint("endpoint/route") as MethodCollection;
methods.Get(() => { });
methods
.WithoutErrorMethod(ex => true)
.WithoutErrorMethod((ex, req, res) => true)
.WithoutErrorMethod<string>((ex, req, res) => true);
Assert.AreEqual(3, methods.First().Pipeline.ExcludeErrorActions.Count);
}
public void MethodCollectionPut()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
MethodCollection methods = endpoints.WithEndpoint("endpoint/route") as MethodCollection;
methods.Put(() => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Put, methods.CurrentMethod.MethodType);
methods.Clear();
Assert.AreEqual(0, methods.Count);
methods.Put<string>((string s) => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Put, methods.CurrentMethod.MethodType);
methods.Clear();
Assert.AreEqual(0, methods.Count);
methods.Put((req) => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Put, methods.CurrentMethod.MethodType);
methods.Clear();
Assert.AreEqual(0, methods.Count);
methods.Put<string>((IRequestMessage<string> req) => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Put, methods.CurrentMethod.MethodType);
methods.Clear();
Assert.AreEqual(0, methods.Count);
methods.Put((req, res) => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Put, methods.CurrentMethod.MethodType);
methods.Clear();
Assert.AreEqual(0, methods.Count);
methods.Put<string>((req, res) => { });
Assert.AreEqual(methods.Count, 1);
Assert.AreEqual(MethodType.Put, methods.CurrentMethod.MethodType);
}
public void ServiceCollectionWithoutServiceEncoding()
{
ServiceCollection services = new ServiceCollection();
services.WithService("Test", "/");
services.WithoutServiceEncoding(new GzipDeflateEncoding());
Assert.AreEqual(1, services.First().Pipeline.ExcludeEncodings.Count);
}
public void MethodCollectionWithHostParameterParser()
{
ServiceCollection services = new ServiceCollection();
EndpointCollection endpoints = services.WithService("Test", "/") as EndpointCollection;
MethodCollection methods = endpoints.WithEndpoint("endpoint/route") as MethodCollection;
Assert.IsFalse(services.RouteValueBinder.HasParserForType(typeof(Service)));
methods.WithHostParameterParser(new NoOpRouteParameterParser(new Type[] { typeof(Service) }));
Assert.IsTrue(services.RouteValueBinder.HasParserForType(typeof(Service)));
}
public void ServiceCollectionWithService()
{
ServiceCollection services = new ServiceCollection();
services.WithService("Test", "/");
Assert.AreEqual(1, services.Count);
}
