Add Single.finallyDo()

Author: artem-zinnatullin

src/main/java/rx/Single.java

@@ -35,6 +35,7 @@
 import rx.internal.operators.OnSubscribeToObservableFuture;
 import rx.internal.operators.OperatorDelay;
 import rx.internal.operators.OperatorDoOnEach;
+import rx.internal.operators.OperatorFinally;
 import rx.internal.operators.OperatorMap;
 import rx.internal.operators.OperatorObserveOn;
 import rx.internal.operators.OperatorOnErrorReturn;
@@ -1946,4 +1947,25 @@ public final Single<T> delay(long delay, TimeUnit unit, Scheduler scheduler) {
     public final Single<T> delay(long delay, TimeUnit unit) {
         return delay(delay, unit, Schedulers.computation());
     }
+
+    /**
+     * Registers an {@link Action0} to be called when this {@link Single} invokes either
+     * {@link SingleSubscriber#onSuccess(Object)}  onSuccess} or {@link SingleSubscriber#onError onError}.
+     * <p>
+     * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/finallyDo.png" alt="">
+     * <dl>
+     *  <dt><b>Scheduler:</b></dt>
+     *  <dd>{@code finallyDo} does not operate by default on a particular {@link Scheduler}.</dd>
+     * </dl>
+     *
+     * @param action
+     *            an {@link Action0} to be invoked when the source {@link Single} finishes.
+     * @return a {@link Single} that emits the same item or error as the source {@link Single}, then invokes the
+     *         {@link Action0}
+     * @see <a href="http://reactivex.io/documentation/operators/do.html">ReactiveX operators documentation: Do</a>
+     */
+    @Experimental
+    public final Single<T> finallyDo(Action0 action) {
+        return lift(new OperatorFinally<T>(action));
+    }
 }

src/test/java/rx/SingleTest.java

@@ -44,7 +44,6 @@
 import rx.schedulers.Schedulers;
 import rx.subscriptions.Subscriptions;
 
-
 public class SingleTest {
 
     @Test
@@ -689,4 +688,55 @@ public void call(SingleSubscriber<? super Integer> singleSubscriber) {
         subscriber.assertNoValues();
         subscriber.assertError(expected);
     }
+
+    @Test
+    public void finallyDoActionShouldBeInvokedAfterOnSuccess() {
+        Action0 finallyAction = mock(Action0.class);
+
+        TestSubscriber<String> testSubscriber = new TestSubscriber<String>();
+
+        Single
+                .just("value")
+                .finallyDo(finallyAction)
+                .subscribe(testSubscriber);
+
+        testSubscriber.assertValue("value");
+        testSubscriber.assertNoErrors();
+
+        verify(finallyAction).call();
+    }
+
+    @Test
+    public void finallyDoActionShouldBeInvokedAfterOnError() {
+        Action0 finallyAction = mock(Action0.class);
+
+        TestSubscriber<Object> testSubscriber = new TestSubscriber<Object>();
+
+        Throwable error = new IllegalStateException();
+
+        Single
+                .error(error)
+                .finallyDo(finallyAction)
+                .subscribe(testSubscriber);
+
+        testSubscriber.assertNoValues();
+        testSubscriber.assertError(error);
+
+        verify(finallyAction).call();
+    }
+
+    @Test
+    public void finallyDoActionShouldNotBeInvokedUntilSubscriberSubscribes() {
+        Action0 finallyAction = mock(Action0.class);
+
+        Single
+                .just("value")
+                .finallyDo(finallyAction);
+
+        Single
+                .error(new IllegalStateException())
+                .finallyDo(finallyAction);
+
+        verifyZeroInteractions(finallyAction);
+    }
 }