react-native-navigation 8.4.3 → 8.5.0

package/android/src/test/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsViewControllerTest.java

@@ -0,0 +1,250 @@
+package com.reactnativenavigation.viewcontrollers.toptabs;
+
+import android.app.Activity;
+import android.view.ViewGroup;
+
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.TestUtils;
+import com.reactnativenavigation.mocks.SimpleViewController;
+import com.reactnativenavigation.mocks.TestComponentViewCreator;
+import com.reactnativenavigation.mocks.TestReactView;
+import com.reactnativenavigation.options.Options;
+import com.reactnativenavigation.options.params.Bool;
+import com.reactnativenavigation.options.params.Text;
+import com.reactnativenavigation.viewcontrollers.component.ComponentPresenter;
+import com.reactnativenavigation.viewcontrollers.viewcontroller.Presenter;
+import com.reactnativenavigation.react.events.ComponentType;
+import com.reactnativenavigation.react.CommandListenerAdapter;
+import com.reactnativenavigation.utils.ViewHelper;
+import com.reactnativenavigation.viewcontrollers.viewcontroller.IReactView;
+import com.reactnativenavigation.viewcontrollers.child.ChildControllersRegistry;
+import com.reactnativenavigation.viewcontrollers.component.ComponentViewController;
+import com.reactnativenavigation.viewcontrollers.stack.StackController;
+import com.reactnativenavigation.viewcontrollers.viewcontroller.ViewController;
+import com.reactnativenavigation.views.toptabs.TopTabsLayoutCreator;
+import com.reactnativenavigation.views.toptabs.TopTabsViewPager;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+@Ignore("New architecture - WIP")
+public class TopTabsViewControllerTest extends BaseTest {
+    private static final int SIZE = 2;
+
+    private StackController stack;
+    private TopTabsController uut;
+    private List<ViewController<?>> tabControllers = new ArrayList<>(SIZE);
+    private final Options options = new Options();
+    private TopTabsViewPager topTabsLayout;
+    private Activity activity;
+    private ChildControllersRegistry childRegistry;
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+
+        activity = newActivity();
+        childRegistry = new ChildControllersRegistry();
+        List<Options> tabOptions = createOptions();
+        tabControllers = createTabsControllers(activity, tabOptions);
+
+        topTabsLayout = spy(new TopTabsViewPager(activity, tabControllers, new TopTabsAdapter(tabControllers)));
+        TopTabsLayoutCreator layoutCreator = Mockito.mock(TopTabsLayoutCreator.class);
+        Mockito.when(layoutCreator.create()).thenReturn(topTabsLayout);
+        Presenter presenter = new Presenter(activity, new Options());
+        options.topBar.buttons.back.visible = new Bool(false);
+        uut = spy(new TopTabsController(activity, childRegistry, "componentId", tabControllers, layoutCreator, options, presenter));
+        tabControllers.forEach(viewController -> viewController.setParentController(uut));
+
+        stack = spy(TestUtils.newStackController(activity).build());
+        stack.ensureViewIsCreated();
+    }
+
+    @NonNull
+    private ArrayList<Options> createOptions() {
+        ArrayList<Options> result = new ArrayList<>();
+        for (int i = 0; i < SIZE; i++) {
+            final Options options = new Options();
+            options.topTabOptions.title = new Text("Tab " + i);
+            options.topBar.title.text = new Text(createTabTopBarTitle(i));
+            result.add(options);
+        }
+        return result;
+    }
+
+    private List<ViewController<?>> createTabsControllers(Activity activity, List<Options> tabOptions) {
+        List<ViewController<?>> tabControllers = new ArrayList<>(SIZE);
+        for (int i = 0; i < SIZE; i++) {
+            ComponentViewController viewController = new ComponentViewController(
+                    activity,
+                    childRegistry,
+                    "idTab" + i,
+                    "theComponentName",
+                    new TestComponentViewCreator(),
+                    tabOptions.get(i),
+                    new Presenter(activity, new Options()),
+                    new ComponentPresenter(Options.EMPTY)
+            );
+            tabControllers.add(spy(viewController));
+        }
+        return tabControllers;
+    }
+
+    @Test
+    public void createsViewFromComponentViewCreator() {
+        uut.ensureViewIsCreated();
+        for (int i = 0; i < SIZE; i++) {
+            verify(tabControllers.get(i), times(1)).createView();
+        }
+    }
+
+    @Test
+    public void componentViewDestroyedOnDestroy() {
+        uut.ensureViewIsCreated();
+        TopTabsViewPager topTabs = uut.getView();
+        for (int i = 0; i < SIZE; i++) {
+            verify(tab(topTabs, i), times(0)).destroy();
+        }
+        uut.destroy();
+        for (ViewController<?> tabController : tabControllers) {
+            verify(tabController, times(1)).destroy();
+        }
+    }
+
+    @Test
+    @Ignore("TopTabs not yet well supported")
+    public void lifecycleMethodsSentWhenSelectedTabChanges() {
+        stack.ensureViewIsCreated();
+        uut.ensureViewIsCreated();
+        tabControllers.get(0).ensureViewIsCreated();
+        tabControllers.get(1).ensureViewIsCreated();
+
+        TestReactView initialTab = getActualTabView(0);
+        TestReactView selectedTab = getActualTabView(1);
+
+        uut.switchToTab(1);
+        verify(initialTab, times(1)).sendComponentStop(ComponentType.Component);
+        verify(selectedTab, times(1)).sendComponentWillStart(ComponentType.Component);
+        verify(selectedTab, times(1)).sendComponentStart(ComponentType.Component);
+        verify(selectedTab, times(0)).sendComponentStop(ComponentType.Component);
+    }
+
+    @Test
+    public void lifecycleMethodsSentWhenSelectedPreviouslySelectedTab() {
+        stack.ensureViewIsCreated();
+        uut.ensureViewIsCreated();
+        uut.onViewDidAppear();
+        uut.switchToTab(1);
+        uut.switchToTab(0);
+
+        verify(getActualTabView(0), times(1)).sendComponentStop(ComponentType.Component);
+        verify(getActualTabView(0), times(2)).sendComponentWillStart(ComponentType.Component);
+        verify(getActualTabView(0), times(2)).sendComponentStart(ComponentType.Component);
+        verify(getActualTabView(1), times(1)).sendComponentStart(ComponentType.Component);
+        verify(getActualTabView(1), times(1)).sendComponentStop(ComponentType.Component);
+    }
+
+    @Test
+    public void setOptionsOfInitialTab() {
+        stack.ensureViewIsCreated();
+        uut.ensureViewIsCreated();
+        uut.onViewWillAppear();
+        verify(tabControllers.get(0), times(1)).onViewWillAppear();
+        verify(tabControllers.get(1), times(0)).onViewWillAppear();
+
+        ViewController<?> comp = tabControllers.get(0);
+        verify(uut, times(1)).applyChildOptions(any(Options.class), eq(comp));
+    }
+
+    @Test
+    public void setOptionsWhenTabChanges() {
+        stack.ensureViewIsCreated();
+        uut.ensureViewIsCreated();
+        tabControllers.get(0).ensureViewIsCreated();
+        tabControllers.get(1).ensureViewIsCreated();
+
+        uut.onViewWillAppear();
+        ViewController<?> currentTab = tab(0);
+        verify(uut, times(1)).applyChildOptions(any(Options.class), eq(currentTab));
+        assertThat(uut.options.topBar.title.text.get()).isEqualTo(createTabTopBarTitle(0));
+
+        uut.switchToTab(1);
+        currentTab = tab(1);
+        verify(uut, times(1)).applyChildOptions(any(Options.class), eq(currentTab));
+        assertThat(uut.options.topBar.title.text.get()).isEqualTo(createTabTopBarTitle(1));
+
+        uut.switchToTab(0);
+        currentTab = tab(0);
+        verify(uut, times(2)).applyChildOptions(any(Options.class), eq(currentTab));
+        assertThat(uut.options.topBar.title.text.get()).isEqualTo(createTabTopBarTitle(0));
+    }
+
+    private TestReactView getActualTabView(int index) {
+        return (TestReactView) tabControllers.get(index).getView().getChildAt(0);
+    }
+
+    @Test
+    public void appliesOptionsOnLayoutWhenVisible() {
+        tabControllers.get(0).ensureViewIsCreated();
+        stack.ensureViewIsCreated();
+        uut.ensureViewIsCreated();
+
+        uut.onViewWillAppear();
+
+        verify(topTabsLayout, times(1)).applyOptions(any(Options.class));
+    }
+
+    @Test
+    public void applyOptions_tabsAreRemovedAfterViewDisappears() {
+        StackController stackController = TestUtils.newStackController(activity).build();
+        stackController.ensureViewIsCreated();
+        ViewController<?> first = new SimpleViewController(activity, childRegistry, "first", Options.EMPTY);
+        disablePushAnimation(first, uut);
+        stackController.push(first, new CommandListenerAdapter());
+        stackController.push(uut, new CommandListenerAdapter());
+
+        uut.onViewWillAppear();
+
+        assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isTrue();
+        disablePopAnimation(uut);
+        stackController.pop(Options.EMPTY, new CommandListenerAdapter());
+
+        first.onViewWillAppear();
+
+        assertThat(ViewHelper.isVisible(stackController.getTopBar().getTopTabs())).isFalse();
+    }
+
+    @Test
+    public void onNavigationButtonPressInvokedOnCurrentTab() {
+        uut.ensureViewIsCreated();
+        uut.onViewWillAppear();
+        uut.switchToTab(1);
+        uut.sendOnNavigationButtonPressed("btn1");
+        verify(tabControllers.get(1), times(1)).sendOnNavigationButtonPressed("btn1");
+    }
+
+    private IReactView tab(TopTabsViewPager topTabs, final int index) {
+        return (IReactView) ((ViewGroup) topTabs.getChildAt(index)).getChildAt(0);
+    }
+
+    private String createTabTopBarTitle(int i) {
+        return "Title " + i;
+    }
+
+    private ViewController<?> tab(int index) {
+        return tabControllers.get(index);
+    }
+}

