junction/tests/Junction.Tests/Unit/ResultTests.cs

using System.Collections.Generic;
using Junction.Domain;
using Xunit;

namespace Junction.Tests.Unit
{
    public class ResultTests
    {
        private static OperationError Err(string msg = "boom") =>
            new OperationError("E", "Src", msg);

        // ---- Result<T> ----

        [Fact]
        public void Generic_Ok_HasValue_IsSuccess_EmptyErrors()
        {
            var r = Result<int>.Ok(42);

            Assert.True(r.IsSuccess);
            Assert.False(r.WasCancelled);
            Assert.Equal(42, r.Value);
            Assert.NotNull(r.Errors);
            Assert.Empty(r.Errors);
        }

        [Fact]
        public void Generic_FailSingle_CarriesError_NotSuccess()
        {
            var r = Result<int>.Fail(Err());

            Assert.False(r.IsSuccess);
            Assert.False(r.WasCancelled);
            Assert.Single(r.Errors);
            Assert.NotNull(r.Errors);
        }

        [Fact]
        public void Generic_FailMany_CarriesAllErrors()
        {
            var errors = new List<OperationError> { Err("a"), Err("b") };
            var r = Result<int>.Fail(errors);

            Assert.False(r.IsSuccess);
            Assert.Equal(2, r.Errors.Count);
        }

        [Fact]
        public void Generic_Failed_ValueIsDefault_NoThrow()
        {
            var rInt = Result<int>.Fail(Err());
            var rRef = Result<string>.Fail(Err());

            Assert.Equal(0, rInt.Value);
            Assert.Null(rRef.Value);
        }

        [Fact]
        public void Generic_Cancelled_IsCancelled_NotSuccess_NotTreatedAsFailure()
        {
            var r = Result<int>.Cancelled();

            Assert.True(r.WasCancelled);
            Assert.False(r.IsSuccess);
            // cancellation is NOT a failure: no errors recorded
            Assert.Empty(r.Errors);
            Assert.NotNull(r.Errors);
        }

        [Fact]
        public void Generic_ErrorsNeverNull_InAnyState()
        {
            Assert.NotNull(Result<int>.Ok(1).Errors);
            Assert.NotNull(Result<int>.Fail(Err()).Errors);
            Assert.NotNull(Result<int>.Cancelled().Errors);
        }

        // ---- non-generic Result ----

        [Fact]
        public void Void_Ok_IsSuccess_EmptyErrors()
        {
            var r = Result.Ok();

            Assert.True(r.IsSuccess);
            Assert.False(r.WasCancelled);
            Assert.NotNull(r.Errors);
            Assert.Empty(r.Errors);
        }

        [Fact]
        public void Void_FailSingle_CarriesError_NotSuccess()
        {
            var r = Result.Fail(Err());

            Assert.False(r.IsSuccess);
            Assert.False(r.WasCancelled);
            Assert.Single(r.Errors);
        }

        [Fact]
        public void Void_FailMany_CarriesAllErrors()
        {
            var r = Result.Fail(new[] { Err("a"), Err("b") });

            Assert.False(r.IsSuccess);
            Assert.Equal(2, r.Errors.Count);
        }

        [Fact]
        public void Void_Cancelled_IsCancelled_NotSuccess_NotTreatedAsFailure()
        {
            var r = Result.Cancelled();

            Assert.True(r.WasCancelled);
            Assert.False(r.IsSuccess);
            Assert.Empty(r.Errors);
        }

        [Fact]
        public void Void_ErrorsNeverNull_InAnyState()
        {
            Assert.NotNull(Result.Ok().Errors);
            Assert.NotNull(Result.Fail(Err()).Errors);
            Assert.NotNull(Result.Cancelled().Errors);
        }
    }
}