Merge pull request #317 from rustpypeng/main

clgwlg · web-flow · commit 60f8f6c06268 · 2024-10-10T12:05:23.000+08:00
feat: add new step to verify element value of web
diff --git a/flybirds/core/dsl/globalization/i18n.py b/flybirds/core/dsl/globalization/i18n.py
@@ -216,7 +216,8 @@
             "验证服务请求[{service}]与[{target_data_path}]一致",
             "验证服务请求[{service}]与json路径[{target_data_path}]一致"],
         "compare service request [{service}] with json file "
-        "[{target_data_path}] with the exceptions removed": ["验证服务请求[{service}]与json路径[{target_data_path}]去除除外项后完全一致"],
+        "[{target_data_path}] with the exceptions removed": [
+            "验证服务请求[{service}]与json路径[{target_data_path}]去除除外项后完全一致"],
         "compare service request [{service}] with xml file "
         "[{target_data_xml_path}]": [
             "验证服务请求[{service}]与xml路径[{target_data_xml_path}]一致"],
@@ -251,6 +252,20 @@
         "exist page text[{selector}]": ["页面存在文案[{selector}]"],
         "the element[{selector}]value is[{param2}]": ["元素[{selector}]的value为[{param2}]"],
         "the element[{selector}]value contains[{param2}]": ["元素[{selector}]的value包含[{param2}]"],
+        "the element[{selector}]value not contains[{param2}]": ["元素[{selector}]的value不包含[{param2}]"],
+        "witch contain [{param1}] element [{selector}] value is[{param2}]": ["参数含有[{param1}]的元素[{selector}]的文案为[{"
+                                                                             "param2}]"],
+        "witch contain [{param1}] element [{selector}] value contain [{param2}]": ["参数含有[{param1}]的元素[{"
+                                                                                   "selector}]的文案包含[{param2}]"],
+        "contain [{param}] by [{selector}] exist": ["存在包含参数[{param}]的元素[{selector}]"],
+        "contain [{param}] by [{selector}] not exist": ["不存在包含参数[{param}]的元素[{selector}]"],
+        "the [{param}] contained by the element [{selector}] has attribute [{attr_name}] with value [{attr_value}]":
+            ["包含参数[{param}]的元素[{selector}]的属性[{attr_name}]值为[{attr_value}]"],
+        "the [{param}] contained by the element [{selector}] has attribute [{attr_name}] contain value [{attr_value}]":
+            ["包含参数[{param}]的元素[{selector}]的属性[{attr_name}]值包含[{attr_value}]"],
+        "the [{param}] contained by the element [{selector}] has attribute [{attr_name}] not contain value [{"
+        "attr_value}]":
+            ["包含参数[{param}]的元素[{selector}]的属性[{attr_name}]值不包含[{attr_value}]"],
         "click[{selector}] and accept dialog": ["点击[{selector}]并接受弹窗"],
         "click[{selector}] and cancel dialog": ["点击[{selector}]并取消弹窗"],
     },
diff --git a/flybirds/core/dsl/step/element.py b/flybirds/core/dsl/step/element.py
@@ -663,13 +663,13 @@ def exist_ele(context, selector=None):
 @step("the element[{selector}]value is[{param2}]")
 @FlybirdsReportTagInfo(group="element", selectors={
     "path": [{"type": "path", "value": "selector", "name": "元素"}]},
-                       verify={"type": ErrorFlag.exist, "value": "param2"},
+                       verify={"type": ErrorFlag.text_equ, "value": "param2"},
                        verify_function="ele_verify_text_error_parse")
 @VerifyStep()
 @ele_wrap
 def ele_exist_value(context, selector=None, param2=None):
     """
-    元素[{selector}]的值为[{param2}]
+    元素[{selector}]的value为[{param2}]
     The specified selector element string exists in the page
     :param context: step context
     :param selector: locator string for selector element (or None).
@@ -688,7 +688,7 @@ def ele_exist_value(context, selector=None, param2=None):
 @ele_wrap
 def ele_contain_value(context, selector=None, param2=None):
     """
-    元素[{selector}]的值包含[{param2}]
+    元素[{selector}]的value包含[{param2}]
     The specified selector element string exists in the page
     :param context: step context
     :param selector: locator string for selector element (or None).
@@ -697,6 +697,168 @@ def ele_contain_value(context, selector=None, param2=None):
     g_Context.step.ele_contain_value(context, selector, param2)
 
 
