From dd4b0d26288e0a051efb4b01412fdad85b9b253e Mon Sep 17 00:00:00 2001
From: "skrasek.michael" <skrasek.michal@email.cz>
Date: Wed, 20 Mar 2024 10:31:22 +0100
Subject: [PATCH] added And unit tests

---
 .../AndTests/AndTests.cs                      | 42 +++++++++++++
 .../AndTests/TheoryData_R1_And.cs             | 62 +++++++++++++++++++
 .../AndTests/TheoryData_R1_AndAsync.cs        | 35 +++++++++++
 .../AndTests/TheoryData_R2_And.cs             | 28 +++++++++
 .../AndTests/TheoryData_TaskOfR1_And.cs       | 62 +++++++++++++++++++
 .../AndTests/TheoryData_TaskOfR2_And.cs       | 28 +++++++++
 .../GlobalUsings.cs                           |  1 +
 .../Obj.cs                                    |  3 +
 8 files changed, 261 insertions(+)
 create mode 100644 tests/RailwayResult.FunctionalExtensions.Tests/AndTests/AndTests.cs
 create mode 100644 tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R1_And.cs
 create mode 100644 tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R1_AndAsync.cs
 create mode 100644 tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R2_And.cs
 create mode 100644 tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_TaskOfR1_And.cs
 create mode 100644 tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_TaskOfR2_And.cs