package/android/src/test/java/com/reactnativenavigation/viewcontrollers/viewcontroller/ViewControllerTest.java

@@ -0,0 +1,356 @@
+package com.reactnativenavigation.viewcontrollers.viewcontroller;
+
+import android.app.Activity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+
+import com.reactnativenavigation.BaseTest;
+import com.reactnativenavigation.TestUtils;
+import com.reactnativenavigation.mocks.Mocks;
+import com.reactnativenavigation.mocks.SimpleViewController;
+import com.reactnativenavigation.options.Options;
+import com.reactnativenavigation.options.params.Bool;
+import com.reactnativenavigation.options.params.NullBool;
+import com.reactnativenavigation.react.CommandListenerAdapter;
+import com.reactnativenavigation.utils.Functions;
+import com.reactnativenavigation.viewcontrollers.child.ChildControllersRegistry;
+import com.reactnativenavigation.viewcontrollers.parent.ParentController;
+import com.reactnativenavigation.viewcontrollers.stack.StackController;
+import com.reactnativenavigation.viewcontrollers.viewcontroller.overlay.ViewControllerOverlay;
+import com.reactnativenavigation.views.component.Component;
+
+import org.assertj.android.api.Assertions;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.robolectric.Shadows;
+
+import java.lang.reflect.Field;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.withSettings;
+
+@Ignore("New architecture - WIP")
+public class ViewControllerTest extends BaseTest {
+
+    private ViewController uut;
+    private Activity activity;
+    private ChildControllersRegistry childRegistry;
+    private YellowBoxDelegate yellowBoxDelegate;
+    private ParentController<?> mockedParent;
+
+    @Override
+    public void beforeEach() {
+        super.beforeEach();
+        yellowBoxDelegate = Mockito.mock(YellowBoxDelegate.class);
+        activity = newActivity();
+        childRegistry = new ChildControllersRegistry();
+        uut = new SimpleViewController(activity, childRegistry, "uut", new Options());
+        mockedParent = Mocks.INSTANCE.parentController(null);
+        uut.setParentController(mockedParent);
+        Mockito.when(mockedParent.resolveChildOptions(any())).thenReturn(Options.EMPTY);
+    }
+
+    @Test
+    public void topMostParent_shouldReturnSelfWhenNoParent(){
+        assertThat(uut.getTopMostParent()).isEqualTo(mockedParent);
+    }
+
+    @Test
+    public void topMostParent_shouldReturnRootParent(){
+        final ParentController<?> root = Mocks.INSTANCE.parentController(null);
+        final ParentController<?> parent1 = Mocks.INSTANCE.parentController(root);
+        uut.setParentController(parent1);
+        assertThat(uut.getTopMostParent()).isEqualTo(root);
+    }
+
+    @Test
+    public void holdsAView() {
+        assertThat(uut.getView()).isNotNull().isInstanceOf(View.class);
+    }
+
+    @Test
+    public void holdsARefToActivity() {
+        assertThat(uut.getActivity()).isNotNull().isEqualTo(activity);
+    }
+
+    @Test
+    public void canOverrideViewCreation() {
+        final FrameLayout otherView = new FrameLayout(activity);
+        yellowBoxDelegate = spy(new YellowBoxDelegate(activity));
+        ViewController myController = new ViewController(activity, "vc", yellowBoxDelegate, new Options(), new ViewControllerOverlay(activity)) {
+            @Override
+            public FrameLayout createView() {
+                return otherView;
+            }
+
+            @Override
+            public void sendOnNavigationButtonPressed(String buttonId) {
+
+            }
+
+            @Override
+            public String getCurrentComponentName() { return null; }
+        };
+        assertThat(myController.getView()).isEqualTo(otherView);
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Test
+    public void holdsAReferenceToStackControllerOrNull() {
+        uut.setParentController(null);
+
+        assertThat(uut.getParentController()).isNull();
+        StackController nav = TestUtils.newStackController(activity).build();
+        nav.ensureViewIsCreated();
+        nav.push(uut, new CommandListenerAdapter());
+        assertThat(uut.getParentController()).isEqualTo(nav);
+    }
+
+    @Test
+    public void handleBackDefaultFalse() {
+        assertThat(uut.handleBack(new CommandListenerAdapter())).isFalse();
+    }
+
+    @Test
+    public void holdsId() {
+        assertThat(uut.getId()).isEqualTo("uut");
+    }
+
+    @Test
+    public void isSameId() {
+        assertThat(uut.isSameId("")).isFalse();
+        assertThat(uut.isSameId(null)).isFalse();
+        assertThat(uut.isSameId("uut")).isTrue();
+    }
+
+    @Test
+    public void findControllerById_SelfOrNull() {
+        assertThat(uut.findController("456")).isNull();
+        assertThat(uut.findController("uut")).isEqualTo(uut);
+    }
+
+    @Test
+    public void runOnPreDraw() {
+        Functions.Func1<View> task = Mockito.mock(Functions.Func1.class);
+        uut.runOnPreDraw(task);
+        dispatchPreDraw(uut.getView());
+        verify(task).run(uut.getView());
+    }
+
+    @Test
+    public void runOnPreDraw_doesNotInvokeTaskIfControllerIsDestroyed() {
+        Functions.Func1<View> task = Mockito.mock(Functions.Func1.class);
+        uut.runOnPreDraw(task);
+        View view = uut.getView();
+        uut.destroy();
+        dispatchPreDraw(view);
+        verify(task, times(1)).run(view);
+    }
+
+    @Test
+    public void onChildViewAdded_delegatesToYellowBoxDelegate() {
+        ViewGroup child = new FrameLayout(activity);
+        ViewGroup view = new FrameLayout(activity);
+        ViewController vc = new ViewController(activity, "", yellowBoxDelegate, new Options(), new ViewControllerOverlay(activity)) {
+            @Override
+            public ViewGroup createView() {
+                return view;
+            }
+
+            @Override
+            public void sendOnNavigationButtonPressed(String buttonId) {
+
+            }
+
+            @Override
+            public String getCurrentComponentName() { return null; }
+        };
+        vc.onChildViewAdded(view, child);
+        View yellowBox = new View(activity);
+        child.addView(yellowBox);
+        verify(yellowBoxDelegate).onChildViewAdded(child, yellowBox);
+    }
+
+    @Test
+    public void onAppear_WhenShown() {
+        ViewController spy = spy(uut);
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        Assertions.assertThat(spy.getView()).isNotShown();
+        verify(spy, times(0)).onViewWillAppear();
+
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        Assertions.assertThat(spy.getView()).isShown();
+
+        verify(spy, times(1)).onViewWillAppear();
+    }
+
+    @Test
+    public void onAppear_CalledAtMostOnce() {
+        ViewController spy = spy(uut);
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        Assertions.assertThat(spy.getView()).isShown();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+
+        verify(spy, times(1)).onViewWillAppear();
+    }
+
+    @Test
+    public void isViewShown_doesNotCreateView() {
+        assertThat(uut.isViewShown()).isFalse();
+        assertThat(uut.view).isNull();
+    }
+
+    @Test
+    public void onDisappear_WhenNotShown_AfterOnAppearWasCalled() {
+        ViewController spy = spy(uut);
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        Assertions.assertThat(spy.getView()).isShown();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        verify(spy, times(1)).onViewWillAppear();
+        verify(spy, times(0)).onViewDisappear();
+
+        spy.getView().setVisibility(View.GONE);
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        Assertions.assertThat(spy.getView()).isNotShown();
+        verify(spy, times(1)).onViewDisappear();
+    }
+
+    @Test
+    public void onDisappear_CalledAtMostOnce() {
+        ViewController spy = spy(uut);
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        Assertions.assertThat(spy.getView()).isShown();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().setVisibility(View.GONE);
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        verify(spy, times(1)).onViewDisappear();
+    }
+
+    @Test
+    public void onDestroy_RemovesGlobalLayoutListener() throws Exception {
+        new SimpleViewController(activity, childRegistry, "ensureNotNull", new Options()).destroy();
+
+        ViewController spy = spy(uut);
+        View view = spy.getView();
+        Shadows.shadowOf(view).setMyParent(mock(ViewParent.class));
+
+        spy.destroy();
+
+        Assertions.assertThat(view).isShown();
+        view.getViewTreeObserver().dispatchOnGlobalLayout();
+        verify(spy, times(0)).onViewWillAppear();
+        verify(spy, times(0)).onViewDisappear();
+
+        Field field = ViewController.class.getDeclaredField("view");
+        field.setAccessible(true);
+        assertThat(field.get(spy)).isNull();
+    }
+
+    @Test
+    public void onDestroy_CallsOnDisappearIfNeeded() {
+        ViewController spy = spy(uut);
+        Shadows.shadowOf(spy.getView()).setMyParent(mock(ViewParent.class));
+        Assertions.assertThat(spy.getView()).isShown();
+        spy.getView().getViewTreeObserver().dispatchOnGlobalLayout();
+        verify(spy, times(1)).onViewWillAppear();
+
+        spy.destroy();
+
+        verify(spy, times(1)).onViewDisappear();
+    }
+
+    @Test
+    public void onDestroy_destroysViewEvenIfHidden() {
+        final SimpleViewController.SimpleView[] spy = new SimpleViewController.SimpleView[1];
+        ViewController uut = new SimpleViewController(activity, childRegistry, "uut", new Options()) {
+            @Override
+            public SimpleView createView() {
+                SimpleView view = spy(super.createView());
+                spy[0] = view;
+                return view;
+            }
+        };
+        assertThat(uut.isViewShown()).isFalse();
+        uut.destroy();
+        verify(spy[0], times(1)).destroy();
+    }
+
+    @Test
+    public void onDestroy_RemovesSelfFromParentIfExists() {
+        LinearLayout parent = new LinearLayout(activity);
+        parent.addView(uut.getView());
+
+        uut.destroy();
+        assertThat(parent.getChildCount()).withFailMessage("expected not to have children").isZero();
+    }
+
+    @Test
+    public void onDestroy_shouldKeepViewIdsStable() {
+        LinearLayout parent = new LinearLayout(activity);
+        ViewGroup view = uut.getView();
+        view.setId(10);
+        parent.addView(view);
+
+        uut.destroy();
+        assertThat(view.getId()).isEqualTo(10);
+    }
+
+    @Test
+    public void ensureViewIsCreated() {
+        ViewController spy = spy(uut);
+        verify(spy, times(0)).getView();
+        spy.ensureViewIsCreated();
+        verify(spy, times(1)).getView();
+    }
+
+    @Test
+    public void isRendered_falseIfViewIsNotCreated() {
+        uut.setWaitForRender(new Bool(true));
+        assertThat(uut.isRendered()).isFalse();
+    }
+
+    @Test
+    public void isRendered_delegatesToView() {
+        uut.setWaitForRender(new Bool(true));
+        uut.view = mock(ViewGroup.class, withSettings().extraInterfaces(Component.class));
+        uut.isRendered();
+        verify((Component) uut.view).isRendered();
+    }
+
+    @Test
+    public void isRendered_returnsTrueForEveryViewByDefault() {
+        uut.setWaitForRender(new NullBool());
+        uut.view = mock(ViewGroup.class);
+        assertThat(uut.isRendered()).isTrue();
+    }
+
+    @Test
+    public void getTopInset_noParent() {
+        uut.setParentController(null);
+        assertThat(uut.getTopInset()).isEqualTo(63);
+    }
+
+    @Test
+    public void onMeasureChild() {
+        ViewController spy = spy(uut);
+        spy.onMeasureChild(mock(CoordinatorLayout.class), spy.getView(), -1, -1, -1, -1);
+        verify(spy).applyTopInset();
+    }
+}
+

package/android/src/test/java/com/reactnativenavigation/viewcontrollers/viewcontroller/YellowBoxDelegateTest.java

@@ -0,0 +1,68 @@
+package com.reactnativenavigation.viewcontrollers.viewcontroller;
+
+import android.app.Activity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import com.reactnativenavigation.BaseTest;
+
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.verify;
+
+public class YellowBoxDelegateTest extends BaseTest {
+    private YellowBoxDelegate uut;
+    private YellowBoxHelper yellowBoxHelper;
+    private View yellowBox;
+    private ViewGroup parent;
+
+    @Override
+    public void beforeEach() {
+        Activity context = newActivity();
+        yellowBox = new View(context);
+        parent = new FrameLayout(context);
+        yellowBoxHelper = Mockito.mock(YellowBoxHelper.class);
+        uut = new YellowBoxDelegate(context, yellowBoxHelper);
+        parent.addView(new View(context)); // We assume view at index 0 is not a yellow box
+        parent.addView(yellowBox);
+    }
+
+    @Test
+    public void onYellowBoxAdded_removedFromParent() {
+        uut.onYellowBoxAdded(parent, yellowBox);
+        assertThat(yellowBox.getParent()).isNull();
+    }
+
+    @Test
+    public void onYellowBoxAdded_storesRefToYellowBoxAndParent() {
+        uut.onYellowBoxAdded(parent, yellowBox);
+        assertThat(uut.getYellowBoxes()).contains(yellowBox);
+        assertThat(uut.getParent()).isEqualTo(parent);
+    }
+
+    @Test
+    public void onReactViewDestroy_yellowBoxIsAddedBackToParent() {
+        uut.onYellowBoxAdded(parent, yellowBox);
+        uut.destroy();
+        assertThat(yellowBox.getParent()).isEqualTo(parent);
+    }
+
+    @Test
+    public void onChildViewAdded() {
+        uut.onChildViewAdded(parent, yellowBox);
+        dispatchPreDraw(yellowBox);
+        verify(yellowBoxHelper).isYellowBox(parent, yellowBox);
+    }
+
+    @Test
+    public void onYellowBoxAdded_notHandledIfDelegateIsDestroyed() {
+        uut.onYellowBoxAdded(parent, yellowBox);
+        uut.destroy();
+
+        uut.onYellowBoxAdded(parent, yellowBox);
+        assertThat(yellowBox.getParent()).isEqualTo(parent);
+    }
+}