Stop passing promise to pop

lib/android/app/src/main/java/com/reactnativenavigation/react/NavigationModule.java

 
 	@ReactMethod
 	public void pop(final String onComponentId, final ReadableMap options, final Promise promise) {
-		handle(() -> navigator().popSpecific(onComponentId, promise));
+		handle(() -> navigator().popSpecific(onComponentId, new CommandListenerAdapter(promise)));
 	}
 
 	@ReactMethod
 	public void popTo(final String componentId, final Promise promise) {
-		handle(() -> navigator().popTo(componentId, promise));
+		handle(() -> navigator().popTo(componentId, new CommandListenerAdapter(promise)));
 	}
 
 	@ReactMethod
 	public void popToRoot(final String componentId, final Promise promise) {
-		handle(() -> navigator().popToRoot(componentId, promise));
+		handle(() -> navigator().popToRoot(componentId, new CommandListenerAdapter(promise)));
 	}
 
 	@ReactMethod
 
 	@ReactMethod
 	public void dismissModal(final String componentId, final Promise promise) {
-		handle(() -> navigator().dismissModal(componentId, promise));
+		handle(() -> navigator().dismissModal(componentId, new CommandListenerAdapter(promise)));
 	}
 
 	@ReactMethod
 	public void dismissAllModals(final Promise promise) {
-		handle(() -> navigator().dismissAllModals(promise));
+		handle(() -> navigator().dismissAllModals(new CommandListenerAdapter(promise)));
 	}
 
 	@ReactMethod

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/ModalStack.java

 import android.support.annotation.Nullable;
 
 import com.facebook.react.bridge.Promise;
-import com.reactnativenavigation.utils.NoOpPromise;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.Task;
+import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
 import com.reactnativenavigation.viewcontrollers.modal.Modal;
 import com.reactnativenavigation.viewcontrollers.modal.ModalCreator;
 import com.reactnativenavigation.viewcontrollers.modal.ModalListener;
         promise.resolve(viewController.getId());
     }
 
-    void dismissModal(final String componentId, Promise promise) {
-        applyOnModal(componentId, (modal) -> modal.dismiss(promise), () -> Navigator.rejectPromise(promise));
+    void dismissModal(final String componentId, CommandListener listener) {
+        applyOnModal(componentId, (modal) -> modal.dismiss(listener), () -> listener.onError("Nothing to dismiss"));
     }
 
     void dismissAll() {
-        dismissAll(new NoOpPromise());
+        dismissAll(new CommandListenerAdapter());
     }
 
-    void dismissAll(Promise promise) {
+    void dismissAll(CommandListener listener) {
         for (Modal modal : modals) {
-            modal.dismiss(size() == 1 ? promise : new NoOpPromise());
+            modal.dismiss(size() == 1 ? listener : new CommandListenerAdapter());
         }
         modals.clear();
     }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/Navigator.java

         }
     }
 