diff --git a/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/AndTests.cs b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/AndTests.cs
new file mode 100644
index 0000000..33ed0e4
--- /dev/null
+++ b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/AndTests.cs
@@ -0,0 +1,42 @@
+namespace RailwayResult.FunctionalExtensions.Tests.AndTests;
+
+public sealed class AndTests
+{
+	[Theory]
+	[ClassData(typeof(TheoryData_R1_And))]
+	public void R1_And(Func<R1, R2> and, R1 input, R2 expectedOutput)
+	{
+		and.Invoke(input).ShouldBe(expectedOutput);
+	}
+
+	[Theory]
+	[ClassData(typeof(TheoryData_TaskOfR1_And))]
+	public async Task TaskOfR1_And(Func<Task<R1>, Task<R2>> and, R1 input, R2 expectedOutput)
+	{
+		var result = await and.Invoke(Task.FromResult(input));
+		result.ShouldBe(expectedOutput);
+	}
+
+	[Theory]
+	[ClassData(typeof(TheoryData_R2_And))]
+	public void R2_And(Func<R2, R3> and, R2 input, R3 expectedOutput)
+	{
+		and.Invoke(input).ShouldBe(expectedOutput);
+	}
+
+	[Theory]
+	[ClassData(typeof(TheoryData_TaskOfR2_And))]
+	public async Task TaskOfR2_And(Func<Task<R2>, Task<R3>> and, R2 input, R3 expectedOutput)
+	{
+		var result = await and.Invoke(Task.FromResult(input));
+		result.ShouldBe(expectedOutput);
+	}
+
+	[Theory]
+	[ClassData(typeof(TheoryData_R1_AndAsync))]
+	public async Task R1_AndAsync(Func<R1, Task<R2>> andAsync, R1 input, R2 expectedOutput)
+	{
+		var result = await andAsync.Invoke(input);
+		result.ShouldBe(expectedOutput);
+	}
+}
diff --git a/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R1_And.cs b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R1_And.cs
new file mode 100644
index 0000000..6f0af0e
--- /dev/null
+++ b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R1_And.cs
@@ -0,0 +1,62 @@
+namespace RailwayResult.FunctionalExtensions.Tests.AndTests;
+
+public sealed class TheoryData_R1_And : TheoryData<Func<R1, R2>, R1, R2>
+{
+	public TheoryData_R1_And()
+	{
+		Add(
+			result => result.And(() => O.B),
+			O.A,
+			(O.A, O.B)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.And(() => O.B),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		//nested result should be unwrapped
+		Add(
+			result => result.And(() => R1.Success(O.B)),
+			O.A,
+			(O.A, O.B)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.And(() => R1.Success(O.B)),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		//and should return error from nested result
+		Add(
+			result => result.And<O, O>(() => Errors.ErrorB),
+			O.A,
+			Errors.ErrorB
+		);
+
+		//nested result should be unwrapped
+		Add(
+			result => result.And(_ => R1.Success(O.B)),
+			O.A,
+			(O.A, O.B)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.And(_ => R1.Success(O.B)),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		//and should return error from nested result
+		Add(
+			result => result.And<O, O>(_ => Errors.ErrorB),
+			O.A,
+			Errors.ErrorB
+		);
+	}
+}
diff --git a/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R1_AndAsync.cs b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R1_AndAsync.cs
new file mode 100644
index 0000000..d2404ea
--- /dev/null
+++ b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R1_AndAsync.cs
@@ -0,0 +1,35 @@
+namespace RailwayResult.FunctionalExtensions.Tests.AndTests;
+
+public sealed class TheoryData_R1_AndAsync : TheoryData<Func<R1, Task<R2>>, R1, R2>
+{
+	public TheoryData_R1_AndAsync()
+	{
+		Add(
+			result => result.AndAsync(_ => Task.FromResult(O.B)),
+			O.A,
+			(O.A, O.B)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.AndAsync(_ => Task.FromResult(O.B)),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		// --- TaskOfR1 ---
+
+		Add(
+			result => Task.FromResult(result).AndAsync(_ => Task.FromResult(O.B)),
+			O.A,
+			(O.A, O.B)
+		);
+
+		//and should return input failure result
+		Add(
+			result => Task.FromResult(result).AndAsync(_ => Task.FromResult(O.B)),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+	}
+}
diff --git a/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R2_And.cs b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R2_And.cs
new file mode 100644
index 0000000..e801d2a
--- /dev/null
+++ b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_R2_And.cs
@@ -0,0 +1,28 @@
+namespace RailwayResult.FunctionalExtensions.Tests.AndTests;
+
+public sealed class TheoryData_R2_And : TheoryData<Func<R2, R3>, R2, R3>
+{
+	public TheoryData_R2_And()
+	{
+		//nested result should be unwrapped
+		Add(
+			result => result.And((_, _) => R1.Success(O.C)),
+			(O.A, O.B),
+			(O.A, O.B, O.C)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.And((_, _) => R1.Success(O.C)),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		//and should return error from nested result
+		Add(
+			result => result.And<O, O, O>((_, _) => Errors.ErrorB),
+			(O.A, O.B),
+			Errors.ErrorB
+		);
+	}
+}
diff --git a/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_TaskOfR1_And.cs b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_TaskOfR1_And.cs
new file mode 100644
index 0000000..76b74c6
--- /dev/null
+++ b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_TaskOfR1_And.cs
@@ -0,0 +1,62 @@
+namespace RailwayResult.FunctionalExtensions.Tests.AndTests;
+
+public sealed class TheoryData_TaskOfR1_And : TheoryData<Func<Task<R1>, Task<R2>>, R1, R2>
+{
+	public TheoryData_TaskOfR1_And()
+	{
+		Add(
+			result => result.And(() => O.B),
+			O.A,
+			(O.A, O.B)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.And(() => O.B),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		//nested result should be unwrapped
+		Add(
+			result => result.And(() => R1.Success(O.B)),
+			O.A,
+			(O.A, O.B)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.And(() => R1.Success(O.B)),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		//and should return error from nested result
+		Add(
+			result => result.And<O, O>(() => Errors.ErrorB),
+			O.A,
+			Errors.ErrorB
+		);
+
+		//nested result should be unwrapped
+		Add(
+			result => result.And(_ => R1.Success(O.B)),
+			O.A,
+			(O.A, O.B)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.And(_ => R1.Success(O.B)),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		//and should return error from nested result
+		Add(
+			result => result.And<O, O>(_ => Errors.ErrorB),
+			O.A,
+			Errors.ErrorB
+		);
+	}
+}
diff --git a/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_TaskOfR2_And.cs b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_TaskOfR2_And.cs
new file mode 100644
index 0000000..9a5604f
--- /dev/null
+++ b/tests/RailwayResult.FunctionalExtensions.Tests/AndTests/TheoryData_TaskOfR2_And.cs
@@ -0,0 +1,28 @@
+namespace RailwayResult.FunctionalExtensions.Tests.AndTests;
+
+public sealed class TheoryData_TaskOfR2_And : TheoryData<Func<Task<R2>, Task<R3>>, R2, R3>
+{
+	public TheoryData_TaskOfR2_And()
+	{
+		//nested result should be unwrapped
+		Add(
+			result => result.And((_, _) => R1.Success(O.C)),
+			(O.A, O.B),
+			(O.A, O.B, O.C)
+		);
+
+		//and should return input failure result
+		Add(
+			result => result.And((_, _) => R1.Success(O.C)),
+			Errors.ErrorA,
+			Errors.ErrorA
+		);
+
+		//and should return error from nested result
+		Add(
+			result => result.And<O, O, O>((_, _) => Errors.ErrorB),
+			(O.A, O.B),
+			Errors.ErrorB
+		);
+	}
+}
diff --git a/tests/RailwayResult.FunctionalExtensions.Tests/GlobalUsings.cs b/tests/RailwayResult.FunctionalExtensions.Tests/GlobalUsings.cs
index 5b81e1d..8067fa1 100644
--- a/tests/RailwayResult.FunctionalExtensions.Tests/GlobalUsings.cs
+++ b/tests/RailwayResult.FunctionalExtensions.Tests/GlobalUsings.cs
@@ -7,3 +7,4 @@
 global using R1N = RailwayResult.Result<RailwayResult.FunctionalExtensions.Tests.Obj?>;
 global using R2 = RailwayResult.Result<(RailwayResult.FunctionalExtensions.Tests.Obj, RailwayResult.FunctionalExtensions.Tests.Obj)>;
 global using R2N = RailwayResult.Result<(RailwayResult.FunctionalExtensions.Tests.Obj?, RailwayResult.FunctionalExtensions.Tests.Obj?)>;
+global using R3 = RailwayResult.Result<(RailwayResult.FunctionalExtensions.Tests.Obj, RailwayResult.FunctionalExtensions.Tests.Obj, RailwayResult.FunctionalExtensions.Tests.Obj)>;
diff --git a/tests/RailwayResult.FunctionalExtensions.Tests/Obj.cs b/tests/RailwayResult.FunctionalExtensions.Tests/Obj.cs
index 8c72db4..5d9d142 100644
--- a/tests/RailwayResult.FunctionalExtensions.Tests/Obj.cs
+++ b/tests/RailwayResult.FunctionalExtensions.Tests/Obj.cs
@@ -6,4 +6,7 @@ public sealed record Obj(string? Value)
 
 	public static readonly O Null = new(null);
 	public static readonly O Empty = new(string.Empty);
+	public static readonly O A = new("A");
+	public static readonly O B = new("B");
+	public static readonly O C = new("C");
 }