Blacked tests

Author: eirenik0

tests/conftest.py

@@ -1,11 +1,17 @@
 import os
+import sys
 from collections import namedtuple
 from itertools import chain
 
 import pytest
 
+try:
+    from typing import Text, Optional, Generator, Iterable
+except ImportError:
+    pass
 
-class Platform(namedtuple('Platform', 'name version browsers extra')):
+
+class Platform(namedtuple("Platform", "name version browsers extra")):
     def platform_capabilities(self):
         # type: () -> Optional[Iterable[dict]]
         """
@@ -14,10 +20,7 @@ def platform_capabilities(self):
         if not self.is_appium_based:
             return
 
-        caps = {
-            'platformName':    self.name,
-            'platformVersion': self.version
-        }
+        caps = {"platformName": self.name, "platformVersion": self.version}
         if isinstance(self.extra, dict):
             caps.update(self.extra)
         return caps
@@ -47,76 +50,102 @@ def get_browser_capabilities(self, browser_name, headless=False):
         from selenium.webdriver import ChromeOptions
 
         options = None
-        if 'firefox' == browser_name:
+        if "firefox" == browser_name:
             options = FirefoxOptions()
-        elif 'chrome' == browser_name:
+        elif "chrome" == browser_name:
             options = ChromeOptions()
-            options.add_argument('disable-infobars')
+            options.add_argument("disable-infobars")
         if options and headless:
             options.headless = True
 
         # huck for preventing overwriting 'platform' value in desired_capabilities by chrome options
         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
-        })
+        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,
+            }
+        )
         if isinstance(self.extra, dict):
             browser_caps.update(self.extra)
         return browser_caps
 
     @property
     def is_appium_based(self):
-        if self.extra and ('appiumVersion' in self.extra or 'deviceName' in self.extra):
+        if self.extra and ("appiumVersion" in self.extra or "deviceName" in self.extra):
             return True
         return False
 
     @property
     def full_name(self):
         if self.version:
-            return '{} {}'.format(self.name, self.version)
+            return "{} {}".format(self.name, self.version)
         return self.name
 
 
-COMMON_BROWSERS = [('chrome', 'latest'), ('firefox', 'latest')]
-SUPPORTED_PLATFORMS = [Platform(name='Windows', version='10',
-                                browsers=COMMON_BROWSERS + [('internet explorer', 'latest'),
-                                                            ('MicrosoftEdge', 'latest')], extra=None),
-                       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",
-                           "deviceOrientation": "portrait",
-                           "browserName":       "Safari",
-                       }), Platform(name='Android', version='6.0', browsers=[], extra={
-                            "appiumVersion":     "1.9.1",
-                            "deviceName":        "Android Emulator",
-                            "deviceOrientation": "portrait",
-                            "browserName":       "Chrome",
-                            "newCommandTimeout": 60 * 5
-                        }),
-                       # Platform(name='Android', version='7.0', browsers=[], extra={
-                       #     "appiumVersion":     "1.9.1",
-                       #     "deviceName":        "Android Emulator",
-                       #     "deviceOrientation": "portrait",
-                       #     "browserName":       "Chrome",
-                       #     "newCommandTimeout": 60 * 5
-                       # }),
-                       # Platform(name='Android', version='8.0', browsers=[], extra={
-                       #     "appiumVersion":     "1.9.1",
-                       #     "deviceName":        "Samsung S9+",
-                       #     "deviceOrientation": "portrait",
-                       #     "browserName":       "Chrome",
-                       #     "newCommandTimeout": 60 * 5
-                       # })
-                       ]
-SUPPORTED_PLATFORMS_DICT = {platform.full_name: platform for platform in SUPPORTED_PLATFORMS}
-SUPPORTED_BROWSERS = set(chain(*[platform.browsers for platform in SUPPORTED_PLATFORMS]))
+COMMON_BROWSERS = [("chrome", "latest"), ("firefox", "latest")]
+SUPPORTED_PLATFORMS = [
+    Platform(
+        name="Windows",
+        version="10",
+        browsers=COMMON_BROWSERS
+        + [("internet explorer", "latest"), ("MicrosoftEdge", "latest")],
+        extra=None,
+    ),
+    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",
+            "deviceOrientation": "portrait",
+            "browserName": "Safari",
+        },
+    ),
+    Platform(
+        name="Android",
+        version="9",
+        browsers=[],
+        extra={
+            "appiumVersion": "1.9.1",
+            "deviceName": "Samsung S9+",
+            "deviceOrientation": "portrait",
+            "browserName": "Chrome",
+            "newCommandTimeout": 60 * 5,
+        },
+    ),  # Platform(name='Android', version='7.0', browsers=[], extra={
+    #     "appiumVersion":     "1.9.1",
+    #     "deviceName":        "Android Emulator",
+    #     "deviceOrientation": "portrait",
+    #     "browserName":       "Chrome",
+    #     "newCommandTimeout": 60 * 5
+    # }),
+    # Platform(name='Android', version='8.0', browsers=[], extra={
+    #     "appiumVersion":     "1.9.1",
+    #     "deviceName":        "Samsung S9+",
+    #     "deviceOrientation": "portrait",
+    #     "browserName":       "Chrome",
+    #     "newCommandTimeout": 60 * 5
+    # })
+]
+SUPPORTED_PLATFORMS_DICT = {
+    platform.full_name: platform for platform in SUPPORTED_PLATFORMS
+}
+SUPPORTED_BROWSERS = set(
+    chain(*[platform.browsers for platform in SUPPORTED_PLATFORMS])
+)
 
 
 def pytest_addoption(parser):
@@ -129,9 +158,9 @@ def pytest_addoption(parser):
 def _get_capabilities(platform_name=None, browser_name=None, headless=False):
     if platform_name is None:
         sys2platform_name = {
-            'linux':  'Linux',
-            'darwin': 'macOS 10.13',
-            'win32':  'Windows 10'
+            "linux": "Linux",
+            "darwin": "macOS 10.13",
+            "win32": "Windows 10",
         }
         platform_name = sys2platform_name[sys.platform]
     platform = SUPPORTED_PLATFORMS_DICT[platform_name]
@@ -146,56 +175,66 @@ def _get_capabilities(platform_name=None, browser_name=None, headless=False):
 
 def _setup_env_vars_for_session():
     import uuid
+
     # setup environment variables once per test run if not settled up
     # needed for multi thread run
-    os.environ['APPLITOOLS_BATCH_ID'] = os.environ.get('APPLITOOLS_BATCH_ID', str(uuid.uuid4()))
+    os.environ["APPLITOOLS_BATCH_ID"] = os.environ.get(
+        "APPLITOOLS_BATCH_ID", str(uuid.uuid4())
+    )
 
 
 def pytest_generate_tests(metafunc):
-    platform_name = metafunc.config.getoption('platform')
-    browser_name = metafunc.config.getoption('browser')
-    headless = metafunc.config.getoption('headless')
+    platform_name = metafunc.config.getoption("platform")
+    browser_name = metafunc.config.getoption("browser")
+    headless = metafunc.config.getoption("headless")
 
     _setup_env_vars_for_session()
 
     if platform_name or browser_name:
         desired_caps = _get_capabilities(platform_name, browser_name, headless)
     else:
         desired_caps = []
-        platforms = getattr(metafunc.function, 'platform', [])
+        platforms = getattr(metafunc.function, "platform", [])
         if platforms:
             platforms = platforms.args
 
         for platform in SUPPORTED_PLATFORMS:
             if platform.name not in platforms:
                 continue
-            desired_caps.extend(_get_capabilities(platform.full_name, headless=headless))
+            desired_caps.extend(
+                _get_capabilities(platform.full_name, headless=headless)
+            )
 
     # update capabilities from capabilities marker
-    if hasattr(metafunc, 'function'):
-        func_capabilities = getattr(metafunc.function, 'capabilities', {})
+    if hasattr(metafunc, "function"):
+        func_capabilities = getattr(metafunc.function, "capabilities", {})
         if func_capabilities:
             for caps in desired_caps:
                 caps.update(func_capabilities.kwargs)
 
     # generate combinations of driver options before run
-    if 'driver' in metafunc.fixturenames:
-        metafunc.parametrize('browser_config', desired_caps, ids=_generate_param_ids(desired_caps), scope='function')
+    if "driver" in metafunc.fixturenames:
+        metafunc.parametrize(
+            "browser_config",
+            desired_caps,
+            ids=_generate_param_ids(desired_caps),
+            scope="function",
+        )
 
 
 def _generate_param_ids(desired_caps):
     results = []
     for caps in desired_caps:
-        platform = caps.get('platform')
-        browser = caps.get('browserName', '')
+        platform = caps.get("platform")
+        browser = caps.get("browserName", "")
         if platform:
-            browser_version = caps.get('version', '')
+            browser_version = caps.get("version", "")
             browser += str(browser_version)
         else:
-            platform = caps.get('platformName')
-            platform_version = caps.get('version', '')
+            platform = caps.get("platformName")
+            platform_version = caps.get("version", "")
             platform += platform_version
-        results.append('platform: {}, browser: {}'.format(platform, browser))
+        results.append("platform: {}, browser: {}".format(platform, browser))
     return results
 
 

tests/functional/conftest.py

@@ -11,8 +11,7 @@
     pytest --browser firefox --headless 1   # run all tests on your current platform with firefox browser in headless mode
 """
 import pytest
