Add Single.finallyDo()

Author: artem-zinnatullin

src/main/java/rx/Single.java

@@ -21,6 +21,7 @@
 import rx.annotations.Experimental;
 import rx.exceptions.Exceptions;
 import rx.exceptions.OnErrorNotImplementedException;
+import rx.functions.Action0;
 import rx.functions.Action1;
 import rx.functions.Func1;
 import rx.functions.Func2;
@@ -33,6 +34,7 @@
 import rx.functions.Func9;
 import rx.internal.operators.OnSubscribeToObservableFuture;
 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;
@@ -1898,4 +1900,25 @@ public void onNext(T t) {
 
         return lift(new OperatorDoOnEach<T>(observer));
     }
+
+    /**
+     * 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

@@ -648,4 +648,55 @@ public void doOnSuccessShouldNotSwallowExceptionThrownByAction() {
 
         verify(action).call(eq("value"));
     }
+
+    @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);
+    }
 }