Merge pull request #10 from applitools/prepare-selenium-sdk

First working version of selenium sdk

Author: eirenik0

.editorconfig

@@ -14,10 +14,7 @@ charset = utf-8
 [*.{py,rst,ini}]
 indent_style = space
 indent_size = 4
-max_line_length = 119
-
-[*.py]
-max_line_length = 119
+max_line_length = 99
 
 [*.rst]
 max_line_length = off

.travis.yml

@@ -1,4 +1,10 @@
 language: python
+addons:
+    apt:
+        sources:
+            - google-chrome
+        packages:
+            - google-chrome-stable
 matrix:
     include:
         - python: 2.7
@@ -13,13 +19,25 @@ matrix:
         - python: 3.6
           env:
               - TOX_ENV=integration
+        - python: 2.7
+          env:
+              - TOX_ENV=selenium
+        - python: 3.6
+          env:
+              - TOX_ENV=selenium
         - python: 3.6
           env:
               - TOX_ENV=lint
 install:
-  - pip install -U tox
+    - npm install -g webdriver-manager
+    - webdriver-manager update
+    - pip install -U tox
 before_script:
-  - export APPLITOOLS_BATCH_ID=`uuidgen -t`
-  - echo $APPLITOOLS_BATCH_ID
+    - export DISPLAY=:99.0
+    - sh -e /etc/init.d/xvfb start
+    - nohup webdriver-manager start --logging=ERROR &
+    - sleep 10 # give webdriver some time to start
 script:
-  - tox -e $TOX_ENV
+    - export APPLITOOLS_BATCH_ID=`uuidgen -t`
+    - echo $APPLITOOLS_BATCH_ID
+    - tox -e $TOX_ENV

eyes_core/applitools/core/capture.py

@@ -1,56 +1,97 @@
 import abc
 import typing as tp
 
-import attr
-
 from .geometry import Point, Region
 from .metadata import CoordinatesType
-from .utils import ABC, image_utils
+from .utils import ABC, image_utils, argument_guard
 
 if tp.TYPE_CHECKING:
     from PIL import Image
 
 __all__ = ('EyesScreenshot',)
 
 
-@attr.s
 class EyesScreenshot(ABC):
     """
      Base class for handling screenshots.
      """
 
-    _image = attr.ib()  # type: Image.Image
+    def __init__(self, image):
+        # type: (Image.Image) -> None
+        self._image = image  # type: Image.Image
 
     @abc.abstractmethod
     def sub_screenshot(self, region, throw_if_clipped=False):
         # type: (Region, bool) -> Region
-        pass
+        """
+        Returns a part of the screenshot based on the given region.
+
+        :param region:           The region for which we should get the sub screenshot.
+        :param throw_if_clipped: Throw an EyesException if the region is not
+                                 fully contained in the screenshot.
+        :return: A screenshot instance containing the given region.
+        """
 
     @abc.abstractmethod
     def convert_location(self, location, from_, to):
         # type: (Point, CoordinatesType, CoordinatesType) -> Point
-        pass
+        """
+        Converts a location's coordinates with the `from_` coordinates type
+        to the `to` coordinates type.
+
+        :param location:  The location which coordinates needs to be converted.
+        :param from_:     The current coordinates type for `location`.
+        :param to:        The target coordinates type for `location`.
+        :return A new location which is the transformation of `location` to
+                the `to` coordinates type.
+        """
 
     @abc.abstractmethod
     def location_in_screenshot(self, location, coordinates_type):
         # type: (Point, CoordinatesType) -> Point
-        pass
+        """
+        Calculates the location in the screenshot of the location given as
+        parameter.
+
+        :param location:         The location as coordinates inside the current frame.
+        :param coordinates_type: The coordinates type of `location`.
+        :return: The corresponding location inside the screenshot,
+                 in screenshot as-is coordinates type.
+        :raise: `OutOfBoundsException` If the location is
+                not inside the frame's region in the screenshot.
+        """
 
     @abc.abstractmethod
-    def intersected_region(self, region, result_coordinate_types):
+    def intersected_region(self, region, coordinates_type):
         # type: (Region, CoordinatesType) -> Region
-        pass
+        """
+        Get the intersection of the given region with the screenshot.
+
+        :param region:          The region to intersect.
+        :param coordinates_type: The coordinates type of `region`.
+        :return The intersected region, in `coordinates_type` coordinates.
+        """
 
     def convert_region_location(self, region, from_, to):
         # type: (Region, CoordinatesType, CoordinatesType) -> Region
