SimpleResults

A lightweight implementation of the Result pattern for error handling without exceptions
git clone git://git.hanetzok.net/SimpleResults
Log | Files | Refs | README | LICENSE

TypedResultTests.cs (3602B)

      1 using AwesomeAssertions;
      2 using SimpleResults.Errors;
      3 using SimpleResults.Results;
      4 
      5 namespace Tests.Results;
      6 
      7 public class TypedResultTests
      8 {
      9     [Fact]
     10     public void Success_ShouldCreateSuccessfulResult()
     11     {
     12         // Arrange
     13         const string value = "Success";
     14         
     15         // Act
     16         var result = TypedResult<string>.Success(value);
     17 
     18         // Assert
     19         result.IsFailure.Should().BeFalse();
     20         result.TryGetValue().Should().Be(value);
     21     }
     22 
     23     [Fact]
     24     public void Failure_WithErrorDetail_ShouldCreateFailedResult()
     25     {
     26         // Arrange
     27         const int errorCode = 404;
     28         const string message = "Not found";
     29         var errorDetail = new ErrorDetail(errorCode, message);
     30 
     31         // Act
     32         var result = TypedResult<string>.Failure(errorDetail);
     33 
     34         // Assert
     35         result.IsFailure.Should().BeTrue();
     36         var error = result.TryGetError();
     37         error.ErrorCode.Should().Be(errorCode);
     38         error.Message.Should().Be(message);
     39     }
     40 
     41     [Fact]
     42     public void Failure_WithCodeMessageAndException_ShouldCreateFailedResult()
     43     {
     44         // Arrange
     45         var exception = new InvalidOperationException("Test exception");
     46         const int code = 500;
     47         const string message = "Internal error";
     48 
     49         // Act
     50         var result = TypedResult<string>.Failure(code, message, exception);
     51 
     52         // Assert
     53         result.IsFailure.Should().BeTrue();
     54         var error = result.TryGetError();
     55         error.ErrorCode.Should().Be(code);
     56         error.Message.Should().Be(message);
     57         error.Exception.Should().Be(exception);
     58     }
     59 
     60     [Fact]
     61     public void Failure_WithCodeMessageAndNullException_ShouldCreateFailedResult()
     62     {
     63         // Act
     64         const int code = 400;
     65         const string message = "Bad request";
     66         var result = TypedResult<string>.Failure(code, message, null);
     67 
     68         // Assert
     69         result.IsFailure.Should().BeTrue();
     70         var error = result.TryGetError();
     71         error.ErrorCode.Should().Be(code);
     72         error.Message.Should().Be(message);
     73         error.Exception.Should().BeNull();
     74     }
     75 
     76     [Fact]
     77     public void TryGetError_OnSuccessfulResult_ShouldThrowNullReferenceException()
     78     {
     79         // Arrange
     80         const string value = "Success";
     81         var result = TypedResult<string>.Success(value);
     82 
     83         // Act & Assert
     84         var exception = Assert.Throws<InvalidOperationException>(() => result.TryGetError());
     85         Assert.Contains("Can't get error", exception.Message);
     86     }
     87 
     88     [Fact]
     89     public void IsFailure_OnFailedResult_ShouldReturnTrue()
     90     {
     91         // Arrange
     92         const int code = 400;
     93         const string message = "Bad request";
     94         var result = TypedResult<string>.Failure(code, message, null);
     95 
     96         // Act & Assert
     97         Assert.True(result.IsFailure);
     98     }
     99 
    100     [Fact]
    101     public void MultipleFailureCalls_ShouldCreateIndependentInstances()
    102     {
    103         // Arrange
    104         const int code1 = 400;
    105         const string message1 = "Error 1";
    106         const int code2 = 500;
    107         const string message2 = "Error 2";
    108         var error1 = new ErrorDetail(code1, message1);
    109         var error2 = new ErrorDetail(code2, message2);
    110 
    111         // Act
    112         var result1 = TypedResult<string>.Failure(error1);
    113         var result2 = TypedResult<string>.Failure(error2);
    114 
    115         // Assert
    116         Assert.NotSame(result1, result2);
    117         Assert.True(result1.IsFailure);
    118         Assert.True(result2.IsFailure);
    119         Assert.Equal(code1, result1.TryGetError().ErrorCode);
    120         Assert.Equal(code2, result2.TryGetError().ErrorCode);
    121     }
    122 }