Kea2-python 0.0.1b3__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/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,7 +329,7 @@ def startFastbotService(options: Options) -> threading.Thread:
 def close_on_exit(proc: subprocess.Popen, f: IO):
     proc.wait()
     f.close()
-  
+
 
 class KeaTestRunner(TextTestRunner):
 
@@ -371,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
@@ -385,7 +420,6 @@ class KeaTestRunner(TextTestRunner):
 
                     try:
                         xml_raw = self.stepMonkey()
-                        stat = self._getStat()
                         propsSatisfiedPrecond = self.getValidProperties(xml_raw, result)
                     except requests.ConnectionError:
                         print(
@@ -394,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
@@ -421,19 +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()
+            
 
         # Source code from unittest Runner
         # process the result
@@ -537,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
@@ -560,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:
@@ -654,8 +712,8 @@ class KeaTestRunner(TextTestRunner):
                     _widgets = _widgets if isinstance(_widgets, list) else [_widgets]
                     for w in _widgets:
                         if isinstance(w, StaticU2UiObject):
-                            xpath = w._getXPath(w.selector)
-                            blocked_set.add(xpath)  # 集合去重
+                            xpath = selector_to_xpath(w.selector, True)
+                            blocked_set.add(xpath)
                         elif isinstance(w, u2.xpath.XPathSelector):
                             xpath = w._parent.xpath
                             blocked_set.add(xpath)
@@ -691,5 +749,9 @@ class KeaTestRunner(TextTestRunner):
     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:
@@ -65,9 +68,7 @@ class LogWatcher:
         t.start()
     
     def close(self):
-        time.sleep(0.2) # wait for the written logfile close
         self.end_flag = True
-        self.read_log()
 
 
 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)

kea2/u2Driver.py

@@ -123,6 +123,7 @@ class StaticU2UiObject(u2.UiObject):
         xpath = f".//node{''.join(attrLocs)}"
         return xpath
 
+
     @property
     def exists(self):
         dict.update(self.selector, {"covered": "false"})
@@ -134,6 +135,12 @@ class StaticU2UiObject(u2.UiObject):
         xpath = self._getXPath(self.selector)
         matched_widgets = self.session.xml.xpath(xpath)
         return len(matched_widgets)
+    
+    def child(self, **kwargs):
+        return StaticU2UiObject(self.session, self.selector.clone().child(**kwargs))
+    
+    def sibling(self, **kwargs):
+        return StaticU2UiObject(self.session, self.selector.clone().sibling(**kwargs))
 
 
 def _get_bounds(raw_bounds):
@@ -324,6 +331,89 @@ def forward_port(self, remote: Union[int, str]) -> int:
         return local_port
 
 
+def selector_to_xpath(selector: u2.Selector, is_initial: bool = True) -> str:
+    """
+    Convert a u2 Selector into an XPath expression compatible with Java Android UI controls.
+
+    Args:
+        selector (u2.Selector): A u2 Selector object
+        is_initial (bool): Whether it is the initial node, defaults to True
+
+    Returns:
+        str: The corresponding XPath expression
+    """
+    try:
+        if is_initial:
+            xpath = ".//node"
+        else:
+            xpath = "node"
+
+        conditions = []
+
+        if "className" in selector:
+            conditions.insert(0, f"[@class='{selector['className']}']")  # 将 className 条件放在前面
+
+        if "text" in selector:
+            conditions.append(f"[@text='{selector['text']}']")
+        elif "textContains" in selector:
+            conditions.append(f"[contains(@text, '{selector['textContains']}')]")
+        elif "textMatches" in selector:
+            conditions.append(f"[re:match(@text, '{selector['textMatches']}')]")
+        elif "textStartsWith" in selector:
+            conditions.append(f"[starts-with(@text, '{selector['textStartsWith']}')]")
+
+        if "description" in selector:
+            conditions.append(f"[@content-desc='{selector['description']}']")
+        elif "descriptionContains" in selector:
+            conditions.append(f"[contains(@content-desc, '{selector['descriptionContains']}')]")
+        elif "descriptionMatches" in selector:
+            conditions.append(f"[re:match(@content-desc, '{selector['descriptionMatches']}')]")
+        elif "descriptionStartsWith" in selector:
+            conditions.append(f"[starts-with(@content-desc, '{selector['descriptionStartsWith']}')]")
+
+        if "packageName" in selector:
+            conditions.append(f"[@package='{selector['packageName']}']")
+        elif "packageNameMatches" in selector:
+            conditions.append(f"[re:match(@package, '{selector['packageNameMatches']}')]")
+
+        if "resourceId" in selector:
+            conditions.append(f"[@resource-id='{selector['resourceId']}']")
+        elif "resourceIdMatches" in selector:
+            conditions.append(f"[re:match(@resource-id, '{selector['resourceIdMatches']}')]")
+
+        bool_props = [
+            "checkable", "checked", "clickable", "longClickable", "scrollable",
+            "enabled", "focusable", "focused", "selected", "covered"
+        ]
+        for prop in bool_props:
+            if prop in selector:
+                value = "true" if selector[prop] else "false"
+                conditions.append(f"[@{prop}='{value}']")
+
+        if "index" in selector:
+            conditions.append(f"[@index='{selector['index']}']")
+        elif "instance" in selector:
+            conditions.append(f"[@instance='{selector['instance']}']")
+
+        xpath += "".join(conditions)
+
+        if "childOrSibling" in selector and selector["childOrSibling"]:
+            for i, relation in enumerate(selector["childOrSibling"]):
+                sub_selector = selector["childOrSiblingSelector"][i]
+                sub_xpath = selector_to_xpath(sub_selector, False)  # 递归处理子选择器
+
+                if relation == "child":
+                    xpath += f"/{sub_xpath}"
+                elif relation == "sibling":
+                    xpath_initial = xpath
+                    xpath = '(' + xpath_initial + f"/following-sibling::{sub_xpath} | " + xpath_initial + f"/preceding-sibling::{sub_xpath})"
+
+        return xpath
+
+    except Exception as e:
+        print(f"Error occurred during selector conversion: {e}")
+        return "//error"
+
 def is_port_in_use(port: int) -> bool:
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
         return s.connect_ex(('127.0.0.1', port)) == 0

kea2/utils.py

@@ -1,6 +1,9 @@
 import logging
 import os
 from pathlib import Path
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .keaUtils import Options
 
 
 def getLogger(name: str) -> logging.Logger:
@@ -50,4 +53,8 @@ def getProjectRoot():
         if cur_dir == root:
             return None
         cur_dir = cur_dir.parent
-    return cur_dir
+    return cur_dir
+
+
+
+