movoid-robotframework-selenium 1.0.0__tar.gz

movoid_robotframework_selenium-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: movoid_robotframework_selenium
+Version: 1.0.0
+Home-page: 
+Author: movoid
+Author-email: bobrobotsun@163.com
+Description-Content-Type: text/markdown
+Requires-Dist: selenium
+Requires-Dist: movoid_function
+Requires-Dist: movoid_robotframework
+Requires-Dist: robotframework_selenium2library
+Requires-Dist: opencv-python
+
+This is a simple program for developer to 

movoid_robotframework_selenium-1.0.0/README.md

@@ -0,0 +1 @@
+This is a simple program for developer to 

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium/RobotFrameworkSelenium.py

@@ -0,0 +1,13 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# File          : RobotFrameworkSelenium
+# Author        : Sun YiFan-Movoid
+# Time          : 2024/2/20 12:33
+# Description   : 
+"""
+from .main import RobotSeleniumBasic
+
+
+class RobotFrameworkSelenium(RobotSeleniumBasic):
+    pass

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium/__init__.py

@@ -0,0 +1,9 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# File          : __init__.py
+# Author        : Sun YiFan-Movoid
+# Time          : 2024/1/30 21:16
+# Description   : 
+"""
+from .main import RobotSeleniumBasic

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium/action/__init__.py

