BAEL - 1060

Review comments incorporated

rxjava-2/src/test/java/com/baeldung/rxjava/RxJavaHooksUnitTest.java

@@ -1,5 +1,8 @@
 package com.baeldung.rxjava;
 
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
 import org.junit.Test;
 
 import io.reactivex.Completable;
@@ -14,316 +17,289 @@ import io.reactivex.schedulers.Schedulers;
 
 public class RxJavaHooksUnitTest {
 
+    private boolean initHookCalled = false;
+    private boolean hookCalled = false;
+
+    @Test
+    public void givenObservable_whenError_shouldExecuteTheHook() {
+        RxJavaPlugins.setErrorHandler(throwable -> {
+            hookCalled = true;
+        });
+
+        Observable.error(new IllegalStateException())
+            .subscribe();
+        assertTrue(hookCalled);
+    }
+
     @Test
     public void givenCompletable_whenAssembled_shouldExecuteTheHook() {
-        try {
+
-            RxJavaPlugins.setOnCompletableAssembly(completable -> {
+        RxJavaPlugins.setOnCompletableAssembly(completable -> {
-                System.out.println("Assembling Completable");
+            hookCalled = true;
-                return completable;
+            return completable;
-            });
+        });
-            Completable.fromSingle(Single.just(1));
+        Completable.fromSingle(Single.just(1));
-        } finally {
+        assertTrue(hookCalled);
-            RxJavaPlugins.reset();
-        }
     }
 
     @Test
     public void givenCompletable_whenSubscribed_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnCompletableSubscribe((completable, observer) -> {
-                System.out.println("Subscribing to Completable");
-                return observer;
-            });
 
-            Completable.fromSingle(Single.just(1))
+        RxJavaPlugins.setOnCompletableSubscribe((completable, observer) -> {
-                .test(true);
+            hookCalled = true;
-        } finally {
+            return observer;
-            RxJavaPlugins.reset();
+        });
-        }
+
+        Completable.fromSingle(Single.just(1))
+            .test();
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenObservable_whenAssembled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnObservableAssembly(observable -> {
-                System.out.println("Assembling Observable");
-                return observable;
-            });
 
-            Observable.range(1, 10);
+        RxJavaPlugins.setOnObservableAssembly(observable -> {
-        } finally {
+            hookCalled = true;
-            RxJavaPlugins.reset();
+            return observable;
-        }
+        });
+
+        Observable.range(1, 10);
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenObservable_whenSubscribed_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnObservableSubscribe((observable, observer) -> {
-                System.out.println("Suscribing to Observable");
-                return observer;
-            });
 
-            Observable.range(1, 10)
+        RxJavaPlugins.setOnObservableSubscribe((observable, observer) -> {
-                .test(true);
+            hookCalled = true;
-        } finally {
+            return observer;
-            RxJavaPlugins.reset();
+        });
-        }
+
+        Observable.range(1, 10)
+            .test();
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenConnectableObservable_whenAssembled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnConnectableObservableAssembly(connectableObservable -> {
-                System.out.println("Assembling ConnectableObservable");
-                return connectableObservable;
-            });
 
-            ConnectableObservable.range(1, 10)
+        RxJavaPlugins.setOnConnectableObservableAssembly(connectableObservable -> {
-                .publish()
+            hookCalled = true;
-                .connect();
+            return connectableObservable;
-        } finally {
+        });
-            RxJavaPlugins.reset();
+
-        }
+        ConnectableObservable.range(1, 10)
+            .publish()
+            .connect();
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenFlowable_whenAssembled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnFlowableAssembly(flowable -> {
-                System.out.println("Assembling Flowable");
-                return flowable;
-            });
 
-            Flowable.range(1, 10);
+        RxJavaPlugins.setOnFlowableAssembly(flowable -> {
-        } finally {
+            hookCalled = true;
-            RxJavaPlugins.reset();
+            return flowable;
-        }
+        });
+
+        Flowable.range(1, 10);
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenFlowable_whenSubscribed_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnFlowableSubscribe((flowable, observer) -> {
-                System.out.println("Suscribing to Flowable");
-                return observer;
-            });
 
-            Flowable.range(1, 10)
+        RxJavaPlugins.setOnFlowableSubscribe((flowable, observer) -> {
-                .test();
+            hookCalled = true;
-        } finally {
+            return observer;
-            RxJavaPlugins.reset();
+        });
-        }
+
+        Flowable.range(1, 10)
+            .test();
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenConnectableFlowable_whenAssembled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnConnectableFlowableAssembly(connectableFlowable -> {
-                System.out.println("Assembling ConnectableFlowable");
-                return connectableFlowable;
-            });
 
