add ErrorStatus methods

pedrovasconcellos · Mar 27, 2023 · 46fde97 · 46fde97
1 parent b5b31a8
commit 46fde97
Show file tree

Hide file tree

Showing 10 changed files with 272 additions and 83 deletions.
diff --git a/README.md b/README.md
@@ -38,19 +38,36 @@ public async Task<Result<Guid>> ExecuteAsync(EmailCommand command)
 ```
 Example of using the Vasconcellos.Common.Result [Controller].
 ```csharp
-    [HttpPost(Name = "post-example")]
+    [HttpPost(Name = "post-example-1")]
     [ProducesResponseType(typeof(Guid), (int)HttpStatusCode.Create)]
     [ProducesResponseType(typeof(IEnumerable<Error>), (int)HttpStatusCode.BadRequest)]
     [ProducesResponseType(typeof(IEnumerable<Error>), (int)HttpStatusCode.NotFound)]
     [ProducesResponseType(typeof(IEnumerable<Error>), (int)HttpStatusCode.InternalServerError)]
-    public async Task<IActionResult> PostExample([FromBody] EmailCommand command)
+    public async Task<IActionResult> PostExample1([FromBody] EmailCommand command)
     {
         var result = await _service.ExecuteAsync(command);
 
         if (result.IsSuccess)
             return this.StatusCode((int)HttpStatusCode.Create, result.Value);
 
-        return this.StatusCode((int)result.GetError().Type, result.Errors);
+        //It is recommended to use [method: GetGreaterStatus] to recover the last most serious error.
+        return this.StatusCode((int)result.GetGreaterStatus(), result.Errors);
+    }
+
+    [HttpPost(Name = "post-example-2")]
+    [ProducesResponseType(typeof(Guid), (int)HttpStatusCode.Create)]
+    [ProducesResponseType(typeof(IEnumerable<Error>), (int)HttpStatusCode.BadRequest)]
+    [ProducesResponseType(typeof(IEnumerable<Error>), (int)HttpStatusCode.NotFound)]
+    [ProducesResponseType(typeof(IEnumerable<Error>), (int)HttpStatusCode.InternalServerError)]
+    public async Task<IActionResult> PostExample2([FromBody] EmailCommand command)
+    {
+        var result = await _service.ExecuteAsync(command);
+
+        if (result.IsSuccess)
+            return this.StatusCode((int)HttpStatusCode.Create, result.Value);
+
+        //The difference is here [method: GetLastStatus].
+        return this.StatusCode((int)result.GetLastStatus(), result.Errors); 
     }
 ```
 

diff --git a/src/Vasconcellos.Common.Results.Tests/Domain/ResultTTest.cs b/src/Vasconcellos.Common.Results.Tests/Domain/ResultTTest.cs
@@ -17,8 +17,9 @@ public async Task Should_FailDefault_ReturnErrorBadDomain()
         {
             var result = Result<object>.Fail(_codeDefault, _messageDefault);
 
-            var error = result.GetError();
-            Assert.Equal(ErrorType.BadDomain, error.Type);
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(error);
+            Assert.Equal(ErrorStatus.BadDomain, error.ErrorStatus);
             Assert.Equal(_codeDefault, error.Code);
             Assert.Equal(_messageDefault, error.Message);
 
@@ -30,62 +31,118 @@ public async Task Should_FailNotFound_ReturnErrorNotFound()
         {
             var result = Result<object>.FailNotFound(_codeDefault, _messageDefault);
 
-            var error = result.GetError();
-            Assert.Equal(ErrorType.NotFound, error.Type);
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(error);
+            Assert.Equal(ErrorStatus.NotFound, error.ErrorStatus);
             Assert.Equal(_codeDefault, error.Code);
             Assert.Equal(_messageDefault, error.Message);
 
             await Task.CompletedTask;
         }
 
         [Theory]
-        [InlineData(ErrorType.Forbidden)]
-        [InlineData(ErrorType.Unauthorized)]
-        [InlineData(ErrorType.Unexpected)]
-        [InlineData(ErrorType.UnprocessableEntity)]
-        [InlineData(ErrorType.BadDomain)]
-        public async Task Should_FailDefault_ReturnErrorTypeX(ErrorType status)
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.Unexpected)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_FailDefault_ReturnErrorStatusX(ErrorStatus status)
         {
             var result = Result<object>.Fail(_codeDefault, _messageDefault, status);
 
-            var error = result.GetError();
-            Assert.Equal(status, error.Type);
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(error);
+            Assert.Equal(status, error.ErrorStatus);
             Assert.Equal(_codeDefault, error.Code);
             Assert.Equal(_messageDefault, error.Message);
 
             await Task.CompletedTask;
         }
 
-        [Fact]
-        public async Task Should_Sucess_ReturnValue()
+        [Theory]
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_GetErrorWithGreaterStatus_ReturnErrorStatusUnexpected(ErrorStatus status)
         {
-            var valueDefault = int.MaxValue;
-            var result = Result<int>.Success(valueDefault);
+            var result = Result<object>.Fail(_codeDefault, _messageDefault, status);
+            result.AddError(_codeDefault, _messageDefault, ErrorStatus.Unexpected);
 
-            var error = result.GetError();
-            Assert.Equal(valueDefault, result.Value);
-            Assert.Null(error);
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(error);
+            Assert.Equal(ErrorStatus.Unexpected, error.ErrorStatus);
+            Assert.Equal(_codeDefault, error.Code);
+            Assert.Equal(_messageDefault, error.Message);
 
             await Task.CompletedTask;
         }
 
         [Theory]
-        [InlineData(ErrorType.Forbidden)]
-        [InlineData(ErrorType.Unauthorized)]
-        [InlineData(ErrorType.UnprocessableEntity)]
-        [InlineData(ErrorType.BadDomain)]
-        public async Task Should_FailDefault_ReturnErrorTypeUnexpected(ErrorType status)
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_GetGreaterStatus_ReturnErrorStatusUnexpected(ErrorStatus status)
         {
             var result = Result<object>.Fail(_codeDefault, _messageDefault, status);
-            result.AddError(_codeDefault, _messageDefault, ErrorType.Unexpected);
+            result.AddError(_codeDefault, _messageDefault, ErrorStatus.Unexpected);
 
-            var error = result.GetError();
-            Assert.Equal(ErrorType.Unexpected, error.Type);
+            var errorStatus = result.GetGreaterStatus();
+            Assert.NotNull(errorStatus);
+            Assert.Equal(ErrorStatus.Unexpected, errorStatus);
+
+            await Task.CompletedTask;
+        }
+
+        [Theory]
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_GetErrorWithLastStatus_ReturnErrorStatusUnexpected(ErrorStatus status)
+        {
+            var result = Result<object>.Fail(_codeDefault, _messageDefault, ErrorStatus.Unexpected);
+            result.AddError(_codeDefault, _messageDefault, status);
+
+            var error = result.GetErrorWithLastStatus();
+            Assert.NotNull(error);
+            Assert.Equal(status, error.ErrorStatus);
             Assert.Equal(_codeDefault, error.Code);
             Assert.Equal(_messageDefault, error.Message);
 
             await Task.CompletedTask;
         }
+
+        [Theory]
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_GetLastStatus_ReturnErrorStatusUnexpected(ErrorStatus status)
+        {
+            var result = Result<object>.Fail(_codeDefault, _messageDefault, ErrorStatus.Unexpected);
+            result.AddError(_codeDefault, _messageDefault, status);
+
+            var errorStatus = result.GetLastStatus();
+            Assert.NotNull(errorStatus);
+            Assert.Equal(status, errorStatus);
+
+            await Task.CompletedTask;
+        }
+
+        [Fact]
+        public async Task Should_Success_ReturnValue()
+        {
+            var valueDefault = int.MaxValue;
+            var result = Result<int>.Success(valueDefault);
+
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.Equal(valueDefault, result.Value);
+            Assert.Null(error);
+
+            await Task.CompletedTask;
+        }
     }
 }
 
diff --git a/src/Vasconcellos.Common.Results.Tests/Domain/ResultTest.cs b/src/Vasconcellos.Common.Results.Tests/Domain/ResultTest.cs
@@ -17,8 +17,9 @@ public async Task Should_FailDefault_ReturnErrorBadDomain()
         {
             var result = Result.Fail(_codeDefault, _messageDefault);
 
-            var error = result.GetError();
-            Assert.Equal(ErrorType.BadDomain, error.Type);
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(error);
+            Assert.Equal(ErrorStatus.BadDomain, error.ErrorStatus);
             Assert.Equal(_codeDefault, error.Code);
             Assert.Equal(_messageDefault, error.Message);
 
@@ -30,61 +31,117 @@ public async Task Should_FailNotFound_ReturnErrorNotFound()
         {
             var result = Result.FailNotFound(_codeDefault, _messageDefault);
 
-            var error = result.GetError();
-            Assert.Equal(ErrorType.NotFound, error.Type);
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(error);
+            Assert.Equal(ErrorStatus.NotFound, error.ErrorStatus);
             Assert.Equal(_codeDefault, error.Code);
             Assert.Equal(_messageDefault, error.Message);
 
             await Task.CompletedTask;
         }
 
         [Theory]
-        [InlineData(ErrorType.Forbidden)]
-        [InlineData(ErrorType.Unauthorized)]
-        [InlineData(ErrorType.Unexpected)]
-        [InlineData(ErrorType.UnprocessableEntity)]
-        [InlineData(ErrorType.BadDomain)]
-        public async Task Should_FailDefault_ReturnErrorTypeX(ErrorType status)
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.Unexpected)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_FailDefault_ReturnErrorStatusX(ErrorStatus status)
         {
             var result = Result.Fail(_codeDefault, _messageDefault, status);
 
-            var error = result.GetError();
-            Assert.Equal(status, error.Type);
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(error);
+            Assert.Equal(status, error.ErrorStatus);
             Assert.Equal(_codeDefault, error.Code);
             Assert.Equal(_messageDefault, error.Message);
 
             await Task.CompletedTask;
         }
 
-        [Fact]
-        public async Task Should_Sucess_ReturnValue()
+        [Theory]
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_GetErrorWithGreaterStatus_ReturnErrorStatusUnexpected(ErrorStatus status)
         {
-            var result = Result.Success();
+            var result = Result.Fail(_codeDefault, _messageDefault, status);
+            result.AddError(_codeDefault, _messageDefault, ErrorStatus.Unexpected);
 
-            var error = result.GetError();
-            Assert.NotNull(result);
-            Assert.Null(error);
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(error);
+            Assert.Equal(ErrorStatus.Unexpected, error.ErrorStatus);
+            Assert.Equal(_codeDefault, error.Code);
+            Assert.Equal(_messageDefault, error.Message);
 
             await Task.CompletedTask;
         }
 
         [Theory]
-        [InlineData(ErrorType.Forbidden)]
-        [InlineData(ErrorType.Unauthorized)]
-        [InlineData(ErrorType.UnprocessableEntity)]
-        [InlineData(ErrorType.BadDomain)]
-        public async Task Should_FailDefault_ReturnErrorTypeUnexpected(ErrorType status)
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_GetGreaterStatus_ReturnErrorStatusUnexpected(ErrorStatus status)
         {
             var result = Result.Fail(_codeDefault, _messageDefault, status);
-            result.AddError(_codeDefault, _messageDefault, ErrorType.Unexpected);
+            result.AddError(_codeDefault, _messageDefault, ErrorStatus.Unexpected);
 
-            var error = result.GetError();
-            Assert.Equal(ErrorType.Unexpected, error.Type);
+            var errorStatus = result.GetGreaterStatus();
+            Assert.NotNull(errorStatus);
+            Assert.Equal(ErrorStatus.Unexpected, errorStatus);
+
+            await Task.CompletedTask;
+        }
+
+        [Theory]
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_GetErrorWithLastStatus_ReturnErrorStatusUnexpected(ErrorStatus status)
+        {
+            var result = Result.Fail(_codeDefault, _messageDefault, ErrorStatus.Unexpected);
+            result.AddError(_codeDefault, _messageDefault, status);
+
+            var error = result.GetErrorWithLastStatus();
+            Assert.NotNull(error);
+            Assert.Equal(status, error.ErrorStatus);
             Assert.Equal(_codeDefault, error.Code);
             Assert.Equal(_messageDefault, error.Message);
 
             await Task.CompletedTask;
         }
+
+        [Theory]
+        [InlineData(ErrorStatus.Forbidden)]
+        [InlineData(ErrorStatus.Unauthorized)]
+        [InlineData(ErrorStatus.UnprocessableEntity)]
+        [InlineData(ErrorStatus.BadDomain)]
+        public async Task Should_GetLastStatus_ReturnErrorStatusUnexpected(ErrorStatus status)
+        {
+            var result = Result.Fail(_codeDefault, _messageDefault, ErrorStatus.Unexpected);
+            result.AddError(_codeDefault, _messageDefault, status);
+
+            var errorStatus = result.GetLastStatus();
+            Assert.NotNull(errorStatus);
+            Assert.Equal(status, errorStatus);
+
+            await Task.CompletedTask;
+        }
+
+        [Fact]
+        public async Task Should_Success_ReturnValue()
+        {
+            var result = Result.Success();
+
+            var error = result.GetErrorWithGreaterStatus();
+            Assert.NotNull(result);
+            Assert.Null(error);
+
+            await Task.CompletedTask;
+        }
     }
 }
 
diff --git a/src/Vasconcellos.Common.Results.Tests/Vasconcellos.Common.Results.Tests.csproj b/src/Vasconcellos.Common.Results.Tests/Vasconcellos.Common.Results.Tests.csproj
@@ -6,7 +6,7 @@
     <Nullable>enable</Nullable>
 
     <IsPackable>false</IsPackable>
-    <ReleaseVersion>1.1.0</ReleaseVersion>
+    <ReleaseVersion>2.0.0</ReleaseVersion>
   </PropertyGroup>
 
   <ItemGroup>

diff --git a/src/Vasconcellos.Common.Results/Domain/Error.cs b/src/Vasconcellos.Common.Results/Domain/Error.cs
@@ -1,19 +1,24 @@
-using Vasconcellos.Common.Results.Enums;
+using System;
+using Vasconcellos.Common.Results.Enums;
 
 namespace Vasconcellos.Common.Results.Domain
 {
     public class Error
     {
-        public Error(string code, string message, ErrorType type = ErrorType.BadDomain)
+        public Error(string code, string message, ErrorStatus errorStatus = ErrorStatus.BadDomain)
         {
             Code = code;
             Message = message;
-            Type = type;
+            ErrorStatus = errorStatus;
+            Created = DateTime.UtcNow;
         }
 
         public string Code { get; }
         public string Message { get; }
-        public ErrorType Type { get; }
+        public ErrorStatus ErrorStatus { get; }
+
+        private DateTime Created { get; }
+        public DateTime GetCreationDate() => Created;
     }
 }