Kea2-python 0.0.1b2__py3-none-any.whl → 0.1.0b0__py3-none-any.whl

kea2/__init__.py

@@ -1,4 +1 @@
-from .keaUtils import KeaTestRunner, precondition, prob, max_tries, Options
-
-import logging
-logging.basicConfig(level=logging.DEBUG)
+from .keaUtils import KeaTestRunner, precondition, prob, max_tries, Options

kea2/adbUtils.py

@@ -147,7 +147,6 @@ def pull_file(remote_path: str, local_path: str, device: Optional[str] = None):
     """
     return run_adb_command(["-s", device, "pull", remote_path, local_path])
 
-
 # Forward-related functions
 
 

kea2/assets/fastbot_configs/widget.block.py

@@ -4,15 +4,35 @@ 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`
+    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 []
 
 
-# conditional block list
-@precondition(lambda d: d(text="In the home page").exists)
+# 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"):
-    # Important: function shold starts with "block_"
-    return [d(text="widgets to block"), d.xpath(".//node[@text='widget to block']")]
+    # 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/keaUtils.py

@@ -14,9 +14,10 @@ from .absDriver import AbstractDriver
 from functools import wraps
 from time import sleep
 from .adbUtils import push_file
+from .resultSyncer import ResultSyncer
 from .logWatcher import LogWatcher
 from .utils import TimeStamp, getProjectRoot, getLogger
-from .u2Driver import StaticU2UiObject
+from .u2Driver import StaticU2UiObject, selector_to_xpath
 import uiautomator2 as u2
 import types
 
@@ -32,8 +33,8 @@ PropName = NewType("PropName", str)
 PropertyStore = NewType("PropertyStore", Dict[PropName, TestCase])
 
 STAMP = TimeStamp().getTimeStamp()
-LOGFILE = f"fastbot_{STAMP}.log"
-RESFILE = f"result_{STAMP}.json"
+LOGFILE: str
+RESFILE: str
 
 def precondition(precond: Callable[[Any], bool]) -> Callable:
     """the decorator @precondition
@@ -120,7 +121,11 @@ class Options:
     # the stamp for log file and result file, default: current time stamp
     log_stamp: str = None
     # the profiling period to get the coverage result.
-    profile_period: int = None
+    profile_period: int = 25
+    # take screenshots for every step
+    take_screenshots: bool = False
+    # the debug mode
+    debug: bool = False
 
     def __setattr__(self, name, value):
         if value is None:
@@ -130,10 +135,21 @@ class Options:
     def __post_init__(self):
         if self.serial and self.Driver:
             self.Driver.setDeviceSerial(self.serial)
+        global LOGFILE, RESFILE, STAMP
         if self.log_stamp:
-            global LOGFILE, RESFILE
-            LOGFILE = f"fastbot_{self.log_stamp}.log"
-            RESFILE = f"result_{self.log_stamp}.json"
+            STAMP = self.log_stamp
+        self.output_dir = Path(self.output_dir).absolute() / f"res_{STAMP}"
+        LOGFILE = f"fastbot_{STAMP}.log"
+        RESFILE = f"result_{STAMP}.json"
+
+        self.profile_period = int(self.profile_period)
+        if self.profile_period < 1:
+            raise ValueError("--profile-period should be greater than 0")
+
+        self.throttle = int(self.throttle)
+        if self.throttle < 0:
+            raise ValueError("--throttle should be greater than or equal to 0")
+
         _check_package_installation(self.serial, self.packageNames)
 
 
@@ -168,6 +184,11 @@ def getFullPropName(testCase: TestCase):
 
 class JsonResult(TextTestResult):
     res: PBTTestResult
+    
+    lastExecutedInfo: Dict = {
+        "propName": "",
+        "state": "",
+    }
 
     @classmethod
     def setProperties(cls, allProperties: Dict):
@@ -184,6 +205,10 @@ class JsonResult(TextTestResult):
 
     def addExcuted(self, test: TestCase):
         self.res[getFullPropName(test)].executed += 1
+        self.lastExecutedInfo = {
+            "propName": getFullPropName(test),
+            "state": "start",
+        }
 
     def addPrecondSatisfied(self, test: TestCase):
         self.res[getFullPropName(test)].precond_satisfied += 1
@@ -191,10 +216,12 @@ class JsonResult(TextTestResult):
     def addFailure(self, test, err):
         super().addFailure(test, err)
         self.res[getFullPropName(test)].fail += 1
+        self.lastExecutedInfo["state"] = "fail"
 
     def addError(self, test, err):
         super().addError(test, err)
         self.res[getFullPropName(test)].error += 1
+        self.lastExecutedInfo["state"] = "error"
 
     def getExcuted(self, test: TestCase):
         return self.res[getFullPropName(test)].executed
@@ -271,14 +298,18 @@ def startFastbotService(options: Options) -> threading.Thread:
         "exec", "app_process",
         "/system/bin", "com.android.commands.monkey.Monkey",
         "-p", *options.packageNames,
