Merge pull request #2 from adomorn/develop

integrated unit test

Resultant.Tests/ErrorTests.cs

@@ -0,0 +1,39 @@
+namespace Resultant.Tests
+{
+ using Xunit;
+
+ namespace Resultant.Tests
+ {
+ public class ErrorTests
+ {
+ [Fact]
+ public void Error_ShouldSetMessage()
+ {
+ var errorMessage = "Test Error";
+ var error = new Error(errorMessage);
+
+ Assert.Equal(errorMessage, error.Message);
+ }
+
+ [Fact]
+ public void Error_ShouldSetDefaultCodeToZero()
+ {
+ var error = new Error("Test Error");
+
+ Assert.Equal(0, error.Code);
+ }
+
+ [Theory]
+ [InlineData(100)]
+ [InlineData(404)]
+ [InlineData(500)]
+ public void Error_ShouldSetCustomCode(int errorCode)
+ {
+ var error = new Error("Test Error", errorCode);
+
+ Assert.Equal(errorCode, error.Code);
+ }
+ }
+ }
+
+}

Resultant.Tests/GlobalUsings.cs

@@ -0,0 +1 @@
+global using Xunit;

Resultant.Tests/PagedResultTests.cs

@@ -0,0 +1,28 @@
+namespace Resultant.Tests
+{
+ public class PagedResultTests
+ {
+ [Fact]
+ public void Create_ShouldReturnSuccessPagedResult()
+ {
+ var items = new List<int> { 1, 2, 3 };
+ var pagedResult = PagedResult<int>.Create(items, 1, 3, 10);
+
+ Assert.True(pagedResult.IsSuccess);
+ Assert.Equal(items, pagedResult.Value);
+ Assert.Equal(1, pagedResult.CurrentPage);
+ Assert.Equal(3, pagedResult.PageSize);
+ Assert.Equal(10, pagedResult.TotalCount);
+ Assert.Equal(4, pagedResult.TotalPages);
+ }
+
+ [Fact]
+ public void Fail_ShouldReturnFailurePagedResult()
+ {
+ var pagedResult = PagedResult<int>.Fail("Error");
+
+ Assert.False(pagedResult.IsSuccess);
+ Assert.True(pagedResult.IsFailure);
+ }
+ }
+}

Resultant.Tests/ResultHelpersTests.cs

@@ -0,0 +1,66 @@
+#pragma warning disable IDE0305
+namespace Resultant.Tests
+{
+ public class ResultHelpersTests
+ {
+ [Fact]
+ public void Combine_WithAllSuccessResults_ShouldReturnSuccess()
+ {
+ var results = new List<Result>
+ {
+ Result.Ok(),
+ Result.Ok()
+ };
+
+
+ var combinedResult = ResultHelpers.Combine(results.ToArray());
+
+
+ Assert.True(combinedResult.IsSuccess);
+ }
+
+ [Fact]
+ public void Combine_WithAnyFailureResults_ShouldReturnFailure()
+ {
+ var results = new List<Result>
+ {
+ Result.Ok(),
+ Result.Fail("Error")
+ };
+
+ var combinedResult = ResultHelpers.Combine(results.ToArray());
+
+ Assert.False(combinedResult.IsSuccess);
+ Assert.True(combinedResult.IsFailure);
+ }
+
+ [Fact]
+ public async Task WhenAll_WithAllSuccessResults_ShouldReturnSuccess()
+ {
+ var tasks = new List<Task<Result>>
+ {
+ Task.FromResult(Result.Ok()),
+ Task.FromResult(Result.Ok())
+ };
+
+ var combinedResult = await ResultHelpers.WhenAll(tasks);
+
+ Assert.True(combinedResult.IsSuccess);
+ }
+
+ [Fact]
+ public async Task WhenAll_WithAnyFailureResults_ShouldReturnFailure()
+ {
+ var tasks = new List<Task<Result>>
+ {
+ Task.FromResult(Result.Ok()),
+ Task.FromResult(Result.Fail("Error"))
+ };
+
+ var combinedResult = await ResultHelpers.WhenAll(tasks);
+
+ Assert.False(combinedResult.IsSuccess);
+ Assert.True(combinedResult.IsFailure);
+ }
+ }
+}

