robotframework-appiumwindows 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

AppiumLibrary/keywords/_runonfailure.py

@@ -1,74 +1,74 @@
-# -*- coding: utf-8 -*-
-
-from robot.libraries import BuiltIn
-
-from .keywordgroup import KeywordGroup
-
-BUILTIN = BuiltIn.BuiltIn()
-
-
-class _RunOnFailureKeywords(KeywordGroup):
-
-    def __init__(self):
-        self._run_on_failure_keyword = None
-        self._running_on_failure_routine = False
-
-    # Public
-
-    def register_keyword_to_run_on_failure(self, keyword):
-        """Sets the keyword to execute when a AppiumLibrary keyword fails.
-
-        `keyword_name` is the name of a keyword (from any available
-        libraries) that  will be executed if a AppiumLibrary keyword fails.
-        It is not possible to use a keyword that requires arguments.
-        Using the value "Nothing" will disable this feature altogether.
-
-        The initial keyword to use is set in `importing`, and the
-        keyword that is used by default is `Capture Page Screenshot`.
-        Taking a screenshot when something failed is a very useful
-        feature, but notice that it can slow down the execution.
-
-        This keyword returns the name of the previously registered
-        failure keyword. It can be used to restore the original
-        value later.
-
-        Example:
-        | Register Keyword To Run On Failure  | Log Source | # Run `Log Source` on failure. |
-        | ${previous kw}= | Register Keyword To Run On Failure  | Nothing    | # Disables run-on-failure functionality and stores the previous kw name in a variable. |
-        | Register Keyword To Run On Failure  | ${previous kw} | # Restore to the previous keyword. |
-
-        This run-on-failure functionality only works when running tests on Python/Jython 2.4
-        or newer and it does not work on IronPython at all.
-        """
-        old_keyword = self._run_on_failure_keyword
-        old_keyword_text = old_keyword if old_keyword is not None else "Nothing"
-
-        new_keyword = keyword if keyword.strip().lower() != "nothing" else None
-        new_keyword_text = new_keyword if new_keyword is not None else "Nothing"
-
-        self._run_on_failure_keyword = new_keyword
-        self._info('%s will be run on failure.' % new_keyword_text)
-
-        return old_keyword_text
-
-    # Private
-
-    def _run_on_failure(self):
-        if self._run_on_failure_keyword is None:
-            return
-        if self._running_on_failure_routine:
-            return
-        self._running_on_failure_routine = True
-        try:
-            BUILTIN.run_keyword(self._run_on_failure_keyword)
-        except Exception as err:
-            self._run_on_failure_error(err)
-        finally:
-            self._running_on_failure_routine = False
-
-    def _run_on_failure_error(self, err):
-        err = "Keyword '%s' could not be run on failure: %s" % (self._run_on_failure_keyword, err)
-        if hasattr(self, '_warn'):
-            self._warn(err)
-            return
-        raise Exception(err)
+# -*- coding: utf-8 -*-
+
+from robot.libraries import BuiltIn
+
+from .keywordgroup import KeywordGroup
+
+BUILTIN = BuiltIn.BuiltIn()
+
+
+class _RunOnFailureKeywords(KeywordGroup):
+
+    def __init__(self):
+        self._run_on_failure_keyword = None
+        self._running_on_failure_routine = False
+
+    # Public
+
+    def register_keyword_to_run_on_failure(self, keyword):
+        """Sets the keyword to execute when a AppiumLibrary keyword fails.
+
+        `keyword_name` is the name of a keyword (from any available
+        libraries) that  will be executed if a AppiumLibrary keyword fails.
+        It is not possible to use a keyword that requires arguments.
+        Using the value "Nothing" will disable this feature altogether.
+
+        The initial keyword to use is set in `importing`, and the
+        keyword that is used by default is `Capture Page Screenshot`.
+        Taking a screenshot when something failed is a very useful
+        feature, but notice that it can slow down the execution.
+
+        This keyword returns the name of the previously registered
+        failure keyword. It can be used to restore the original
+        value later.
+
+        Example:
+        | Register Keyword To Run On Failure  | Log Source | # Run `Log Source` on failure. |
+        | ${previous kw}= | Register Keyword To Run On Failure  | Nothing    | # Disables run-on-failure functionality and stores the previous kw name in a variable. |
+        | Register Keyword To Run On Failure  | ${previous kw} | # Restore to the previous keyword. |
+
+        This run-on-failure functionality only works when running tests on Python/Jython 2.4
+        or newer and it does not work on IronPython at all.
+        """
+        old_keyword = self._run_on_failure_keyword
+        old_keyword_text = old_keyword if old_keyword is not None else "Nothing"
+
+        new_keyword = keyword if keyword.strip().lower() != "nothing" else None
+        new_keyword_text = new_keyword if new_keyword is not None else "Nothing"
+
+        self._run_on_failure_keyword = new_keyword
+        self._info('%s will be run on failure.' % new_keyword_text)
+
+        return old_keyword_text
+
+    # Private
+
+    def _run_on_failure(self):
+        if self._run_on_failure_keyword is None:
+            return
+        if self._running_on_failure_routine:
+            return
+        self._running_on_failure_routine = True
+        try:
+            BUILTIN.run_keyword(self._run_on_failure_keyword)
+        except Exception as err:
+            self._run_on_failure_error(err)
+        finally:
+            self._running_on_failure_routine = False
+
+    def _run_on_failure_error(self, err):
+        err = "Keyword '%s' could not be run on failure: %s" % (self._run_on_failure_keyword, err)
+        if hasattr(self, '_warn'):
+            self._warn(err)
+            return
+        raise Exception(err)