-
-from applitools.core import logger, StdoutLogger
+from applitools.core import StdoutLogger, logger
 from applitools.core.utils import iteritems
 
 logger.set_logger(StdoutLogger())
@@ -26,18 +25,19 @@ def eyes(request, eyes_class):
     eyes.hide_scrollbars = True
 
     # configure eyes options through @pytest.mark.eyes() marker
-    eyes_mark_opts = request.node.get_closest_marker('eyes')
+    eyes_mark_opts = request.node.get_closest_marker("eyes")
     eyes_mark_opts = eyes_mark_opts.kwargs if eyes_mark_opts else {}
 
     # configure eyes through @pytest.mark.parametrize('eyes', [])
-    eyes_parametrized_opts = getattr(request, 'param', {})
+    eyes_parametrized_opts = getattr(request, "param", {})
     if set(eyes_mark_opts.keys()).intersection(eyes_parametrized_opts):
-        raise ValueError("Eyes options conflict. The values from .mark.eyes and .mark.parametrize shouldn't intersect.")
+        raise ValueError(
+            "Eyes options conflict. The values from .mark.eyes and .mark.parametrize shouldn't intersect."
+        )
 
     eyes_mark_opts.update(eyes_parametrized_opts)
     for key, val in iteritems(eyes_mark_opts):
         setattr(eyes, key, val)
 
     yield eyes
     eyes.abort_if_not_closed()