Resultant.Tests/ResultOfTTests.cs

@@ -0,0 +1,142 @@
+namespace Resultant.Tests
+{
+ public class ResultOfTTests
+ {
+ [Fact]
+ public void Ok_ShouldReturnSuccessResultWithValue()
+ {
+ var result = Result.Ok(100);
+
+ Assert.True(result.IsSuccess);
+ Assert.Equal(100, result.Value);
+ }
+
+ [Fact]
+ public void Fail_ShouldReturnFailureResult()
+ {
+ var errors = new List<Error> { new("Error") };
+ var result = Result.Fail<int>(errors);
+
+ Assert.False(result.IsSuccess);
+ Assert.True(result.IsFailure);
+ Assert.Single(result.Errors);
+ Assert.Equal("Error", result.Errors.First().Message);
+ }
+
+ [Fact]
+ public async Task MapAsync_ShouldMapValueWhenSuccess()
+ {
+ var result = Result.Ok(10);
+ var mappedResult = await result.MapAsync(value => Task.FromResult(value * 2));
+
+ Assert.True(mappedResult.IsSuccess);
+ Assert.Equal(20, mappedResult.Value);
+ }
+
+ [Fact]
+ public async Task BindAsync_ShouldNotBindWhenFailure()
+ {
+ var errors = new List<Error> { new("Error") };
+ var result = Result.Fail<int>(errors);
+ var boundResult = await result.BindAsync(value => Task.FromResult(Result.Ok(value * 2)));
+
+ Assert.False(boundResult.IsSuccess);
+ }
+ [Fact]
+ public void ImplicitCastToValueType_ShouldReturnValueForSuccess()
+ {
+ Result<int> result = Result.Ok(123);
+ int value = result;
+
+ Assert.Equal(123, value);
+ }
+
+ [Fact]
+ public void ImplicitCastToValueType_ShouldThrowForFailure()
+ {
+ var errors = new List<Error> { new Error("Error") };
+ Result<int> result = Result.Fail<int>(errors);
+
+ Assert.Throws<InvalidOperationException>(() => (int)result);
+ }
+
+ [Fact]
+ public void Map_ShouldTransformValueOnSuccess()
+ {
+ Result<int> initialResult = Result.Ok(10);
+ var mappedResult = initialResult.Map(value => value * 2);
+
+ Assert.True(mappedResult.IsSuccess);
+ Assert.Equal(20, mappedResult.Value);
+ }
+
+ [Fact]
+ public void Map_ShouldNotTransformOnFailure()
+ {
+ var errors = new List<Error> { new Error("Error") };
+ Result<int> initialResult = Result.Fail<int>(errors);
+ var mappedResult = initialResult.Map(value => value * 2);
+
+ Assert.False(mappedResult.IsSuccess);
+ }
+
+ [Fact]
+ public void Bind_ShouldTransformToNewResultOnSuccess()
+ {
+ Result<int> initialResult = Result.Ok(10);
+ var boundResult = initialResult.Bind(value => Result.Ok(value.ToString()));
+
+ Assert.True(boundResult.IsSuccess);
+ Assert.Equal("10", boundResult.Value);
+ }
+
+ [Fact]
+ public void Bind_ShouldNotTransformOnFailure()
+ {
+ var errors = new List<Error> { new Error("Error") };
+ Result<int> initialResult = Result.Fail<int>(errors);
+ var boundResult = initialResult.Bind(value => Result.Ok(value.ToString()));
+
+ Assert.False(boundResult.IsSuccess);
+ }
+
+ [Fact]
+ public async Task MapAsync_ShouldTransformValueOnSuccess()
+ {
+ Result<int> initialResult = Result.Ok(10);
+ var mappedResult = await initialResult.MapAsync(value => Task.FromResult(value * 2));
+
+ Assert.True(mappedResult.IsSuccess);
+ Assert.Equal(20, mappedResult.Value);
+ }
+
+ [Fact]
+ public async Task MapAsync_ShouldNotTransformOnFailure()
+ {
+ var errors = new List<Error> { new Error("Error") };
+ Result<int> initialResult = Result.Fail<int>(errors);
+ var mappedResult = await initialResult.MapAsync(value => Task.FromResult(value * 2));
+
+ Assert.False(mappedResult.IsSuccess);
+ }
+ [Fact]
+ public async Task BindAsync_ShouldTransformToNewResultOnSuccess()
+ {
+ Result<int> initialResult = Result.Ok(10);
+ var boundResult = await initialResult.BindAsync(value => Task.FromResult(Result.Ok(value.ToString())));
+
+ Assert.True(boundResult.IsSuccess);
+ Assert.Equal("10", boundResult.Value);
+ }
+
+ [Fact]
+ public async Task BindAsync_ShouldNotTransformOnFailure()
+ {
+ var errors = new List<Error> { new Error("Error") };
+ Result<int> initialResult = Result.Fail<int>(errors);
+ var boundResult = await initialResult.BindAsync(value => Task.FromResult(Result.Ok(value.ToString())));
+
+ Assert.False(boundResult.IsSuccess);
+ }
+ }
+}

