New async extensions

src/Optional.Async.Tests/AsyncEitherTests.cs

@@ -1,10 +1,80 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Threading.Tasks;
 
 namespace Optional.Async.Tests
 {
     [TestClass]
     public class AsyncEitherTests
     {
+        [TestMethod]
+        public async Task AsyncEither_SomeNotNullAsync()
+        {
+            // Arrange
+            var task = Task.FromResult<object>(null);
+            var exception = "A truly exceptional string :)";
+
+            // Act
+            var result = await task.SomeNotNullAsync(exception);
+
+            // Assert
+            var expectedResult = (await task).SomeNotNull(exception);
+
+            result.Should().Be(expectedResult);
+        }
+
+        [TestMethod]
+        public async Task AsyncEither_SomeWhenAsync()
+        {
+            // Arrange
+            var value = ValueGenerator.RandomString();
+            var task = Task.FromResult(value);
+
+            Func<string, bool> predicate = s => s == "This should definitely return false";
+            var error = "Error";
+
+            // Act
+            var result = await task.SomeWhenAsync(predicate, error);
+
+            // Assert
+            var expectedResult = (await task).SomeWhen(predicate, error);
+
+            result.Should().Be(expectedResult);
+        }
+
+        [TestMethod]
+        public async Task AsyncEither_SomeWhenAsync_With_ExceptionFactory()
+        {
+            // Arrange
+            var value = ValueGenerator.RandomString();
+            var task = Task.FromResult(value);
+
+            Func<string, bool> predicate = s => s == "This should definitely return false";
+            Func<string, int> exceptionFactory = _ => 10;
+
+            // Act
+            var result = await task.SomeWhenAsync(predicate, exceptionFactory);
+
+            // Assert
+            var expectedResult = (await task).SomeWhen(predicate, exceptionFactory);
+
+            result.Should().Be(expectedResult);
+        }
+
+        [TestMethod]
+        public async Task AsyncEither_ToAsync()
+        {
+            // Arrange
+            var option = 10.Some<int, string>();
+
+            // Act
+            var result = option.ToAsync();
+
+            // Assert
+            (await result).Should().Be(option);
+        }
+
         [TestMethod]
         public void AsyncEither_MapAsync()
         {

src/Optional.Async.Tests/AsyncMaybeTests.cs

@@ -1,6 +1,7 @@
 using FluentAssertions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Optional.Unsafe;
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -9,6 +10,89 @@ namespace Optional.Async.Tests
     [TestClass]
     public class AsyncMaybeTests
     {
+        [TestMethod]
+        public async Task AsyncMaybe_ToAsync()
+        {
+            // Arrange
+            var option = 10.Some();
+
+            // Act
+            var result = option.ToAsync();
+
+            // Assert
+            (await result).Should().Be(option);
+        }
+
+        [TestMethod]
+        public async Task AsyncMaybe_FlatMapAsync_To_Exceptional()
+        {
+            // Arrange
+            var option = Option.None<int>();
+            var exceptionalOption = Option.None<int, string>(ValueGenerator.RandomString());
+            var error = "Error";
+
+            // Act
+            var result = await option.FlatMapAsync(_ => Task.FromResult(exceptionalOption), error);
+
+            // Assert
+            var expected = Option.None<int, string>(error);
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public async Task AsyncMaybe_FilterAsync_Should_Return_Exception()
+        {
+            // Arrange
+            var optionTask = ValueGenerator.DelayedSome(10);
+
+            Func<int, Task<bool>> predicate = _ => Task.FromResult(false);
+            var exception = "Error";
+
+            // Act
+            var result = await optionTask.FilterAsync(predicate, exception);
+
+            // Assert
+            var expected = Option.None<int, string>(exception);
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public async Task AsyncMaybe_FilterAsync_Should_Return_Value()
+        {
+            // Arrange
+            var value = 10;
+            var optionTask = ValueGenerator.DelayedSome(value);
+
+            Func<int, Task<bool>> predicate = _ => Task.FromResult(true);
+            var exception = "Error";
+
+            // Act
+            var result = await optionTask.FilterAsync(predicate, exception);
+
+            // Assert
+            var expected = Option.Some<int, string>(value);
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public async Task AsyncMaybe_SomeNotNull()
+        {
+            // Arrange
+            object nullObject = null;
+            var nullTask = Task.FromResult(nullObject);
+
+            // Act
+            var result = await nullTask.SomeNotNullAsync();
+
+            // Assert
+            var expected = nullObject.SomeNotNull();
+
+            result.Should().Be(expected);
+        }
+
         [TestMethod]
         public async Task AsyncMaybe_CanMapAsync()
         {

src/Optional.Async.Tests/ValueGenerator.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 
 namespace Optional.Async.Tests
 {
@@ -10,6 +11,10 @@ public static async Task<T> DelayedValue<T>(T value)
             return value;
         }
 
+        public static string RandomString() => Guid.NewGuid().ToString();
+        public static Func<T, Task<TResult>> AsyncOperation<T, TResult>(TResult result) => _ => Task.FromResult(result);
+        public static Func<T, TResult> SynchronousOperation<T, TResult>(TResult result) => _ => result;
+
         public static Task<Option<T>> DelayedSome<T>(T value) => DelayedValue(value.Some());
         public static Task<Option<T, TException>> DelayedSome<T, TException>(T value) => DelayedValue(value.Some<T, TException>());