AppiumLibrary/keywords/_screenrecord.py

@@ -1,138 +1,138 @@
-# -*- coding: utf-8 -*-
-
-import base64
-import os
-
-import robot
-
-from .keywordgroup import KeywordGroup
-
-
-class _ScreenrecordKeywords(KeywordGroup):
-
-    def __init__(self):
-        self._screenrecord_index = 0
-        self._recording = None
-        self._output_format = None
-
-    def start_screen_recording(self,
-                               timeLimit='180s',
-                               **options):
-        """Starts an asynchronous Screen Recording for the current open application.
-
-        ``timeLimit`` sets the actual time limit of the recorded video.
-          - The default value for both iOS and Android is 180 seconds (3 minutes).
-          - The maximum value for Android is 3 minutes.
-          - The maximum value for iOS is 10 minutes.
-
-        === Optional Args ===
-
-         - ``bitRate`` (Android Only) The video bit rate for the video, in megabits per second.
-            4 Mbp/s(4000000) is by default for Android API level below 27.                      \
-              20 Mb/s(20000000) for API level 27 and above.
-
-         - ``videoSize`` (Android Only) The format is widthxheight. The default value is the    \
-            device's native display resolution (if supported), 1280x720 if not. For best        \
-                results, use a size supported by your device's Advanced Video Coding (AVC)      \
-                    encoder. For example, "1280x720"
-
-         - ``bugReport`` (Android Only) Set it to true in order to display additional           \
-            information on the video overlay, such as a timestamp, that is helpful in           \
-                videos captured to illustrate bugs. This option is only supported since         \
-                    API level 27 (Android O).
-
-         - ``videoQuality`` (iOS Only) The video encoding quality (low, medium, high,           \
-            photo - defaults to medium).
-
-         - ``videoFps`` 	(iOS Only) The Frames Per Second rate of the recorded video.        \
-            Change this value if the resulting video is too slow or too fast. Defaults to 10.   \
-                This can decrease the resulting file size.
-
-         - ``videoScale`` (iOS Only) The scaling value to apply. Read                           \
-            https://trac.ffmpeg.org/wiki/Scaling for possible values. Example value of 720p     \
-                scaling is '1280:720'. This can decrease/increase the resulting file size.      \
-                    No scale is applied by default.
-
-        `Start Screen Recording` is used hand in hand with `Stop Screen Recording`.
-        See `Stop Screen Recording` for more details.
-        Example:
-            | `Start Screen Recording`  |                   | # starts a screen record session  |
-            | ....     keyword actions  |                   |                                   |
-            | `Stop Screen Recording`   | filename=output   | # saves the recorded session      |
-        """
-        timeLimit = robot.utils.timestr_to_secs(timeLimit)
-        options['timeLimit'] = timeLimit
-        self._output_format = self._set_output_format() \
-            if self._output_format is None else self._output_format
-        if self._recording is None:
-            self._recording = self._current_application().start_recording_screen(**options)
-
-    def stop_screen_recording(self, filename=None, **options):
-        """Gathers the output from the previously started screen recording  \
-            to a media file, then embeds it to the log.html(Android Only).
-
-        Requires an active or exhausted Screen Recording Session.
-        See `Start Screen Recording` for more details.
-
-        === Optional Args ===
-
-         - ``remotePath`` The path to the remote location, where the resulting video should be  \
-            uploaded. The following protocols are supported _http/https_, ftp. Null or empty  \
-                string value (the default setting) means the content of resulting file should   \
-                    be encoded as Base64 and passed as the endpoint response value. An          \
-                        exception will be thrown if the generated media file is too big to fit  \
-                            into the available process memory.
-
-         - ``username`` The name of the user for the remote authentication.
-
-         - ``password`` The password for the remote authentication.
-
-         - ``method`` The http multipart upload method name. The _PUT_ one is used by default.
-
-        Example:
-            | `Start Screen Recording`  |                   | # starts a screen record session  |
-            | ....     keyword actions  |                   |                                   |
-            | `Stop Screen Recording`   | filename=output   | # saves the recorded session      |
-        """
-        if self._recording is not None:
-            self._recording = self._current_application().stop_recording_screen(**options)
-            return self._save_recording(filename, options)
-        else:
-            raise RuntimeError("There is no Active Screen Record Session.")
-
-    def _save_recording(self, filename, options):
-        path, link = self._get_screenrecord_paths(options, filename)
-        decoded = base64.b64decode(self._recording)
-        with open(path, 'wb') as screenrecording:
-            screenrecording.write(decoded)
-        # Embed the Screen Recording to the log file
-        # if the current platform is Android and no remotePath is set.
-        if self._is_android() and not self._is_remotepath_set(options):
-            self._html('</td></tr><tr><td colspan="3"><a href="{vid}">'
-                       '<video width="800px" controls>'
-                       '<source src="{vid}" type="video/mp4">'
-                       '</video></a>'.format(vid=link)
-                       )
-        # Empty Screen Record Variable
-        self._recording = None
-        return path
-
-    def _set_output_format(self):
-        return '.ffmpeg' if self._is_ios() else '.mp4'
-
-    def _get_screenrecord_paths(self, options, filename=None):
-        if filename is None:
-            self._screenrecord_index += 1
-            filename = 'appium-screenrecord-{index}{ext}'.format(index=self._screenrecord_index,
-                                                                 ext=self._output_format
-                                                                 )
-        else:
-            filename = (filename.replace('/', os.sep)) + self._output_format
-        logdir = options['remotePath'] if self._is_remotepath_set(options) \
-            else self._get_log_dir()
-        path = os.path.join(logdir, filename)
-        link = robot.utils.get_link_path(path, logdir)
-        return path, link
-
-    def _is_remotepath_set(self, options):
-        return True if 'remotePath' in options else False
+# -*- coding: utf-8 -*-
+
+import base64
+import os
+
+import robot
+
+from .keywordgroup import KeywordGroup
+
+
+class _ScreenrecordKeywords(KeywordGroup):
+
+    def __init__(self):
+        self._screenrecord_index = 0
+        self._recording = None
+        self._output_format = None
+
+    def start_screen_recording(self,
+                               timeLimit='180s',
+                               **options):
+        """Starts an asynchronous Screen Recording for the current open application.
+
+        ``timeLimit`` sets the actual time limit of the recorded video.
+          - The default value for both iOS and Android is 180 seconds (3 minutes).
+          - The maximum value for Android is 3 minutes.
+          - The maximum value for iOS is 10 minutes.
+
+        === Optional Args ===
+
+         - ``bitRate`` (Android Only) The video bit rate for the video, in megabits per second.
+            4 Mbp/s(4000000) is by default for Android API level below 27.                      \
+              20 Mb/s(20000000) for API level 27 and above.
+
+         - ``videoSize`` (Android Only) The format is widthxheight. The default value is the    \
+            device's native display resolution (if supported), 1280x720 if not. For best        \
+                results, use a size supported by your device's Advanced Video Coding (AVC)      \
+                    encoder. For example, "1280x720"
+
+         - ``bugReport`` (Android Only) Set it to true in order to display additional           \
+            information on the video overlay, such as a timestamp, that is helpful in           \
+                videos captured to illustrate bugs. This option is only supported since         \
+                    API level 27 (Android O).
+
+         - ``videoQuality`` (iOS Only) The video encoding quality (low, medium, high,           \
+            photo - defaults to medium).
+
+         - ``videoFps`` 	(iOS Only) The Frames Per Second rate of the recorded video.        \
+            Change this value if the resulting video is too slow or too fast. Defaults to 10.   \
+                This can decrease the resulting file size.
+
+         - ``videoScale`` (iOS Only) The scaling value to apply. Read                           \
+            https://trac.ffmpeg.org/wiki/Scaling for possible values. Example value of 720p     \
+                scaling is '1280:720'. This can decrease/increase the resulting file size.      \
+                    No scale is applied by default.
+
+        `Start Screen Recording` is used hand in hand with `Stop Screen Recording`.
+        See `Stop Screen Recording` for more details.
+        Example:
+            | `Start Screen Recording`  |                   | # starts a screen record session  |
+            | ....     keyword actions  |                   |                                   |
+            | `Stop Screen Recording`   | filename=output   | # saves the recorded session      |
+        """
+        timeLimit = robot.utils.timestr_to_secs(timeLimit)
+        options['timeLimit'] = timeLimit
+        self._output_format = self._set_output_format() \
+            if self._output_format is None else self._output_format
+        if self._recording is None:
+            self._recording = self._current_application().start_recording_screen(**options)
+
+    def stop_screen_recording(self, filename=None, **options):
+        """Gathers the output from the previously started screen recording  \
+            to a media file, then embeds it to the log.html(Android Only).
+
+        Requires an active or exhausted Screen Recording Session.
+        See `Start Screen Recording` for more details.
+
+        === Optional Args ===
+
+         - ``remotePath`` The path to the remote location, where the resulting video should be  \
+            uploaded. The following protocols are supported _http/https_, ftp. Null or empty  \
+                string value (the default setting) means the content of resulting file should   \
+                    be encoded as Base64 and passed as the endpoint response value. An          \
+                        exception will be thrown if the generated media file is too big to fit  \
+                            into the available process memory.
+
+         - ``username`` The name of the user for the remote authentication.
+
+         - ``password`` The password for the remote authentication.
+
+         - ``method`` The http multipart upload method name. The _PUT_ one is used by default.
+
+        Example:
+            | `Start Screen Recording`  |                   | # starts a screen record session  |
+            | ....     keyword actions  |                   |                                   |
+            | `Stop Screen Recording`   | filename=output   | # saves the recorded session      |
+        """
+        if self._recording is not None:
+            self._recording = self._current_application().stop_recording_screen(**options)
+            return self._save_recording(filename, options)
+        else:
+            raise RuntimeError("There is no Active Screen Record Session.")
+
+    def _save_recording(self, filename, options):
+        path, link = self._get_screenrecord_paths(options, filename)
+        decoded = base64.b64decode(self._recording)
+        with open(path, 'wb') as screenrecording:
+            screenrecording.write(decoded)
+        # Embed the Screen Recording to the log file
+        # if the current platform is Android and no remotePath is set.
+        if self._is_android() and not self._is_remotepath_set(options):
+            self._html('</td></tr><tr><td colspan="3"><a href="{vid}">'
+                       '<video width="800px" controls>'
+                       '<source src="{vid}" type="video/mp4">'
+                       '</video></a>'.format(vid=link)
+                       )
+        # Empty Screen Record Variable
+        self._recording = None
+        return path
+
+    def _set_output_format(self):
+        return '.ffmpeg' if self._is_ios() else '.mp4'
+
+    def _get_screenrecord_paths(self, options, filename=None):
+        if filename is None:
+            self._screenrecord_index += 1
+            filename = 'appium-screenrecord-{index}{ext}'.format(index=self._screenrecord_index,
+                                                                 ext=self._output_format
+                                                                 )
+        else:
+            filename = (filename.replace('/', os.sep)) + self._output_format
+        logdir = options['remotePath'] if self._is_remotepath_set(options) \
+            else self._get_log_dir()
+        path = os.path.join(logdir, filename)
+        link = robot.utils.get_link_path(path, logdir)
+        return path, link
+
+    def _is_remotepath_set(self, options):
+        return True if 'remotePath' in options else False

