Apply options only on first controller (#2734)

lib/android/app/src/main/java/com/reactnativenavigation/parse/Options.java

         bottomTabsOptions = new BottomTabsOptions();
         return this;
     }
+
+    public Options clearTopTabOptions() {
+        topTabOptions = new TopTabOptions();
+        return this;
+    }
+
+    public Options clearTopTabsOptions() {
+        topTabsOptions = new TopTabsOptions();
+        return this;
+    }
+
+    public Options clearBottomTabOptions() {
+        bottomTabOptions = new BottomTabOptions();
+        return this;
+    }
 }

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

         int tabIndex = findTabContainingComponent(childComponent);
         if (tabIndex >= 0) new BottomTabOptionsPresenter(bottomTabs).present(options, tabIndex);
         applyOnParentController(parentController ->
-                ((ParentController) parentController).applyOptions(this.options.copy().clearBottomTabsOptions(), childComponent)
+                ((ParentController) parentController).applyOptions(this.options.copy().clearBottomTabsOptions().clearBottomTabOptions(), childComponent)
         );
     }
 

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

         super.applyOptions(options, component);
         stackLayout.applyOptions(this.options, component);
         applyOnParentController(parentController ->
-                ((ParentController) parentController).applyOptions(this.options, component)
+                ((ParentController) parentController).applyOptions(this.options.copy().clearTopBarOptions(), component)
         );
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/toptabs/TopTabsController.java

     @Override
     public void applyOptions(Options options, ReactComponent childComponent) {
         super.applyOptions(options, childComponent);
-        applyOnParentController(parentController ->
-                ((ParentController) parentController).applyOptions(this.options, childComponent)
+        applyOnParentController(parentController -> {
+                Options opt = this.options.copy();
+                ((ParentController) parentController).applyOptions(opt.clearTopTabOptions().clearTopTabsOptions(), childComponent);
+            }
         );
     }
 

lib/android/app/src/test/java/com/reactnativenavigation/parse/OptionsTest.java

         assertThat(uut.bottomTabsOptions.color.hasValue()).isFalse();
     }
 
-//    topBarOptions.mergeWithDefault(other.topBarOptions);
-//        topTabOptions.mergeWithDefault(other.topTabOptions);
-//        topTabsOptions.mergeWithDefault(other.topTabsOptions);
-//        bottomTabOptions.mergeWithDefault(other.bottomTabOptions);
-//        bottomTabsOptions.mergeWithDefault(other.bottomTabsOptions);
+    @Test
+    public void clear_topTabsOptions() throws Exception {
+        Options uut = new Options();
+        uut.topTabsOptions.fontSize = new Number(666);
+        uut.clearTopTabsOptions();
+        assertThat(uut.topTabsOptions.fontSize.hasValue()).isFalse();
+    }
+
+
+    @Test
+    public void clear_topTabOptions() throws Exception {
+        Options uut = new Options();
+        uut.topTabOptions.title = new Text("some title");
+        uut.clearTopTabOptions();
+        assertThat(uut.topTabOptions.title.hasValue()).isFalse();
+    }
 }

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

 import com.reactnativenavigation.mocks.MockPromise;
 import com.reactnativenavigation.mocks.SimpleViewController;
 import com.reactnativenavigation.parse.Options;
+import com.reactnativenavigation.parse.Text;
+import com.reactnativenavigation.views.ReactComponent;
 
 import org.assertj.core.api.iterable.Extractor;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 
 import javax.annotation.Nullable;
 
         assertThat(parent.getView().getChildAt(1)).isEqualTo(uut.getView());
     }
 
