Added FromError / FromException methods and various tests

Author: SharePointRadi

src/OneBitSoftware.Utilities.OperationResult/OneBitSoftware.Utilities.OperationResult.csproj

@@ -31,7 +31,7 @@
     <PackageRequireLicenseAcceptance>False</PackageRequireLicenseAcceptance>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageTags>OneBitSoftware; OperationResult;</PackageTags>
-    <Version>1.1.5</Version>
+    <Version>1.1.6</Version>
   </PropertyGroup>
 
 </Project>

src/OneBitSoftware.Utilities.OperationResult/OperationResult.cs

@@ -59,11 +59,14 @@ public OperationResult()
     /// <summary>
     /// Initializes a new instance of the <see cref="OperationResult"/> class.
     /// </summary>
-    /// <param name="loggerService">An instance of <see cref="ILogger"/> to use for automatic logging.</param>
+    /// <param name="logger">An instance of <see cref="ILogger"/> to use for automatic logging.</param>
     /// <remarks>If the operation is a get operation, an empty result (no results) must return a truthy Success value.</remarks>
-    public OperationResult(ILogger loggerService)
+    public OperationResult(ILogger? logger)
     {
-        this._logger = loggerService;
+        if (logger is not null)
+        {
+            this._logger = logger; 
+        }
     }
 
     /// <summary>
