move to one handle method

dasiths · Mar 21, 2020 · 5732178 · 5732178
1 parent c920688
commit 5732178
Show file tree

Hide file tree

Showing 10 changed files with 66 additions and 67 deletions.
diff --git a/README.md b/README.md
@@ -34,7 +34,7 @@ In the NuGet Package Manager Console, type:
 ```C#
     public class SimpleMessageEndpoint : AsyncGetEndpoint<SimpleMessage, SimpleResponse>
     {
-        protected override async Task<ActionResult<SimpleResponse>> HandleAsync(SimpleMessage requestModel, CancellationToken cancellationToken = default)
+        public override async Task<ActionResult<SimpleResponse>> HandleAsync(SimpleMessage requestModel, CancellationToken cancellationToken = default)
         {	
 	    // Handle in place or dispatch to the domain i.e. return await _someDomainService.HandleAsync(requestModel)
 	

diff --git a/src/SimpleEndPoints/Core/Endpoint.cs b/src/SimpleEndPoints/Core/Endpoint.cs
@@ -8,63 +8,55 @@ namespace SimpleEndpoints.Core
     [Route("[endpoint]")]
     public abstract class AsyncEndpoint : ControllerBase
     {
-        [NonAction]
-        protected abstract Task<IActionResult> HandleAsync(CancellationToken cancellationToken = default);
+        public abstract Task<IActionResult> HandleAsync(CancellationToken cancellationToken = default);
     }
 
     [ApiController]
     [Route("[endpoint]")]
     public abstract class AsyncEndpointWithRequest<TRequest> : ControllerBase
     {
-        [NonAction]
-        protected abstract Task<IActionResult> HandleAsync(TRequest requestModel, CancellationToken cancellationToken = default);
+        public abstract Task<IActionResult> HandleAsync(TRequest requestModel, CancellationToken cancellationToken = default);
     }
 
     [ApiController]
     [Route("[endpoint]")]
     public abstract class AsyncEndpoint<TResponse> : ControllerBase
     {
-        [NonAction]
-        protected abstract Task<ActionResult<TResponse>> HandleAsync(CancellationToken cancellationToken = default);
+        public abstract Task<ActionResult<TResponse>> HandleAsync(CancellationToken cancellationToken = default);
     }
 
     [ApiController]
     [Route("[endpoint]")]
     public abstract class AsyncEndpoint<TRequest, TResponse> : ControllerBase
     {
-        [NonAction]
-        protected abstract Task<ActionResult<TResponse>> HandleAsync(TRequest requestModel, CancellationToken cancellationToken = default);
+        public abstract Task<ActionResult<TResponse>> HandleAsync(TRequest requestModel, CancellationToken cancellationToken = default);
     }
 
     [ApiController]
     [Route("[endpoint]")]
     public abstract class Endpoint : ControllerBase
     {
-        [NonAction]
-        protected abstract IActionResult Handle();
+        public abstract IActionResult Handle();
     }
 
     [ApiController]
     [Route("[endpoint]")]
     public abstract class EndpointWithRequest<TRequest> : ControllerBase
     {
-        [NonAction]
-        protected abstract IActionResult Handle(TRequest requestModel);
+        public abstract IActionResult Handle(TRequest requestModel);
     }
 
     [ApiController]
     [Route("[endpoint]")]
     public abstract class Endpoint<TResponse> : ControllerBase
     {
-        [NonAction]
-        protected abstract ActionResult<TResponse> Handle();
+        public abstract ActionResult<TResponse> Handle();
     }
 
     [ApiController]
     [Route("[endpoint]")]
     public abstract class Endpoint<TRequest, TResponse> : ControllerBase
     {
-        [NonAction]
-        protected abstract ActionResult<TResponse> Handle(TRequest requestModel);
+        public abstract ActionResult<TResponse> Handle(TRequest requestModel);
     }
 }
diff --git a/src/SimpleEndPoints/VerbScoped/DeleteEndpoint.cs b/src/SimpleEndPoints/VerbScoped/DeleteEndpoint.cs
@@ -9,28 +9,26 @@ namespace SimpleEndpoints.VerbScoped
     public abstract class AsyncDeleteEndpoint<TRequest> : AsyncEndpointWithRequest<TRequest>
     {
         [HttpDelete]
-        public virtual Task<IActionResult> Delete(TRequest model, CancellationToken cancellationToken = default) =>
-            HandleAsync(model, cancellationToken);
+        public abstract override Task<IActionResult> HandleAsync(TRequest model,
+            CancellationToken cancellationToken = default);
     }
 
     public abstract class AsyncDeleteEndpoint<TRequest, TResponse> : AsyncEndpoint<TRequest, TResponse>
     {
         [HttpDelete]
-        public virtual Task<ActionResult<TResponse>> Delete(TRequest model, CancellationToken cancellationToken = default) =>
-            HandleAsync(model, cancellationToken);
+        public abstract override Task<ActionResult<TResponse>> HandleAsync(TRequest model,
+            CancellationToken cancellationToken = default);
     }
 
     public abstract class DeleteEndpoint<TRequest> : EndpointWithRequest<TRequest>
     {
         [HttpDelete]
-        public virtual IActionResult Delete(TRequest model) =>
-            Handle(model);
+        public abstract override IActionResult Handle(TRequest model);
     }
 
     public abstract class DeleteEndpoint<TRequest, TResponse> : Endpoint<TRequest, TResponse>
     {
         [HttpDelete]
-        public virtual ActionResult<TResponse> Delete(TRequest model) =>
-            Handle(model);
+        public abstract override ActionResult<TResponse> Handle(TRequest model);
     }
 }
diff --git a/src/SimpleEndPoints/VerbScoped/GetEndpoint.cs b/src/SimpleEndPoints/VerbScoped/GetEndpoint.cs
@@ -9,56 +9,52 @@ namespace SimpleEndpoints.VerbScoped
     public abstract class AsyncGetEndpoint : AsyncEndpoint
     {
         [HttpGet]
-        public virtual Task<IActionResult> Get(CancellationToken cancellationToken = default) =>
-            HandleAsync(cancellationToken);
+        public abstract override Task<IActionResult> HandleAsync(CancellationToken cancellationToken = default);
     }
 
     public abstract class AsyncGetEndpointWithRequest<TRequest> : AsyncEndpointWithRequest<TRequest>
     {
         [HttpGet]
-        public virtual Task<IActionResult> Get([FromQuery]TRequest model, CancellationToken cancellationToken = default) =>
-            HandleAsync(model, cancellationToken);
+        public abstract override Task<IActionResult> HandleAsync([FromQuery] TRequest model,
+            CancellationToken cancellationToken = default);
     }
 
     public abstract class AsyncGetEndpoint<TResponse> : AsyncEndpoint<TResponse>
     {
         [HttpGet]
-        public virtual Task<ActionResult<TResponse>> Get(CancellationToken cancellationToken = default) =>
-            HandleAsync(cancellationToken);
+        public abstract override Task<ActionResult<TResponse>> HandleAsync(
+            CancellationToken cancellationToken = default);
     }
 
     public abstract class AsyncGetEndpoint<TRequest, TResponse> : AsyncEndpoint<TRequest, TResponse>
     {
         [HttpGet]
-        public virtual Task<ActionResult<TResponse>> Get([FromQuery]TRequest model, CancellationToken cancellationToken = default) =>
-            HandleAsync(model, cancellationToken);
+        public abstract override Task<ActionResult<TResponse>> HandleAsync([FromQuery] TRequest model,
+            CancellationToken cancellationToken = default);
     }
 
     public abstract class GetEndpoint : Endpoint
     {
         [HttpGet]
-        public virtual IActionResult Get() =>
-            Handle();
+        public abstract override IActionResult Handle();
     }
 
     public abstract class GetEndpoint<TResponse> : Endpoint<TResponse>
     {
         [HttpGet]
-        public virtual ActionResult<TResponse> Get() =>
-            Handle();
+        public abstract override ActionResult<TResponse> Handle();
     }
 
     public abstract class GetEndpointWithRequest<TRequest> : EndpointWithRequest<TRequest>
     {
         [HttpGet]
-        public virtual IActionResult Get([FromQuery]TRequest model) =>
-            Handle(model);
+        public abstract override IActionResult Handle([FromQuery] TRequest model);
     }
 
     public abstract class GetEndpoint<TRequest, TResponse> : Endpoint<TRequest, TResponse>
     {
         [HttpGet]
-        public virtual ActionResult<TResponse> Get([FromQuery]TRequest model) =>
-            Handle(model);
+        public abstract override ActionResult<TResponse> Handle([FromQuery] TRequest model);
     }
 }
+
diff --git a/src/SimpleEndPoints/VerbScoped/PostEndpoint.cs b/src/SimpleEndPoints/VerbScoped/PostEndpoint.cs
@@ -9,28 +9,25 @@ namespace SimpleEndpoints.VerbScoped
     public abstract class AsyncPostEndpoint<TRequest> : AsyncEndpointWithRequest<TRequest>
     {
         [HttpPost]
-        public virtual Task<IActionResult> Post(TRequest model, CancellationToken cancellationToken = default) =>
-            HandleAsync(model, cancellationToken);
+        public abstract override Task<IActionResult> HandleAsync(TRequest model, CancellationToken cancellationToken = default);
     }
 
     public abstract class AsyncPostEndpoint<TRequest, TResponse> : AsyncEndpoint<TRequest, TResponse>
     {
         [HttpPost]
-        public virtual Task<ActionResult<TResponse>> Post(TRequest model, CancellationToken cancellationToken = default) =>
-            HandleAsync(model, cancellationToken);
+        public abstract override Task<ActionResult<TResponse>> HandleAsync(TRequest model,
+            CancellationToken cancellationToken = default);
     }
 
     public abstract class PostEndpoint<TRequest> : EndpointWithRequest<TRequest>
     {
         [HttpPost]
-        public virtual IActionResult Post(TRequest model) =>
-            Handle(model);
+        public abstract override IActionResult Handle(TRequest model);
     }
 
     public abstract class PostEndpoint<TRequest, TResponse> : Endpoint<TRequest, TResponse>
     {
         [HttpPost]
-        public virtual ActionResult<TResponse> Post(TRequest model) =>
-            Handle(model);
+        public abstract override ActionResult<TResponse> Handle(TRequest model);
     }
 }
diff --git a/src/SimpleEndPoints/VerbScoped/PutEndpoint.cs b/src/SimpleEndPoints/VerbScoped/PutEndpoint.cs
@@ -9,28 +9,26 @@ namespace SimpleEndpoints.VerbScoped
     public abstract class AsyncPutEndpoint<TRequest> : AsyncEndpointWithRequest<TRequest>
     {
         [HttpPut]
-        public virtual Task<IActionResult> Put(TRequest model, CancellationToken cancellationToken = default) =>
-            HandleAsync(model, cancellationToken);
+        public abstract override Task<IActionResult> HandleAsync(TRequest model,
+            CancellationToken cancellationToken = default);
     }
 
     public abstract class AsyncPutEndpoint<TRequest, TResponse> : AsyncEndpoint<TRequest, TResponse>
     {
         [HttpPut]
-        public virtual Task<ActionResult<TResponse>> Put(TRequest model, CancellationToken cancellationToken = default) =>
-            HandleAsync(model, cancellationToken);
+        public abstract override Task<ActionResult<TResponse>> HandleAsync(TRequest model,
+            CancellationToken cancellationToken = default);
     }
 
     public abstract class PutEndpoint<TRequest> : EndpointWithRequest<TRequest>
     {
         [HttpPut]
-        public virtual IActionResult Put(TRequest model) =>
-            Handle(model);
+        public abstract override IActionResult Handle(TRequest model);
     }
 
     public abstract class PutEndpoint<TRequest, TResponse> : Endpoint<TRequest, TResponse>
     {
         [HttpPut]
-        public virtual ActionResult<TResponse> Put(TRequest model) =>
-            Handle(model);
+        public abstract override ActionResult<TResponse> Handle(TRequest model);
     }
 }
diff --git a/src/SimpleEndpoints.Example/Endpoints/Basic/BasicEndpoint.cs b/src/SimpleEndpoints.Example/Endpoints/Basic/BasicEndpoint.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+using SimpleEndpoints.Core;
+
+namespace SimpleEndpoints.Example.Endpoints.Basic
+{
+    public class BasicEndpoint: AsyncEndpoint<GreetingRequest, string>
+    {
+        [HttpGet]
+        public override async Task<ActionResult<string>> HandleAsync([FromQuery]GreetingRequest requestModel, CancellationToken cancellationToken = default)
+        {
+            return $"Hello {requestModel.Name}";
+        }
+    }
+
+    public class GreetingRequest
+    {
+        public string Name { get; set; }
+    }
+}
diff --git a/src/SimpleEndpoints.Example/Endpoints/SimpleMessage/SimpleMessageEndpoint.cs b/src/SimpleEndpoints.Example/Endpoints/SimpleMessage/SimpleMessageEndpoint.cs
@@ -7,15 +7,9 @@ namespace SimpleEndpoints.Example.Endpoints.SimpleMessage
 {
     public class SimpleMessageEndpoint : AsyncPostEndpoint<SimpleMessage, SimpleResponse>
     {
-        // Override if you want to change the default behaviour such as model binding
-        // Here we force it to use the [FromQuery] model binding instead of the default [FromBody] and define a custom Route
+        // Here we force it to use a custom Route
         [HttpPost("custom")]
-        public override Task<ActionResult<SimpleResponse>> Post([FromQuery]SimpleMessage model, CancellationToken cancellationToken = default)
-        {
-            return base.Post(model, cancellationToken);
-        }
-
-        protected override async Task<ActionResult<SimpleResponse>> HandleAsync(SimpleMessage requestModel, CancellationToken cancellationToken = default)
+        public override async Task<ActionResult<SimpleResponse>> HandleAsync(SimpleMessage requestModel, CancellationToken cancellationToken = default)
         {
             return await Task.FromResult(new SimpleResponse()
             {

diff --git a/src/SimpleEndpoints.Example/Endpoints/WeatherForecast/WeatherForecastEndpoint.cs b/src/SimpleEndpoints.Example/Endpoints/WeatherForecast/WeatherForecastEndpoint.cs
@@ -15,7 +15,7 @@ public class WeatherForecastEndpoint : AsyncGetEndpoint<List<WeatherForecast>>
             "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
         };
 
-        protected override async Task<ActionResult<List<WeatherForecast>>> HandleAsync(CancellationToken cancellationToken = default)
+        public override async Task<ActionResult<List<WeatherForecast>>> HandleAsync(CancellationToken cancellationToken = default)
         {
             var rng = new Random();
             return await Task.FromResult(Enumerable.Range(1, 5).Select(index => new WeatherForecast

diff --git a/src/SimpleEndpoints.Tests/SmokeTests.cs b/src/SimpleEndpoints.Tests/SmokeTests.cs
@@ -22,7 +22,7 @@ public SmokeTests()
         public async Task When_Calling_Basic_Endpoint_It_Returns_Payload()
         {
             // Arrange
-            var client = _factory.CreateClient();
+            using var client = _factory.CreateClient();
 
             // Act
             var response = await client.GetAsync("/weatherforecast");