Command-processing (#14)

* ICommandResult, UnsuccessfulCommandResult

* v1 action

Author: ChrisSimmons

.github/workflows/push.yml

@@ -5,6 +5,7 @@ on: [push]
 jobs:
   push:
     permissions:
+      checks: write
       contents: read
       packages: write
-    uses: NetChris/workflows/.github/workflows/push-dotnet-build-test-pack-push-default.yml@v0.0
+    uses: NetChris/workflows/.github/workflows/push-dotnet-build-test-pack-push-default.yml@v1

NetChris.Core.UnitTests/CommandResult/SuccessfulCommandResultTests.cs

@@ -0,0 +1,28 @@
+using FluentAssertions;
+using NetChris.Core.CommandResult;
+using Xunit;
+
+namespace NetChris.Core.UnitTests.CommandResult;
+
+public abstract class SuccessfulCommandResultTests
+{
+    protected abstract ICommandResult CommandResult { get; }
+
+    [Fact]
+    public void IsSuccessful()
+    {
+        CommandResult.Successful.Should().BeTrue();
+    }
+
+    [Fact]
+    public void HasEmptyFailureDetail()
+    {
+        CommandResult.FailureDetail.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void HasNoPrimaryFailure()
+    {
+        CommandResult.PrimaryFailure.Should().BeNull();
+    }
+}

NetChris.Core.UnitTests/CommandResult/TypedSuccessfulCommandResultTests.cs

@@ -0,0 +1,24 @@
+using FluentAssertions;
+using NetChris.Core.CommandResult;
+using Xunit;
+
+namespace NetChris.Core.UnitTests.CommandResult;
+
+public class TypedSuccessfulCommandResultTests : SuccessfulCommandResultTests
+{
+    private readonly ICommandResult<TypedSuccessfulCommandResultTests> _typedResult;
+
+    public TypedSuccessfulCommandResultTests()
+    {
+        _typedResult =
+            new SuccessfulCommandResult<TypedSuccessfulCommandResultTests>(this);
+    }
+
+    protected override ICommandResult CommandResult => _typedResult;
+
+    [Fact]
+    public void ThereIsAResult()
+    {
+        _typedResult.Result.Should().Be(this);
+    }
+}

NetChris.Core.UnitTests/CommandResult/TypedUnsuccessfulCommandResultTests.cs

@@ -0,0 +1,20 @@
+using FluentAssertions;
+using NetChris.Core.CommandResult;
+using Xunit;
+
+namespace NetChris.Core.UnitTests.CommandResult;
+
+public class TypedUnsuccessfulCommandResultTests : UnsuccessfulCommandResultTests
+{
+    private readonly ICommandResult<TypedUnsuccessfulCommandResultTests> _typedResult =
+        UnsuccessfulCommandResult.FromSingleFailure<TypedUnsuccessfulCommandResultTests>(
+            "TypedResourceNotFound", "Resource not found: TYPED");
+
+    [Fact]
+    public void ThereIsNoResult()
+    {
+        _typedResult.Result.Should().BeNull();
+    }
+
+    protected override ICommandResult CommandResult => _typedResult;
+}

NetChris.Core.UnitTests/CommandResult/UnsuccessfulCommandResultTests.cs

@@ -0,0 +1,28 @@
+using FluentAssertions;
+using NetChris.Core.CommandResult;
+using Xunit;
+
+namespace NetChris.Core.UnitTests.CommandResult;
+
+public abstract class UnsuccessfulCommandResultTests
+{
+    protected abstract ICommandResult CommandResult { get; }
+
+    [Fact]
+    public void IsNotSuccessful()
+    {
+        CommandResult.Successful.Should().BeFalse();
+    }
+
+    [Fact]
+    public void HasNonEmptyFailureDetail()
+    {
+        CommandResult.FailureDetail.Should().NotBeEmpty();
+    }
+
+    [Fact]
+    public void HasPrimaryFailure()
+    {
+        CommandResult.PrimaryFailure.Should().NotBeNull();
+    }
+}

NetChris.Core.UnitTests/CommandResult/UntypedSuccessfulCommandResultTests.cs

@@ -0,0 +1,8 @@
+using NetChris.Core.CommandResult;
+
+namespace NetChris.Core.UnitTests.CommandResult;
+
+public class UntypedSuccessfulCommandResultTests : SuccessfulCommandResultTests
+{
+    protected override ICommandResult CommandResult => new SuccessfulCommandResult();
+}

NetChris.Core.UnitTests/CommandResult/UntypedUnsuccessfulCommandResultTests.cs

@@ -0,0 +1,10 @@
+using NetChris.Core.CommandResult;
+
+namespace NetChris.Core.UnitTests.CommandResult;
+
+public class UntypedUnsuccessfulCommandResultTests : UnsuccessfulCommandResultTests
+{
+    protected override ICommandResult CommandResult => UnsuccessfulCommandResult.FromSingleFailure(
+        "UntypedResourceNotFound", "Resource not found: UNTYPED");
+
+}

NetChris.Core/CommandResult/ICommandResult.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using NetChris.Core.Values;
+
+namespace NetChris.Core.CommandResult;
+
+/// <summary>
+/// Result of executing a command, with a typed result object
+/// </summary>
+public interface ICommandResult<TResult> : ICommandResult
+{
+    /// <summary>
+    /// The result of the command
+    /// </summary>
+    TResult? Result { get; }
+}
+
+/// <summary>
+/// Result of executing a command
+/// </summary>
+public interface ICommandResult
+{
+    /// <summary>
+    /// Gets a value indicating whether the command was successful.
+    /// </summary>
+    bool Successful { get; }
+
+    /// <summary>
+    /// Gets the command result failure detail.
+    /// </summary>
+    IEnumerable<SimpleResult> FailureDetail { get; }
+
+    /// <summary>
+    /// Gets the <see cref="Exception"/> causing the command failure, if any.
+    /// </summary>
+    Exception? Exception { get; }
+
+    /// <summary>
+    /// The primary failure, if any
+    /// </summary>
+    SimpleResult? PrimaryFailure { get; }
+}

NetChris.Core/CommandResult/SuccessfulCommandResult.cs

@@ -0,0 +1,41 @@
+using NetChris.Core.Values;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace NetChris.Core.CommandResult;
+
+/// <summary>
+/// Simple implementation of a successful command result.
+/// </summary>
+public class SuccessfulCommandResult : ICommandResult
+{
+    /// <inheritdoc />
+    public bool Successful => true;
+
+    /// <inheritdoc />
+    public IEnumerable<SimpleResult> FailureDetail => new ReadOnlyCollection<SimpleResult>(new List<SimpleResult>());
+
+    /// <inheritdoc />
+    public virtual Exception? Exception => null;
+
+    /// <inheritdoc />
+    public SimpleResult? PrimaryFailure => null;
+}
+
+/// <summary>
+/// Simple implementation of a successful command result, with the typed result object.
+/// </summary>
+public class SuccessfulCommandResult<TResult> : SuccessfulCommandResult, ICommandResult<TResult>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SuccessfulCommandResult{T}" /> class.
+    /// </summary>
+    public SuccessfulCommandResult(TResult result)
+    {
+        Result = result;
+    }
+
+    /// <inheritdoc />
+    public TResult Result { get; }
+}

NetChris.Core/CommandResult/UnsuccessfulCommandResult.cs

@@ -0,0 +1,85 @@
+using NetChris.Core.Values;
+using System;
+using System.Collections.Generic;
+
+namespace NetChris.Core.CommandResult;
+
+/// <summary>
+/// Simple implementation of an unsuccessful command result.
+/// </summary>
+public class UnsuccessfulCommandResult : ICommandResult
+{
+    /// <summary>
+    /// Get a new instance of <see cref="UnsuccessfulCommandResult"/> with a single failure.
+    /// </summary>
+    public static UnsuccessfulCommandResult FromSingleFailure(SimpleResult primaryFailure)
+    {
+        return new UnsuccessfulCommandResult(new[] { primaryFailure }, primaryFailure);
+    }
+
+    /// <summary>
+    /// Get a new instance of <see cref="UnsuccessfulCommandResult"/> with a single failure.
+    /// </summary>
+    public static UnsuccessfulCommandResult FromSingleFailure(string resultCode, string message)
+    {
+        return FromSingleFailure(new SimpleResult(resultCode, message));
+    }
+    /// <summary>
+    /// Get a new instance of <see cref="UnsuccessfulCommandResult"/> with a single failure.
+    /// </summary>
+    public static UnsuccessfulCommandResult<TSingleFailureResult> FromSingleFailure<TSingleFailureResult>(SimpleResult primaryFailure)
+    {
+        return new UnsuccessfulCommandResult<TSingleFailureResult>(new[] { primaryFailure }, primaryFailure);
+    }
+
+    /// <summary>
+    /// Get a new instance of <see cref="UnsuccessfulCommandResult"/> with a single failure.
+    /// </summary>
+    public static UnsuccessfulCommandResult<TSingleFailureResult> FromSingleFailure<TSingleFailureResult>(string resultCode, string message)
+    {
+        return FromSingleFailure<TSingleFailureResult>(new SimpleResult(resultCode, message));
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UnsuccessfulCommandResult" /> class.
+    /// </summary>
+    /// <param name="failureDetail">The command result failure reasons.</param>
+    /// <param name="primaryFailure">The primary command result failure reason.</param>
+    public UnsuccessfulCommandResult(IEnumerable<SimpleResult> failureDetail, SimpleResult primaryFailure)
+    {
+        FailureDetail = failureDetail;
+        PrimaryFailure = primaryFailure;
+    }
+
+    /// <inheritdoc />
+    public bool Successful => false;
+
+    /// <inheritdoc />
+    public IEnumerable<SimpleResult> FailureDetail { get; }
+
+    /// <inheritdoc />
+    public virtual Exception? Exception => null;
+
+    /// <inheritdoc />
+    public SimpleResult PrimaryFailure { get; }
+}
+
+/// <summary>
+/// Simple implementation of an unsuccessful command result.
+/// </summary>
+public class UnsuccessfulCommandResult<TResult> : UnsuccessfulCommandResult, ICommandResult<TResult>
+{
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UnsuccessfulCommandResult" /> class.
+    /// </summary>
+    /// <param name="failureDetail">The command result failure reasons.</param>
+    /// <param name="primaryFailure">The primary command result failure reason.</param>
+    public UnsuccessfulCommandResult(IEnumerable<SimpleResult> failureDetail, SimpleResult primaryFailure) : base(
+        failureDetail, primaryFailure)
+    {
+    }
+
+    /// <inheritdoc />
+    public TResult? Result => default;
+}