@@ -157,6 +160,33 @@ public OperationResult AppendException(Exception exception, int errorCode = 0, L
     /// <returns>All error messages, joined with a new line character.</returns>
     public override string ToString() => string.Join(Environment.NewLine, this.Errors);
 
+    /// <summary>
+    /// Creates an instance of <see cref="OperationResult"/> and appends the passed exception to it's error collection.
+    /// </summary>
+    /// <param name="exception">The <see cref="Exception"/> to append.</param>
+    /// <param name="logger">An optional instance of <see cref="ILogger"/>.</param>
+    /// <returns>An <see cref="OperationResult"/> containing the passed exception.</returns>
+    public static OperationResult FromException(Exception exception, ILogger? logger = null)
+    {
+        var result = new OperationResult(logger);
+        return result.AppendException(exception);
+    }
+
+    /// <summary>
+    /// Creates an instance of <see cref="OperationResult"/> and appends the passed error message details to it's internal error collection.
+    /// </summary>
+    /// <param name="message">A message to append to the internal errors collection.</param>
+    /// <param name="code">An optional code to include in the error.</param>
+    /// <param name="logLevel">A log event level. Defaults to Error.</param>
+    /// <param name="details">An optional detail message to add to the error.</param>
+    /// <param name="logger">An optional instance of <see cref="ILogger"/>.</param>
+    /// <returns>An <see cref="OperationResult"/> containing the passed exception.</returns>
+    public static OperationResult FromError(string message, int? code = null, LogLevel logLevel = LogLevel.Error, string? details = null, ILogger? logger = null)
+    {
+        var result = new OperationResult(logger);
+        return result.AppendError(message, code, logLevel, details);
+    }
+
     // TODO: this method needs completing.
     private static LogLevel GetLogLevel(LogLevel? optionalLevel) => optionalLevel ?? LogLevel.Error;
 

tests/OneBitSoftware.Utilities.OperationResultTests/OperationResultAppendErrorsTests.cs

@@ -0,0 +1,80 @@
+namespace OneBitSoftware.Utilities.OperationResultTests;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+public class OperationResultAppendErrorsTests
+{
+    [Fact]
+    public void AppendErrors_ShouldListAllErrors()
+    {
+        // Arrange
+        var errorCode1 = 666;
+        var message1 = "Error";
+        var detail1 = "Detail";
+        var operationResultTarget = new OperationResult();
+        operationResultTarget.AppendError(message1, errorCode1, LogLevel.Debug, detail1);
+        operationResultTarget.AppendException(new Exception(message1));
+
+        var errorCode2 = 669;
+        var message2 = "Error2";
+        var detail2 = "Detail2";
+        var operationResultBase = new OperationResult();
+        operationResultBase.AppendError(message2, errorCode2, LogLevel.Debug, detail2);
+
+        // Act
+        operationResultBase.AppendErrors(operationResultTarget);
+
+        // Assert
+        Assert.False(operationResultBase.Success);
+        Assert.False(operationResultTarget.Success);
+        Assert.True(operationResultBase.Fail);
+        Assert.True(operationResultTarget.Fail);
+
+        Assert.Equal(3, operationResultBase.Errors.Count);
+        Assert.Equal(2, operationResultTarget.Errors.Count);
+
+        Assert.NotNull(operationResultBase.Errors.Single(r => r.Code.Equals(errorCode2)));
+        Assert.NotNull(operationResultBase.Errors.Single(r => r.Message.Equals(message2)));
+        Assert.NotNull(operationResultBase.Errors.Single(r => r.Details is not null && r.Details.Equals(detail2)));
+    }
+
+    [Fact]
+    public void AppendErrorsT_ShouldListAllErrors()
+    {
+        // Arrange
+        var errorCode1 = 666;
+        var message1 = "Error";
+        var detail1 = "Detail";
+        var operationResultTarget = new OperationResult<object>();
+        operationResultTarget.AppendError(message1, errorCode1, LogLevel.Debug, detail1);
+        operationResultTarget.AppendException(new Exception(message1));
+
+        var errorCode2 = 669;
+        var message2 = "Error2";
+        var detail2 = "Detail2";
+        var operationResultBase = new OperationResult<object>();
+        operationResultBase.AppendError(message2, errorCode2, LogLevel.Debug, detail2);
+
+        // Act
+        operationResultBase.AppendErrors(operationResultTarget);
+
+        // Assert
+        Assert.False(operationResultBase.Success);
+        Assert.False(operationResultTarget.Success);
+        Assert.True(operationResultBase.Fail);
+        Assert.True(operationResultTarget.Fail);
+
+        Assert.Equal(3, operationResultBase.Errors.Count);
+        Assert.Equal(2, operationResultTarget.Errors.Count);
+
+        Assert.NotNull(operationResultBase.Errors.Single(r => r.Code.Equals(errorCode2)));
+        Assert.NotNull(operationResultBase.Errors.Single(r => r.Message.Equals(message2)));
+        Assert.NotNull(operationResultBase.Errors.Single(r => r.Details is not null && r.Details.Equals(detail2)));
+    }
+}

tests/OneBitSoftware.Utilities.OperationResultTests/OperationResultConstructorTests.cs

@@ -1,39 +1,97 @@
-using Xunit;
+namespace OneBitSoftware.Utilities.OperationResultTests;
 
-namespace OneBitSoftware.Utilities.OperationResultTests
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+public class OperationResultConstructorTests
 {
-    public class OperationResultConstructorTests
+    [Fact]
+    public void NewOperationResult_ShouldNotBeNull()
     {
-        [Fact]
-        public void NewOperationResult_ShouldNotBeNull()
-        {
-            var sut = new OperationResult();
+        var sut = new OperationResult();
 
-            Assert.NotNull(sut);
-        }
+        Assert.NotNull(sut);
+        Assert.True(sut.Success);
+        Assert.False(sut.Fail);
+    }
 
-        [Fact]
-        public void NewOperationResultWithNullLogger_ShouldSucceed()
-        {
-            var sut = new OperationResult(null);
+    [Fact]
+    public void NewOperationResultWithNullLogger_ShouldSucceed()
+    {
+        var sut = new OperationResult(null);
+
+        Assert.NotNull(sut);
+        Assert.True(sut.Success);
+        Assert.False(sut.Fail);
+    }
 
-            Assert.NotNull(sut);
-        }
+    [Fact]
+    public void NewOperationResultT_ShouldNotBeNull()
+    {
+        var sut = new OperationResult<object>();
 
-        [Fact]
-        public void NewOperationResultT_ShouldNotBeNull()
-        {
-            var sut = new OperationResult<object>();
+        Assert.NotNull(sut);
+        Assert.True(sut.Success);
+        Assert.False(sut.Fail);
+    }
 
-            Assert.NotNull(sut);
-        }
+    [Fact]
+    public void NewOperationResultTWithNullLogger_ShouldSucceed()
+    {
+        var sut = new OperationResult<object>(null);
 
-        [Fact]
-        public void NewOperationResultTWithNullLogger_ShouldSucceed()
-        {
-            var sut = new OperationResult<object>(null);
+        Assert.NotNull(sut);
+        Assert.True(sut.Success);
+        Assert.False(sut.Fail);
+    }
 
-            Assert.NotNull(sut);
-        }
+    [Fact]
+    public void NewOperationResultFromException_ShouldSucceed()
+    {
+        var result = OperationResult.FromException(new Exception());
+        Assert.NotNull(result);
+        Assert.False(result.Success);
+        Assert.True(result.Fail);
+    }
+
+    [Fact]
+    public void NewOperationResultTFromException_ShouldSucceed()
+    {
+        var result = OperationResult<object>.FromException(new Exception());
+        Assert.NotNull(result);
+        Assert.False(result.Success);
+        Assert.True(result.Fail);
+    }
+
+    [Fact]
+    public void NewOperationResultTFromError_ShouldSucceed()
+    {
+        var errorCode = 666;
+        var message = "Error";
+        var detail = "Detail";
+        var result = OperationResult<object>.FromError(message, errorCode, LogLevel.Debug, detail, null);
+        Assert.NotNull(result);
+        Assert.False(result.Success);
+        Assert.True(result.Fail);
+        Assert.True(result.Errors.Any(e => e.Code.Equals(errorCode)));
+        Assert.True(result.Errors.Any(e => e.Message.Equals(message)));
+        Assert.True(result.Errors.Any(e => e.Details != null && e.Details.Equals(detail)));
+        Assert.Equal(1, result.Errors.Count);
+    }
+
+    [Fact]
+    public void NewOperationResultFromError_ShouldSucceed()
+    {
+        var errorCode = 666;
+        var message = "Error";
+        var detail = "Detail";
+        var result = OperationResult.FromError(message, errorCode, LogLevel.Debug, detail, null);
+        Assert.NotNull(result);
+        Assert.False(result.Success);
+        Assert.True(result.Fail);
+        Assert.True(result.Errors.Any(e => e.Code.Equals(errorCode)));
+        Assert.True(result.Errors.Any(e => e.Message.Equals(message)));
+        Assert.True(result.Errors.Any(e => e.Details != null && e.Details.Equals(detail)));
+        Assert.Equal(1, result.Errors.Count);
     }
-}
+}