+    @Test
+    public void applyOptions_applyOnlyOnFirstStack() throws Exception {
+        StackController parent = spy(new StackController(activity, "someStack", new Options()));
+        parent.ensureViewIsCreated();
+        parent.push(uut, new MockPromise());
+
+        Options childOptions = new Options();
+        childOptions.topBarOptions.title = new Text("Something");
+        child1.options = childOptions;
+        uut.push(child1, new MockPromise());
+        child1.ensureViewIsCreated();
+        child1.onViewAppeared();
+
+        ArgumentCaptor<Options> optionsCaptor = ArgumentCaptor.forClass(Options.class);
+        ArgumentCaptor<ReactComponent> viewCaptor = ArgumentCaptor.forClass(ReactComponent.class);
+        verify(parent, times(1)).applyOptions(optionsCaptor.capture(), viewCaptor.capture());
+        assertThat(optionsCaptor.getValue().topBarOptions.title.hasValue()).isFalse();
+    }
+
     private void assertContainsOnlyId(String... ids) {
         assertThat(uut.size()).isEqualTo(ids.length);
         assertThat(uut.getChildControllers()).extracting((Extractor<ViewController, String>) ViewController::getId).containsOnly(ids);

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.parse.Options;
 import com.reactnativenavigation.views.TopTabsLayoutCreator;
 import com.reactnativenavigation.views.TopTabsViewPager;
 
-import org.assertj.core.api.Assertions;
 import org.junit.Test;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.spy;
     private List<Options> tabOptions = new ArrayList<>(SIZE);
     private final Options options = new Options();
     private TopTabsViewPager topTabsLayout;
+    private Activity activity;
 
     @Override
     public void beforeEach() {
         super.beforeEach();
 
-        final Activity activity = newActivity();
+        activity = newActivity();
         tabOptions = createOptions();
-        tabControllers = createTabsControllers(activity);
+        tabControllers = createTabsControllers(activity, tabOptions);
 
         topTabsLayout = spy(new TopTabsViewPager(activity, tabControllers, new TopTabsAdapter(tabControllers)));
         TopTabsLayoutCreator layoutCreator = Mockito.mock(TopTabsLayoutCreator.class);
         tabControllers.forEach(viewController -> viewController.setParentController(uut));
 
         parentController = spy(new StackController(activity, "stackId", new Options()));
+        parentController.push(uut, new MockPromise());
         uut.setParentController(parentController);
     }
 
         return result;
     }
 
-    private List<ViewController> createTabsControllers(Activity activity) {
+    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(
         uut.onViewAppeared();
         ReactComponent currentTab = tabView(0);
         verify(uut, times(1)).applyOptions(any(Options.class), eq(currentTab));
-        Assertions.assertThat(uut.options.topBarOptions.title.get()).isEqualTo(createTabTopBarTitle(0));
+        assertThat(uut.options.topBarOptions.title.get()).isEqualTo(createTabTopBarTitle(0));
 
         uut.switchToTab(1);
         currentTab = tabView(1);
         verify(uut, times(1)).applyOptions(any(Options.class), eq(currentTab));
-        Assertions.assertThat(uut.options.topBarOptions.title.get()).isEqualTo(createTabTopBarTitle(1));
+        assertThat(uut.options.topBarOptions.title.get()).isEqualTo(createTabTopBarTitle(1));
 
         uut.switchToTab(0);
         currentTab = tabView(0);
         verify(uut, times(2)).applyOptions(any(Options.class), eq(currentTab));
-        Assertions.assertThat(uut.options.topBarOptions.title.get()).isEqualTo(createTabTopBarTitle(0));
+        assertThat(uut.options.topBarOptions.title.get()).isEqualTo(createTabTopBarTitle(0));
     }
 
     private TestReactView getActualTabView(int index) {
         verify(topTabsLayout, times(1)).applyOptions(any(Options.class));
     }
 
+    @Test
+    public void applyOptions_applyOnlyOnFirstTopTabs() throws Exception {
+        tabOptions.get(0).topTabOptions.title = new Text("tab title");
+        tabControllers.get(0).onViewAppeared();
+        ArgumentCaptor<Options> optionsCaptor = ArgumentCaptor.forClass(Options.class);
+        ArgumentCaptor<ReactComponent> viewCaptor = ArgumentCaptor.forClass(ReactComponent.class);
+        verify(parentController, times(1)).applyOptions(optionsCaptor.capture(), viewCaptor.capture());
+        assertThat(optionsCaptor.getValue().topTabOptions.title.hasValue()).isFalse();
+    }
+
     private IReactView tab(TopTabsViewPager topTabs, final int index) {
         return (IReactView) ((ViewGroup) topTabs.getChildAt(index)).getChildAt(0);
     }