-        assert region is not None
-        assert isinstance(region, Region)
-        assert from_ is not None
-        assert to is not None
-
-        if region.is_empty:
+        """
+        Converts a region's location coordinates with the `from_`
+        coordinates type to the `to` coordinates type.
+
+        :param region: The region which location's coordinates needs to be converted.
+        :param from_:  The current coordinates type for `region`.
+        :param to:     The target coordinates type for `region`.
+        :return:       A new region which is the transformation of `region` to
+                       the `to` coordinates type.
+        """
+        argument_guard.not_none(region)
+        argument_guard.is_a(region, Region)
+        if region.is_size_empty:
             return Region.create_empty_region()
 
+        argument_guard.not_none(from_)
+        argument_guard.not_none(to)
+
         updated_location = self.convert_location(region.location, from_, to)
         return Region(updated_location.x, updated_location.y, region.width, region.height)
 
@@ -59,13 +100,9 @@ def image_region(self):
         # type: () -> Region
         return Region(0, 0, self._image.width, self._image.height, CoordinatesType.SCREENSHOT_AS_IS)
 
-    @staticmethod
-    def from_region(region):
-        # type: (Region) -> Image.Image
-        return Image.new('RGBA', (region.width, region.height))
-
-    def get_bytes(self):
-        # type: () -> bytes
+    @property
+    def bytes(self):
+        # type: () -> __builtins__.bytes
         """
         Returns the bytes of the screenshot.
 

eyes_core/applitools/core/eyes_base.py

@@ -98,9 +98,6 @@ def __init__(self, server_url=DEFAULT_EYES_SERVER):
         # If true, Eyes will treat new tests the same as failed tests.
         self.fail_on_new_test = False  # type: bool
 
-        # The number of milliseconds to wait before each time a screenshot is taken.
-        self.wait_before_screenshots = EyesBase._DEFAULT_WAIT_BEFORE_SCREENSHOTS  # type: int
-
         # If true, we will send full DOM to the server for analyzing
         self.send_dom = False  # type: bool
 
@@ -131,7 +128,7 @@ def set_viewport_size(self, size):
         """
 
     @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.
@@ -150,10 +147,6 @@ def _environment(self):
     def _inferred_environment(self):
         pass
 
-    @property
-    def _seconds_to_wait_screenshot(self):
-        return self.wait_before_screenshots / 1000.0
-
     @property
     def match_level(self):
         # type: () -> tp.Text
@@ -430,7 +423,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:

eyes_core/applitools/core/geometry.py

@@ -4,6 +4,7 @@
 import typing as tp
 from collections import OrderedDict
 
+from .utils import argument_guard
 from .metadata import CoordinatesType
 from .errors import EyesError
 
@@ -13,7 +14,24 @@
 __all__ = ('Point', 'Region',)
 
 
-class Point(object):
+class DictAccessMixin(object):
+    def __getitem__(self, item):
+        if item not in self.__slots__:
+            raise KeyError
+        return getattr(self, item)
+
+
+class StateMixin(object):
+    def __getstate__(self):
+        return OrderedDict([(name, getattr(self, name)) for name in self.__slots__])
+
+    # Required is required in order for jsonpickle to work on this object.
+    # noinspection PyMethodMayBeStatic
+    def __setstate__(self, state):
+        raise EyesError('Cannot create Point instance from dict!')
+
+
+class Point(DictAccessMixin, StateMixin):
     """
     A point with the coordinates (x,y).
     """
@@ -24,15 +42,6 @@ def __init__(self, x=0, y=0):
         self.x = int(round(x))
         self.y = int(round(y))
 
-    def __getstate__(self):
-        return OrderedDict([("x", self.x),
-                            ("y", self.y)])
-
-    # Required is required in order for jsonpickle to work on this object.
-    # noinspection PyMethodMayBeStatic
-    def __setstate__(self, state):
-        raise EyesError('Cannot create Point instance from dict!')
-
     def __add__(self, other):
         return Point(self.x + other.x, self.y + other.y)
 
@@ -164,11 +173,10 @@ def rotate_about(self, p, theta):
         return result
 
     def scale(self, scale_ratio):