@@ -0,0 +1,9 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# File          : __init__.py
+# Author        : Sun YiFan-Movoid
+# Time          : 2024/2/16 20:10
+# Description   : 
+"""
+from .action import SeleniumAction

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium/action/action.py

@@ -0,0 +1,204 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# File          : basic
+# Author        : Sun YiFan-Movoid
+# Time          : 2024/2/16 20:12
+# Description   : 
+"""
+
+import os
+import pathlib
+import re
+import time
+from typing import List
+
+from movoid_robotframework import robot_log_keyword, do_until_check, do_when_error
+from movoid_robotframework.error import RfError
+from selenium.webdriver import Keys
+from selenium.webdriver.remote.webelement import WebElement
+
+from ..common import BasicCommon
+
+
+class SeleniumAction(BasicCommon):
+    def __init__(self):
+        super().__init__()
+        self._check_element_attribute_change_value = None
+
+    @robot_log_keyword
+    def selenium_take_full_screenshot(self, screenshot_name='python-screenshot.png'):
+        return self.selenium_take_screenshot(image_name=screenshot_name)
+
+    @robot_log_keyword
+    def selenium_click_element_with_offset(self, click_locator, x, y, operate='click'):
+        tar_element = self.selenium_analyse_element(click_locator)
+        self.action_chains.move_to_element_with_offset(tar_element, x, y)
+        if operate == 'click':
+            self.action_chains.click()
+        elif operate in ('double_click', 'doubleclick'):
+            self.action_chains.double_click()
+        self.action_chains.perform()
+
+    @robot_log_keyword
+    def selenium_check_element_attribute(self, check_locator, check_attribute='innerText', check_value='', check_regex=True, check_check_bool=True):
+        """
+        检查所有元素中，是否存在一个属性满足要求的元素
+        :param check_locator: 元素定位
+        :param check_attribute: 属性名
+        :param check_value: 属性值
+        :param check_regex: 是否做正则匹配
+        :param check_check_bool: 要求满足条件还是不满足条件的
+        :return: 判定结果
+        """
+        tar_elements = self.selenium_find_elements_by_locator(check_locator)
+        tar_exist = False
+        for i_element, one_element in enumerate(tar_elements):
+            tar_value = one_element.get_attribute(check_attribute)
+            self.print(f'{check_attribute} of <{check_locator}>({i_element}) is:{tar_value}')
+            if check_regex:
+                check_result = bool(re.search(check_value, tar_value))
+                self.print(f'{check_result}: <{check_value}> in <{tar_value}>')
+            else:
+                check_result = check_value == tar_value
+                self.print(f'{check_result}: <{check_value}> == <{tar_value}>')
+            tar_exist = tar_exist or check_result == check_check_bool
+        self.print(f'check result is:{tar_exist}')
+        return tar_exist
+
+    @robot_log_keyword
+    def selenium_find_elements_with_attribute(self, find_locator, find_value='', find_attribute='innerText', find_regex=True, find_check_bool=True) -> List[WebElement]:
+        tar_elements = self.selenium_analyse_elements(find_locator)
+        find_elements = []
+        if find_attribute is None:
+            find_elements = tar_elements
+            self.print(f'find {len(find_elements)} elements only locator <{find_locator}>')
+        else:
+            self.print(f'find {len(tar_elements)} elements <{find_locator}> first')
+            for i_element, one_element in enumerate(tar_elements):
+                tar_value = one_element.get_attribute(find_attribute)
+                self.print(f'{find_attribute} of <{find_locator}>({i_element}) is:{tar_value}')
+                if find_regex:
+                    check_result = bool(re.search(find_value, tar_value))
+                    self.print(f'{check_result}: <{find_value}> in <{tar_value}>')
+                else:
+                    check_result = find_value == tar_value
+                    self.print(f'{check_result}: <{find_value}> == <{tar_value}>')
+                if check_result == find_check_bool:
+                    find_elements.append(one_element)
+            self.print(f'find {len(find_elements)} elements <{find_locator}> <{find_attribute}> is <{find_value}>(regex={find_regex},check={find_check_bool})')
+        return find_elements
+
+    @robot_log_keyword
+    def selenium_find_element_with_attribute(self, find_locator, find_value='', find_attribute='innerText', find_regex=True, find_check_bool=True):
+        find_elements = self.selenium_find_elements_with_attribute(find_locator, find_value=find_value, find_attribute=find_attribute, find_regex=find_regex, find_check_bool=find_check_bool)
+        if len(find_elements) == 0:
+            raise RfError(f'fail to find <{find_locator}> with <{find_attribute}> is <{find_value}>(re={find_regex},bool={find_check_bool})')
+        return find_elements[0]
+
+    @robot_log_keyword
+    def selenium_get_locator_attribute(self, target_locator, target_attribute='innerText'):
+        tar_element = self.selenium_find_element_by_locator(target_locator)
+        return tar_element.get_attribute(target_attribute)
+
+    @robot_log_keyword
+    def selenium_new_screenshot_folder(self):
+        screen_path = self.get_robot_variable("Screenshot_path")
+        if screen_path:
+            screen_pathlib = pathlib.Path(screen_path)
+            if not screen_pathlib.exists():
+                os.mkdir(screen_path)
+                self.print('create dir : {}'.format(screen_path))
+
+    @robot_log_keyword
+    def selenium_delete_elements(self, delete_locator):
+        elements = self.selenium_find_elements_by_locator(delete_locator)
+        self.print(f'find {len(elements)} elements:{delete_locator}')
+        for one_element in elements:
+            self.selenium_execute_js_script('arguments[0].remove();', one_element)
+        self.print(f'delete all {len(elements)} elements:{delete_locator}')
+
+    @robot_log_keyword
+    def selenium_input_delete_all_and_input(self, input_locator, input_text):
+        input_element = self.selenium_analyse_element(input_locator)
+        self.print(f'try to input ({str(input_text)}) by ({input_text})')
+        input_text = str(input_text)
+        self.print(f'find element:{input_element.get_attribute("outerHTML")},')
+        now_str = input_element.get_attribute('value')
+        self.print(f'element has text({len(now_str)}):{now_str}')
+        for _ in now_str:
+            input_element.send_keys(Keys.BACK_SPACE)
+        for i in input_text:
+            input_element.send_keys(i)
+            time.sleep(0.01)
+        self.print(f'input {input_text} success')
+        self.selenium_wait_until_find_element_attribute(input_locator, input_text, 'value')
+
+    @robot_log_keyword
+    def selenium_check_contain_element(self, check_locator, check_exist=True):
+        find_elements = self.selenium_find_elements_by_locator(check_locator)
+        find_elements_bool = len(find_elements) > 0
+        self.print(f'we find {find_elements_bool}→{check_exist} {check_locator}')
+        return find_elements_bool == check_exist
+
+    @robot_log_keyword
+    def selenium_check_contain_elements(self, check_locator, check_count=1):
+        check_count = int(check_count)
+        find_elements = self.selenium_find_elements_by_locator(check_locator)
+        find_elements_num = len(find_elements)
+        self.print(f'we find {find_elements_num}→{check_count} {check_locator}')
+        return find_elements_num == check_count
+
+    @robot_log_keyword
+    def selenium_check_element_attribute_change_init(self, check_locator, check_attribute=''):
+        tar_element = self.selenium_find_element_by_locator(check_locator)
+        self._check_element_attribute_change_value = tar_element.get_attribute(check_attribute)
+        self.print(f'we find {check_attribute} of {check_locator} is {self._check_element_attribute_change_value}')
+        return False
+
+    @robot_log_keyword
+    def selenium_check_element_attribute_change_loop(self, check_locator, check_attribute=''):
+        tar_element = self.selenium_find_element_by_locator(check_locator)
+        temp_value = tar_element.get_attribute(check_attribute)
+        re_bool = self._check_element_attribute_change_value == temp_value
+        self.print(f'we find {check_attribute} of {check_locator} is {temp_value}{"==" if re_bool else "!="}{self._check_element_attribute_change_value}')
+        return re_bool
+
+    def always_true(self):
+        return True
+
+    @robot_log_keyword
+    @do_when_error(selenium_take_full_screenshot)
+    @do_until_check(selenium_click_element_with_offset, always_true)
+    def selenium_click_until_available(self):
+        pass
+
+    @robot_log_keyword
+    @do_when_error(selenium_take_full_screenshot)
+    @do_until_check(selenium_click_element_with_offset, selenium_check_contain_element)
+    def selenium_click_until_find_element(self):
+        pass
+
+    @robot_log_keyword
+    @do_when_error(selenium_take_full_screenshot)
+    @do_until_check(selenium_click_element_with_offset, selenium_check_contain_elements)
+    def selenium_click_until_find_elements(self):
+        pass
+
+    @robot_log_keyword
+    @do_when_error(selenium_take_full_screenshot)
+    @do_until_check(selenium_click_element_with_offset, selenium_find_element_with_attribute)
+    def selenium_click_until_find_element_attribute(self):
+        pass
+
+    @robot_log_keyword
+    @do_when_error(selenium_take_full_screenshot)
+    @do_until_check(always_true, selenium_find_element_with_attribute)
+    def selenium_wait_until_find_element_attribute(self):
+        pass
+
+    @robot_log_keyword
+    @do_when_error(selenium_take_full_screenshot)
+    @do_until_check(selenium_click_element_with_offset, selenium_check_element_attribute_change_loop, init_check_function=selenium_check_element_attribute_change_init)
+    def selenium_click_until_attribute_change(self):
+        pass

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium/common.py

