Issue-107: Fix IfFulfilled not awaiting full task

src/TaskExtensionsIfFulfilled.cs

@@ -10,53 +10,37 @@ public static partial class TaskExtensions
   /// </summary>
   /// <typeparam name="T">The task's underlying type.</typeparam>
   /// <param name="task">The task.</param>
-  /// <param name="consumer">The action to perform if the task is fulfilled.</param>
+  /// <param name="onFulfilled">The action to perform if the task is fulfilled.</param>
   /// <returns>The task.</returns>
-  public static Task<T> IfFulfilled<T>(this Task<T> task, Action<T> consumer)
-    => task.ResultMap(TaskStatics.Tap(consumer));
+  public static Task<T> IfFulfilled<T>(this Task<T> task, Action<T> onFulfilled)
+    => task.ResultMap(TaskStatics.Tap(onFulfilled));
 
   /// <summary>
   /// Executes a function and throws away the result if the <see name="Task{T}"/> is in a fulfilled state.
   /// </summary>
   /// <typeparam name="T">The task's underlying type.</typeparam>
-  /// <typeparam name="R">The type of the discarded result of <paramref name="func"/>.</typeparam>
+  /// <typeparam name="R">The type of the discarded result of <paramref name="onFulfilled"/>.</typeparam>
   /// <param name="task">The task.</param>
-  /// <param name="func">The function to execute if the task is fulfilled.</param>
+  /// <param name="onFulfilled">The function to execute if the task is fulfilled.</param>
   /// <returns>The task.</returns>
-  public static Task<T> IfFulfilled<T, R>(this Task<T> task, Func<T, Task<R>> func)
+  public static Task<T> IfFulfilled<T, R>(this Task<T> task, Func<T, Task<R>> onFulfilled)
     => task.ContinueWith(continuationTask =>
     {
       if (continuationTask.IsFaulted || continuationTask.IsCanceled)
       {
         return continuationTask;
       }
 
-      return continuationTask.Then(value =>
-      {
-        func(value);
-        return value;
-      });
+      return continuationTask.Then(value => onFulfilled(value).Then(_ => value));
     }).Unwrap();
 
   /// <summary>
   /// Executes a function and throws away the result if the <see name="Task{T}"/> is in a fulfilled state.
   /// </summary>
   /// <typeparam name="T">The task's underlying type.</typeparam>
   /// <param name="task">The task.</param>
-  /// <param name="func">The function to execute if the task is fulfilled.</param>
+  /// <param name="onFulfilled">The function to execute if the task is fulfilled.</param>
   /// <returns>The task.</returns>
-  public static Task<T> IfFulfilled<T>(this Task<T> task, Func<T, Task> func)
-    => task.ContinueWith(continuationTask =>
-    {
-      if (continuationTask.IsFaulted || continuationTask.IsCanceled)
-      {
-        return continuationTask;
-      }
-
-      return continuationTask.Then(async value =>
-      {
-        await func(value);
-        return value;
-      });
-    }).Unwrap();
+  public static Task<T> IfFulfilled<T>(this Task<T> task, Func<T, Task> onFulfilled)
+    => task.IfFulfilled(value => onFulfilled(value).ContinueWith(_ => value));
 }

tests/unit/IfFaulted/WithFullTaskFunc.cs

@@ -23,7 +23,7 @@ public async Task ItShouldPerformASideEffect()
       await Task.FromException<int>(new ArgumentNullException())
         .IfFaulted(onFaulted);
     }
-    catch (ArgumentNullException exception)
+    catch (ArgumentNullException)
     {
     }
 
@@ -154,4 +154,29 @@ public async Task ItShouldResultInAFaultedTaskWithAnException()
 
     await Assert.ThrowsAsync<ArgumentNullException>(() => testTask);
   }
+
+  [Fact]
+  public async Task ItShouldProperlyCaptureTheTask()
+  {
+    int actualValue = 0;
+    int expectedValue = 5;
+    Func<Exception, Task<int>> onFaulted = async _ =>
+    {
+      await Task.Delay(TimeSpan.FromSeconds(1));
+
+      actualValue = 5;
+      return 5;
+    };
+
+    try
+    {
+      await Task.FromException<int>(new ArgumentNullException())
+        .IfFaulted(onFaulted);
+    }
+    catch (ArgumentNullException)
+    {
+    }
+
+    Assert.Equal(expectedValue, actualValue);
+  }
 }

tests/unit/IfFaulted/WithRawTaskFunc.cs

@@ -24,7 +24,7 @@ public async Task ItShouldPerformASideEffect()
       await Task.FromException<int>(new ArgumentNullException())
         .IfFaulted(onFaulted);
     }
-    catch (ArgumentNullException exception)
+    catch (ArgumentNullException)
     {
     }
 
@@ -155,4 +155,28 @@ public async Task ItShouldResultInAFaultedTaskWithAnException()
 
     await Assert.ThrowsAsync<ArgumentNullException>(() => testTask);
   }
+
+  [Fact]
+  public async Task ItShouldProperlyCaptureTheTask()
+  {
+    int actualValue = 0;
+    int expectedValue = 5;
+    Func<Exception, Task> onFaulted = async _ =>
+    {
+      await Task.Delay(TimeSpan.FromSeconds(1));
+
+      actualValue = 5;
+    };
+
+    try
+    {
+      await Task.FromException<int>(new ArgumentNullException())
+        .IfFaulted(onFaulted);
+    }
+    catch (ArgumentNullException)
+    {
+    }
+
+    Assert.Equal(expectedValue, actualValue);
+  }
 }

tests/unit/IfFulfilled/WithFullTaskFunc.cs

@@ -141,4 +141,23 @@ public async Task ItShouldResultInAFaultedTaskWithAnException()
 
     await Assert.ThrowsAsync<ArgumentNullException>(() => testTask);
   }
+
+  [Fact]
+  public async Task ItShouldProperlyCaptureTheTask()
+  {
+    int actualValue = 0;
+    int expectedValue = 5;
+    Func<int, Task<int>> onFulfilled = async _ =>
+    {
+      await Task.Delay(TimeSpan.FromSeconds(1));
+
+      actualValue = 5;
+      return 5;
+    };
+
+    await Task.FromResult(5)
+      .IfFulfilled(onFulfilled);
+
+    Assert.Equal(expectedValue, actualValue);
+  }
 }

tests/unit/IfFulfilled/WithRawTaskFunc.cs

@@ -141,4 +141,22 @@ public async Task ItShouldResultInAFaultedTaskWithAnException()
 
     await Assert.ThrowsAsync<ArgumentNullException>(() => testTask);
   }
+
+  [Fact]
+  public async Task ItShouldProperlyCaptureTheTask()
+  {
+    int actualValue = 0;
+    int expectedValue = 5;
+    Func<int, Task> onFulfilled = async _ =>
+    {
+      await Task.Delay(TimeSpan.FromSeconds(1));
+
+      actualValue = 5;
+    };
+
+    await Task.FromResult(5)
+      .IfFulfilled(onFulfilled);
+
+    Assert.Equal(expectedValue, actualValue);
+  }
 }