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