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

ResultTests.cs (3326B)

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