+@step("the element[{selector}]value not contains[{param2}]")
+@FlybirdsReportTagInfo(group="element", selectors={
+    "path": [{"type": "path", "value": "selector", "name": "元素"}]},
+                       verify={"type": ErrorFlag.text_not_contains, "value": "param2"},
+                       verify_function="ele_verify_text_error_parse")
+@VerifyStep()
+@ele_wrap
+def ele_not_contain_value(context, selector=None, param2=None):
+    """
+    元素[{selector}]的value不包含[{param2}]
+    The specified selector element string exists in the page
+    :param context: step context
+    :param selector: locator string for selector element (or None).
+    :param param2: element value.
+    """
+    g_Context.step.ele_not_contain_value(context, selector, param2)
+
+
+@step("witch contain [{param1}] element [{selector}] value is[{param2}]")
+@FlybirdsReportTagInfo(group="element", selectors={
+    "path": [{"type": "text", "value": "param1", "name": "文本"},
+             {"type": "attr", "value": "param2", "name": "属性"},
+             {"type": "path", "value": "selector", "name": "元素"}]},
+                       verify={"type": ErrorFlag.text_equ, "value": "param2"},
+                       verify_function="ele_verify_text_error_parse")
+@VerifyStep()
+@ele_wrap
+def ele_contain_param_value(context, param1=None, selector=None, param2=None):
+    """
+    参数含有[{param1}]的元素[{selector}]的文案为[{param2}]
+    The specified selector element string exists in the page
+    :param context: step context
+    :param selector: locator string for selector element (or None).
+    :param param1: element value.
+    :param param2: element value.
+    """
+    g_Context.step.ele_contain_param_value(context, param1, selector, param2)
+
+
+@step("witch contain [{param1}] element [{selector}] value contain [{param2}]")
+@FlybirdsReportTagInfo(group="element", selectors={
+    "path": [{"type": "text", "value": "param1", "name": "文本"},
+             {"type": "attr", "value": "param2", "name": "属性"},
+             {"type": "path", "value": "selector", "name": "元素"}]},
+                       verify={"type": ErrorFlag.text_contains, "value": "param2"},
+                       verify_function="ele_verify_text_error_parse")
+@VerifyStep()
+@ele_wrap
+def ele_contain_param_contain_value(context, param1=None, selector=None, param2=None):
+    """
+    参数含有[{param1}]的元素[{selector}]的文案包含[{param2}]
+    The specified selector element string exists in the page
+    :param context: step context
+    :param selector: locator string for selector element (or None).
+    :param param1: element value.
+    :param param2: element value.
+    """
+    g_Context.step.ele_contain_param_contain_value(context, param1, selector, param2)
+
+
+@step("contain [{param}] by [{selector}] exist")
+@FlybirdsReportTagInfo(group="element", selectors={
+    "path": [{"type": "path", "value": "selector", "name": "元素"}]},
+                       verify={"type": ErrorFlag.exist, "value": "param"},
+                       verify_function="ele_verify_text_error_parse")
+@VerifyStep()
+@ele_wrap
+def ele_contain_param_exist(context, param=None, selector=None):
+    """
+    存在包含参数[{param}]的元素[{selector}]
+    The specified selector element string exists in the page
+    :param context: step context
+    :param selector: locator string for selector element (or None).
+    :param param: element value.
+    """
+    g_Context.step.ele_contain_param_exist(context, param, selector)
+
+
+@step("contain [{param}] by [{selector}] not exist")
+@FlybirdsReportTagInfo(group="element", selectors={
+    "path": [{"type": "path", "value": "selector", "name": "元素"}]},
+                       verify={"type": ErrorFlag.not_exist, "value": "param"},
+                       verify_function="ele_verify_text_error_parse")
+@VerifyStep()
+@ele_wrap
+def ele_contain_param_not_exist(context, param=None, selector=None):
+    """
+    不存在包含参数[{param}]的元素[{selector}]
+    The specified selector element string exists in the page
+    :param context: step context
+    :param selector: locator string for selector element (or None).
+    :param param: element value.
+    """
+    g_Context.step.ele_contain_param_not_exist(context, param, selector)
+
+
+@step("the [{param}] contained by the element [{selector}] has attribute [{attr_name}] with value [{attr_value}]")
+@FlybirdsReportTagInfo(group="element", selectors={
+    "path": [{"type": "text", "value": "param", "name": "文本"},
+             {"type": "path", "value": "selector", "name": "元素"},
+             {"type": "attr", "value": "attr_name", "name": "属性"}]},
+                       verify={"type": ErrorFlag.text_equ, "value": "attr_value"},
+                       verify_function="ele_verify_text_error_parse")
+@VerifyStep()
+@ele_wrap
+def ele_contain_param_attr_exist(context, param=None, selector=None, attr_name=None, attr_value=None):
+    """
+    包含参数[{param}]的元素[{selector}]的属性[{attr_name}]值为[{attr_value}]
+    The specified selector element string exists in the page
+    :param context: step context
+    :param param: element value.
+    :param selector: locator string for selector element (or None).
+    :param attr_name: attribute name
+    :param attr_value: attribute value
+    """
+    g_Context.step.ele_contain_param_attr_exist(context, param, selector, attr_name, attr_value)
+
+
+@step("the [{param}] contained by the element [{selector}] has attribute [{attr_name}] contain value [{attr_value}]")
+@FlybirdsReportTagInfo(group="element", selectors={
+    "path": [{"type": "text", "value": "param", "name": "文本"},
+             {"type": "path", "value": "selector", "name": "元素"},
+             {"type": "attr", "value": "attr_name", "name": "属性"}]},
+                       verify={"type": ErrorFlag.text_contains, "value": "attr_value"},
+                       verify_function="ele_verify_text_error_parse")
+@VerifyStep()
+@ele_wrap
+def ele_contain_param_attr_contain(context, param=None, selector=None, attr_name=None, attr_value=None):
+    """
+    包含参数[{param}]的元素[{selector}]的属性[{attr_name}]值包含[{attr_value}]
+    The specified selector element string exists in the page
+    :param context: step context
+    :param param: element value.
+    :param selector: locator string for selector element (or None).
+    :param attr_name: attribute name
+    :param attr_value: attribute value
+    """
+    g_Context.step.ele_contain_param_attr_contain(context, param, selector, attr_name, attr_value)
+
+
+@step("the [{param}] contained by the element [{selector}] has attribute [{attr_name}] not contain value [{attr_value}]")
+@FlybirdsReportTagInfo(group="element", selectors={
+    "path": [{"type": "text", "value": "param", "name": "文本"},
+             {"type": "path", "value": "selector", "name": "元素"},
+             {"type": "attr", "value": "attr_name", "name": "属性"}]},
+                       verify={"type": ErrorFlag.text_not_contains, "value": "attr_value"},
+                       verify_function="ele_verify_text_error_parse")
+@VerifyStep()
+@ele_wrap
+def ele_contain_param_attr_not_contain(context, param=None, selector=None, attr_name=None, attr_value=None):
+    """
+    包含参数[{param}]的元素[{selector}]的属性[{attr_name}]值不包含[{attr_value}]
+    The specified selector element string exists in the page
+    :param context: step context
+    :param param: element value.
+    :param selector: locator string for selector element (or None).
+    :param attr_name: attribute name
+    :param attr_value: attribute value
+    """
+    g_Context.step.ele_contain_param_attr_not_contain(context, param, selector, attr_name, attr_value)
+
+
 @step("in[{p_selector}]from {param2} find[{c_selector}]element")
 @FlybirdsReportTagInfo(group="element", selectors={
     "path": [{"type": "path", "value": "p_selector", "name": "元素"},
diff --git a/flybirds/core/plugin/plugins/default/step/swipe.py b/flybirds/core/plugin/plugins/default/step/swipe.py
@@ -2,7 +2,7 @@
 """
 Element swipe
 """
-from airtest.core.android.touch_methods.base_touch import BaseTouch, DownEvent, SleepEvent, MoveEvent
+from airtest.core.android.touch_methods.base_touch import BaseTouch, DownEvent, SleepEvent, MoveEvent, UpEvent
 from airtest.core.android.touch_methods.touch_proxy import AdbTouchImplementation, MinitouchImplementation
 from airtest.core.api import text, time
 from airtest.utils.snippet import (on_method_ready)
@@ -422,6 +422,7 @@ def build_swipe_search_point(direction, screen_size, selector_dict, swipe_pages=
         end_point = [start_x * pw, start_y * ph - ph * swipe_pages]
         move_distance = ph * swipe_pages
     # 设置默认触屏起始坐标
+    log.info("start_point: %s, end_point: %s, move_distance: %s" % (start_point, end_point, move_distance))
     return start_point, end_point, move_distance
 
 
diff --git a/flybirds/core/plugin/plugins/default/web/element.py b/flybirds/core/plugin/plugins/default/web/element.py
@@ -112,7 +112,10 @@ def get_ele_text(self, param):
         if e_text is None or e_text.strip() == '':
             e_text = locator.get_attribute('value')
             if e_text is None or e_text.strip() == '':
-                e_text = ""
+                e_text = locator.evaluate('(element) => { console.log("element.value");return element.value}',
+                                          timeout=timeout)
+                if e_text is None or e_text.strip() == '':
+                    e_text = ""
         return e_text
 
     def ele_hover(self, context, param):
@@ -145,6 +148,9 @@ def ele_text_not_include(self, context, param_1, param_2):
         e_text = self.get_ele_text(param_1)
         verify_helper.text_not_container(param_2, e_text)
 
+    # def ele_contain_param_attr_include(self, context, param_1, param_2):
+    #     verify_helper.text_container(param_1, param_2)
+
     def find_text(self, context, param):
         # param_temp = handle_str(param)
         param_dict = params_to_dic(param)
@@ -209,20 +215,19 @@ def ele_exist_value(self, context, selector, param):
         locator, timeout = self.get_ele_locator(selector)
         ele_value = locator.evaluate('(element) => { console.log("element.value");return element.value}',
                                      timeout=timeout)
-        if ele_value is None or param.strip() != ele_value.strip():
-            message = f"expect the value of [{selector}] element is [{param}] " \
-                      f"but actual is [{ele_value}]"
-            raise FlybirdVerifyException(message, error_name=ErrorName.ElementFoundError)
+        verify_helper.text_equal(param, ele_value)
 
     def ele_contain_value(self, context, selector, param):
         locator, timeout = self.get_ele_locator(selector)
         ele_value = locator.evaluate('(element) => { console.log("element.value");return element.value}',
                                      timeout=timeout)
+        verify_helper.text_container(param, ele_value)
 
-        if ele_value is None or param.strip() not in ele_value.strip():
-            message = f"expect the value of [{selector}] element is [{param}] " \
-                      f"but actual is [{ele_value}]"
-            raise FlybirdVerifyException(message, error_name=ErrorName.ElementFoundError)
+    def ele_not_contain_value(self, context, selector, param):
+        locator, timeout = self.get_ele_locator(selector)
+        ele_value = locator.evaluate('(element) => { console.log("element.value");return element.value}',
+                                     timeout=timeout)
+        verify_helper.text_not_container(param, ele_value)
 
     def wait_for_ele(self, context, param):
         locator, timeout = self.get_ele_locator(param)
diff --git a/flybirds/core/plugin/plugins/default/web/step.py b/flybirds/core/plugin/plugins/default/web/step.py
@@ -212,6 +212,70 @@ def ele_contain_value(cls, context, selector, param):
         ele = gr.get_value("plugin_ele")
         ele.ele_contain_value(context, selector, param)
 
+    @classmethod
+    def ele_not_contain_value(cls, context, selector, param):
+        ele = gr.get_value("plugin_ele")
+        ele.ele_not_contain_value(context, selector, param)
+
+    @classmethod
+    def ele_contain_param_value(cls, context, param1, selector, param2):
+        params = param1.split(',')
+        for param in params:
+            selector = selector.replace('{}', param, 1)
+        ele = gr.get_value("plugin_ele")
+        ele.ele_text_equal(context, selector, param2)
+
+    @classmethod
+    def ele_contain_param_contain_value(cls, context, param1, selector, param2):
+        params = param1.split(',')
+        for param in params:
+            selector = selector.replace('{}', param, 1)
+        ele = gr.get_value("plugin_ele")
+        ele.ele_text_include(context, selector, param2)
+
+    @classmethod
+    def ele_contain_param_exist(cls, context, param1, selector):
+        params = param1.split(',')
+        for param in params:
+            selector = selector.replace('{}', param, 1)
+        ele = gr.get_value("plugin_ele")
+        ele.ele_exist(context, selector)
+
+    @classmethod
+    def ele_contain_param_not_exist(cls, context, param1, selector):
+        params = param1.split(',')
+        for param in params:
+            selector = selector.replace('{}', param, 1)
+        ele = gr.get_value("plugin_ele")
+        ele.ele_not_exist(context, selector)
+
+    @classmethod
+    def ele_contain_param_attr_exist(cls, context, param, selector, attr_name, attr_value):
+        params = param.split(',')
+        for param in params:
+            selector = selector.replace('{}', param, 1)
+        ele = gr.get_value("plugin_ele")
+        ele_attr = ele.get_ele_attr(selector, attr_name)
+        ele.ele_text_equal(context, ele_attr, attr_value)
+
+    @classmethod
+    def ele_contain_param_attr_contain(cls, context, param, selector, attr_name, attr_value):
+        params = param.split(',')
+        for param in params:
+            selector = selector.replace('{}', param, 1)
+        ele = gr.get_value("plugin_ele")
+        # ele_attr = ele.get_ele_attr(selector, attr_name)
+        ele.is_text_attr_container(context, selector, attr_name, attr_value)
+
+    @classmethod
+    def ele_contain_param_attr_not_contain(cls, context, param, selector, attr_name, attr_value):
+        params = param.split(',')
+        for param in params:
+            selector = selector.replace('{}', param, 1)
+        ele = gr.get_value("plugin_ele")
+        # ele_attr = ele.get_ele_attr(selector, attr_name)
+        ele.is_text_attr_not_container(context, selector, attr_name, attr_value)
+
     @classmethod
     def wait_ele_exit(cls, context, selector):
         ele = gr.get_value("plugin_ele")
