Adding mobile support

Author: malazay

Pipfile

@@ -3,11 +3,17 @@ name = "pypi"
 url = "https://pypi.org/simple"
 verify_ssl = true
 
+[[source]]
+name = "test"
+url = "https://test.pypi.org/simple"
+verify_ssl = true
+
 [dev-packages]
 twine = "*"
 setuptools = "*"
 wheel = "*"
 autopep8 = "*"
+samu-todo = "*"
 
 [packages]
 selenium = "*"
@@ -19,6 +25,8 @@ jinja2 = "*"
 coverage = "*"
 sphinx = "*"
 pyunitreport = "*"
+appium-python-client = "*"
+allure-behave = "*"
 
 [requires]
 python_version = "3.7"

Pipfile.lock

@@ -1,4 +1,4 @@
-[![CircleCI](https://circleci.com/gh/malazay/samuranium.svg?style=svg)](https://circleci.com/gh/malazay/samuranium)
+[![CircleCI](https://circleci.com/gh/malazay/samuranium.svg?style=shield)](https://circleci.com/gh/malazay/samuranium)
 
 # Samuranium Automation Framework
 

README.md

@@ -0,0 +1,6 @@
+[behave]
+paths =
+    /features
+
+[behave.formatters]
+allure = allure_behave.formatter:AllureFormatter

behave.ini

@@ -1,2 +1,2 @@
-python3 setup.py sdist bdist_wheel
-twine upload --repository-url https://test.pypi.org/legacy/ dist/*build.sh
+python3 setup_test.py sdist bdist_wheel
+twine upload --repository-url https://test.pypi.org/legacy/ dist/*

build_test.sh

@@ -1,19 +1,23 @@
+import time
+
 from selenium.webdriver.remote.webelement import WebElement as we
 from selenium.webdriver.common.by import By
 from samuranium.utils.time import get_current_time
-from samuranium.utils.logger import Logger
 from timeit import default_timer as timer
+from selenium.common.exceptions import NoSuchElementException
 
 
 class WebElement:
     """
     Web element class
     """
-    def __init__(self, browser, selector, max_wait_time=30):
-        self.browser = browser
-        self.logger = Logger() # In the future this will be obtained from the core class so there is only 1 logger instance
+    def __init__(self, samuranium, selector, exact_selector=False, max_wait_time=None):
+        self.samuranium = samuranium
+        self.browser = self.samuranium.browser
+        self.logger = self.samuranium.logger
         self.selector = selector
-        self.max_wait_time = max_wait_time
+        self.exact_selector = exact_selector
+        self.max_wait_time = max_wait_time if max_wait_time else float(self.samuranium.config.default_wait_time)
 
     @property
     def element(self):
@@ -27,21 +31,66 @@ def element(self):
     def text(self):
         return self.element.text
 
+    def is_present(self):
+        return self.element is not None
+
+
+    def ensure_element_exists(self):
+        if not self.is_present():
+            raise NoSuchElementException('Element with selector "{}" was not found after {} seconds'.
+                                         format(self.selector, self.max_wait_time))
+
     def __finder_strategies(self):
         return {'xpath': By.XPATH, 'css': By.CSS_SELECTOR, 'id': By.ID, 'class_name': By.CLASS_NAME,
                 'link_text': By.LINK_TEXT, 'name': By.NAME}
 
+    def __xpath_strategies(self):
+        return {'match_xpath': '{}','exact_text': '//*[text()="{}"]',
+                'normalize_text': '//*[text()[normalize-space()="{}"]]'}
+
+    def __css_strategies(self):
+        return {'match_css': '{}', 'class_name': '.{}', 'id': '#{}'}
+
     def __find_element(self):
         start_time = get_current_time()
         while timer() - start_time < self.max_wait_time:
             for strategy_name, method in self.__finder_strategies().items():
                 try:
-                    element: we = self.browser.find_element(method, self.selector)
-                    return element
+                    if strategy_name == 'xpath':
+                        element: we =  self.__find_by_xpath()
+                        if element:
+                            return element
+                    elif strategy_name == 'css':
+                        element: we = self.__find_by_css_selector()
+                        if element:
+                            return element
+                    if not self.exact_selector:
+                        element: we = self.browser.find_element(method, self.selector)
+                        return element
                 except:
                     pass
         return None
 
+    def __find_by_xpath(self):
+        for finder_name, xpath_strategy in self.__xpath_strategies().items():
+            try:
+                if self.exact_selector:
+                    return self.browser.find_element_by_xpath(self.selector)
+                return self.browser.find_element_by_xpath(xpath_strategy.format(self.selector))
+            except NoSuchElementException:
+                pass
+        return None
+
+    def __find_by_css_selector(self):
+        for finder_name, css_stragegy in self.__css_strategies().items():
+            try:
+                if self.exact_selector:
+                    return self.browser.find_element_by_css_selector(self.selector)
+                return self.browser.find_element_by_css_selector(css_stragegy.format(self.selector))
+            except NoSuchElementException:
+                pass
+        return None
+
     def is_displayed(self):
         return self.element.is_displayed()
 
@@ -55,11 +104,14 @@ def click(self):
             return False
 
     def input_text(self, text):
-        try:
-            self.element.send_keys(text)
-            return True
-        except Exception as e:
-            self.logger.error('Not possible to send text {} to element with selector {}'.format(
-                text, self.selector), e)
-            return False
+        for _ in range(5):
+            try:
+                self.element.send_keys(text)
+                return True
+            except Exception as e:
+                self.logger.error('Not possible to send text {} to element with selector {}'.format(
+                    text, self.selector), e)
+                self.logger.debug("Waiting 1 second until element is interactable")
+                time.sleep(1)
+        return False
 

samuranium/WebElement.py

@@ -1,28 +1,41 @@
+import datetime
+import os
+
 from selenium import webdriver
 from selenium.webdriver.common.keys import Keys
 from webdriver_manager.chrome import ChromeDriverManager
 from webdriver_manager.firefox import GeckoDriverManager
 from samuranium.WebElement import WebElement
+from samuranium.mobile import Mobile
+from samuranium.utils.config import Config
 from samuranium.utils.logger import Logger
 from samuranium.reporter import Reporter
+from samuranium.utils.paths import REPORT_SCREENSHOTS_PATH
+
 
 class Samuranium:
     """
     Main class for Samuranium
 
     This is called when 'import Samuranium from samuraniun'
     """
-    def __init__(self, selected_browser='chrome'):
+
+    def __init__(self, context=None, selected_browser=None):
         """
         Initialization function
         Args:
             selected_browser: a string expecting browser name. Ex: 'chrome', 'firefox'
         """
-        self.selected_browser = selected_browser
+        self.context = context
+        self.config = Config(context)
+        self.selected_browser = selected_browser if selected_browser else self.config.browser
         self.browser = self.__set_browser()
         self.logger = Logger()
         self.reporter = Reporter()
         self.selected_element = None
+        if self.context:
+            context.samuranium = self
+            context.browser = self.browser
 
     def get_browser(self):
         """
@@ -41,7 +54,11 @@ def __set_browser(self):
         Returns: Webdriver element
 
         """
-        return {'chrome': self.__get_chrome, 'firefox': self.__get_firefox}.get(self.selected_browser)()
+        return {'chrome': self.__get_chrome, 'firefox': self.__get_firefox,
+                'android-browser': self.__get_android_browser}.get(self.selected_browser)()
+
+    def __get_android_browser(self):
+        return Mobile(self).get_driver()
 
     def __get_chrome(self):
         """
@@ -84,25 +101,28 @@ def wait_for_element(self, selector):
         Returns: Boolean for element.is_displayed()
 
         """
-        self.selected_element = WebElement(self.browser, selector)
-        if not self.selected_element:
-            raise Exception("Element not found") # Todo handle this exception properly :D
+        self.selected_element = WebElement(self, selector)
+        self.selected_element.ensure_element_exists()
         return self.selected_element.is_displayed()
 
-    def find_element(self, selector):
+    def find_element(self, selector, exact_selector=False):
         """
         Finds an element by the given selector
 
         Sets the element to self.selected_element so you can use it before action methods like click_on_element
+
+        Warnings:
+            Triggers a NoSuchElementException if not found
         Args:
             selector: Any valid selector
 
         Returns: WebElement
         """
-        self.selected_element: WebElement = WebElement(self.browser, selector)
+        self.selected_element: WebElement = WebElement(self, selector, exact_selector=exact_selector)
+        self.selected_element.ensure_element_exists()
         return self.selected_element
 
-    def click_on_element(self, selector=None):
+    def click_on_element(self, selector=None, exact_selector=False):
         """
         Clicks on an element by a given selector
         If no selector is passed, it will try to click on self.selected_element, set by find_element for instance
@@ -111,7 +131,7 @@ def click_on_element(self, selector=None):
             selector: Any valid selector
         """
         if selector:
-            self.selected_element = WebElement(self.browser, selector)
+            self.find_element(selector, exact_selector)
         self.selected_element.click()
 
     def input_text_on_element(self, text, selector=None):
@@ -123,7 +143,7 @@ def input_text_on_element(self, text, selector=None):
             selector: (optional) Any valid selector.
         """
         if selector:
-            self.selected_element = WebElement(self.browser, selector)
+            self.find_element(selector)
         self.selected_element.input_text(text)
 
     def press_enter_key(self):
@@ -153,9 +173,33 @@ def press_backspace_key(self, times=1):
         for _ in range(0, times):
             self.selected_element.input_text(Keys.BACKSPACE)
 
+    def save_screenshot(self, name=None, output_folder=None):
+        if not output_folder:
+            output_folder = REPORT_SCREENSHOTS_PATH
+        if not name:
+            name = 'randomvalue.png'
+        if not name.endswith('.png'):
+            name = '{}.png'.format(name)
+        screenshot_path = os.path.join(output_folder, name)
+        os.makedirs(output_folder, exist_ok=True)
+        self.browser.save_screenshot(screenshot_path)
+
+    def save_error_screenshot(self, step):
+        output_folder = REPORT_SCREENSHOTS_PATH
+        os.makedirs(output_folder, exist_ok=True)
+        screenshot_name = '{}.png'.format(str(datetime.datetime.now().strftime("%Y%m%d_%H-%M-%S")))
+        screenshot_path = os.path.join(output_folder, screenshot_name)
+        self.browser.save_screenshot(screenshot_path)
+        step.screenshot = screenshot_path
+
+
     def tear_down(self):
         """
         Closes the browser and sets self.browser = None
         """
+        try:
+            os.environ.pop('VERSION')
+        except Exception:
+            pass
         self.browser.quit()
         self.browser = None

samuranium/__init__.py

@@ -0,0 +1,4 @@
+from samuranium.runner import samuranium_runner
+
+if __name__ == '__main__':
+    samuranium_runner()

samuranium/__main__.py

@@ -0,0 +1,54 @@
+import os
+import time
+
+import requests
+
+from samuranium.utils.general import get_random_port, run_command
+from webdriver_manager.chrome import ChromeDriverManager
+
+
+class AppiumServerManager:
+    def __init__(self, samuranium):
+        self.config = samuranium.config
+        self.appium_command = 'appium'
+        self.port = None
+        self.logs_port = None
+        self.process = None
+        self.pid = None
+        self.chromedriver_version = self.config.get_property('mobile', 'chromedriver')
+
+
+    def is_running(self):
+        try:
+            _status_request = requests.get('http://127.0.0.1:{}/wd/hub/status'.format(self.port))
+            return _status_request.status_code == 200 and _status_request.json().get('status') == 0
+        except:
+            return False
+
+    @property
+    def chromedriver_path(self):
+        if self.chromedriver_version:
+            os.environ['VERSION'] = self.chromedriver_version
+            return ChromeDriverManager().install()
+        return None
+
+    def _wait_until_ready(self):
+        max_wait_time = 0
+        while not self.is_running() and max_wait_time <= 30:
+            time.sleep(5)
+        print("Server started")
+
+    def start(self):
+        self.port = get_random_port()
+        self.logs_port = get_random_port()
+        command = '{} -p {} -G 0.0.0.0:{} '.format(self.appium_command, self.port,  self.logs_port)
+        if self.chromedriver_path:
+            command = '{} --chromedriver-executable {}'.format(command, self.chromedriver_path)
+        self.process = run_command(command)
+        self.pid = self.process.pid
+        self._wait_until_ready()
+
+    def stop(self):
+        self.process.kill()
+        self.process = None
+        self.pid = None