Merge pull request #7 from Felix-CodingClimber/dev-felix

Removed invalid conversion from source generated ErrorResult.

Author: Felix-CodingClimber

DotNetElements.Core.ResultObject.Examples/DotNetElements.Core.ResultObject.Examples.csproj

@@ -9,7 +9,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="DotNetElements.Core.Result" Version="0.0.4" />
+		<PackageReference Include="DotNetElements.Core.Result" Version="0.1.3" />
 	</ItemGroup>
 
 </Project>

DotNetElements.Core.ResultObject.SourceGenerator.Tests/SnapshotResults/ErrorResultGeneratorSnapshotTests.GeneratesErrorResultCorrectly#ErrorResult.ExampleResult.g.verified.cs

@@ -41,7 +41,6 @@ public bool TryGetValue([NotNullWhen(true)] out TValue? value, [NotNullWhen(fals
         public static implicit operator ExampleResult<TValue>(ExampleResultHelper.ExampleResult result) => result.IsFail ? new(false, default!, result.GetErrorUnsafe()) : throw new ResultException("Can not convert a successful result to a result with a value");
 
         // Optional conversions
-        public ExampleResultHelper.ExampleResult AsCrudResult() => IsOk ? ExampleResultHelper.ExampleResult.Ok() : ExampleResultHelper.ExampleResult.Fail(Error);
         public Result AsResult() => IsOk ? Result.Ok() : Result.Fail();
         public Result<TValue> AsResultWithValue() => IsOk ? Result<TValue>.Ok(Value) : Result<TValue>.Fail();
     }

DotNetElements.Core.ResultObject.SourceGenerator/ErrorResultOutputWriter.cs

@@ -55,7 +55,6 @@ public bool TryGetValue([NotNullWhen(true)] out TValue? value, [NotNullWhen(fals
         public static implicit operator ").Append(result.FullName).Append("(").Append(result.SimpleNameHelper).Append(@" result) => result.IsFail ? new(false, default!, result.GetErrorUnsafe()) : throw new ResultException(""Can not convert a successful result to a result with a value"");
     
         // Optional conversions
-        public ").Append(result.SimpleNameHelper).Append(" AsCrudResult() => IsOk ? ").Append(result.SimpleNameHelper).Append(".Ok() : ").Append(result.SimpleNameHelper).Append(@".Fail(Error);
         public Result AsResult() => IsOk ? Result.Ok() : Result.Fail();
         public Result<TValue> AsResultWithValue() => IsOk ? Result<TValue>.Ok(Value) : Result<TValue>.Fail();
     }

DotNetElements.Core.ResultObject.Tests/ErrorResultTests.cs

@@ -6,5 +6,5 @@ public partial class TestErrorResult;
 [TestClass]
 public class ErrorResultTests
 {
-    // todo
+    
 }

DotNetElements.Core.ResultObject.Tests/ResultHelperTests.cs

@@ -0,0 +1,25 @@
+using static DotNetElements.Core.ResultObject.ResultHelper;
+
+namespace DotNetElements.Core.ResultObject.Tests;
+
+[TestClass]
+public class ResultHelperTests
+{
+    [TestMethod]
+    public void ResultOk_ShouldBeOk()
+    {
+		Result result = Ok();
+
+        Assert.IsTrue(result.IsOk);
+        Assert.IsFalse(result.IsFail);
+    }
+
+    [TestMethod]
+    public void ResultFail_ShouldBeFail()
+    {
+		Result result = Fail();
+
+        Assert.IsFalse(result.IsOk);
+        Assert.IsTrue(result.IsFail);
+    }
+}

DotNetElements.Core.ResultObject.Tests/ResultWithErrorTests.cs

@@ -0,0 +1,54 @@
+namespace DotNetElements.Core.ResultObject.Tests;
+
+[TestClass]
+public class ResultWithErrorTests
+{
+    [TestMethod]
+    public void ResultOk_ShouldBeOk()
+    {
+        ResultWithError result = ResultWithError.Ok();
+
+        Assert.IsTrue(result.IsOk);
+        Assert.IsFalse(result.IsFail);
+    }
+
+    [TestMethod]
+    public void ResultFail_ShouldBeFail()
+    {
+        ResultWithError result = ResultWithError.Fail("TestErrorMessage");
+
+        Assert.IsFalse(result.IsOk);
+        Assert.IsTrue(result.IsFail);
+    }
+
+    [TestMethod]
+    public void ResultWithError_ShouldContainError()
+    {
+        string error = "TestErrorMessage";
+        ResultWithError result = ResultWithError.Fail(error);
+
+        Assert.IsTrue(result.IsFail);
+        Assert.AreEqual(result.GetErrorUnsafe(), error);
+    }
+
+    [TestMethod]
+    [ExpectedException(typeof(ResultOkException))]
+    public void ResultFail_GetErrorUnsafe_ShouldThrowException()
+    {
+        ResultWithError result = ResultWithError.Ok();
+
+        result.GetErrorUnsafe();
+    }
+
+    [TestMethod]
+    public void ResultWithError_HasError_ShouldReturnTrueAndError()
+    {
+        string error = "TestErrorMessage";
+        ResultWithError result = ResultWithError.Fail(error);
+
+        bool hasError = result.HasError(out string? resultError);
+
+        Assert.IsTrue(hasError);
+        Assert.AreEqual(error, resultError);
+    }
+}

DotNetElements.Core.ResultObject/Result.cs

@@ -54,6 +54,52 @@ private Result(bool isOk)
     public static implicit operator Result(ResultFail _) => new Result(false);
 }
 
+public readonly struct ResultWithError
+{
+    public bool IsOk { get; private init; }
+
+    public bool IsFail => !IsOk;
+
+    private readonly string? error;
+
+    private ResultWithError(bool isOk, string? error = null)
+    {
+        IsOk = isOk;
+        this.error = error;
+    }
+
+    public static ResultWithError Ok() => new(true);
+    public static ResultWithError Fail(string error) => new(false, error);
+
+    public bool HasError([NotNullWhen(true)] out string? error)
+    {
+        error = this.error;
+
+        return IsFail;
+    }
+
+    public string GetErrorUnsafe() => error ?? throw new ResultOkException();
+
+    // Optional conversions
+    public Result AsResult => IsOk ? Result.Ok() : Result.Fail();
+
+    // Helper methods
+    public static ResultWithError OkIf(bool isSuccess, string error)
+    {
+        return isSuccess ? Ok() : Fail(error);
+    }
+
+    public static ResultWithError OkIf(Func<bool> predicate, string error)
+    {
+        return predicate.Invoke() ? Ok() : Fail(error);
+    }
+
+    public static ResultWithError OkIfNotNull<TValue>(TValue? value, string error)
+    {
+        return value is not null ? Ok() : Fail(error);
+    }
+}
+
 public abstract class ErrorResult<TError>
 {
     public bool IsOk { get; private init; }
@@ -78,7 +124,9 @@ public bool HasError([NotNullWhen(true)] out TError? error)
     public TError GetErrorUnsafe() => Error ?? throw new ResultOkException();
 }
 
+// todo check if this is needed
 public readonly struct ResultOk;
+// todo check if this is needed
 public readonly struct ResultFail;
 
 public static partial class ResultHelper