-    void pop(final String fromId, Promise promise) {
+    void pop(final String fromId, CommandListener listener) {
         ViewController from = findControllerById(fromId);
         if (from != null) {
-            from.performOnParentStack(stack -> ((StackController) stack).pop(promise));
+            from.performOnParentStack(stack -> ((StackController) stack).pop(listener));
         }
     }
 
-    public void popSpecific(final String id, Promise promise) {
+    public void popSpecific(final String id, CommandListener listener) {
         ViewController from = findControllerById(id);
         if (from != null) {
-            from.performOnParentStack(stack -> ((StackController) stack).popSpecific(from, promise), () -> rejectPromise(promise));
+            from.performOnParentStack(stack -> ((StackController) stack).popSpecific(from, listener), () -> listener.onError("Nothing to pop"));
         } else {
-            rejectPromise(promise);
+            listener.onError("Nothing to pop");
         }
     }
 
-    public void popToRoot(final String id, Promise promise) {
+    public void popToRoot(final String id, CommandListener listener) {
         ViewController from = findControllerById(id);
         if (from != null) {
-            from.performOnParentStack(stack -> ((StackController) stack).popToRoot(promise));
+            from.performOnParentStack(stack -> ((StackController) stack).popToRoot(listener));
         }
     }
 
-    public void popTo(final String componentId, Promise promise) {
+    public void popTo(final String componentId, CommandListener listener) {
         ViewController target = findControllerById(componentId);
         if (target != null) {
-            target.performOnParentStack(stack -> ((StackController) stack).popTo(target, promise), () -> rejectPromise(promise));
+            target.performOnParentStack(stack -> ((StackController) stack).popTo(target, listener), () -> listener.onError("Nothing to pop"));
         } else {
-            rejectPromise(promise);
+            listener.onError("Nothing to pop");
         }
     }
 
         modalStack.showModal(viewController, promise);
     }
 
-    public void dismissModal(final String componentId, Promise promise) {
-        modalStack.dismissModal(componentId, promise);
+    public void dismissModal(final String componentId, CommandListener listener) {
+        modalStack.dismissModal(componentId, listener);
     }
 
     @Override
         }
     }
 
-    public void dismissAllModals(Promise promise) {
-        modalStack.dismissAll(promise);
+    public void dismissAllModals(CommandListener listener) {
+        modalStack.dismissAll(listener);
     }
 
     public void showOverlay(ViewController overlay) {
         overlayManager.dismiss(getView(), componentId);
     }
 
-    static void rejectPromise(Promise promise) {
-        promise.reject(new Throwable("Nothing to pop"));
-    }
-
     @Nullable
     @Override
     public ViewController findControllerById(String id) {

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/StackController.java

 import android.support.v4.view.ViewPager;
 import android.view.View;
 
-import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.anim.NavigationAnimator;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.utils.CommandListenerAdapter;
-import com.reactnativenavigation.utils.NoOpPromise;
 import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 
 public class StackController extends ParentController<StackLayout> {
 
-    private static final NoOpPromise NO_OP = new NoOpPromise();
     private final IdStack<ViewController> stack = new IdStack<>();
     private final NavigationAnimator animator;
     private final ReactViewCreator topBarButtonCreator;
         }
     }
 
-    void pop(final Promise promise) {
+    void pop(CommandListener listener) {
         if (!canPop()) {
-            Navigator.rejectPromise(promise);
+            listener.onError("Nothing to pop");
             return;
         }
 
         final ViewController enteringController = stack.peek();
         popInternal(exitingController, enteringController);
 
-        finishPopping(exitingController.getView(), exitingController, promise);
+        finishPopping(exitingController.getView(), exitingController, listener);
     }
 
-    void animatePop(final Promise promise) {
+    void animatePop(CommandListener listener) {
         if (!canPop()) {
-            Navigator.rejectPromise(promise);
+            listener.onError("Nothing to pop");
             return;
         }
 
         final ViewController enteringController = stack.peek();
         popInternal(exitingController, enteringController);
 
-        animator.animatePop(exitingController.getView(), () -> finishPopping(exitingController.getView(),
-                exitingController, promise));
+        animator.animatePop(
+                exitingController.getView(),
+                () -> finishPopping(exitingController.getView(), exitingController, listener)
+        );
     }
 
     private void popInternal(ViewController disappearing, ViewController appearing) {
         return stack.size() > 1;
     }
 
-    private void finishPopping(View exitingView, ViewController poppedTop, Promise promise) {
+    private void finishPopping(View exitingView, ViewController poppedTop, CommandListener listener) {
         getView().removeView(exitingView);
         poppedTop.destroy();
-        promise.resolve(poppedTop.getId());
+        listener.onSuccess(poppedTop.getId());
     }
 
-    void popSpecific(final ViewController childController, Promise promise) {
+    void popSpecific(final ViewController childController, CommandListener listener) {
         if (stack.isTop(childController.getId())) {
-            animatePop(promise);
+            animatePop(listener);
         } else {
             stack.remove(childController.getId());
             childController.destroy();
-            promise.resolve(childController.getId());
+            listener.onSuccess(childController.getId());
         }
     }
 
-    void popTo(final ViewController viewController, Promise promise) {
+    void popTo(final ViewController viewController, CommandListener listener) {
         if (!stack.containsId(viewController.getId())) {
-            Navigator.rejectPromise(promise);
+            listener.onError("Nothing to pop");
             return;
         }
 
             String nextControlId = iterator.next();
             boolean animate = nextControlId.equals(viewController.getId());
             if (animate) {
-                animatePop(promise);
+                animatePop(listener);
             } else {
-                pop(NO_OP);
+                pop(listener);
             }
             currentControlId = nextControlId;
         }
     }
 
-    void popToRoot(Promise promise) {
+    void popToRoot(CommandListener listener) {
         while (canPop()) {
             boolean animate = stack.size() == 2; // First element is root
             if (animate) {
-                animatePop(promise);
+                animatePop(listener);
             } else {
-                pop(NO_OP);
+                pop(listener);
             }
         }
     }
     @Override
     public boolean handleBack() {
         if (canPop()) {
-            animatePop(NO_OP);
+            animatePop(new CommandListenerAdapter());
             return true;
         }
         return false;

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/modal/Modal.java

 import android.view.KeyEvent;
 import android.view.View;
 
-import com.facebook.react.bridge.Promise;
 import com.reactnativenavigation.R;
 import com.reactnativenavigation.anim.ModalAnimator;
+import com.reactnativenavigation.viewcontrollers.Navigator.CommandListener;
 import com.reactnativenavigation.viewcontrollers.ViewController;
 
 import static android.view.View.MeasureSpec.EXACTLY;
     public final ViewController viewController;
     private final Dialog dialog;
     private ModalListener modalListener;
-    @Nullable private Promise dismissPromise;
+    @Nullable private CommandListener dismissCommandListener;
 
     private ModalAnimator animator;
 
         });
     }
 
-    public void dismiss(Promise promise) {
-        dismissPromise = promise;
+    public void dismiss(CommandListener listener) {
+        dismissCommandListener = listener;
         animator.animateDismiss(viewController.getView(), new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
     @Override
     public void onDismiss(DialogInterface dialog) {
         modalListener.onModalDismiss(this);
-        if (dismissPromise != null) {
-            dismissPromise.resolve(viewController.getId());
+        if (dismissCommandListener != null) {
+            dismissCommandListener.onSuccess(viewController.getId());
         }
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/FloatingActionButtonTest.java

 import android.view.ViewGroup;
 
 import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import com.reactnativenavigation.views.Fab;
         stackController.push(childFab);
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
-        stackController.pop(new MockPromise());
+        stackController.pop(new CommandListenerAdapter());
         childNoFab.onViewAppeared();
         assertThat(hasFab()).isFalse();
     }
         stackController.push(childNoFab);
         childNoFab.onViewAppeared();
         assertThat(hasFab()).isFalse();
-        stackController.pop(new MockPromise());
+        stackController.pop(new CommandListenerAdapter());
         childFab.onViewAppeared();
         assertThat(hasFab()).isTrue();
     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/ModalStackTest.java

 import com.reactnativenavigation.mocks.ModalCreatorMock;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.viewcontrollers.modal.Modal;
 import com.reactnativenavigation.viewcontrollers.modal.ModalListener;
 
     }
 
     @Test
-    public void modalRefIsSaved() throws Exception {
+    public void modalRefIsSaved() {
         uut.showModal(viewController, new MockPromise());
         assertThat(findModal(CONTROLLER_ID)).isNotNull();
     }
 
     @Test
-    public void modalIsShown() throws Exception {
+    public void modalIsShown() {
         uut.showModal(viewController, new MockPromise() {
             @Override
             public void resolve(@Nullable Object value) {
     }
 
     @Test
-    public void modalIsDismissed() throws Exception {
+    public void modalIsDismissed() {
         uut.showModal(viewController, new MockPromise());
         final Modal modal = findModal(CONTROLLER_ID);
         assertThat(modal).isNotNull();
-        uut.dismissModal(CONTROLLER_ID, new MockPromise() {
+        uut.dismissModal(CONTROLLER_ID, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertThat(findModal(CONTROLLER_ID)).isNull();
                 verify(uut, times(1)).onModalDismiss(modal);
             }
     }
 
     @Test
-    public void dismissAllModals() throws Exception {
+    public void dismissAllModals() {
         uut.showModal(new SimpleViewController(newActivity(), "1", new Options()), new MockPromise());
         uut.showModal(new SimpleViewController(newActivity(), "2", new Options()), new MockPromise());
-        uut.dismissAll(new MockPromise() {
+        uut.dismissAll(new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertThat(uut.isEmpty()).isTrue();
             }
         });
     }
 
     @Test
-    public void isEmpty() throws Exception {
+    public void isEmpty() {
         assertThat(uut.isEmpty()).isTrue();
         uut.showModal(viewController, new MockPromise());
         assertThat(uut.isEmpty()).isFalse();
-        uut.dismissAll(new MockPromise());
+        uut.dismissAll(new CommandListenerAdapter());
         assertThat(uut.isEmpty()).isTrue();
     }
 
     @Test
-    public void onDismiss() throws Exception {
+    public void onDismiss() {
         uut.showModal(viewController, new MockPromise());
         uut.showModal(new SimpleViewController(newActivity(), "otherComponent", new Options()), new MockPromise());
-        uut.dismissAll(new MockPromise() {
+        uut.dismissAll(new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 verify(uut, times(2)).onModalDismiss(any());
             }
         });
     }
 
     @Test
-    public void onDismiss_onViewAppearedInvokedOnPreviousModal() throws Exception {
+    public void onDismiss_onViewAppearedInvokedOnPreviousModal() {
         SimpleViewController viewController = spy(new SimpleViewController(newActivity(), "otherComponent", new Options()));
         uut.showModal(viewController, new MockPromise());
         uut.showModal(this.viewController, new MockPromise());
-        uut.dismissModal(CONTROLLER_ID, new MockPromise() {
+        uut.dismissModal(CONTROLLER_ID, new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 verify(viewController, times(1)).onViewAppeared();
             }
         });

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/NavigatorTest.java

 
     @Test
     public void pop_InvalidDoesNothing() {
-        uut.pop("123", new MockPromise());
+        uut.pop("123", new CommandListenerAdapter());
         uut.setRoot(child1, new MockPromise());
-        uut.pop(child1.getId(), new MockPromise());
+        uut.pop(child1.getId(), new CommandListenerAdapter());
         assertThat(uut.getChildControllers()).hasSize(1);
     }
 
                 stack2.push(child4, new CommandListenerAdapter() {
                             @Override
                             public void onSuccess(String childId) {
-                                uut.pop("child4", new MockPromise());
+                                uut.pop("child4", new CommandListenerAdapter());
                                 assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
                             }
                         }
         bottomTabsController.setTabs(Arrays.asList(stack1, stack2));
         uut.setRoot(bottomTabsController, new MockPromise());
 
-        uut.popSpecific(child2.getId(), new MockPromise());
+        uut.popSpecific(child2.getId(), new CommandListenerAdapter());
 
         assertThat(stack2.getChildControllers()).containsOnly(child4, child3);
     }
         stack2.push(child5, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.popTo(child2.getId(), new MockPromise());
+                uut.popTo(child2.getId(), new CommandListenerAdapter());
                 assertThat(stack2.getChildControllers()).containsOnly(child2);
             }
         });
         stack2.push(child5, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.popToRoot(child3.getId(), new MockPromise());
+                uut.popToRoot(child3.getId(), new CommandListenerAdapter());
                 assertThat(stack2.getChildControllers()).containsOnly(child2);
             }
         });
 
     @Test
     public void pop_InvalidDoesNothing_Promise() {
-        uut.pop("123", new MockPromise());
+        uut.pop("123", new CommandListenerAdapter());
         uut.setRoot(child1, new MockPromise());
-        uut.pop(child1.getId(), new MockPromise() {
+        uut.pop(child1.getId(), new CommandListenerAdapter() {
             @Override
-            public void reject(Throwable reason) {
+            public void onError(String reason) {
                 assertThat(uut.getChildControllers()).hasSize(1);
             }
         });
         stack2.push(child4, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.pop("child4", new MockPromise());
+                uut.pop("child4", new CommandListenerAdapter());
                 assertThat(stack2.getChildControllers()).containsOnly(child2, child3);
             }
         });
         child1.ensureViewIsCreated();
         child2.ensureViewIsCreated();
 
-        MockPromise promise = new MockPromise() {
+        Navigator.CommandListener listener = new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertThat(parentController.getChildControllers().size()).isEqualTo(1);
             }
         };
-        uut.popSpecific("child2", promise);
-        verify(parentController, times(1)).popSpecific(child2, promise);
+        uut.popSpecific("child2", listener);
+        verify(parentController, times(1)).popSpecific(child2, listener);
     }
 
     @Test
         uut.showModal(child1, new MockPromise() {
             @Override
             public void resolve(@Nullable Object value) {
-                uut.dismissModal("child1", new MockPromise() {
+                uut.dismissModal("child1", new CommandListenerAdapter() {
                     @Override
-                    public void resolve(@Nullable Object value) {
+                    public void onSuccess(String childId) {
                         verify(parentController, times(1)).onViewRegainedFocus();
                     }
                 });

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/StackControllerTest.java

 
 import com.reactnativenavigation.BaseTest;
 import com.reactnativenavigation.anim.NavigationAnimator;
-import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.mocks.TopBarBackgroundViewCreatorMock;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
 
-import javax.annotation.Nullable;
-
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
             @Override
             public void onSuccess(String childId) {
                 assertContainsOnlyId(child2.getId(), child1.getId());
-                uut.pop(new MockPromise());
+                uut.pop(new CommandListenerAdapter());
                 assertContainsOnlyId(child1.getId());
             }
         });
         uut.push(child2, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.pop(new MockPromise());
+                uut.pop(new CommandListenerAdapter());
                 verify(uut, times(1)).applyChildOptions(uut.options, eq((ReactComponent) child1.getView()));
             }
         });
         uut.push(child2, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.animatePop(new MockPromise() {
+                uut.animatePop(new CommandListenerAdapter() {
                     @Override
-                    public void resolve(@Nullable Object value) {
+                    public void onSuccess(String childId) {
                         verify(stackLayout[0], times(1)).onChildWillDisappear(child2.options, child1.options, () -> {
                         });
                     }
     @Test
     public void popDoesNothingWhenZeroOrOneChild() {
         assertThat(uut.isEmpty()).isTrue();
-        uut.pop(new MockPromise());
+        uut.pop(new CommandListenerAdapter());
         assertThat(uut.isEmpty()).isTrue();
 
         uut.push(child1, new CommandListenerAdapter());
-        uut.pop(new MockPromise());
+        uut.pop(new CommandListenerAdapter());
         assertContainsOnlyId(child1.getId());
     }
 
             public void onSuccess(String childId) {
                 assertIsChildById(uut.getView(), child2View);
                 assertNotChildOf(uut.getView(), child1View);
-                uut.pop(new MockPromise());
+                uut.pop(new CommandListenerAdapter());
                 assertNotChildOf(uut.getView(), child2View);
                 assertIsChildById(uut.getView(), child1View);
             }
         uut.push(child2, new CommandListenerAdapter() {
             @Override
             public void onSuccess(String childId) {
-                uut.popSpecific(child2, new MockPromise() {
+                uut.popSpecific(child2, new CommandListenerAdapter() {
                     @Override
-                    public void resolve(@Nullable Object value) {
+                    public void onSuccess(String childId) {
                         assertContainsOnlyId(child1.getId());
                         assertIsChildById(uut.getView(), child1.getView());
                     }
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
         assertIsChildById(uut.getView(), child2.getView());
-        uut.popSpecific(child1, new MockPromise());
+        uut.popSpecific(child1, new CommandListenerAdapter());
         assertContainsOnlyId(child2.getId());
         assertIsChildById(uut.getView(), child2.getView());
     }
                 assertThat(uut.size()).isEqualTo(3);
                 assertThat(uut.peek()).isEqualTo(child3);
 
-                uut.popTo(child1, new MockPromise());
+                uut.popTo(child1, new CommandListenerAdapter());
 
                 assertThat(uut.size()).isEqualTo(1);
                 assertThat(uut.peek()).isEqualTo(child1);
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child3, new CommandListenerAdapter());
         assertThat(uut.size()).isEqualTo(2);
-        uut.popTo(child2, new MockPromise());
+        uut.popTo(child2, new CommandListenerAdapter());
         assertThat(uut.size()).isEqualTo(2);
     }
 
                 assertThat(uut.size()).isEqualTo(3);
                 assertThat(uut.peek()).isEqualTo(child3);
 
-                uut.popToRoot(new MockPromise() {
+                uut.popToRoot(new CommandListenerAdapter() {
                     @Override
-                    public void resolve(@Nullable Object value) {
+                    public void onSuccess(String childId) {
                         assertThat(uut.size()).isEqualTo(1);
                         assertThat(uut.peek()).isEqualTo(child1);
                     }
     @Test
     public void popToRoot_EmptyStackDoesNothing() {
         assertThat(uut.isEmpty()).isTrue();
-        uut.popToRoot(new MockPromise());
+        uut.popToRoot(new CommandListenerAdapter());
         assertThat(uut.isEmpty()).isTrue();
     }
 
             @Override
             public void onSuccess(String childId) {
                 verify(child3, times(0)).destroy();
-                uut.pop(new MockPromise());
+                uut.pop(new CommandListenerAdapter());
                 verify(child3, times(1)).destroy();
             }
         });
         child2 = spy(child2);
         uut.push(child1, new CommandListenerAdapter());
         uut.push(child2, new CommandListenerAdapter());
-        uut.pop(new MockPromise());
+        uut.pop(new CommandListenerAdapter());
         verify(child1, times(1)).onViewWillAppear();
         verify(child2, times(1)).onViewWillDisappear();
     }
 
         assertThat(uut.getTopBar().getVisibility()).isEqualTo(View.GONE);
         uut.push(child2, new CommandListenerAdapter());
-        uut.animatePop(new MockPromise() {
+        uut.animatePop(new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 verify(uut.getTopBar(), times(1)).hide();
             }
         });
         uut.push(child3, new CommandListenerAdapter());
 
         verify(child2, times(0)).destroy();
-        uut.popSpecific(child2, new MockPromise());
+        uut.popSpecific(child2, new CommandListenerAdapter());
         verify(child2, times(1)).destroy();
     }
 
                 verify(child2, times(0)).destroy();
                 verify(child3, times(0)).destroy();
 
-                uut.popTo(child1, new MockPromise() {
+                uut.popTo(child1, new CommandListenerAdapter() {
                     @Override
-                    public void resolve(@Nullable Object value) {
+                    public void onSuccess(String childId) {
                         verify(child2, times(1)).destroy();
                         verify(child3, times(1)).destroy();
                     }

lib/android/app/src/test/java/com/reactnativenavigation/viewcontrollers/TopTabsViewControllerTest.java

 import android.view.ViewGroup;
 
 import com.reactnativenavigation.BaseTest;
-import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.TestComponentViewCreator;
 import com.reactnativenavigation.mocks.TestReactView;
 import com.reactnativenavigation.mocks.TitleBarReactViewCreatorMock;
 import com.reactnativenavigation.parse.Options;
 import com.reactnativenavigation.parse.params.Bool;
 import com.reactnativenavigation.parse.params.Text;
+import com.reactnativenavigation.utils.CommandListenerAdapter;
 import com.reactnativenavigation.utils.ViewHelper;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarBackgroundViewController;
 import com.reactnativenavigation.viewcontrollers.topbar.TopBarController;
 import java.util.ArrayList;
 import java.util.List;
 
-import javax.annotation.Nullable;
-
 import static org.assertj.core.api.Java6Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
         uut.onViewAppeared();
 
         assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isTrue();
-        stackController.animatePop(new MockPromise() {
+        stackController.animatePop(new CommandListenerAdapter() {
             @Override
-            public void resolve(@Nullable Object value) {
+            public void onSuccess(String childId) {
                 assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isFalse();
             }
         });