-        return Point(int(math.ceil(self.x * scale_ratio)),
-                     int(math.ceil(self.y * scale_ratio)))
+        return Point(int(math.ceil(self.x * scale_ratio)), int(math.ceil(self.y * scale_ratio)))
 
 
-class Region(object):
+class Region(DictAccessMixin, StateMixin):
     """
     A rectangle identified by left,top, width, height.
     """
@@ -182,15 +190,6 @@ def __init__(self, left=0, top=0, width=0, height=0, coordinates_type=Coordinate
         self.height = int(round(height))
         self.coordinates_type = coordinates_type
 
-    def __getstate__(self):
-        return OrderedDict([("top", self.top), ("left", self.left), ("width", self.width),
-                            ("height", self.height), ("coordinatesType", self.coordinates_type)])
-
-    # Required is required in order for jsonpickle to work on this object.
-    # noinspection PyMethodMayBeStatic
-    def __setstate__(self, state):
-        raise EyesError('Cannot create Region instance from dict!')
-
     @classmethod
     def create_empty_region(cls):
         return cls(0, 0, 0, 0)
@@ -228,10 +227,11 @@ def location(self):
         return Point(self.left, self.top)
 
     @location.setter
-    def location(self, p):
+    def location(self, point):
         # type: (Point) -> None
         """Sets the top left corner of the region"""
-        self.left, self.top = p.x, p.y
+        argument_guard.not_none(point)
+        self.left, self.top = point.x, point.y
 
     @property
     def bottom_right(self):
@@ -265,8 +265,12 @@ def is_same(self, other):
         :return: Whether or not the rectangles have same coordinates.
         :rtype: bool
         """
-        return (self.left == other.left and self.top == other.top and self.width == other.width
-                and self.height == other.height)
+        return (
+            self.left == other.left
+            and self.top == other.top
+            and self.width == other.width
+            and self.height == other.height
+        )
 
     def is_same_size(self, other):
         # type: (Region) -> bool
@@ -291,13 +295,15 @@ def clip_negative_location(self):
         self.left = max(self.left, 0)
         self.top = max(self.top, 0)
 
+    @property
     def is_size_empty(self):
         # type: () -> bool
         """
         :return: true if the region's size is 0, false otherwise.
         """
         return self.width <= 0 or self.height <= 0
 
+    @property
     def is_empty(self):
         # type: () -> bool
         """
@@ -323,8 +329,8 @@ def overlaps(self, other):
         """
         Return true if a rectangle overlaps this rectangle.
         """
-        return ((self.left <= other.left <= self.right or other.left <= self.left <= other.right)
-                and (self.top <= other.top <= self.bottom or other.top <= self.top <= other.bottom))
+        return ((self.left <= other.left <= self.right or other.left <= self.left <= other.right) and (
+            self.top <= other.top <= self.bottom or other.top <= self.top <= other.bottom))
 
     def intersect(self, other):
         # type: (Region) -> None
@@ -362,8 +368,7 @@ def get_sub_regions(self, max_sub_region_size):
                 current_height = current_bottom - current_top
                 current_width = current_right - current_left
 
-                sub_regions.append(Region(current_left, current_top, current_width,
-                                          current_height))
+                sub_regions.append(Region(current_left, current_top, current_width, current_height))
 
                 current_left += max_sub_region_size["width"]
 
@@ -378,17 +383,11 @@ def middle_offset(self):
 
     def offset(self, dx, dy):
         location = self.location.offset(dx, dy)
-        return Region(left=location.x, top=location.y,
-                      width=self.size['width'],
-                      height=self.size['height'])
+        return Region(left=location.x, top=location.y, width=self.size['width'], height=self.size['height'])
 
     def scale(self, scale_ratio):
-        return Region(
-            left=int(math.ceil(self.left * scale_ratio)),
-            top=int(math.ceil(self.top * scale_ratio)),
-            width=int(math.ceil(self.width * scale_ratio)),
-            height=int(math.ceil(self.height * scale_ratio))
-        )
+        return Region(left=int(math.ceil(self.left * scale_ratio)), top=int(math.ceil(self.top * scale_ratio)),
+                      width=int(math.ceil(self.width * scale_ratio)), height=int(math.ceil(self.height * scale_ratio)))
 
     def __str__(self):
         return "(%s, %s) %s x %s" % (self.left, self.top, self.width, self.height)