-            ConnectableFlowable.range(1, 10)
+        RxJavaPlugins.setOnConnectableFlowableAssembly(connectableFlowable -> {
-                .publish()
+            hookCalled = true;
-                .connect();
+            return connectableFlowable;
-        } finally {
+        });
-            RxJavaPlugins.reset();
+
-        }
+        ConnectableFlowable.range(1, 10)
+            .publish()
+            .connect();
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenParallel_whenAssembled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnParallelAssembly(parallelFlowable -> {
-                System.out.println("Assembling ParallelFlowable");
-                return parallelFlowable;
-            });
 
-            Flowable.range(1, 10)
+        RxJavaPlugins.setOnParallelAssembly(parallelFlowable -> {
-                .parallel();
+            hookCalled = true;
-        } finally {
+            return parallelFlowable;
-            RxJavaPlugins.reset();
+        });
-        }
+
+        Flowable.range(1, 10)
+            .parallel();
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenMaybe_whenAssembled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnMaybeAssembly(maybe -> {
-                System.out.println("Assembling Maybe");
-                return maybe;
-            });
 
-            Maybe.just(1);
+        RxJavaPlugins.setOnMaybeAssembly(maybe -> {
-        } finally {
+            hookCalled = true;
-            RxJavaPlugins.reset();
+            return maybe;
-        }
+        });
+
+        Maybe.just(1);
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenMaybe_whenSubscribed_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnMaybeSubscribe((maybe, observer) -> {
-                System.out.println("Suscribing to Maybe");
-                return observer;
-            });
 
-            Maybe.just(1)
+        RxJavaPlugins.setOnMaybeSubscribe((maybe, observer) -> {
-                .test();
+            hookCalled = true;
-        } finally {
+            return observer;
-            RxJavaPlugins.reset();
+        });
-        }
+
+        Maybe.just(1)
+            .test();
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenSingle_whenAssembled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setOnSingleAssembly(single -> {
-                System.out.println("Assembling Single");
-                return single;
-            });
 
-            Single.just(1);
+        RxJavaPlugins.setOnSingleAssembly(single -> {
-        } finally {
+            hookCalled = true;
-            RxJavaPlugins.reset();
+            return single;
-        }
+        });
+
+        Single.just(1);
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenSingle_whenSubscribed_shouldExecuteTheHook() {
 
-        try {
+        RxJavaPlugins.setOnSingleSubscribe((single, observer) -> {
-            RxJavaPlugins.setOnSingleSubscribe((single, observer) -> {
+            hookCalled = true;
-                System.out.println("Suscribing to Single");
+            return observer;
-                return observer;
+        });
-            });
 
-            Single.just(1)
+        Single.just(1)
-                .test();
+            .test();
-        } finally {
+        assertTrue(hookCalled);
-            RxJavaPlugins.reset();
-        }
     }
 
     @Test
     public void givenAnyScheduler_whenCalled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setScheduleHandler((runnable) -> {
-                System.out.println("Executing Scheduler");
-                return runnable;
-            });
 
-            Observable.range(1, 10)
+        RxJavaPlugins.setScheduleHandler((runnable) -> {
-                .map(v -> v * 2)
+            hookCalled = true;
-                .subscribeOn(Schedulers.single())
+            return runnable;
-                .test();
+        });
 
