stevanfreeborn.results/tests/StevanFreeborn.Results.Tests/ResultTTests.cs

using System.Globalization;

namespace StevanFreeborn.Results.Tests;

public class ResultTTests
{
  [Test]
  public async Task Ok_WhenCalledWithValue_ItShouldReturnSuccessResult()
  {
    var result = Result.Ok<string, Error>("test");

    await Assert.That(result.IsSuccess).IsTrue();
    await Assert.That(result.IsFailure).IsFalse();
    await Assert.That(result.Value).IsEqualTo("test");
  }

  [Test]
  public async Task Fail_WhenCalled_ItShouldReturnFailureResult()
  {
    var error = new Error("code", "message");
    var result = Result.Fail<string, Error>(error);

    await Assert.That(result.IsFailure).IsTrue();
    await Assert.That(result.IsSuccess).IsFalse();
    await Assert.That(result.Error).IsEqualTo(error);
  }

  [Test]
  public void Value_WhenResultIsFailure_ItShouldThrowInvalidOperationException()
  {
    var result = Result.Fail<string, Error>(new Error("code", "message"));

    Assert.Throws<InvalidOperationException>(() => _ = result.Value);
  }

  [Test]
  public void Error_WhenResultIsSuccess_ItShouldThrowInvalidOperationException()
  {
    var result = Result.Ok<string, Error>("test");

    Assert.Throws<InvalidOperationException>(() => _ = result.Error);
  }

  [Test]
  public async Task ImplicitConversion_FromValue_ItShouldReturnSuccessResult()
  {
    Result<string, Error> result = "test";

    await Assert.That(result.IsSuccess).IsTrue();
    await Assert.That(result.Value).IsEqualTo("test");
  }

  [Test]
  public async Task ImplicitConversion_FromError_ItShouldReturnFailureResult()
  {
    var error = new Error("code", "message");
    Result<string, Error> result = error;

    await Assert.That(result.IsFailure).IsTrue();
    await Assert.That(result.Error).IsEqualTo(error);
  }

  [Test]
  public async Task Map_WhenResultIsSuccess_ItShouldTransformValue()
  {
    var result = Result.Ok<int, Error>(5);
    var mapped = result.Map(n => n.ToString(CultureInfo.InvariantCulture));

    await Assert.That(mapped.IsSuccess).IsTrue();
    await Assert.That(mapped.Value).IsEqualTo("5");
  }

  [Test]
  public async Task Map_WhenResultIsFailure_ItShouldPropagateError()
  {
    var error = new Error("code", "message");
    var result = Result.Fail<int, Error>(error);
    var mapped = result.Map(n => n.ToString(CultureInfo.InvariantCulture));

    await Assert.That(mapped.IsFailure).IsTrue();
    await Assert.That(mapped.Error).IsEqualTo(error);
  }

  [Test]
  public async Task MapError_WhenResultIsFailure_ItShouldTransformError()
  {
    var originalError = new Error("original", "original message");
    var result = Result.Fail<int, Error>(originalError);
    var transformed = result.MapError(e => new Error("transformed", e.Message));

    await Assert.That(transformed.IsFailure).IsTrue();
    await Assert.That(transformed.Error.Code).IsEqualTo("transformed");
  }

  [Test]
  public async Task MapError_WhenResultIsSuccess_ItShouldReturnUnchanged()
  {
    var result = Result.Ok<int, Error>(5);
    var mapped = result.MapError(e => new Error("transformed", e.Message));

    await Assert.That(mapped.IsSuccess).IsTrue();
    await Assert.That(mapped.Value).IsEqualTo(5);
  }

  [Test]
  public async Task Bind_WhenResultIsSuccess_ItShouldChainToBinderResult()
  {
    var result = Result.Ok<int, Error>(5);
    var bound = result.Bind(n => Result.Ok<string, Error>(n.ToString(CultureInfo.InvariantCulture)));

    await Assert.That(bound.IsSuccess).IsTrue();
    await Assert.That(bound.Value).IsEqualTo("5");
  }

  [Test]
  public async Task Bind_WhenResultIsFailure_ItShouldPropagateError()
  {
    var error = new Error("code", "message");
    var result = Result.Fail<int, Error>(error);
    var bound = result.Bind(n => Result.Ok<string, Error>(n.ToString(CultureInfo.InvariantCulture)));

    await Assert.That(bound.IsFailure).IsTrue();
    await Assert.That(bound.Error).IsEqualTo(error);
  }

  [Test]
  public async Task Bind_WhenResultIsSuccess_ItShouldReturnBinderFailureResult()
  {
    var result = Result.Ok<int, Error>(5);
    var bound = result.Bind(_ => Result.Fail<string, Error>(new Error("bind_error", "bound failed")));

    await Assert.That(bound.IsFailure).IsTrue();
    await Assert.That(bound.Error.Code).IsEqualTo("bind_error");
  }

  [Test]
  public async Task Match_WhenResultIsSuccess_ItShouldReturnOnSuccessValue()
  {
    var result = Result.Ok<string, Error>("test");
    var matched = result.Match(v => v.Length, _ => 0);

    await Assert.That(matched).IsEqualTo(4);
  }

  [Test]
  public async Task Match_WhenResultIsFailure_ItShouldReturnOnFailureValue()
  {
    var result = Result.Fail<string, Error>(new Error("code", "message"));
    var matched = result.Match(v => v.Length, e => -1);

    await Assert.That(matched).IsEqualTo(-1);
  }

  [Test]
  public async Task Match_WhenResultIsSuccess_ItShouldInvokeOnSuccess()
  {
    var result = Result.Ok<string, Error>("test");
    var invoked = false;

    result.Match(v => { invoked = true; }, _ => { });

    await Assert.That(invoked).IsTrue();
  }

  [Test]
  public async Task Match_WhenResultIsFailure_ItShouldInvokeOnFailure()
  {
    var error = new Error("code", "message");
    var result = Result.Fail<string, Error>(error);
    var invoked = false;

    result.Match(_ => { }, e => { invoked = true; });

    await Assert.That(invoked).IsTrue();
  }

  [Test]
  public async Task Try_WhenFuncSucceeds_ItShouldReturnOkWithValue()
  {
    var result = Result.Try<int, Error>(() => 42);

    await Assert.That(result.IsSuccess).IsTrue();
    await Assert.That(result.Value).IsEqualTo(42);
  }

  [Test]
  public async Task Try_WhenFuncThrowsException_ItShouldReturnFailWithUnexpectedError()
  {
    var result = Result.Try<int, Error>(() => throw new InvalidOperationException("test error"));

    await Assert.That(result.IsFailure).IsTrue();
    await Assert.That(result.Error.Code).IsEqualTo("UnexpectedError");
  }

  [Test]
  public async Task Try_WhenFuncThrowsException_ItShouldUseCustomError()
  {
    var result = Result.Try<int, Error>(() => throw new InvalidOperationException("test"), ex => new Error("custom", ex.Message));

    await Assert.That(result.IsFailure).IsTrue();
    await Assert.That(result.Error.Code).IsEqualTo("custom");
  }
}