AppiumLibrary/keywords/_screenshot.py

@@ -1,109 +1,105 @@
-# -*- coding: utf-8 -*-
-
-import os
-from base64 import b64decode
-
-import robot
-
-from .keywordgroup import KeywordGroup, ignore_on_fail
-
-
-class _ScreenshotKeywords(KeywordGroup):
-
-    # Public
-
-    def appium_get_element_screenshot(self, locator, timeout=20, filename=None):
-        """
-        Get a screenshot of element to base64
-        If provide filename, saves a screenshot to a PNG image file.
-
-        Parameters:
-        -----------
-        locator: Element locator
-        timeout: timeout in second to find element
-        filename : str
-            - The full path you wish to save your screenshot to. This
-            - should end with a `.png` extension.
-
-        Example:
-        --------
-        >>> driver.get_screenshot_as_file("/Screenshots/foo.png")
-        """
-
-        element = self._invoke_original("appium_get_element", locator, timeout, False)
-
-        if not element:
-            self._info(f'Not found {locator}, return None')
-            return None
-
-        base64data = element.screenshot_as_base64
-
-        if filename:
-            if not str(filename).lower().endswith(".png"):
-                self._info(
-                    "name used for saved screenshot does not match file type. It should end with a `.png` extension")
-
-            png = b64decode(base64data.encode("ascii"))
-            try:
-                with open(filename, "wb") as f:
-                    f.write(png)
-            except OSError:
-                self._info(f'Fail to write screenshot file {filename}, return False')
-                return False
-            finally:
-                del png
-            return True
-
-        return base64data
-
-    @ignore_on_fail
-    def appium_get_screenshot(self):
-        return self._invoke_original("appium_capture_page_screenshot", None, False)
-
-    def appium_capture_page_screenshot(self, filename=None, embed=True):
-        try:
-            return self._invoke_original("capture_page_screenshot", filename, embed)
-        except Exception as err:
-            self._info(err)
-        return None
-
-    def capture_page_screenshot(self, filename=None, embed=True):
-        """Takes a screenshot of the current page and embeds it into the log.
-
-        `filename` argument specifies the name of the file to write the
-        screenshot into. If no `filename` is given, the screenshot will be
-        embedded as Base64 image to the log.html. In this case no file is created in the filesystem.
-
-        `embed` is True: the screenshot will be embedded to the log.html
-
-        Warning: this behavior is new in 1.7. Previously if no filename was given
-        the screenshots where stored as separate files named `appium-screenshot-<counter>.png`
-        """
-        if filename:
-            path, link = self._get_screenshot_paths(filename)
-
-            if hasattr(self._current_application(), 'get_screenshot_as_file'):
-                self._current_application().get_screenshot_as_file(path)
-            else:
-                self._current_application().save_screenshot(path)
-
-            # Image is shown on its own row and thus prev row is closed on purpose
-            if embed:
-                self._html('</td></tr><tr><td colspan="3"><a href="%s">'
-                           '<img src="%s" width="800px"></a>' % (link, link))
-            return path
-        else:
-            base64_screenshot = self._current_application().get_screenshot_as_base64()
-            if embed:
-                self._html('</td></tr><tr><td colspan="3">'
-                           '<img src="data:image/png;base64, %s" width="800px">' % base64_screenshot)
-            return None
-
-    # Private
-
-    def _get_screenshot_paths(self, filename):
-        filename = filename.replace('/', os.sep)
-        logdir = self._get_log_dir()
-        path = os.path.join(logdir, filename)
-        link = robot.utils.get_link_path(path, logdir)
-        return path, link
+# -*- coding: utf-8 -*-
+
+import os
+from base64 import b64decode
+
+import robot
+
+from .keywordgroup import KeywordGroup, ignore_on_fail
+
+
+class _ScreenshotKeywords(KeywordGroup):
+
+    # Public
+
+    def appium_get_element_screenshot(self, locator, timeout=20, filename=None):
+        """
+        Get a screenshot of element to base64
+        If provide filename, saves a screenshot to a PNG image file.
+
+        Parameters:
+        -----------
+        locator: Element locator
+        timeout: timeout in second to find element
+        filename : str
+            - The full path you wish to save your screenshot to. This
+            - should end with a `.png` extension.
+
+        Example:
+        --------
+        >>> driver.get_screenshot_as_file("/Screenshots/foo.png")
+        """
+
+        element = self.appium_get_element(locator, timeout, False)
+
+        if not element:
+            self._info(f'Not found {locator}, return None')
+            return None
+
+        base64data = element.screenshot_as_base64
+
+        if filename:
+            if not str(filename).lower().endswith(".png"):
+                self._info("name used for saved screenshot does not match file type. It should end with a `.png` extension")
+
+            png = b64decode(base64data.encode("ascii"))
+            try:
+                with open(filename, "wb") as f:
+                    f.write(png)
+            except OSError:
+                self._info(f'Fail to write screenshot file {filename}, return False')
+                return False
+            finally:
+                del png
+            return True
+
+        return base64data
+
+    @ignore_on_fail
+    def appium_get_screenshot(self):
+        return self.appium_capture_page_screenshot(None, False)
+
+    def appium_capture_page_screenshot(self, filename=None, embed=True):
+        try:
+            return self.capture_page_screenshot(filename, embed)
+        except Exception as err:
+            self._info(err)
+        return None
+
+    def capture_page_screenshot(self, filename=None, embed=True):
+        """Takes a screenshot of the current page and embeds it into the log.
+
+        `filename` argument specifies the name of the file to write the
+        screenshot into. If no `filename` is given, the screenshot will be
+        embedded as Base64 image to the log.html. In this case no file is created in the filesystem.
+
+        `embed` is True: the screenshot will be embedded to the log.html
+
+        Warning: this behavior is new in 1.7. Previously if no filename was given
+        the screenshots where stored as separate files named `appium-screenshot-<counter>.png`
+        """
+        if filename:
+            path, link = self._get_screenshot_paths(filename)
+
+            if hasattr(self._current_application(), 'get_screenshot_as_file'):
+                self._current_application().get_screenshot_as_file(path)
+            else:
+                self._current_application().save_screenshot(path)
+
+            # Image is shown on its own row and thus prev row is closed on purpose
+            if embed:
+                self._html('</td></tr><tr><td colspan="3"><a href="%s"><img src="%s" width="800px"></a>' % (link, link))
+            return path
+        else:
+            base64_screenshot = self._current_application().get_screenshot_as_base64()
+            if embed:
+                self._html('</td></tr><tr><td colspan="3"><img src="data:image/png;base64, %s" width="800px">' % base64_screenshot)
+            return None
+
+    # Private
+    def _get_screenshot_paths(self, filename):
+        filename = filename.replace('/', os.sep)
+        logdir = self._get_log_dir()
+        path = os.path.join(logdir, filename)
+        link = robot.utils.get_link_path(path, logdir)
+        return path, link