-            Observable.range(1, 10)
+        Observable.range(1, 10)
-                .map(v -> v * 2)
+            .map(v -> v * 2)
-                .subscribeOn(Schedulers.computation())
+            .subscribeOn(Schedulers.single())
-                .test();
+            .test();
-        } finally {
+        hookCalled = false;
-            RxJavaPlugins.reset();
+        Observable.range(1, 10)
-        }
+            .map(v -> v * 2)
+            .subscribeOn(Schedulers.computation())
+            .test();
+        assertTrue(hookCalled);
     }
 
     @Test
     public void givenComputationScheduler_whenCalled_shouldExecuteTheHooks() {
-        try {
-            RxJavaPlugins.setInitComputationSchedulerHandler((scheduler) -> {
-                System.out.println("Initializing Computation Scheduler");
-                return scheduler.call();
-            });
-            RxJavaPlugins.setComputationSchedulerHandler((scheduler) -> {
-                System.out.println("Executing Computation Scheduler");
-                return scheduler;
-            });
 
-            Observable.range(1, 10)
+        RxJavaPlugins.setInitComputationSchedulerHandler((scheduler) -> {
-                .map(v -> v * 2)
+            initHookCalled = true;
-                .subscribeOn(Schedulers.computation())
+            return scheduler.call();
-                .test();
+        });
-        } finally {
+        RxJavaPlugins.setComputationSchedulerHandler((scheduler) -> {
-            RxJavaPlugins.reset();
+            hookCalled = true;
-        }
+            return scheduler;
+        });
+
+        Observable.range(1, 10)
+            .map(v -> v * 2)
+            .subscribeOn(Schedulers.computation())
+            .test();
+        assertTrue(hookCalled && initHookCalled);
     }
 
     @Test
     public void givenIOScheduler_whenCalled_shouldExecuteTheHooks() {
-        try {
-            RxJavaPlugins.setInitIoSchedulerHandler((scheduler) -> {
-                System.out.println("Initializing IO Scheduler");
-                return scheduler.call();
-            });
 
-            RxJavaPlugins.setIoSchedulerHandler((scheduler) -> {
+        RxJavaPlugins.setInitIoSchedulerHandler((scheduler) -> {
-                System.out.println("Executing IO Scheduler");
+            initHookCalled = true;
-                return scheduler;
+            return scheduler.call();
-            });
+        });
 
-            Observable.range(1, 10)
+        RxJavaPlugins.setIoSchedulerHandler((scheduler) -> {
-                .map(v -> v * 2)
+            hookCalled = true;
-                .subscribeOn(Schedulers.io())
+            return scheduler;
-                .test();
+        });
-        } finally {
+
-            RxJavaPlugins.reset();
+        Observable.range(1, 10)
-        }
+            .map(v -> v * 2)
+            .subscribeOn(Schedulers.io())
+            .test();
+        assertTrue(hookCalled && initHookCalled);
     }
 
     @Test
     public void givenNewThreadScheduler_whenCalled_shouldExecuteTheHook() {
-        try {
-            RxJavaPlugins.setInitNewThreadSchedulerHandler((scheduler) -> {
-                System.out.println("Initializing newThread Scheduler");
-                return scheduler.call();
-            });
 
-            RxJavaPlugins.setNewThreadSchedulerHandler((scheduler) -> {
+        RxJavaPlugins.setInitNewThreadSchedulerHandler((scheduler) -> {
-                System.out.println("Executing newThread Scheduler");
+            initHookCalled = true;
-                return scheduler;
+            return scheduler.call();
-            });
+        });
 
-            Observable.range(1, 15)
+        RxJavaPlugins.setNewThreadSchedulerHandler((scheduler) -> {
-                .map(v -> v * 2)
+            hookCalled = true;
-                .subscribeOn(Schedulers.newThread())
+            return scheduler;
-                .test();
+        });
 
-        } finally {
+        Observable.range(1, 15)
-            RxJavaPlugins.reset();
+            .map(v -> v * 2)
-        }
+            .subscribeOn(Schedulers.newThread())
+            .test();
+        assertTrue(hookCalled && initHookCalled);
     }
 
     @Test
     public void givenSingleScheduler_whenCalled_shouldExecuteTheHooks() {
-        try {
-            RxJavaPlugins.setInitSingleSchedulerHandler((scheduler) -> {
-                System.out.println("Initializing Single Scheduler");
-                return scheduler.call();
-            });
 
-            RxJavaPlugins.setSingleSchedulerHandler((scheduler) -> {
+        RxJavaPlugins.setInitSingleSchedulerHandler((scheduler) -> {
-                System.out.println("Executing Single Scheduler");
+            initHookCalled = true;
-                return scheduler;
+            return scheduler.call();
-            });
-
-            Observable.range(1, 10)
-                .map(v -> v * 2)
-                .subscribeOn(Schedulers.single())
-                .test();
-
-        } finally {
-            RxJavaPlugins.reset();
-        }
-    }
-
-    @Test
-    public void givenObservable_whenError_shouldExecuteTheHook() {
-        RxJavaPlugins.setErrorHandler(throwable -> {
-            System.out.println("Handling error" + throwable.getCause());
         });
 
-        Observable.error(new IllegalStateException())
+        RxJavaPlugins.setSingleSchedulerHandler((scheduler) -> {
-            .subscribe();
+            hookCalled = true;
+            return scheduler;
+        });
+
+        Observable.range(1, 10)
+            .map(v -> v * 2)
+            .subscribeOn(Schedulers.single())
+            .test();
+        assertTrue(hookCalled && initHookCalled);
+
+    }
+
+    @After
+    public void reset() {
+        initHookCalled = false;
+        hookCalled = false;
+        RxJavaPlugins.reset();
     }
 }