@@ -0,0 +1,150 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# File          : common
+# Author        : Sun YiFan-Movoid
+# Time          : 2024/2/16 18:47
+# Description   : 
+"""
+import math
+import os
+from typing import List, Tuple, Union
+
+import cv2
+import robot.libraries.BuiltIn
+import selenium.webdriver.chrome.webdriver
+from Selenium2Library import Selenium2Library
+from movoid_robotframework.error import RfError
+from selenium.webdriver import ActionChains
+from selenium.webdriver.remote.webelement import WebElement
+from movoid_robotframework import RobotBasic, robot_log_keyword
+
+
+class BasicCommon(RobotBasic):
+    def __init__(self):
+        super().__init__()
+        self.built: robot.libraries.BuiltIn.BuiltIn = getattr(self, 'built', None)
+        self.selenium_lib: Selenium2Library = getattr(self, 'built', None)
+        self.driver: selenium.webdriver.chrome.webdriver.WebDriver = getattr(self, 'driver', None)
+        self.action_chains: ActionChains = getattr(self, 'action_chains', None)
+        self.screenshot_root: str = getattr(self, 'screenshot_root', None)
+        self.outer_coordinate: Tuple[float] = getattr(self, 'outer_coordinate', None)
+        self.inner_coordinate: Tuple[float] = getattr(self, 'inner_coordinate', None)
+        self.window_x: float = getattr(self, 'window_x', None)
+        self.window_y: float = getattr(self, 'window_y', None)
+
+    @robot_log_keyword
+    def selenium_init(self):
+        self.selenium_lib = self.built.get_library_instance('Selenium2Library')
+        self.driver = self.selenium_lib.driver
+        self.action_chains = ActionChains(self.driver)
+        self.screenshot_root = self.selenium_lib.screenshot_root_directory
+
+    @robot_log_keyword
+    def selenium_find_elements_by_locator(self, locator) -> List[WebElement]:
+        by, path = locator.split('=', 1)
+        return self.driver.find_elements(by, path)
+
+    @robot_log_keyword
+    def selenium_find_element_by_locator(self, locator) -> WebElement:
+        by, path = locator.split('=', 1)
+        return self.driver.find_element(by, path)
+
+    @robot_log_keyword
+    def selenium_execute_js_script(self, js_code: str, *args):
+        return self.driver.execute_script(js_code, *args)
+
+    @robot_log_keyword
+    def analyse_color_function(self, color_function):
+        re_func = None
+        if callable(color_function):
+            return color_function
+        elif isinstance(color_function, str):
+            if ',' in color_function:
+                re_func = self.exchange_list3_to_color_function(color_function.split(',', 2))
+            else:
+                raise RfError('you input [{}] to find a color function, but it is not in default_color_function'.format(color_function))
+        elif isinstance(color_function, list):
+            re_func = self.exchange_list3_to_color_function(color_function)
+        return re_func
+
+    @robot_log_keyword
+    def exchange_list3_to_color_function(self, formula_list):
+        return lambda r, g, b: eval('r' + formula_list[0]) and eval('g' + formula_list[1]) and eval('b' + formula_list[2])
+
+    @robot_log_keyword
+    def selenium_get_full_screenshot_path(self, screenshot_name):
+        suite = self.get_robot_variable('SUITE NAME').replace(' ', '_')
+        case_ori = self.get_robot_variable('TEST NAME')
+        folder_name = suite if case_ori is None else f"{suite}-{case_ori.replace(' ', '_')}"
+        full_folder_path = os.path.join(self.screenshot_root, folder_name)
+        if not os.path.exists(full_folder_path):
+            os.mkdir(full_folder_path)
+            self.print(f'create image folder:{folder_name}')
+        return os.path.join(full_folder_path, screenshot_name)
+
+    @robot_log_keyword
+    def selenium_cut_screenshot(self, screenshot_locator, image_name='element-cut-image.png'):
+        tar_name, tar_path = self.selenium_take_screenshot(None, image_name)
+        full_image = self.selenium_analyse_image(tar_name)
+        if screenshot_locator is None:
+            return full_image
+        else:
+            tar_element = self.selenium_analyse_element(screenshot_locator)
+            element_position = self.selenium_execute_js_script('return arguments[0].getBoundingClientRect();', tar_element)
+            self.print(element_position)
+            cut_rect = [math.floor(element_position['left']), math.floor(element_position['top']), math.floor(element_position['right']), math.floor(element_position['bottom'])]
+            cut_image = full_image[cut_rect[1]:cut_rect[3], cut_rect[0]:cut_rect[2]]
+            self.print(cut_image.shape)
+            tar_path_split = os.path.splitext(tar_path)
+            cv2.imwrite(tar_path_split[0] + '(cut)' + tar_path_split[1], cut_image)
+            return cut_image
+
+    @robot_log_keyword
+    def selenium_take_screenshot(self, screenshot_locator=None, image_name='python-screenshot.png', rename=True):
+        tar_name = image_name
+        ind = 1
+        tar_path = self.selenium_get_full_screenshot_path(tar_name)
+        while rename and os.path.isfile(tar_path):
+            ind += 1
+            name, post = os.path.splitext(image_name)
+            tar_name = f'{name}-{ind}{post}'
+            tar_path = self.selenium_get_full_screenshot_path(tar_name)
+        if screenshot_locator is None:
+            self.selenium_lib.capture_page_screenshot(tar_path)
+            self.print(f'take a full window screenshot:{tar_name}')
+        else:
+            self.selenium_lib.capture_element_screenshot(screenshot_locator, tar_path)
+            self.print(f'take a DOM({screenshot_locator}) screenshot:{tar_name}')
+        return tar_name, tar_path
+
+    @robot_log_keyword
+    def selenium_take_full_screenshot(self, screenshot_name='python-screenshot.png'):
+        return self.selenium_take_screenshot(image_name=screenshot_name)
+
+    @robot_log_keyword
+    def selenium_analyse_image(self, image):
+        if isinstance(image, str):
+            image_full_path = image if os.path.isfile(image) else self.selenium_get_full_screenshot_path(image)
+            self.print(f'try to read image:{image_full_path}')
+            return cv2.imread(image_full_path)
+        else:
+            return image
+
+    @robot_log_keyword
+    def selenium_analyse_element(self, locator: Union[WebElement, str]) -> WebElement:
+        if isinstance(locator, str):
+            return self.selenium_find_element_by_locator(locator)
+        elif isinstance(locator, list):
+            return locator[0]
+        else:
+            return locator
+
+    @robot_log_keyword
+    def selenium_analyse_elements(self, locator: Union[List[WebElement], str]) -> List[WebElement]:
+        if isinstance(locator, str):
+            return self.selenium_find_elements_by_locator(locator)
+        elif isinstance(locator, WebElement):
+            return [locator]
+        else:
+            return locator

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium/main.py

@@ -0,0 +1,13 @@
+#! /usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# File          : main
+# Author        : Sun YiFan-Movoid
+# Time          : 2024/2/16 18:47
+# Description   : 
+"""
+from .action import SeleniumAction
+
+
+class RobotSeleniumBasic(SeleniumAction):
+    pass

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: movoid_robotframework_selenium
+Version: 1.0.0
+Home-page: 
+Author: movoid
+Author-email: bobrobotsun@163.com
+Description-Content-Type: text/markdown
+Requires-Dist: selenium
+Requires-Dist: movoid_function
+Requires-Dist: movoid_robotframework
+Requires-Dist: robotframework_selenium2library
+Requires-Dist: opencv-python
+
+This is a simple program for developer to 

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+setup.py
+movoid_robotframework_selenium/RobotFrameworkSelenium.py
+movoid_robotframework_selenium/__init__.py
+movoid_robotframework_selenium/common.py
+movoid_robotframework_selenium/main.py
+movoid_robotframework_selenium.egg-info/PKG-INFO
+movoid_robotframework_selenium.egg-info/SOURCES.txt
+movoid_robotframework_selenium.egg-info/dependency_links.txt
+movoid_robotframework_selenium.egg-info/requires.txt
+movoid_robotframework_selenium.egg-info/top_level.txt
+movoid_robotframework_selenium/action/__init__.py
+movoid_robotframework_selenium/action/action.py

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium.egg-info/requires.txt

@@ -0,0 +1,5 @@
+selenium
+movoid_function
+movoid_robotframework
+robotframework_selenium2library
+opencv-python

movoid_robotframework_selenium-1.0.0/movoid_robotframework_selenium.egg-info/top_level.txt

@@ -0,0 +1 @@
+movoid_robotframework_selenium

movoid_robotframework_selenium-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

movoid_robotframework_selenium-1.0.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding='utf-8') as fh:
+    long_description = fh.read()
+
+setup(
+    name='movoid_robotframework_selenium',
+    version='1.0.0',
+    packages=find_packages(),
+    url='',
+    license='',
+    author='movoid',
+    author_email='bobrobotsun@163.com',
+    description='',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    install_requires=['selenium',
+                      'movoid_function',
+                      'movoid_robotframework',
+                      'robotframework_selenium2library',
+                      'opencv-python',
+                      ],
+)