Resultant.Tests/ResultTests.cs

@@ -0,0 +1,68 @@
+namespace Resultant.Tests
+{
+ public class ResultTests
+ {
+ [Fact]
+ public void Ok_ShouldReturnSuccessResult()
+ {
+ var result = Result.Ok();
+
+ Assert.True(result.IsSuccess);
+ Assert.False(result.IsFailure);
+ }
+
+ [Fact]
+ public void Fail_ShouldReturnFailureResult()
+ {
+ var result = Result.Fail("Error");
+
+ Assert.False(result.IsSuccess);
+ Assert.True(result.IsFailure);
+ Assert.Single(result.Errors);
+ Assert.Equal("Error", result.Errors.FirstOrDefault()?.Message);
+ }
+
+ [Fact]
+ public void Fail_WithMultipleErrors_ShouldReturnAllErrors()
+ {
+ var errors = new List<Error> { new("Error1"), new("Error2") };
+ var result = Result.Fail(errors);
+
+ Assert.False(result.IsSuccess);
+ Assert.True(result.IsFailure);
+ Assert.Equal(2, result.Errors.Count());
+ }
+ [Fact]
+ public void ImplicitCastToBool_ShouldBeTrueForSuccess()
+ {
+ Result result = Result.Ok();
+ bool isSuccess = result;
+
+ Assert.True(isSuccess);
+ }
+
+ [Fact]
+ public void ImplicitCastToBool_ShouldBeFalseForFailure()
+ {
+ var errors = new List<Error> { new Error("Error") };
+ Result result = Result.Fail(errors);
+ bool isFailure = result;
+
+ Assert.False(isFailure);
+ }
+ [Fact]
+ public void ToString_SuccessResult_ShouldReturnSuccess()
+ {
+ var result = Result.Ok();
+ Assert.Equal("Success", result.ToString());
+ }
+
+ [Fact]
+ public void ToString_FailureResult_ShouldReturnFailureAndError()
+ {
+ var errors = new List<Error> { new Error("Error") };
+ var result = Result.Fail(errors);
+ Assert.Equal("Failure: Error", result.ToString());
+ }
+ }
+}

Resultant.Tests/Resultant.Tests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <TargetFramework>net8.0</TargetFramework>
+ <ImplicitUsings>enable</ImplicitUsings>
+ <Nullable>enable</Nullable>
+
+ <IsPackable>false</IsPackable>
+ <IsTestProject>true</IsTestProject>
+ </PropertyGroup>
+
+ <ItemGroup>
+ <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
+ <PackageReference Include="xunit" Version="2.4.2" />
+ <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+ <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+ <PrivateAssets>all</PrivateAssets>
+ </PackageReference>
+ <PackageReference Include="coverlet.collector" Version="6.0.0">
+ <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+ <PrivateAssets>all</PrivateAssets>
+ </PackageReference>
+ </ItemGroup>
+
+ <ItemGroup>
+ <ProjectReference Include="..\Resultant\Resultant.csproj" />
+ </ItemGroup>
+
+</Project>