Add Tap* extensions to Maybe

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Left.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_Task_Left : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_Task_Left_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.AsTask().TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.Right.cs

@@ -0,0 +1,26 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_Task_Right : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_Task_Right_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.TapNoValue(() =>
+            {
+                property = "Some value";
+                return Task.CompletedTask;
+            });
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.Task.cs

@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_Task : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_Task_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe
+                .AsTask()
+                .TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Left.cs

@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_ValueTask_Left : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_ValueTask_Left_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.AsValueTask().TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.Right.cs

@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_ValueTask_Right : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_ValueTask_Right_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.TapNoValue(() =>
+            {
+                property = "Some value";
+                return ValueTask.CompletedTask;
+            });
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.ValueTask.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests_ValueTask : MaybeTestBase
+    {
+        [Fact]
+        public async Task TapNoValue_ValueTask_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe
+                .AsValueTask()
+                .TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapNoValueTests.cs

@@ -0,0 +1,21 @@
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapNoValueTests : MaybeTestBase
+    {
+        [Fact]
+        public void TapNoValue_executes_action_when_no_value()
+        {
+            string property = null;
+
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = maybe.TapNoValue(() => property = "Some value");
+
+            property.Should().Be("Some value");
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Left.cs

@@ -0,0 +1,32 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_Task_Left : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_Task_Lef_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe.AsTask().Tap(value => executed = true);
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_Task_Lef_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe.AsTask().Tap(value => value.Should().Be(T.Value));
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.Right.cs

@@ -0,0 +1,40 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_Task_Right : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_Task_Right_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+
+            var returnedMaybe = await maybe.Tap(value =>
+            {
+                maybe = T.Value;
+                return Task.CompletedTask;
+            });
+
+            maybe.HasNoValue.Should().BeTrue();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_Task_Right_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+
+            var returnedMaybe = await maybe.Tap(value =>
+            {
+                value.Should().Be(T.Value);
+                return Task.CompletedTask;
+            });
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.Task.cs

@@ -0,0 +1,44 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_Task : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_Task_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe
+                .AsTask()
+                .Tap(value =>
+                {
+                    executed = true;
+                    return Task.CompletedTask;
+                });
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_Task_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe
+                .AsTask()
+                .Tap(value =>
+                {
+                    value.Should().Be(T.Value);
+                    return Task.CompletedTask;
+                });
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Left.cs

@@ -0,0 +1,33 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_ValueTask_Left : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_ValueTask_Lef_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe.AsValueTask().Tap(value => executed = true);
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_ValueTask_Lef_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe.AsValueTask().Tap(value => value.Should().Be(T.Value));
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}

CSharpFunctionalExtensions.Tests/MaybeTests/Extensions/TapTests.ValueTask.Right.cs

@@ -0,0 +1,41 @@
+using System.Threading.Tasks;
+using CSharpFunctionalExtensions.ValueTasks;
+using FluentAssertions;
+using Xunit;
+
+namespace CSharpFunctionalExtensions.Tests.MaybeTests.Extensions
+{
+    public class TapTests_ValueTask_Right : MaybeTestBase
+    {
+        [Fact]
+        public async Task Tap_ValueTask_Right_does_not_execute_action_if_no_value()
+        {
+            Maybe<T> maybe = null;
+            var executed = false;
+
+            var returnedMaybe = await maybe.Tap(value =>
+            {
+                executed = true;
+                return ValueTask.CompletedTask;
+            });
+
+            executed.Should().BeFalse();
+            returnedMaybe.HasNoValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Tap_ValueTask_Right_executes_action_if_value()
+        {
+            Maybe<T> maybe = T.Value;
+
+            var returnedMaybe = await maybe.Tap(value =>
+            {
+                value.Should().Be(T.Value);
+                return ValueTask.CompletedTask;
+            });
+
+            maybe.Value.Should().Be(T.Value);
+            returnedMaybe.Value.Should().BeSameAs(maybe.Value);
+        }
+    }
+}