Bugfix/running with mobile device (#30)

* Fix issue during scaling on mobile

* Fix issue with logging
* Fix blank screenshots from mobile device
* Update style

* Specify pytest version below 4

* Add mobile platforms tests to test runner

* Add more ignores to flake8

Author: Serhii Khalymon

applitools/core/eyes_base.py

@@ -228,7 +228,7 @@ def set_viewport_size(driver, viewport_size):
         pass
 
     @abc.abstractmethod
-    def _assign_viewport_size(self):
+    def _ensure_viewport_size(self):
         # type: () -> None
         """
         Assign the viewport size we need to be in the default content frame.
@@ -502,7 +502,7 @@ def _create_start_info(self):
     def _start_session(self):
         # type: () -> None
         logger.debug("_start_session()")
-        self._assign_viewport_size()
+        self._ensure_viewport_size()
 
         # initialization of Eyes parameters if empty from ENV variables
         if not self.branch_name:

applitools/core/scaling.py

@@ -70,8 +70,9 @@ def update_scale_ratio(self, image_to_scale_width):
             logger.info('Calculating the scale ratio..')
             self._scale_ratio = 1.0 / self.device_pixel_ratio
             if self.is_mobile_device:
+                # FIXME: This code should execute cause strange bugs with calculation
                 logger.info('Mobile device, so using 2 step calculation for scale ration...')
-                logger.info('Scale ratio based on DRP: ' + self._scale_ratio)
+                logger.info('Scale ratio based on DRP: ' + str(self._scale_ratio))
                 self._scale_ratio = self.get_scale_ratio_to_viewport(viewport_width,
                                                                      image_to_scale_width,
                                                                      self._scale_ratio)

applitools/selenium/capture/eyes_webdriver_screenshot.py

@@ -7,12 +7,12 @@
 
 from applitools.core import EyesScreenshot, EyesError, Point, Region, OutOfBoundsError
 from applitools.utils import image_utils
+from applitools.selenium import eyes_selenium_utils
 
 if tp.TYPE_CHECKING:
     from PIL import Image
-
     from applitools.utils.custom_types import ViewPort
-    from applitools.selenium import EyesWebDriver, eyes_selenium_utils
+    from applitools.selenium import EyesWebDriver
 
 
 class EyesWebDriverScreenshot(EyesScreenshot):

applitools/selenium/eyes.py

@@ -132,9 +132,9 @@ def _get_environment(self):
                 logger.info("Setting OS: " + os)
             else:
                 logger.info('No mobile OS detected.')
-        app_env = {'os': os, 'hostingApp': self.host_app,
+        app_env = {'os':          os, 'hostingApp': self.host_app,
                    'displaySize': self._viewport_size,
-                   'inferred': self._get_inferred_environment()}
+                   'inferred':    self._get_inferred_environment()}
         return app_env
 
     def get_driver(self):
@@ -149,28 +149,10 @@ def get_viewport_size(self):
         """
         Returns the size of the viewport of the application under test (e.g, the browser).
         """
-        return self._driver.get_viewport_size()
-
-    def _assign_viewport_size(self):
-        # type: () -> None
-        """
-        Assign the viewport size we need to be in the default content frame.
-        """
-        original_frame_chain = self._driver.get_frame_chain()
-        self._driver.switch_to.default_content()
-        try:
-            if self._viewport_size:
-                logger.debug("Assigning viewport size {0}".format(self._viewport_size))
-                self.set_viewport_size(self._driver, self._viewport_size)
-            else:
-                logger.debug("No viewport size given. Extracting the viewport size from the driver...")
-                self._viewport_size = self.get_viewport_size()
-                logger.debug("Viewport size {0}".format(self._viewport_size))
-        except EyesError:
-            raise TestFailedError('Failed to assign viewport size!')
-        finally:
-            # Going back to the frame we started at
-            self._driver.switch_to.frames(original_frame_chain)
+        if self._viewport_size:
+            return self._viewport_size
+        self._viewport_size = self._driver.get_viewport_size()
+        return self._viewport_size
 
     def get_title(self):
         if self._should_get_title:
@@ -209,10 +191,11 @@ def _update_scaling_params(self):
         logger.info("Setting scale provider...")
         try:
             scale_provider = ContextBasedScaleProvider(
-                top_level_context_entire_size=self._driver.get_entire_page_size(),
-                viewport_size=self._driver.get_viewport_size(),
-                device_pixel_ratio=device_pixel_ratio,
-                is_mobile_device=eyes_selenium_utils.is_mobile_device(self._driver))  # type: ScaleProvider
+                    top_level_context_entire_size=self._driver.get_entire_page_size(),
+                    viewport_size=self.get_viewport_size(),
+                    device_pixel_ratio=device_pixel_ratio,
+                    # always False as in Java version
+                    is_mobile_device=False)  # type: ScaleProvider
         except Exception:
             # This can happen in Appium for example.
             logger.info("Failed to set ContextBasedScaleProvider.")
@@ -284,14 +267,20 @@ def _viewport_screenshot(self, scale_provider):
         # type: (ScaleProvider) -> EyesWebDriverScreenshot
         logger.info('Viewport screenshot requested')
         screenshot64 = self._driver.get_screesnhot_as_base64_from_main_frame(
-            self.seconds_to_wait_screenshot)
+                self.seconds_to_wait_screenshot)
         screenshot = image_utils.image_from_bytes(base64.b64decode(screenshot64))
         scale_provider.update_scale_ratio(screenshot.width)
         pixel_ratio = 1 / scale_provider.scale_ratio
         if pixel_ratio != 1.0:
             screenshot = image_utils.scale_image(screenshot, 1.0 / pixel_ratio)
         return EyesWebDriverScreenshot.create_from_image(screenshot, self._driver).get_viewport_screenshot()
 
+    def _ensure_viewport_size(self):
+        if self._viewport_size is None:
+            self._viewport_size = self._driver.get_default_content_viewport_size()
+            if not eyes_selenium_utils.is_mobile_device(self._driver):
+                self.set_viewport_size(self._driver, self._viewport_size)
+
     def open(self, driver, app_name, test_name, viewport_size=None):
         # type: (AnyWebDriver, tp.Text, tp.Text, tp.Optional[ViewPort]) -> EyesWebDriver
         if self.is_disabled:
@@ -307,6 +296,7 @@ def open(self, driver, app_name, test_name, viewport_size=None):
                 logger.info("WARNING: driver is not a RemoteWebDriver (class: {0})".format(driver.__class__))
             self._driver = EyesWebDriver(driver, self, self._stitch_mode)
 
+        self._ensure_viewport_size()
         self.open_base(app_name, test_name, viewport_size)
 
         return self._driver
@@ -485,5 +475,5 @@ def try_capture_dom(self):
             return dom_json
         except Exception as e:
             warnings.warn(
-                'Exception raising during capturing DOM Json. Passing...\n Got next error: {}'.format(str(e)))
+                    'Exception raising during capturing DOM Json. Passing...\n Got next error: {}'.format(str(e)))
             return None

applitools/selenium/eyes_selenium_utils.py

@@ -165,8 +165,8 @@ def set_browser_size_by_viewport_size(driver, actual_viewport_size, required_siz
     browser_size = get_window_size(driver)
     logger.debug("Current browser size: {}".format(browser_size))
     required_browser_size = dict(
-        width=browser_size['width'] + (required_size['width'] - actual_viewport_size['width']),
-        height=browser_size['height'] + (required_size['height'] - actual_viewport_size['height'])
+            width=browser_size['width'] + (required_size['width'] - actual_viewport_size['width']),
+            height=browser_size['height'] + (required_size['height'] - actual_viewport_size['height'])
     )
     return set_browser_size(driver, required_browser_size)
 
@@ -223,8 +223,8 @@ def set_viewport_size(driver, required_size):
                 curr_height_change += height_step
 
             required_browser_size = dict(
-                width=browser_size['width'] + curr_width_change,
-                height=browser_size['height'] + curr_height_change)
+                    width=browser_size['width'] + curr_width_change,
+                    height=browser_size['height'] + curr_height_change)
             if required_browser_size == last_required_browser_size:
                 logger.info("Browser size is as required but viewport size does not match!")
                 logger.info("Browser size: {}, Viewport size: {}".format(required_browser_size,
@@ -258,3 +258,55 @@ def set_overflow(driver, overflow):
 def timeout(timeout):
     time.sleep(timeout)
     yield
+
+
+def is_landscape_orientation(driver):
+    if is_mobile_device(driver):
+        appium_driver = get_underlying_driver(driver)  # type: AppiumRemoteWebDriver
+
+        original_context = None
+        try:
+            # We must be in native context in order to ask for orientation,
+            # because of an Appium bug.
+            original_context = appium_driver.context
+            if len(appium_driver.contexts) > 1 and not original_context.uppar() == 'NATIVE_APP':
+                appium_driver.switch_to.context('NATIVE_APP')
+            else:
+                original_context = None
+        except WebDriverException as e:
+            original_context = None
+
+        try:
+            orieintation = appium_driver.orientation
+            return orieintation.lower() == 'landscape'
+        except Exception as e:
+            logger.debug("WARNING: Couldn't get device orientation. Assuming Portrait.")
+        finally:
+            if original_context is not None:
+                appium_driver.switch_to.context(original_context)
+
+        return False
+
+
+def get_viewport_size_or_display_size(driver):
+    logger.info("get_viewport_size_or_display_size()")
+
+    try:
+        return get_viewport_size(driver)
+    except Exception as e:
+        logger.info("Failed to extract viewport size using Javascript: {}".format(str(e)))
+    # If we failed to extract the viewport size using JS, will use the
+    # window size instead.
+
+    logger.info("Using window size as viewport size.")
+    window_size = get_window_size(driver)
+    width = window_size['width']
+    height = window_size['height']
+    try:
+        if is_landscape_orientation(driver) and height > width:
+            height, width = width, height
+    except WebDriverException as e:
+        # Not every WebDriver supports querying for orientation.
+        pass
+    logger.info("Done! Size {:d} x {:d}".format(width, height))
+    return dict(width=width, height=height)

applitools/selenium/webdriver.py

@@ -195,7 +195,9 @@ class EyesWebDriver(object):
                             'desired_capabilities', 'log_types', 'name', 'page_source', 'title',
                             'window_handles', 'switch_to', 'mobile', 'current_context', 'context',
                             'current_activity', 'network_connection', 'available_ime_engines',
-                            'active_ime_engine', 'device_time', 'w3c', 'contexts', 'current_package']
+                            'active_ime_engine', 'device_time', 'w3c', 'contexts', 'current_package',
+                            # Appium specific
+                            'battery_info']
     _SETTABLE_PROPERTIES = ['orientation', 'file_detector']
 
     # This should pretty much cover all scroll bars (and some fixed position footer elements :) ).
@@ -219,6 +221,7 @@ def __init__(self, driver, eyes, stitch_mode=StitchMode.Scroll):
         # tp.List of frames the user switched to, and the current offset, so we can properly
         # calculate elements' coordinates
         self._frames = []  # type: tp.List[EyesFrame]
+        self._default_content_viewport_size = None  # type: tp.Optional[ViewPort]
         self.driver_takes_screenshot = driver.capabilities.get('takesScreenshot', False)
 
         # Creating the rest of the driver interface by simply forwarding it to the underlying
@@ -661,19 +664,27 @@ def get_viewport_size(self):
         """
         return eyes_selenium_utils.get_viewport_size(self)
 
-    def get_default_content_viewport_size(self):
-        # type: () -> ViewPort
+    def get_default_content_viewport_size(self, force_query=False):
+        # type: (bool) -> ViewPort
         """
         Gets the viewport size.
 
         :return: The viewport size of the most outer frame.
         """
+        if self._default_content_viewport_size and not force_query:
+            return self._default_content_viewport_size
+
         current_frames = self.get_frame_chain()
         # If we're inside a frame, then we should first switch to the most outer frame.
-        self.switch_to.default_content()
-        viewport_size = self.get_viewport_size()
-        self.switch_to.frames(current_frames)
-        return viewport_size
+        # Optimization
+        if current_frames:
+            self.switch_to.default_content()
+        self._default_content_viewport_size = eyes_selenium_utils.get_viewport_size_or_display_size(self.driver)
+
+        if current_frames:
+            self.switch_to.frames(current_frames)
+
+        return self._default_content_viewport_size
 
     def reset_origin(self):
         # type: () -> None

setup.cfg

@@ -20,7 +20,7 @@ import-order-style = pep8
 application-import-names = applitools
 max-line-length = 120
 max-complexity = 12
-ignore = F401,W503,F841,B006,E731
+ignore = F401,W503,F841,B006,E731,E241,E126
 exclude = .git,__pycache__,test,.tox,*.egg
 
 [mypy]

setup.py

@@ -65,7 +65,7 @@ def get_version():
             'towncrier',
         ],
         'testing': [
-            'pytest >= 3.0.0',
+            'pytest < 4.0.0',
             'pytest-cov',
             'pytest-xdist',
         ],