-        "--agent-u2" if options.agent == "u2" else "--agent", 
+        "--agent-u2" if options.agent == "u2" else "--agent",
         "reuseq",
         "--running-minutes", f"{options.running_mins}",
         "--throttle", f"{options.throttle}",
-        "--bugreport", "--output-directory", "/sdcard/fastbot_report",
-        "-v", "-v", "-v"
+        "--bugreport",
     ]
 
+    if options.profile_period:
+        shell_command += ["--profile-period", f"{options.profile_period}"]
+
+    shell_command += ["-v", "-v", "-v"]
+
     full_cmd = ["adb"] + (["-s", options.serial] if options.serial else []) + ["shell"] + shell_command
 
     outfile = open(LOGFILE, "w", encoding="utf-8", buffering=1)
@@ -298,14 +329,15 @@ def startFastbotService(options: Options) -> threading.Thread:
 def close_on_exit(proc: subprocess.Popen, f: IO):
     proc.wait()
     f.close()
-  
+
 
 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):
@@ -370,6 +402,10 @@ class KeaTestRunner(TextTestRunner):
                 # setUp for the u2 driver
                 self.scriptDriver = self.options.Driver.getScriptDriver()
                 check_alive(port=self.scriptDriver.lport)
+                self._init()
+
+                resultSyncer = ResultSyncer(self.device_output_dir, self.options.output_dir)
+                resultSyncer.run()
 
                 end_by_remote = False
                 self.stepsCount = 0
@@ -384,7 +420,6 @@ class KeaTestRunner(TextTestRunner):
 
                     try:
                         xml_raw = self.stepMonkey()
-                        stat = self._getStat()
                         propsSatisfiedPrecond = self.getValidProperties(xml_raw, result)
                     except requests.ConnectionError:
                         print(
@@ -393,6 +428,9 @@ class KeaTestRunner(TextTestRunner):
                         end_by_remote = True
                         break
 
+                    if self.options.profile_period and self.stepsCount % self.options.profile_period == 0:
+                        resultSyncer.sync_event.set()
+
                     print(f"{len(propsSatisfiedPrecond)} precond satisfied.", flush=True)
 
                     # Go to the next round if no precond satisfied
@@ -420,20 +458,23 @@ class KeaTestRunner(TextTestRunner):
                     print("execute property %s." % execPropName, flush=True)
 
                     result.addExcuted(test)
+                    self._logScript(result.lastExecutedInfo)
                     try:
                         test(result)
                     finally:
                         result.printErrors()
 
+                    self._logScript(result.lastExecutedInfo)
                     result.flushResult(outfile=RESFILE)
 
                 if not end_by_remote:
                     self.stopMonkey()
                 result.flushResult(outfile=RESFILE)
+                resultSyncer.close()    
 
             print(f"Finish sending monkey events.", flush=True)
             log_watcher.close()
-            self.tearDown()
+            
 
         # Source code from unittest Runner
         # process the result
@@ -475,15 +516,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
             }
         )
 
@@ -533,14 +578,31 @@ class KeaTestRunner(TextTestRunner):
                 validProps[propName] = test
         return validProps
 
-    def _getStat(self):
-        # profile when reaching the profile period
-        if (self.options.profile_period and 
-            self.stepsCount % self.options.profile_period == 0
-        ):
-            URL = f"http://localhost:{self.scriptDriver.lport}/getStat"
-            r = requests.get(URL)
-            res = json.loads(r.content)
+    def _logScript(self, execution_info:Dict):
+        URL = f"http://localhost:{self.scriptDriver.lport}/logScript"
+        r = requests.post(
+            url=URL,
+            json=execution_info
+        )
+        res = r.content.decode(encoding="utf-8")
+        if res != "OK":
+            print(f"[ERROR] Error when logging script: {execution_info}", flush=True)
+
+    def _init(self):
+        URL = f"http://localhost:{self.scriptDriver.lport}/init"
+        data = {
+            "takeScreenshots": self.options.take_screenshots,
+            "Stamp": STAMP
+        }
+        print(f"[INFO] Init fastbot: {data}", flush=True)
+        r = requests.post(
+            url=URL,
+            json=data
+        )
+        res = r.content.decode(encoding="utf-8")
+        import re
+        self.device_output_dir = re.match(r"outputDir:(.+)", res).group(1)
+        print(f"[INFO] Fastbot initiated. Device outputDir: {res}", flush=True)
 
     def collectAllProperties(self, test: TestSuite):
         """collect all the properties to prepare for PBT
@@ -556,7 +618,7 @@ class KeaTestRunner(TextTestRunner):
             """remove the tearDown function in PBT
             """
             def tearDown(self): ...
-            testCase = types.MethodType(tearDown, testCase)
+            testCase.tearDown = types.MethodType(tearDown, testCase)
         
         def iter_tests(suite):
             for test in suite:
@@ -577,17 +639,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,46 +670,88 @@ 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 = selector_to_xpath(w.selector, True)
+                            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.
         """