-

tests/functional/eyes_images/conftest.py

@@ -1,7 +1,6 @@
 import os
 
 import pytest
-
 from applitools.images import Eyes
 from applitools.images.__version__ import __version__
 
@@ -12,11 +11,14 @@ def eyes_class():
 
 
 def _setup_env_vars_for_session():
-    python_version = os.environ.get('TRAVIS_PYTHON_VERSION', None)
+    python_version = os.environ.get("TRAVIS_PYTHON_VERSION", None)
     if not python_version:
         import platform
+
         python_version = platform.python_version()
-    os.environ['APPLITOOLS_BATCH_NAME'] = 'Python {} | Images SDK {}'.format(python_version, __version__)
+    os.environ["APPLITOOLS_BATCH_NAME"] = "Python {} | Images SDK {}".format(
+        python_version, __version__
+    )
 
 
 def pytest_generate_tests(metafunc):

tests/functional/eyes_images/test_functional.py

@@ -1,38 +1,44 @@
 # from applitools.core import Region, UnscaledFixedCutProvider
 from os import path
 
-from PIL import Image
-
 from applitools.images import Region, Target
+from PIL import Image
 
 here = path.abspath(path.dirname(__file__))
 
 
 def test_check_image(eyes):
-    eyes.open('images', 'TestCheckImage', dimension=dict(width=100, height=400))
-    eyes.check_image(path.join(here, 'resources/minions-800x500.jpg'))
+    eyes.open("images", "TestCheckImage", dimension=dict(width=100, height=400))
+    eyes.check_image(path.join(here, "resources/minions-800x500.jpg"))
     eyes.close()
 
 
 def test_check_image_path_fluent(eyes):
-    eyes.open('images', 'TestCheckImage_Fluent')
-    eyes.check("TestCheckImage_Fluent", Target().image(path.join(here, "resources/minions-800x500.jpg")))
+    eyes.open("images", "TestCheckImage_Fluent")
+    eyes.check(
+        "TestCheckImage_Fluent",
+        Target().image(path.join(here, "resources/minions-800x500.jpg")),
+    )
     eyes.close()
 
 
 def test_check_raw_image_fluent(eyes):
-    eyes.open('images', 'TestCheckImage_Fluent')
-    eyes.check("TestCheckImage_Fluent", Target().image(Image.new('RGBA', (600, 600))))
+    eyes.open("images", "TestCheckImage_Fluent")
+    eyes.check("TestCheckImage_Fluent", Target().image(Image.new("RGBA", (600, 600))))
     eyes.close()
 
 
 def test_check_image_with_ignore_region_fluent(eyes):
-    eyes.open('images', 'TestCheckImageWithIgnoreRegion_Fluent')
-    eyes.check("TestCheckImage_WithIgnoreRegion_Fluent",
-               Target().image(path.join(here, "resources/minions-800x500.jpg"))
-               .ignore(Region(10, 20, 30, 40)))
+    eyes.open("images", "TestCheckImageWithIgnoreRegion_Fluent")
+    eyes.check(
+        "TestCheckImage_WithIgnoreRegion_Fluent",
+        Target()
+        .image(path.join(here, "resources/minions-800x500.jpg"))
+        .ignore(Region(10, 20, 30, 40)),
+    )
     eyes.close()
 
+
 # def test_check_image_fluent_cut_provider(eyes):
 #     eyes.image_cut = UnscaledFixedCutProvider(200, 100, 100, 50)
 #     eyes.check("TestCheckImage_Fluent", Target.image("resources/minions-800x500.jpg"))