tests/conftest.py

@@ -101,8 +101,9 @@ def driver(request, browser_config):
     username = os.environ.get('SAUCE_USERNAME', None)
     access_key = os.environ.get('SAUCE_ACCESS_KEY', None)
 
+    force_remote = request.config.getoption('remote')
     selenium_url = os.environ.get('SELENIUM_SERVER_URL', 'http://127.0.0.1:4444/wd/hub')
-    if 'ondemand.saucelabs.com' in selenium_url:
+    if 'ondemand.saucelabs.com' in selenium_url or force_remote:
         selenium_url = "https://%s:%[email protected]:443/wd/hub" % (username, access_key)
     logger.debug('SELENIUM_URL={}'.format(selenium_url))
 
@@ -133,6 +134,7 @@ def pytest_addoption(parser):
     parser.addoption("--platform", action="store")
     parser.addoption("--browser", action="store")
     parser.addoption("--headless", action="store")
+    parser.addoption("--remote", action="store")
 
 
 def _get_capabilities(platform_name=None, browser_name=None, headless=False):

tests/platfroms.py

@@ -54,8 +54,8 @@ def get_browser_capabilities(self, browser_name, headless=False):
         browser_caps = options.to_capabilities() if options else {}
         browser_name, browser_version = [b for b in self.browsers if browser_name.lower() == b[0].lower()][0]
         browser_caps.update({'browserName': browser_name,
-                             'version': browser_version,
-                             'platform': self.full_name})
+                             'version':     browser_version,
+                             'platform':    self.full_name})
         if isinstance(self.extra, dict):
             browser_caps.update(self.extra)
         return browser_caps