+        try:
+            self.stopMonkey()
+        except Exception as e:
+            pass
         if self.options.Driver:
             self.options.Driver.tearDown()

kea2/kea_launcher.py

@@ -1,8 +1,6 @@
-import os
 import sys
 import argparse
 import unittest
-from pathlib import Path
 from typing import List
 
 def _set_runner_parser(subparsers: "argparse._SubParsersAction[argparse.ArgumentParser]"):
@@ -49,6 +47,7 @@ def _set_runner_parser(subparsers: "argparse._SubParsersAction[argparse.Argument
         dest="running_minutes",
         type=int,
         required=False,
+        default=10,
         help="Time to run fastbot",
     )
 
@@ -89,8 +88,18 @@ def _set_runner_parser(subparsers: "argparse._SubParsersAction[argparse.Argument
         dest="profile_period",
         type=int,
         required=False,
+        default=25,
         help="Steps to profile the testing statistics.",
     )
+    
+    parser.add_argument(
+        "--take-screenshots",
+        dest="take_screenshots",
+        required=False,
+        action="store_true",
+        default=False,
+        help="Take screenshots for every step.",
+    )
 
     parser.add_argument(
         "extra",
@@ -118,6 +127,10 @@ def driver_info_logger(args):
         print("  running_minutes:", args.running_minutes, flush=True)
     if args.throttle_ms:
         print("  throttle_ms:", args.throttle_ms, flush=True)
+    if args.log_stamp:
+        print("  log_stamp:", args.log_stamp, flush=True)
+    if args.take_screenshots:
+        print("  take_screenshots:", args.take_screenshots, flush=True)
 
 
 def parse_args(argv: List):
@@ -140,9 +153,7 @@ def _sanitize_args(args):
 def run(args=None):
     if args is None:
         args = parse_args(sys.argv[1:])
-
     _sanitize_args(args)
-
     driver_info_logger(args)
     unittest_info_logger(args)
 
@@ -159,6 +170,7 @@ def run(args=None):
         throttle=args.throttle_ms,
         log_stamp=args.log_stamp,
         profile_period=args.profile_period,
+        take_screenshots=args.take_screenshots,
     )
 
     KeaTestRunner.setOptions(options)

kea2/logWatcher.py

@@ -20,10 +20,13 @@ class LogWatcher:
         self.buffer = ""
         self.last_pos = 0
 
-        while True:
+        while not self.end_flag:
             self.read_log()
             time.sleep(poll_interval)
         
+        time.sleep(0.2)
+        self.read_log()
+        
     def read_log(self):
         time.sleep(0.02)
         with open(self.log_file, 'r', encoding='utf-8') as f:
@@ -46,25 +49,26 @@ 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)
         t.start()
     
     def close(self):
-        time.sleep(0.2) # wait for the written logfile close
-        self.read_log()
+        self.end_flag = True
 
 
 if __name__ == "__main__":

kea2/resultSyncer.py

@@ -0,0 +1,56 @@
+import threading
+from .adbUtils import adb_shell, pull_file
+from .utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class ResultSyncer:
+
+    def __init__(self, device_output_dir, output_dir):
+        self.device_output_dir = device_output_dir
+        self.output_dir = output_dir
+        self.running = False
+        self.thread = None
+        self.sync_event = threading.Event()
+
+    def run(self):
+        """Start a background thread to sync device data when triggered"""
+        self.running = True
+        self.thread = threading.Thread(target=self._sync_thread, daemon=True)
+        self.thread.start()
+
+    def _sync_thread(self):
+        """Thread function that waits for sync event and then syncs data"""
+        while self.running:
+            # Wait for sync event with a timeout to periodically check if still running
+            if self.sync_event.wait(timeout=3):
+                self._sync_device_data()
+                self.sync_event.clear()
+
+    def close(self):
+        self.running = False
+        self.sync_event.set()
+        if self.thread and self.thread.is_alive():
+            self.thread.join(timeout=10)
+        self._sync_device_data()
+        try:
+            logger.debug(f"Removing device output directory: {self.device_output_dir}")
+            remove_device_dir = ["rm", "-rf", self.device_output_dir]
+            adb_shell(remove_device_dir)
+        except Exception as e:
+            logger.error(f"Error removing device output directory: {e}", flush=True)
+
+    def _sync_device_data(self):
+        """
+        Sync the device data to the local directory.
+        """
+        try:
+            logger.debug("Syncing data")
+
+            pull_file(self.device_output_dir, str(self.output_dir))
+
+            remove_pulled_screenshots = ["find", self.device_output_dir, "-name", "\"*.png\"", "-delete"]
+            adb_shell(remove_pulled_screenshots)
+        except Exception as e:
+            logger.error(f"Error in data sync: {e}", flush=True)