Merge pull request #9 from isaacnborges/feature/unauthorized

isaacnborges · web-flow · commit f39095dc78ad · 2022-05-31T11:13:59.000-03:00
Add support to UnauthorizedException
diff --git a/README-nuget.md b/README-nuget.md
@@ -84,6 +84,7 @@ The custom middleware supports the following **Exceptions**:
 Exception              Status code description  Status code
 ---------------------  -----------------------  -----------
 DomainException        BadRequest                  400        
+UnauthorizedException  Unauthorized                401        
 CannotAccessException  Forbidden                   403        
 NotFoundException      NotFound                    404        
 Exception              InternalServerError         500        
@@ -109,6 +110,7 @@ public class InvalidStateException : DomainException
 #### Throw exceptions
 ```c#
 throw new InvalidStateException("Custom domain exception message");
+throw new UnauthorizedException("Custom unauthorized exception message");
 throw new CannotAccessException("Custom cannot access exception message");
 throw new NotFoundException("Custom not found exception message");
 throw new Exception("Custom exception message");
diff --git a/README.md b/README.md
@@ -84,6 +84,7 @@ The custom middleware supports the following **Exceptions**:
 | Exception             | Status code description | Status code |
 |-----------------------|-------------------------|:-----------:|
 | DomainException       | BadRequest              | 400         |
+| UnauthorizedException | Unauthorized            | 401         |
 | CannotAccessException | Forbidden               | 403         |
 | NotFoundException     | NotFound                | 404         |
 | Exception             | InternalServerError     | 500         |
@@ -108,6 +109,7 @@ public class InvalidStateException : DomainException
 #### Throw exceptions
 ```c#
 throw new InvalidStateException("Custom domain exception message");
+throw new UnauthorizedException("Custom unauthorized exception message");
 throw new CannotAccessException("Custom cannot access exception message");
 throw new NotFoundException("Custom not found exception message");
 throw new Exception("Custom exception message");
diff --git a/samples/CustomExceptionMiddleware.WebAppTest/Controllers/CustomerController.cs b/samples/CustomExceptionMiddleware.WebAppTest/Controllers/CustomerController.cs
@@ -27,6 +27,13 @@ public IActionResult GetDomain([FromQuery] bool returnCustomer = false)
             return Ok(result);
         }
 
+        [HttpGet("unauthorized")]
+        public IActionResult GetUnauthorized([FromQuery] bool returnCustomer = false)
+        {
+            var result = _customerService.GetUnauthorizedException(returnCustomer);
+            return Ok(result);
+        }
+
         [HttpGet("cannot-access")]
         public IActionResult GetCannotAccess([FromQuery] bool returnCustomer = false)
         {
diff --git a/samples/CustomExceptionMiddleware.WebAppTest/CustomerService.cs b/samples/CustomExceptionMiddleware.WebAppTest/CustomerService.cs
@@ -20,6 +20,14 @@ public IEnumerable<Customer> GetDomainException(bool returnCustomers)
             throw new InvalidStateException("Custom domain exception message");
         }
 