@@ -80,17 +80,29 @@ def full_name(self):
     Platform(name='Linux', version='', browsers=COMMON_BROWSERS, extra=None),
     Platform(name='macOS', version='10.13', browsers=COMMON_BROWSERS + [('safari', 'latest')], extra=None),
 
-    Platform(name='iPhone', version='10.0', browsers=[], extra={
-        "appiumVersion": "1.7.2",
-        "deviceName": "Iphone Emulator",
+    Platform(name='iPhone', version='11.3', browsers=[], extra={
+        "appiumVersion":     "1.9.1",
+        "deviceName":        "Iphone Emulator",
         "deviceOrientation": "portrait",
-        "browserName": "Safari",
+        "browserName":       "Safari",
     }),
     Platform(name='Android', version='6.0', browsers=[], extra={
-        "appiumVersion": "1.7.2",
-        "deviceName": "Android Emulator",
+        "appiumVersion":                 "1.9.1",
+        "deviceName":                    "Android Emulator",
+        "deviceOrientation":             "portrait",
+        "browserName":                   "Chrome",
+    }),
+    Platform(name='Android', version='7.0', browsers=[], extra={
+        "appiumVersion":                 "1.9.1",
+        "deviceName":                    "Android Emulator",
+        "deviceOrientation":             "portrait",
+        "browserName":                   "Chrome",
+    }),
+    Platform(name='Android', version='8.0', browsers=[], extra={
+        "appiumVersion":     "1.9.1",
+        "deviceName":        "Samsung S9+",
         "deviceOrientation": "portrait",
-        "browserName": "Browser",
+        "browserName":       "Chrome",
     })
 ]
 SUPPORTED_PLATFORMS_DICT = {platform.full_name: platform for platform in SUPPORTED_PLATFORMS}