Kea2-python 0.0.1b2__tar.gz → 0.0.1b3__tar.gz

{kea2_python-0.0.1b2 → kea2_python-0.0.1b3}/Kea2_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Kea2-python
-Version: 0.0.1b2
+Version: 0.0.1b3
 Summary: A python library for supporting and customizing automated UI testing for mobile apps
 Author-email: Xixian Liang <xixian@stu.ecnu.edu.cn>
 Requires-Python: >=3.8
@@ -20,7 +20,7 @@ Dynamic: license-file
     <img src="https://github.com/user-attachments/assets/58f68b00-cc9c-4620-9e2e-66c43cf7caae" style="border-radius: 14px; width: 20%; height: 20%;"/> 
 </div>
 
-Kea2 is an easy-to-use Python library for supporting, customizing and improving automated UI testing for mobile apps. The library is currently built on top of [Fastbot](https://github.com/bytedance/Fastbot_Android) and [uiautomator2](https://github.com/openatx/uiautomator2), and targeting [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) apps.
+Kea2 is an easy-to-use Python library for supporting, customizing and improving automated UI testing for mobile apps. Kea2's novelty is able to fuse the scripts (usually written by human) with automated UI testing tools, thus allowing many interesting and powerful features. Kea2 is currently built on top of [Fastbot](https://github.com/bytedance/Fastbot_Android) and [uiautomator2](https://github.com/openatx/uiautomator2) and targets [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) apps.
 
 ### Kea2 has three important features:
 - **Feature 1**(查找稳定性问题): coming with the full capability of [Fastbot](https://github.com/bytedance/Fastbot_Android) for stress testing and finding *stability problems* (i.e., *crashing bugs*); 
@@ -49,7 +49,7 @@ Kea2, released as a Python library, currently works with:
 - [uiautomator2](https://github.com/openatx/uiautomator2) as the UI test driver; 
 - [Fastbot](https://github.com/bytedance/Fastbot_Android) as the backend automated UI testing tool.
 
-In the future, Kea2 will be extended to support
+**Roadmap**: In the future, Kea2 will be extended to support
 - [pytest](https://docs.pytest.org/en/stable/)
 - [Appium](https://github.com/appium/appium), [Hypium]() (for HarmonyOS)
 - other automated UI testing tools (not limited to Fastbot)
@@ -175,20 +175,31 @@ You can find the full example in script `quicktest.py`, and run this script with
 kea2 run -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 200 --driver-name d unittest discover -p quicktest.py
 ```
 
-### Example 2: blacklisting specific UI widgets
+### Example 2: blacklisting specific UI elements
 
-We support blacklisting specific widgets so that Fastbot can avoid interacting with these widgets during fuzzing. We support (1) `Global Block List` (always taking effective), and (2) `Conditional Block List` (only taking effective when some conditions are met).
+We support blacklisting specific elements so that Fastbot can avoid interacting with these 
+elements during fuzzing. 
 
-The list of blocked widgets are specified in Kea2's config file `configs/widget.block.py` (generated when running `kea2 init`). 
-The widgets needed to be blocked can be flexibly specified by u2 selector (e.g., `text`, `description`) or `xpath`, etc.
+We support two granularity levels for UI blocking:
 
-#### Global Block List
+- Widget Blocking: Block individual UI widgets.
+
+- Tree Blocking : Block a UI widget trees by specifying its root node.
+It can block the root node and all its descendants.
+
+We support (1) `Global Block List` (always taking effective), and (2) `Conditional Block List` (only taking effective when some conditions are met).
+
+The list of blocked elements are specified in Kea2's config file `configs/widget.block.py` (generated when running `kea2 init`). 
+The elements needed to be blocked can be flexibly specified by u2 selector (e.g., `text`, `description`) or `xpath`, etc.
+
+#### Widget Blocking
+##### Global Block List
 We can define the function `global_block_widgets` to specify which UI widgets should be blocked globally. The blocking always takes effect. 
 
 ```python
 # file: configs/widget.block.py
 
-    def global_block_widgets(d: "Device"):
+def global_block_widgets(d: "Device"):
     """
     global block list.
     return the widgets which should be blocked globally
@@ -197,8 +208,8 @@ We can define the function `global_block_widgets` to specify which UI widgets sh
             d.xpath(".//node[@text='widget to block']"),
             d(description="widgets to block")]
 ```
-#### Conditional Block List
-We can define any reserved function whose name starts with "block_" and decorate such function by `@precondition` to allow conditional block list.
+##### Conditional Block List
+We can define any reserved function whose name starts with "block_" (but not requiring "block_tree_" prefix) and decorate such function by `@precondition` to allow conditional block list.
 In this case, the blocking only takes effect when the precondition is satisfied.
 ```python
 # file: configs/widget.block.py
@@ -212,6 +223,37 @@ def block_sth(d: "Device"):
             d(description="widgets to block")]
 ```
 
+#### Tree Blocking
+##### Global Block List
+We can define the function `global_block_tree` to specify which UI widget trees should be blocked globally. The blocking always takes effect. 
+
+```python
+# file: configs/widget.block.py
+
+def global_block_tree(d: "Device"):
+    """
+    Specify UI widget trees to be blocked globally during testing.
+    Returns a list of root nodes whose entire subtrees will be blocked from exploration.
+    This function is only available in 'u2 agent' mode.
+    """
+     return [d(text="trees to block"), d.xpath(".//node[@text='tree to block']")]
+```
+##### Conditional Block List
+We can define any reserved function whose name starts with "block_tree_" and decorate such function by `@precondition` to allow conditional block list.
+In this case, the blocking only takes effect when the precondition is satisfied.
+```python
+# file: configs/widget.block.py
+
+# Example of conditional tree blocking with precondition
+
+@precondition(lambda d: d(text="In the home page").exists)
+def block_tree_sth(d: "Device"):
+    # Note: Function name must start with "block_tree_"
+    return [d(text="trees to block"), 
+            d.xpath(".//node[@text='tree to block']"),
+            d(description="trees to block")]
+```
+
 ## Feature 3(支持断言机制): Supporting auto-assertions by scripts.
 
 Kea2 supports auto-assertions when running Fastbot for finding *logic bugs* (i.e., *non-crashing bugs*). To achieve this, you can add assertions in the scripts. When an assertion fails during automated UI testing, we find a likely functional bug. This idea is inspired by  [property-based testing](https://en.wikipedia.org/wiki/Software_testing#Property_testing) inheritted from [Kea](https://github.com/ecnusse/Kea).
@@ -339,7 +381,7 @@ kea2 run -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --runn
 | --max-step | The maxium number of monkey events to send (only available in `--agent u2`) | `inf` |
 | --throttle | The delay time (ms) between two monkey events | `200` |
 | --driver-name | The name of driver used in the script. If `--driver-name d` is specified, you should use `d` to interact with a device, e..g, `self.d(..).click()`. |
-| --log-stamp | the stamp for log file and result file, default: current time stamp | |
+| --log-stamp | the stamp for log file and result file. (e.g. `--log-stamp 123` then `fastbot_123.log` and `result_123.json` will be generated.) default: current time stamp | |
 | unittest | Specify to load which scripts. This  sub-command `unittest` is fully compatible with unittest. See `python3 -m unittest -h` for more options of unittest. This option is only available in `--agent u2`.
 
 

{kea2_python-0.0.1b2 → kea2_python-0.0.1b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Kea2-python
-Version: 0.0.1b2
+Version: 0.0.1b3
 Summary: A python library for supporting and customizing automated UI testing for mobile apps
 Author-email: Xixian Liang <xixian@stu.ecnu.edu.cn>
 Requires-Python: >=3.8
@@ -20,7 +20,7 @@ Dynamic: license-file
     <img src="https://github.com/user-attachments/assets/58f68b00-cc9c-4620-9e2e-66c43cf7caae" style="border-radius: 14px; width: 20%; height: 20%;"/> 
 </div>
 
-Kea2 is an easy-to-use Python library for supporting, customizing and improving automated UI testing for mobile apps. The library is currently built on top of [Fastbot](https://github.com/bytedance/Fastbot_Android) and [uiautomator2](https://github.com/openatx/uiautomator2), and targeting [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) apps.
+Kea2 is an easy-to-use Python library for supporting, customizing and improving automated UI testing for mobile apps. Kea2's novelty is able to fuse the scripts (usually written by human) with automated UI testing tools, thus allowing many interesting and powerful features. Kea2 is currently built on top of [Fastbot](https://github.com/bytedance/Fastbot_Android) and [uiautomator2](https://github.com/openatx/uiautomator2) and targets [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) apps.
 
 ### Kea2 has three important features:
 - **Feature 1**(查找稳定性问题): coming with the full capability of [Fastbot](https://github.com/bytedance/Fastbot_Android) for stress testing and finding *stability problems* (i.e., *crashing bugs*); 
@@ -49,7 +49,7 @@ Kea2, released as a Python library, currently works with:
 - [uiautomator2](https://github.com/openatx/uiautomator2) as the UI test driver; 
 - [Fastbot](https://github.com/bytedance/Fastbot_Android) as the backend automated UI testing tool.
 
-In the future, Kea2 will be extended to support
+**Roadmap**: In the future, Kea2 will be extended to support
 - [pytest](https://docs.pytest.org/en/stable/)
 - [Appium](https://github.com/appium/appium), [Hypium]() (for HarmonyOS)
 - other automated UI testing tools (not limited to Fastbot)
@@ -175,20 +175,31 @@ You can find the full example in script `quicktest.py`, and run this script with
 kea2 run -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 200 --driver-name d unittest discover -p quicktest.py
 ```
 
-### Example 2: blacklisting specific UI widgets
+### Example 2: blacklisting specific UI elements
 
-We support blacklisting specific widgets so that Fastbot can avoid interacting with these widgets during fuzzing. We support (1) `Global Block List` (always taking effective), and (2) `Conditional Block List` (only taking effective when some conditions are met).
+We support blacklisting specific elements so that Fastbot can avoid interacting with these 
+elements during fuzzing. 
 
-The list of blocked widgets are specified in Kea2's config file `configs/widget.block.py` (generated when running `kea2 init`). 
-The widgets needed to be blocked can be flexibly specified by u2 selector (e.g., `text`, `description`) or `xpath`, etc.
+We support two granularity levels for UI blocking:
 
-#### Global Block List
+- Widget Blocking: Block individual UI widgets.
+
+- Tree Blocking : Block a UI widget trees by specifying its root node.
+It can block the root node and all its descendants.
+
+We support (1) `Global Block List` (always taking effective), and (2) `Conditional Block List` (only taking effective when some conditions are met).
+
+The list of blocked elements are specified in Kea2's config file `configs/widget.block.py` (generated when running `kea2 init`). 
+The elements needed to be blocked can be flexibly specified by u2 selector (e.g., `text`, `description`) or `xpath`, etc.
+
+#### Widget Blocking
+##### Global Block List
 We can define the function `global_block_widgets` to specify which UI widgets should be blocked globally. The blocking always takes effect. 
 
 ```python
 # file: configs/widget.block.py
 
-    def global_block_widgets(d: "Device"):
+def global_block_widgets(d: "Device"):
     """
     global block list.
     return the widgets which should be blocked globally
@@ -197,8 +208,8 @@ We can define the function `global_block_widgets` to specify which UI widgets sh
             d.xpath(".//node[@text='widget to block']"),
             d(description="widgets to block")]
 ```
-#### Conditional Block List
-We can define any reserved function whose name starts with "block_" and decorate such function by `@precondition` to allow conditional block list.
+##### Conditional Block List
+We can define any reserved function whose name starts with "block_" (but not requiring "block_tree_" prefix) and decorate such function by `@precondition` to allow conditional block list.
 In this case, the blocking only takes effect when the precondition is satisfied.
 ```python
 # file: configs/widget.block.py
@@ -212,6 +223,37 @@ def block_sth(d: "Device"):
             d(description="widgets to block")]
 ```
 
+#### Tree Blocking
+##### Global Block List
+We can define the function `global_block_tree` to specify which UI widget trees should be blocked globally. The blocking always takes effect. 
+
+```python
+# file: configs/widget.block.py
+
+def global_block_tree(d: "Device"):
+    """
+    Specify UI widget trees to be blocked globally during testing.
+    Returns a list of root nodes whose entire subtrees will be blocked from exploration.
+    This function is only available in 'u2 agent' mode.
+    """
+     return [d(text="trees to block"), d.xpath(".//node[@text='tree to block']")]
+```
+##### Conditional Block List
+We can define any reserved function whose name starts with "block_tree_" and decorate such function by `@precondition` to allow conditional block list.
+In this case, the blocking only takes effect when the precondition is satisfied.
+```python
+# file: configs/widget.block.py
+
+# Example of conditional tree blocking with precondition
+
+@precondition(lambda d: d(text="In the home page").exists)
+def block_tree_sth(d: "Device"):
+    # Note: Function name must start with "block_tree_"
+    return [d(text="trees to block"), 
+            d.xpath(".//node[@text='tree to block']"),
+            d(description="trees to block")]
+```
+
 ## Feature 3(支持断言机制): Supporting auto-assertions by scripts.
 
 Kea2 supports auto-assertions when running Fastbot for finding *logic bugs* (i.e., *non-crashing bugs*). To achieve this, you can add assertions in the scripts. When an assertion fails during automated UI testing, we find a likely functional bug. This idea is inspired by  [property-based testing](https://en.wikipedia.org/wiki/Software_testing#Property_testing) inheritted from [Kea](https://github.com/ecnusse/Kea).
@@ -339,7 +381,7 @@ kea2 run -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --runn
 | --max-step | The maxium number of monkey events to send (only available in `--agent u2`) | `inf` |
 | --throttle | The delay time (ms) between two monkey events | `200` |
 | --driver-name | The name of driver used in the script. If `--driver-name d` is specified, you should use `d` to interact with a device, e..g, `self.d(..).click()`. |
-| --log-stamp | the stamp for log file and result file, default: current time stamp | |
+| --log-stamp | the stamp for log file and result file. (e.g. `--log-stamp 123` then `fastbot_123.log` and `result_123.json` will be generated.) default: current time stamp | |
 | unittest | Specify to load which scripts. This  sub-command `unittest` is fully compatible with unittest. See `python3 -m unittest -h` for more options of unittest. This option is only available in `--agent u2`.
 
 

{kea2_python-0.0.1b2 → kea2_python-0.0.1b3}/README.md

@@ -8,7 +8,7 @@
     <img src="https://github.com/user-attachments/assets/58f68b00-cc9c-4620-9e2e-66c43cf7caae" style="border-radius: 14px; width: 20%; height: 20%;"/> 
 </div>
 
-Kea2 is an easy-to-use Python library for supporting, customizing and improving automated UI testing for mobile apps. The library is currently built on top of [Fastbot](https://github.com/bytedance/Fastbot_Android) and [uiautomator2](https://github.com/openatx/uiautomator2), and targeting [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) apps.
+Kea2 is an easy-to-use Python library for supporting, customizing and improving automated UI testing for mobile apps. Kea2's novelty is able to fuse the scripts (usually written by human) with automated UI testing tools, thus allowing many interesting and powerful features. Kea2 is currently built on top of [Fastbot](https://github.com/bytedance/Fastbot_Android) and [uiautomator2](https://github.com/openatx/uiautomator2) and targets [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) apps.
 
 ### Kea2 has three important features:
 - **Feature 1**(查找稳定性问题): coming with the full capability of [Fastbot](https://github.com/bytedance/Fastbot_Android) for stress testing and finding *stability problems* (i.e., *crashing bugs*); 
@@ -37,7 +37,7 @@ Kea2, released as a Python library, currently works with:
 - [uiautomator2](https://github.com/openatx/uiautomator2) as the UI test driver; 
 - [Fastbot](https://github.com/bytedance/Fastbot_Android) as the backend automated UI testing tool.
 
-In the future, Kea2 will be extended to support
+**Roadmap**: In the future, Kea2 will be extended to support
 - [pytest](https://docs.pytest.org/en/stable/)
 - [Appium](https://github.com/appium/appium), [Hypium]() (for HarmonyOS)
 - other automated UI testing tools (not limited to Fastbot)
@@ -163,20 +163,31 @@ You can find the full example in script `quicktest.py`, and run this script with
 kea2 run -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --running-minutes 10 --throttle 200 --driver-name d unittest discover -p quicktest.py
 ```
 
-### Example 2: blacklisting specific UI widgets
+### Example 2: blacklisting specific UI elements
 
-We support blacklisting specific widgets so that Fastbot can avoid interacting with these widgets during fuzzing. We support (1) `Global Block List` (always taking effective), and (2) `Conditional Block List` (only taking effective when some conditions are met).
+We support blacklisting specific elements so that Fastbot can avoid interacting with these 
+elements during fuzzing. 
 
-The list of blocked widgets are specified in Kea2's config file `configs/widget.block.py` (generated when running `kea2 init`). 
-The widgets needed to be blocked can be flexibly specified by u2 selector (e.g., `text`, `description`) or `xpath`, etc.
+We support two granularity levels for UI blocking:
 
-#### Global Block List
+- Widget Blocking: Block individual UI widgets.
+
+- Tree Blocking : Block a UI widget trees by specifying its root node.
+It can block the root node and all its descendants.
+
+We support (1) `Global Block List` (always taking effective), and (2) `Conditional Block List` (only taking effective when some conditions are met).
+
+The list of blocked elements are specified in Kea2's config file `configs/widget.block.py` (generated when running `kea2 init`). 
+The elements needed to be blocked can be flexibly specified by u2 selector (e.g., `text`, `description`) or `xpath`, etc.
+
+#### Widget Blocking
+##### Global Block List
 We can define the function `global_block_widgets` to specify which UI widgets should be blocked globally. The blocking always takes effect. 
 
 ```python
 # file: configs/widget.block.py
 
-    def global_block_widgets(d: "Device"):
+def global_block_widgets(d: "Device"):
     """
     global block list.
     return the widgets which should be blocked globally
@@ -185,8 +196,8 @@ We can define the function `global_block_widgets` to specify which UI widgets sh
             d.xpath(".//node[@text='widget to block']"),
             d(description="widgets to block")]
 ```
-#### Conditional Block List
-We can define any reserved function whose name starts with "block_" and decorate such function by `@precondition` to allow conditional block list.
+##### Conditional Block List
+We can define any reserved function whose name starts with "block_" (but not requiring "block_tree_" prefix) and decorate such function by `@precondition` to allow conditional block list.
 In this case, the blocking only takes effect when the precondition is satisfied.
 ```python
 # file: configs/widget.block.py
@@ -200,6 +211,37 @@ def block_sth(d: "Device"):
             d(description="widgets to block")]
 ```
 
+#### Tree Blocking
+##### Global Block List
+We can define the function `global_block_tree` to specify which UI widget trees should be blocked globally. The blocking always takes effect. 
+
+```python
+# file: configs/widget.block.py
+
+def global_block_tree(d: "Device"):
+    """
+    Specify UI widget trees to be blocked globally during testing.
+    Returns a list of root nodes whose entire subtrees will be blocked from exploration.
+    This function is only available in 'u2 agent' mode.
+    """
+     return [d(text="trees to block"), d.xpath(".//node[@text='tree to block']")]
+```
+##### Conditional Block List
+We can define any reserved function whose name starts with "block_tree_" and decorate such function by `@precondition` to allow conditional block list.
+In this case, the blocking only takes effect when the precondition is satisfied.
+```python
+# file: configs/widget.block.py
+
+# Example of conditional tree blocking with precondition
+
+@precondition(lambda d: d(text="In the home page").exists)
+def block_tree_sth(d: "Device"):
+    # Note: Function name must start with "block_tree_"
+    return [d(text="trees to block"), 
+            d.xpath(".//node[@text='tree to block']"),
+            d(description="trees to block")]
+```
+
 ## Feature 3(支持断言机制): Supporting auto-assertions by scripts.
 
 Kea2 supports auto-assertions when running Fastbot for finding *logic bugs* (i.e., *non-crashing bugs*). To achieve this, you can add assertions in the scripts. When an assertion fails during automated UI testing, we find a likely functional bug. This idea is inspired by  [property-based testing](https://en.wikipedia.org/wiki/Software_testing#Property_testing) inheritted from [Kea](https://github.com/ecnusse/Kea).
@@ -327,7 +369,7 @@ kea2 run -s "emulator-5554" -p it.feio.android.omninotes.alpha --agent u2 --runn
 | --max-step | The maxium number of monkey events to send (only available in `--agent u2`) | `inf` |
 | --throttle | The delay time (ms) between two monkey events | `200` |
 | --driver-name | The name of driver used in the script. If `--driver-name d` is specified, you should use `d` to interact with a device, e..g, `self.d(..).click()`. |
-| --log-stamp | the stamp for log file and result file, default: current time stamp | |
+| --log-stamp | the stamp for log file and result file. (e.g. `--log-stamp 123` then `fastbot_123.log` and `result_123.json` will be generated.) default: current time stamp | |
 | unittest | Specify to load which scripts. This  sub-command `unittest` is fully compatible with unittest. See `python3 -m unittest -h` for more options of unittest. This option is only available in `--agent u2`.
 
 

kea2_python-0.0.1b3/kea2/assets/fastbot_configs/widget.block.py

@@ -0,0 +1,38 @@
+from kea2.utils import Device
+from kea2.keaUtils import precondition
+
+
+def global_block_widgets(d: "Device"):
+    """
+    Specify UI widgets to be blocked globally during testing.
+    Returns a list of widgets that should be blocked from exploration.
+    This function is only available in 'u2 agent' mode.
+    """
+    # return [d(text="widgets to block"), d.xpath(".//node[@text='widget to block']")]
+    return []
+
+
+# Example of conditional blocking with precondition
+# @precondition(lambda d: d(text="In the home page").exists)
+@precondition(lambda d: False)
+def block_sth(d: "Device"):
+    # Note: Function name must start with "block_"
+    return []
+
+
+def global_block_tree(d: "Device"):
+    """
+    Specify UI widget trees to be blocked globally during testing.
+    Returns a list of root nodes whose entire subtrees will be blocked from exploration.
+    This function is only available in 'u2 agent' mode.
+    """
+    # return [d(text="trees to block"), d.xpath(".//node[@text='tree to block']")]
+    return []
+
+
+# Example of conditional tree blocking with precondition
+# @precondition(lambda d: d(text="In the home page").exists)
+@precondition(lambda d: False)
+def block_tree_sth(d: "Device"):
+    # Note: Function name must start with "block_tree_"
+    return []

{kea2_python-0.0.1b2 → kea2_python-0.0.1b3}/kea2/keaUtils.py

@@ -305,7 +305,8 @@ class KeaTestRunner(TextTestRunner):
     resultclass: JsonResult
     allProperties: PropertyStore
     options: Options = None
-    _block_widgets_funcs = None
+    _block_funcs: Dict[Literal["widgets", "trees"], List[Callable]] = None
+    # _block_trees_funcs = None
 
     @classmethod
     def setOptions(cls, options: Options):
@@ -433,7 +434,6 @@ class KeaTestRunner(TextTestRunner):
 
             print(f"Finish sending monkey events.", flush=True)
             log_watcher.close()
-            self.tearDown()
 
         # Source code from unittest Runner
         # process the result
@@ -475,15 +475,19 @@ class KeaTestRunner(TextTestRunner):
         """
         send a step monkey request to the server and get the xml string.
         """
-        block_widgets: List[str] = self._getBlockedWidgets()
+        block_dict = self._getBlockedWidgets()
+        block_widgets: List[str] = block_dict['widgets']
+        block_trees: List[str] = block_dict['trees']
         URL = f"http://localhost:{self.scriptDriver.lport}/stepMonkey"
         logger.debug(f"Sending request: {URL}")
         logger.debug(f"Blocking widgets: {block_widgets}")
+        logger.debug(f"Blocking trees: {block_trees}")
         r = requests.post(
             url=URL,
             json={
                 "steps_count": self.stepsCount,
-                "block_widgets": block_widgets
+                "block_widgets": block_widgets,
+                "block_trees": block_trees
             }
         )
 
@@ -577,17 +581,24 @@ class KeaTestRunner(TextTestRunner):
                 # save it into allProperties for PBT
                 self.allProperties[testMethodName] = t
                 print(f"[INFO] Load property: {getFullPropName(t)}", flush=True)
-    
+
     @property
     def _blockWidgetFuncs(self):
-        if self._block_widgets_funcs is None:
-            self._block_widgets_funcs = list()
+        """
+        load and process blocking functions from widget.block.py configuration file.
+
+        Returns:
+            dict: A dictionary containing two lists:
+                - 'widgets': List of functions that block individual widgets
+                - 'trees': List of functions that block widget trees
+        """
+        if self._block_funcs is None:
+            self._block_funcs = {"widgets": list(), "trees": list()}
             root_dir = getProjectRoot()
             if root_dir is None or not os.path.exists(
-                file_block_widgets := root_dir / "configs" / "widget.block.py"
+                    file_block_widgets := root_dir / "configs" / "widget.block.py"
             ):
                 print(f"[WARNING] widget.block.py not find", flush=True)
-            
 
             def __get_block_widgets_module():
                 import importlib.util
@@ -601,43 +612,81 @@ class KeaTestRunner(TextTestRunner):
 
             import inspect
             for func_name, func in inspect.getmembers(mod, inspect.isfunction):
-                if func_name.startswith("block_") or func_name == "global_block_widgets":
+                if func_name == "global_block_widgets":
+                    self._block_funcs["widgets"].append(func)
+                    setattr(func, PRECONDITIONS_MARKER, (lambda d: True,))
+                    continue
+                if func_name == "global_block_tree":
+                    self._block_funcs["trees"].append(func)
+                    setattr(func, PRECONDITIONS_MARKER, (lambda d: True,))
+                    continue
+                if func_name.startswith("block_") and not func_name.startswith("block_tree_"):
+                    if getattr(func, PRECONDITIONS_MARKER, None) is None:
+                        logger.warning(f"No precondition in block widget function: {func_name}. Default globally active.")
+                        setattr(func, PRECONDITIONS_MARKER, (lambda d: True,))
+                    self._block_funcs["widgets"].append(func)
+                    continue
+                if func_name.startswith("block_tree_"):
                     if getattr(func, PRECONDITIONS_MARKER, None) is None:
-                        if func_name.startswith("block_"):
-                            logger.warning(f"No precondition in block widget function: {func_name}. Default globally active.")
-                        setattr(func, PRECONDITIONS_MARKER, (lambda d: True, ))
-                    self._block_widgets_funcs.append(func)
+                        logger.warning(f"No precondition in block tree function: {func_name}. Default globally active.")
+                        setattr(func, PRECONDITIONS_MARKER, (lambda d: True,))
+                    self._block_funcs["trees"].append(func)
+
+        return self._block_funcs
 
-        return self._block_widgets_funcs
 
     def _getBlockedWidgets(self):
-        blocked_widgets = list()
-        for func in self._blockWidgetFuncs:
+        """
+           Executes all blocking functions to get lists of widgets and trees to be blocked during testing.
+
+           Returns:
+               dict: A dictionary containing:
+                   - 'widgets': List of XPath strings for individual widgets to block
+                   - 'trees': List of XPath strings for widget trees to block
+           """
+        def _get_xpath_widgets(func):
+            blocked_set = set()
             try:
                 script_driver = self.options.Driver.getScriptDriver()
-                preconds = getattr(func, PRECONDITIONS_MARKER)
-                if all([precond(script_driver) for precond in preconds]):
+                preconds = getattr(func, PRECONDITIONS_MARKER, [])
+                if all(precond(script_driver) for precond in preconds):
                     _widgets = func(self.options.Driver.getStaticChecker())
-                    if not isinstance(_widgets, list):
-                        _widgets = [_widgets]
+                    _widgets = _widgets if isinstance(_widgets, list) else [_widgets]
                     for w in _widgets:
                         if isinstance(w, StaticU2UiObject):
-                            blocked_widgets.append(w._getXPath(w.selector))
+                            xpath = w._getXPath(w.selector)
+                            blocked_set.add(xpath)  # 集合去重
                         elif isinstance(w, u2.xpath.XPathSelector):
-                            def getXPathRepr(w):
-                                return w._parent.xpath
-                            blocked_widgets.append(getXPathRepr(w))
+                            xpath = w._parent.xpath
+                            blocked_set.add(xpath)
                         else:
                             logger.warning(f"{w} Not supported")
-                    # blocked_widgets.extend([
-                    #     w._getXPath(w.selector) for w in _widgets
-                    # ])
             except Exception as e:
-                logger.error(f"error when getting blocked widgets: {e}")
-                import traceback
+                logger.error(f"Error processing blocked widgets: {e}")
                 traceback.print_exc()
+            return blocked_set
+
+        res = {
+            "widgets": set(),
+            "trees": set()
+        }
+
+
+        for func in self._blockWidgetFuncs["widgets"]:
+            widgets = _get_xpath_widgets(func)
+            res["widgets"].update(widgets)
+
+
+        for func in self._blockWidgetFuncs["trees"]:
+            trees = _get_xpath_widgets(func)
+            res["trees"].update(trees)
+
+
+        res["widgets"] = list(res["widgets"] - res["trees"])
+        res["trees"] = list(res["trees"])
+
+        return res
 
-        return blocked_widgets
 
     def __del__(self):
         """tearDown method. Cleanup the env.

{kea2_python-0.0.1b2 → kea2_python-0.0.1b3}/kea2/logWatcher.py

@@ -46,17 +46,19 @@ class LogWatcher:
                     exception_body + 
                     "\nSee fastbot.log for details."
                 )
-        statistic_match = PATTERN_STATISTIC.search(buffer)
-        if statistic_match:
-            statistic_body = statistic_match.group(1).strip()
-            if statistic_body:
-                print(
-                    "[INFO] Fastbot exit:\n" + 
-                    statistic_body
-                , flush=True)
+        if self.end_flag:
+            statistic_match = PATTERN_STATISTIC.search(buffer)
+            if statistic_match:
+                statistic_body = statistic_match.group(1).strip()
+                if statistic_body:
+                    print(
+                        "[INFO] Fastbot exit:\n" + 
+                        statistic_body
+                    , flush=True)
 
     def __init__(self, log_file):
         self.log_file = log_file
+        self.end_flag = False
 
         threading.excepthook = thread_excepthook
         t = threading.Thread(target=self.watcher, daemon=True)
@@ -64,6 +66,7 @@ class LogWatcher:
     
     def close(self):
         time.sleep(0.2) # wait for the written logfile close
+        self.end_flag = True
         self.read_log()
 
 

{kea2_python-0.0.1b2 → kea2_python-0.0.1b3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "Kea2-python"
-version = "0.0.1b2"
+version = "0.0.1b3"
 description = "A python library for supporting and customizing automated UI testing for mobile apps"
 readme = "README.md"
 requires-python = ">=3.8"

kea2_python-0.0.1b2/kea2/assets/fastbot_configs/widget.block.py

@@ -1,18 +0,0 @@
-from kea2.utils import Device
-from kea2.keaUtils import precondition
-
-
-def global_block_widgets(d: "Device"):
-    """
-    global block widgets.
-    return the widgets you want to block globally
-    only available in mode `u2 agent`
-    """
-    return []
-
-
-# conditional block list
-@precondition(lambda d: d(text="In the home page").exists)
-def block_sth(d: "Device"):
-    # Important: function shold starts with "block_"
-    return [d(text="widgets to block"), d.xpath(".//node[@text='widget to block']")]