Detox android (#2811)

* Make detox android test suit pass

Disabled emulator animations due to limitation of espresso/detox which can't wait until
a push/pop animation ends

* Fix orientation parsing and enable detox orientation tests

* remove only

* Fix BottomTabs testId

* Support user orientation

* Fix rightButtons testId

* Add Modals tests

* e2e fix ios

AndroidE2E/app/src/androidTest/java/com/reactnativenavigation/e2e/androide2e/OverlayTest.java

 		elementByText("PUSH OPTIONS SCREEN").click();
         elementByText("SHOW OVERLAY").click();
 		assertExists(By.text("Test view"));
-        assetDismissed();
+        assertDismissed();
 	}
 
     @Test
 		assertExists(By.text("Test view"));
         elementByText("DYNAMIC OPTIONS").click();
         assertExists(By.text("Dynamic Title"));
-        assetDismissed();
+        assertDismissed();
 	}
 
-    private void assetDismissed() throws UiObjectNotFoundException {
+    private void assertDismissed() throws UiObjectNotFoundException {
         elementByText("OK").click();
         assertExists(By.text("Overlay disappeared"));
         elementByText("OK").click();

e2e/Modals.test.js

 const Utils = require('./Utils');
 const testIDs = require('../playground/src/testIDs');
 
-const { elementByLabel, elementById } = Utils;
+const { elementByLabel, elementById, tapDeviceBackAndroid } = Utils;
 
 describe('modal', () => {
   beforeEach(async () => {
     await elementById(testIDs.DISMISS_ALL_MODALS_BUTTON).tap();
     await expect(elementById(testIDs.WELCOME_SCREEN_HEADER)).toBeVisible();
   });
+
+  it('push into modal', async () => {
+    await elementById(testIDs.SHOW_MODAL_BUTTON).tap();
+    await elementById(testIDs.PUSH_BUTTON).tap();
+    await expect(elementByLabel('Pushed Screen')).toBeVisible();
+  });
+
+  it(':android: push into modal', async () => {
+    await elementById(testIDs.SHOW_MODAL_BUTTON).tap();
+    await elementById(testIDs.PUSH_BUTTON).tap();
+    await elementById(testIDs.PUSH_BUTTON).tap();
+    tapDeviceBackAndroid();
+    await expect(elementByLabel('Pushed Screen')).toBeVisible();
+  });
 });

e2e/Orientations.test.js

 
 const { elementById } = Utils;
 
-describe(':ios: orientation', () => {
+describe('orientation', () => {
+
   beforeEach(async () => {
     await device.relaunchApp();
   });
     await elementById(testIDs.DISMISS_BUTTON).tap();
   });
 
-  it('portrait only', async () => {
+  it(':ios: portrait only', async () => {
     await elementById(testIDs.ORIENTATION_BUTTON).tap();
     await elementById(testIDs.PORTRAIT_ORIENTATION_BUTTON).tap();
     await expect(elementById(testIDs.PORTRAIT_ELEMENT)).toBeVisible();
     await elementById(testIDs.DISMISS_BUTTON).tap();
   });
 
-  it('landscape only', async () => {
+  it(':ios: landscape only', async () => {
     await elementById(testIDs.ORIENTATION_BUTTON).tap();
     await elementById(testIDs.LANDSCAPE_ORIENTATION_BUTTON).tap();
     await device.setOrientation('landscape');

e2e/ScreenStyle.test.js

   });
 
   it('set dynamic options with valid options will do something and not crash', async () => {
-    // we have no way of testing individual styles for the screen
     await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
     await elementById(testIDs.DYNAMIC_OPTIONS_BUTTON).tap();
     await expect(elementById(testIDs.OPTIONS_SCREEN_HEADER)).toBeVisible();
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
   });
 
-  it(':ios: hides topBar onScroll down and shows it on scroll up', async () => {
+  it('hides topBar onScroll down and shows it on scroll up', async () => {
     await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
     await elementById(testIDs.SCROLLVIEW_SCREEN_BUTTON).tap();
     await elementById(testIDs.TOGGLE_TOP_BAR_HIDE_ON_SCROLL).tap();
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
     await element(by.id(testIDs.SCROLLVIEW_ELEMENT)).swipe('up', 'slow');
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeNotVisible();
-    await element(by.id(testIDs.SCROLLVIEW_ELEMENT)).swipe('down', 'slow');
+    await element(by.id(testIDs.SCROLLVIEW_ELEMENT)).swipe('down', 'fast');
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
   });
 
     await expect(element(by.text('TeSt'))).toBeVisible();
   });
 
-  it(':ios: hide Tab Bar', async () => {
+  it('hide Tab Bar', async () => {
     await elementById(testIDs.TAB_BASED_APP_BUTTON).tap();
     await expect(elementById(testIDs.BOTTOM_TABS_ELEMENT)).toBeVisible();
     await elementById(testIDs.HIDE_BOTTOM_TABS_BUTTON).tap();
     await expect(elementById(testIDs.BOTTOM_TABS_ELEMENT)).toBeNotVisible();
   });
 
-  it(':ios: show Tab Bar', async () => {
+  it('show Tab Bar', async () => {
     await elementById(testIDs.TAB_BASED_APP_BUTTON).tap();
     await elementById(testIDs.HIDE_BOTTOM_TABS_BUTTON).tap();
     await expect(elementById(testIDs.BOTTOM_TABS_ELEMENT)).toBeNotVisible();
     await expect(elementById(testIDs.CENTERED_TEXT_HEADER)).toBeVisible();
   });
 
-  it(':ios: set right buttons', async () => {
+  it('set right buttons', async () => {
     await elementById(testIDs.PUSH_OPTIONS_BUTTON).tap();
     await expect(elementById('buttonOne')).toBeVisible();
     await elementById('buttonOne').tap();
 
   it('stack options should not override component options', async () => {
     await elementById(testIDs.TAB_BASED_APP_BUTTON).tap();
-    await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeNotVisible();
-    await elementById(testIDs.SECOND_TAB_BAR_BUTTON).tap();
     await expect(elementById(testIDs.TOP_BAR_ELEMENT)).toBeVisible();
   });
 });

e2e/Utils.js

+const exec = require('shell-utils').exec;
+
 module.exports = {
   elementByLabel: (label) => {
     return element(by.text(label));
     } catch (err) {
       return element(by.type('_UIModernBarButton').and(by.label('Back'))).tap();
     }
+  },
+  tapDeviceBackAndroid: () => {
+    exec.execSync('adb shell input keyevent 4');
   }
 };

e2e/init.js

 const detox = require('detox');
 const config = require('../package.json').detox;
+const exec = require('shell-utils').exec;
 
 before(async () => {
   await detox.init(config, { launchApp: false });
+  disableAndroidEmulatorAnimations();
 });
 
 after(async () => {
   await detox.cleanup();
 });
+
+// Temporary solution, #2809
+function disableAndroidEmulatorAnimations() {
+  exec.execAsync(`adb shell settings put global window_animation_scale 0.0`);
+  exec.execAsync(`adb shell settings put global transition_animation_scale 0.0`);
+  exec.execAsync(`adb shell settings put global animator_duration_scale 0.0`);
+}

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

         if (other.backgroundColor.hasValue()) {
 		    backgroundColor = other.backgroundColor;
         }
+        if (other.testId.hasValue()) {
+            testId = other.testId;
+        }
     }
 
     void mergeWithDefault(final BottomTabsOptions defaultOptions) {

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

         Options result = new Options();
         if (json == null) return result;
 
-        result.orientationOptions = OrientationOptions.parse(json.optJSONArray("orientation"));
+        result.orientationOptions = OrientationOptions.parse(json);
         result.topBarOptions = TopBarOptions.parse(typefaceManager, json.optJSONObject("topBar"));
         result.topTabsOptions = TopTabsOptions.parse(json.optJSONObject("topTabs"));
         result.topTabOptions = TopTabOptions.parse(typefaceManager, json.optJSONObject("topTab"));

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

 import com.reactnativenavigation.parse.params.Orientation;
 
 import org.json.JSONArray;
+import org.json.JSONObject;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 public class OrientationOptions {
-    Orientation[] orientations = new Orientation[0];
+    List<Orientation> orientations = new ArrayList<>();
 
-    public static OrientationOptions parse(JSONArray orientations) {
+    public static OrientationOptions parse(JSONObject json) {
         OrientationOptions options = new OrientationOptions();
-        if (orientations == null) return options;
+        if (json == null) return options;
 
-        List<Orientation> parsed = new ArrayList<>();
-        for (int i = 0; i < orientations.length(); i++) {
-            Orientation o = Orientation.fromString(orientations.optString(i, "default"));
-            if (o != null) {
-                parsed.add(o);
+        JSONArray orientations = json.optJSONArray("orientation");
+        if (orientations == null) {
+            String orientation = json.optString("orientation", Orientation.Default.name);
+            options.orientations.add(Orientation.fromString(orientation));
+        } else {
+            List<Orientation> parsed = new ArrayList<>();
+            for (int i = 0; i < orientations.length(); i++) {
+                Orientation o = Orientation.fromString(orientations.optString(i, "default"));
+                if (o != null) {
+                    parsed.add(o);
+                }
             }
+            options.orientations = parsed;
         }
-        options.orientations = parsed.toArray(new Orientation[0]);
 
         return options;
     }
     public int getValue() {
         if (!hasValue()) return Orientation.Default.orientationCode;
 
-        int result = 0;
-        for (Orientation orientation : orientations) {
-            result |= orientation.orientationCode;
+        switch (orientations.get(0)) {
+            case Landscape:
+                return orientations.contains(Orientation.Portrait) ? Orientation.PortraitLandscape.orientationCode : Orientation.Landscape.orientationCode;
+            case Portrait:
+                return orientations.contains(Orientation.Landscape) ? Orientation.PortraitLandscape.orientationCode : Orientation.Portrait.orientationCode;
+            default:
+            case Default:
+                return Orientation.Default.orientationCode;
         }
-        return result;
     }
 
     public void mergeWith(OrientationOptions other) {
     }
 
     private boolean hasValue() {
-        return orientations.length > 0;
+        return !orientations.isEmpty();
     }
 
     public void mergeWithDefault(OrientationOptions defaultOptions) {
 
     @Override
     public String toString() {
-        return hasValue() ? Arrays.toString(orientations) : Orientation.Default.toString();
+        return hasValue() ? Arrays.toString(orientations.toArray(new Orientation[0])) : Orientation.Default.toString();
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/parse/params/Orientation.java

 public enum Orientation {
     Portrait("portrait", Configuration.ORIENTATION_PORTRAIT, ActivityInfo.SCREEN_ORIENTATION_PORTRAIT),
     Landscape("landscape", Configuration.ORIENTATION_LANDSCAPE, ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE),
-    Default("default", Configuration.ORIENTATION_UNDEFINED, ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
+    Default("default", Configuration.ORIENTATION_UNDEFINED, ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED),
+    PortraitLandscape("sensor", Configuration.ORIENTATION_UNDEFINED, ActivityInfo.SCREEN_ORIENTATION_USER);
 
     public String name;
     public int configurationCode;

lib/android/app/src/main/java/com/reactnativenavigation/views/TitleBarButton.java

             ActionMenuView buttonsLayout = ViewUtils.findChildByClass(toolbar, ActionMenuView.class);
             List<TextView> buttons = ViewUtils.findChildrenByClass(buttonsLayout, TextView.class);
             for (TextView view : buttons) {
-                if (button.title.hasValue() && button.title.get().equals(view.getText())) {
+                if (button.title.hasValue() && button.title.get().equals(view.getText().toString())) {
                     view.setTag(testId.get());
                 } else if (button.icon.hasValue() && ArrayUtils.contains(view.getCompoundDrawables(), icon)) {
                     view.setTag(testId.get());

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

 import com.reactnativenavigation.parse.params.Orientation;
 
 import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
 import org.junit.Test;
 
 import java.util.Arrays;
     @Test
     public void parseOrientations() throws Exception {
         OrientationOptions options = OrientationOptions.parse(create("default", "landscape", "portrait"));
-        assertThat(options.orientations[0]).isEqualTo(Orientation.Default);
-        assertThat(options.orientations[1]).isEqualTo(Orientation.Landscape);
-        assertThat(options.orientations[2]).isEqualTo(Orientation.Portrait);
+        assertThat(options.orientations.get(0)).isEqualTo(Orientation.Default);
+        assertThat(options.orientations.get(1)).isEqualTo(Orientation.Landscape);
+        assertThat(options.orientations.get(2)).isEqualTo(Orientation.Portrait);
+    }
+
+    @Test
+    public void parseSingleOrientation() throws Exception {
+        OrientationOptions options = OrientationOptions.parse(create("landscape"));
+        assertThat(options.orientations.get(0)).isEqualTo(Orientation.Landscape);
+    }
+
+    @Test
+    public void landscapePortrait_regardedAsUserOrientation() throws Exception {
+        OrientationOptions options = OrientationOptions.parse(create("landscape", "portrait"));
+        assertThat(options.getValue()).isEqualTo(Orientation.PortraitLandscape.orientationCode);
+    }
+
+    @Test
+    public void portraitLandscape_regardedAsUserOrientation() throws Exception {
+        OrientationOptions options = OrientationOptions.parse(create("portrait", "landscape"));
+        assertThat(options.getValue()).isEqualTo(Orientation.PortraitLandscape.orientationCode);
     }
 
     @Test
     public void unsupportedOrientationsAreIgnored() throws Exception {
         OrientationOptions options = OrientationOptions.parse(create("default", "autoRotate"));
         assertThat(options.orientations).hasSize(1);
-        assertThat(options.orientations[0]).isEqualTo(Orientation.Default);
+        assertThat(options.orientations.get(0)).isEqualTo(Orientation.Default);
     }
 
     @Test
         assertThat(options.getValue()).isEqualTo(Orientation.Default.orientationCode);
     }
 
-    private JSONArray create(String... orientations) {
-        return new JSONArray(Arrays.asList(orientations));
+    private JSONObject create(String... orientations) {
+        JSONObject orientation = new JSONObject();
+        try {
+            orientation.putOpt("orientation", orientations.length > 1 ? new JSONArray(Arrays.asList(orientations)) : orientations[0]);
+        } catch (JSONException e) {
+            throw new RuntimeException("Unable to create orientation object");
+        }
+        return orientation;
     }
 }

lib/ios/RNNNavigationOptions.m

 	for (id key in otherOptions) {
 		if ([self hasProperty:key]) {
 			if ([[self valueForKey:key] isKindOfClass:[RNNOptions class]]) {
-			RNNOptions* options = [self valueForKey:key];
-			[options mergeWith:[otherOptions objectForKey:key]];
-		} else {
-			[self setValue:[otherOptions objectForKey:key] forKey:key];
-		} 		
+				RNNOptions* options = [self valueForKey:key];
+				[options mergeWith:[otherOptions objectForKey:key]];
+			} else {
+				[self setValue:[otherOptions objectForKey:key] forKey:key];
+			}
+		}
+	}
+}
+
+-(void)mergeIfEmptyWith:(NSDictionary *)otherOptions {
+	for (id key in otherOptions) {
+		if ([self hasProperty:key]) {
+			if ([[self valueForKey:key] isKindOfClass:[RNNOptions class]]) {
+				RNNOptions* options = [self valueForKey:key];
+				[options mergeIfEmptyWith:[otherOptions objectForKey:key]];
+			} else if (![self valueForKey:key]) {
+				[self setValue:[otherOptions objectForKey:key] forKey:key];
+			}
 		}
 	}
 }

lib/ios/RNNOptions.h

 
 - (instancetype)initWithDict:(NSDictionary*)dict;
 - (void)mergeWith:(NSDictionary*)otherOptions;
+- (void)mergeIfEmptyWith:(NSDictionary*)otherOptions;
 - (void)applyOn:(UIViewController *)viewController defaultOptions:(RNNOptions*)defaultOptions;
 - (BOOL)hasProperty:(NSString*)propName;
 

lib/ios/RNNOptions.m

 	}
 }
 
+-(void)mergeIfEmptyWith:(NSDictionary *)otherOptions {
+	for (id key in otherOptions) {
+		if ([self hasProperty:key] && ![self valueForKey:key]) {
+			[self setValue:[otherOptions objectForKey:key] forKey:key];
+		}
+	}
+}
+
 - (BOOL)hasProperty:(NSString*)propName {
 	return [self respondsToSelector:NSSelectorFromString(propName)];
 }

lib/ios/RNNRootViewController.m

 }
 
 - (void)mergeOptions:(NSDictionary *)options {
-	[self.options mergeWith:options];
+	[self.options mergeIfEmptyWith:options];
 }
 
 - (void)setCustomNavigationTitleView {

playground/src/screens/WelcomeScreen.js

                     },
                     options: {
                       topBar: {
-                        visible: (Platform.OS === 'android') ? true : false,
+                        visible: true,
                         title: 'React Native Navigation!'
                       }
                     }
                   title: 'Tab 1',
                   icon: require('../images/one.png'),
                   testID: testIDs.FIRST_TAB_BAR_BUTTON
+                },
+                topBar: {
+                  visible: false
                 }
               }
             }