+        public IEnumerable<Customer> GetUnauthorizedException(bool returnCustomers)
+        {
+            if (returnCustomers)
+                return GetCustomers();
+
+            throw new UnauthorizedException("Custom unauthorized exception message");
+        }
+
         public IEnumerable<Customer> GetCannotAccessException(bool returnCustomers)
         {
             if (returnCustomers)
diff --git a/samples/CustomExceptionMiddleware.WebAppTest/ICustomerService.cs b/samples/CustomExceptionMiddleware.WebAppTest/ICustomerService.cs
@@ -6,6 +6,7 @@ public interface ICustomerService
     {
         IEnumerable<Customer> Get(int customersCount);
         IEnumerable<Customer> GetDomainException(bool returnCustomers);
+        IEnumerable<Customer> GetUnauthorizedException(bool returnCustomers);
         IEnumerable<Customer> GetCannotAccessException(bool returnCustomers);
         IEnumerable<Customer> GetNotFoundException(bool returnCustomers);
         IEnumerable<Customer> GetException(bool returnCustomers);
diff --git a/src/CustomExceptionMiddleware.cs b/src/CustomExceptionMiddleware.cs
@@ -55,6 +55,10 @@ public async Task InvokeAsync(HttpContext httpContext)
             {
                 await HandleDomainException(httpContext, ex);
             }
+            catch (UnauthorizedException ex) when (NotContainExceptionAttribute(httpContext))
+            {
+                await HandleUnauthorizedException(httpContext, ex);
+            }
             catch (CannotAccessException ex) when (NotContainExceptionAttribute(httpContext))
             {
                 await HandleCannotAccessException(httpContext, ex);
@@ -74,6 +78,11 @@ private async Task HandleDomainException(HttpContext httpContext, DomainExceptio
             await HandleException(httpContext, exception, HttpStatusCode.BadRequest);
         }
 
+        private async Task HandleUnauthorizedException(HttpContext httpContext, UnauthorizedException exception)
+        {
+            await HandleException(httpContext, exception, HttpStatusCode.Unauthorized);
+        }
+
         private async Task HandleCannotAccessException(HttpContext httpContext, CannotAccessException exception)
         {
             await HandleException(httpContext, exception, HttpStatusCode.Forbidden);
diff --git a/src/CustomExceptionMiddleware.csproj b/src/CustomExceptionMiddleware.csproj
@@ -2,7 +2,7 @@
 
 	<PropertyGroup>
 		<TargetFrameworks>netstandard2.0;netstandard2.1;</TargetFrameworks>
-		<Version>1.2.0</Version>
+		<Version>1.2.1</Version>
 		<Authors>Isaac Nunes Borges</Authors>
 		<Company>isaacnborges</Company>
 		<LangVersion>10.0</LangVersion>
diff --git a/src/CustomExceptions/UnauthorizedException.cs b/src/CustomExceptions/UnauthorizedException.cs
@@ -0,0 +1,31 @@
+﻿using System;
+using System.Runtime.Serialization;
+
+namespace CustomExceptionMiddleware.CustomExceptions
+{
+    [Serializable]
+    public class UnauthorizedException : CustomException
+    {
+        public UnauthorizedException()
+        { }
+
+        public UnauthorizedException(string message) : base(message)
+        { }
+
+        public UnauthorizedException(string message, Exception innerException) : base(message, innerException)
+        { }
+
+        public UnauthorizedException(string message, string exceptionType) : base(message)
+        {
+            ExceptionType = exceptionType;
+        }
+
+        public UnauthorizedException(string message, string exceptionType, Exception innerException) : base(message, innerException)
+        {
+            ExceptionType = exceptionType;
+        }
+
+        protected UnauthorizedException(SerializationInfo info, StreamingContext context) : base(info, context)
+        { }
+    }
+}
diff --git a/tests/CustomExceptionMiddlewareWebAppTests.cs b/tests/CustomExceptionMiddlewareWebAppTests.cs
@@ -56,6 +56,22 @@ public async Task GetAsync_ThrowDomainException_ShouldReturnBadRequest()
             responseContent.Type.Should().Be(ValidationErrors);
         }
 
+        [Fact(DisplayName = "Should return unauthorized and throw an unauthorized exception")]
+        public async Task GetAsync_ThrowUnauthorizedException_ShouldUnauthorized()
+        {
+            // Arrange
+            _url += "/unauthorized";
+
+            // Act
+            var response = await _client.GetAsync(_url);
+
+            // Assert
+            response.Should().Be401Unauthorized();
+            var responseContent = await response.Content.ReadAsAsync<CustomErrorResponse>();
+            responseContent.Error.Msg.Should().Be("Custom unauthorized exception message");
+            responseContent.Type.Should().Be(ValidationErrors);
+        }
+
         [Fact(DisplayName = "Should return forbidden and throw a cannot access exception")]
         public async Task GetAsync_ThrowCannotAccessException_ShouldReturnForbidden()
         {
@@ -119,6 +135,21 @@ public async Task GetAsyncDomain_GetCustomers_ShouldReturnOK()
             responseContent.Should().NotBeNullOrEmpty();
         }
 
+        [Fact(DisplayName = "Should return Ok and get customers from unauthorized url")]
+        public async Task GetAsyncUnauthorized_GetCustomers_ShouldReturnOK()
+        {
+            // Arrange
+            _url += $"/unauthorized?returnCustomer={true}";
+
+            // Act
+            var response = await _client.GetAsync(_url);
+
+            // Assert
+            response.Should().Be200Ok();
+            var responseContent = await response.Content.ReadAsAsync<IEnumerable<Customer>>();
+            responseContent.Should().NotBeNullOrEmpty();
+        }
+
         [Fact(DisplayName = "Should return Ok and get customers from cannot access url")]
         public async Task GetAsyncCannotAccess_GetCustomers_ShouldReturnOK()
         {
diff --git a/tests/CustomExceptionsTests.cs b/tests/CustomExceptionsTests.cs
@@ -12,6 +12,58 @@ public class CustomExceptionsTests
         private readonly string _errorMessage = "Custom error message example";
         private readonly string _exceptionType = "NEWEXCEPTION_ERROR";
 
+        #region UnauthorizedException
+        [Fact(DisplayName = "Should throw unauthorized exception")]
+        public void NewUnauthorizedException_ThrowException_ShouldThrowUnauthorizedException()
+        {
+            // Act
+            Action action = () => throw new UnauthorizedException();
+
+            // Assert
+            action.Should().Throw<UnauthorizedException>();
+        }
+
+        [Fact(DisplayName = "Should throw unauthorized exception with message")]
+        public void NewUnauthorizedException_ThrowException_ShouldThrowUnauthorizedExceptionWithMessage()
+        {
+            // Act
+            Action action = () => throw new UnauthorizedException(_errorMessage);
+
+            // Assert
+            action.Should().Throw<UnauthorizedException>().WithMessage(_errorMessage);
+        }
+
+        [Fact(DisplayName = "Should throw unauthorized exception with message and inner exception")]
+        public void NewUnauthorizedException_ThrowException_ShouldThrowUnauthorizedExceptionWithMessageAndInnerException()
+        {
+            // Act
+            Action action = () => throw new UnauthorizedException(_errorMessage, new UnauthorizedException());
+
+            // Assert
+            action.Should().Throw<UnauthorizedException>().WithMessage(_errorMessage).WithInnerException<UnauthorizedException>();
+        }
+
+        [Fact(DisplayName = "Should throw unauthorized exception with message and exception type")]
+        public void NewUnauthorizedException_ThrowException_ShouldThrowUnauthorizedExceptionWithMessageAndExceptionType()
+        {
+            // Act
+            Action action = () => throw new UnauthorizedException(_errorMessage, _exceptionType);
+
+            // Assert
+            action.Should().Throw<UnauthorizedException>().WithMessage(_errorMessage);
+        }
+
+        [Fact(DisplayName = "Should throw unauthorized exception with message, exception type and inner exception")]
+        public void NewUnauthorizedException_ThrowException_ShouldThrowUnauthorizedExceptionWithMessageAndExceptionTypeAndInnerException()
+        {
+            // Act
+            Action action = () => throw new UnauthorizedException(_errorMessage, _exceptionType, new UnauthorizedException());
+
+            // Assert
+            action.Should().Throw<UnauthorizedException>().WithMessage(_errorMessage).WithInnerException<UnauthorizedException>();
+        }
+        #endregion
+
         #region CannotAccessException
         [Fact(DisplayName = "Should throw cannot access exception")]
         public void NewCannotAccessException_ThrowException_ShouldThrowCannotAccessException()

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,13 @@ public IActionResult GetDomain([FromQuery] bool returnCustomer = false)`
`27`	`27`	`return Ok(result);`
`28`	`28`	`}`
`29`	`29`
	`30`	`+ [HttpGet("unauthorized")]`
	`31`	`+ public IActionResult GetUnauthorized([FromQuery] bool returnCustomer = false)`
	`32`	`+ {`
	`33`	`+ var result = _customerService.GetUnauthorizedException(returnCustomer);`
	`34`	`+ return Ok(result);`
	`35`	`+ }`
	`36`	`+`
`30`	`37`	`[HttpGet("cannot-access")]`
`31`	`38`	`public IActionResult GetCannotAccess([FromQuery] bool returnCustomer = false)`
`32`	`39`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,14 @@ public IEnumerable<Customer> GetDomainException(bool returnCustomers)`
`20`	`20`	`throw new InvalidStateException("Custom domain exception message");`
`21`	`21`	`}`
`22`	`22`
	`23`	`+ public IEnumerable<Customer> GetUnauthorizedException(bool returnCustomers)`
	`24`	`+ {`
	`25`	`+ if (returnCustomers)`
	`26`	`+ return GetCustomers();`
	`27`	`+`
	`28`	`+ throw new UnauthorizedException("Custom unauthorized exception message");`
	`29`	`+ }`
	`30`	`+`
`23`	`31`	`public IEnumerable<Customer> GetCannotAccessException(bool returnCustomers)`
`24`	`32`	`{`
`25`	`33`	`if (returnCustomers)`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ public interface ICustomerService`
`6`	`6`	`{`
`7`	`7`	`IEnumerable<Customer> Get(int customersCount);`
`8`	`8`	`IEnumerable<Customer> GetDomainException(bool returnCustomers);`
	`9`	`+ IEnumerable<Customer> GetUnauthorizedException(bool returnCustomers);`
`9`	`10`	`IEnumerable<Customer> GetCannotAccessException(bool returnCustomers);`
`10`	`11`	`IEnumerable<Customer> GetNotFoundException(bool returnCustomers);`
`11`	`12`	`IEnumerable<Customer> GetException(bool returnCustomers);`
Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,10 @@ public async Task InvokeAsync(HttpContext httpContext)`
`55`	`55`	`{`
`56`	`56`	`await HandleDomainException(httpContext, ex);`
`57`	`57`	`}`
	`58`	`+ catch (UnauthorizedException ex) when (NotContainExceptionAttribute(httpContext))`
	`59`	`+ {`
	`60`	`+ await HandleUnauthorizedException(httpContext, ex);`
	`61`	`+ }`
`58`	`62`	`catch (CannotAccessException ex) when (NotContainExceptionAttribute(httpContext))`
`59`	`63`	`{`
`60`	`64`	`await HandleCannotAccessException(httpContext, ex);`
`@@ -74,6 +78,11 @@ private async Task HandleDomainException(HttpContext httpContext, DomainExceptio`
`74`	`78`	`await HandleException(httpContext, exception, HttpStatusCode.BadRequest);`
`75`	`79`	`}`
`76`	`80`
	`81`	`+ private async Task HandleUnauthorizedException(HttpContext httpContext, UnauthorizedException exception)`
	`82`	`+ {`
	`83`	`+ await HandleException(httpContext, exception, HttpStatusCode.Unauthorized);`
	`84`	`+ }`
	`85`	`+`
`77`	`86`	`private async Task HandleCannotAccessException(HttpContext httpContext, CannotAccessException exception)`
`78`	`87`	`{`
`79`	`88`	`await HandleException(httpContext, exception, HttpStatusCode.Forbidden);`