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

kea2/keaUtils.py

@@ -1,10 +1,8 @@
 import json
 import os
 from pathlib import Path
-import subprocess
-import threading
 import traceback
-from typing import IO, Callable, Any, Dict, List, Literal, NewType, Union
+from typing import Callable, Any, Dict, List, Literal, NewType, TypedDict, Union
 from unittest import TextTestRunner, registerResult, TestSuite, TestCase, TextTestResult
 import random
 import warnings
@@ -12,11 +10,12 @@ from dataclasses import dataclass, asdict
 import requests
 from .absDriver import AbstractDriver
 from functools import wraps
-from time import sleep
-from .adbUtils import push_file
+from .bug_report_generator import BugReportGenerator
+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
+from .fastbotManager import FastbotManager
 import uiautomator2 as u2
 import types
 
@@ -30,10 +29,14 @@ logger = getLogger(__name__)
 # Class Typing
 PropName = NewType("PropName", str)
 PropertyStore = NewType("PropertyStore", Dict[PropName, TestCase])
+PropertyExecutionInfo = TypedDict(
+    "PropertyExecutionInfo",
+    {"propName": PropName, "state": Literal["start", "pass", "fail", "error"]}
+)
 
 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 +123,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 +137,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 +186,11 @@ def getFullPropName(testCase: TestCase):
 
 class JsonResult(TextTestResult):
     res: PBTTestResult
+    
+    lastExecutedInfo: PropertyExecutionInfo = {
+        "propName": "",
+        "state": "",
+    }
 
     @classmethod
     def setProperties(cls, allProperties: Dict):
@@ -184,6 +207,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,128 +218,34 @@ 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 updateExectedInfo(self):
+        if self.lastExecutedInfo["state"] == "start":
+            self.lastExecutedInfo["state"] = "pass"
 
     def getExcuted(self, test: TestCase):
         return self.res[getFullPropName(test)].executed
 
 
-def activateFastbot(options: Options, port=None) -> threading.Thread:
-    """
-    activate fastbot.
-    :params: options: the running setting for fastbot
-    :params: port: the listening port for script driver
-    :return: the fastbot daemon thread
-    """
-    cur_dir = Path(__file__).parent
-    push_file(
-        Path.joinpath(cur_dir, "assets/monkeyq.jar"),
-        "/sdcard/monkeyq.jar",
-        device=options.serial
-    )
-    push_file(
-        Path.joinpath(cur_dir, "assets/fastbot-thirdpart.jar"),
-        "/sdcard/fastbot-thirdpart.jar",
-        device=options.serial,
-    )
-    push_file(
-        Path.joinpath(cur_dir, "assets/framework.jar"), 
-        "/sdcard/framework.jar",
-        device=options.serial
-    )
-    push_file(
-        Path.joinpath(cur_dir, "assets/fastbot_libs/arm64-v8a"),
-        "/data/local/tmp",
-        device=options.serial
-    )
-    push_file(
-        Path.joinpath(cur_dir, "assets/fastbot_libs/armeabi-v7a"),
-        "/data/local/tmp",
-        device=options.serial
-    )
-    push_file(
-        Path.joinpath(cur_dir, "assets/fastbot_libs/x86"),
-        "/data/local/tmp",
-        device=options.serial
-    )
-    push_file(
-        Path.joinpath(cur_dir, "assets/fastbot_libs/x86_64"),
-        "/data/local/tmp",
-        device=options.serial
-    )
-
-    t = startFastbotService(options)
-    print("[INFO] Running Fastbot...", flush=True)
-
-    return t
-
-
-def check_alive(port):
-    """
-    check if the script driver and proxy server are alive.
-    """
-    for _ in range(10):
-        sleep(2)
-        try:
-            requests.get(f"http://localhost:{port}/ping")
-            return
-        except requests.ConnectionError:
-            print("[INFO] waiting for connection.", flush=True)
-            pass
-    raise RuntimeError("Failed to connect fastbot")
-
-
-def startFastbotService(options: Options) -> threading.Thread:
-    shell_command = [
-        "CLASSPATH=/sdcard/monkeyq.jar:/sdcard/framework.jar:/sdcard/fastbot-thirdpart.jar",
-        "exec", "app_process",
-        "/system/bin", "com.android.commands.monkey.Monkey",
-        "-p", *options.packageNames,
-        "--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"
-    ]
-
-    full_cmd = ["adb"] + (["-s", options.serial] if options.serial else []) + ["shell"] + shell_command
-
-    outfile = open(LOGFILE, "w", encoding="utf-8", buffering=1)
-
-    print("[INFO] Options info: {}".format(asdict(options)), flush=True)
-    print("[INFO] Launching fastbot with shell command:\n{}".format(" ".join(full_cmd)), flush=True)
-    print("[INFO] Fastbot log will be saved to {}".format(outfile.name), flush=True)
-
-    # process handler
-    proc = subprocess.Popen(full_cmd, stdout=outfile, stderr=outfile)
-    t = threading.Thread(target=close_on_exit, args=(proc, outfile), daemon=True)
-    t.start()
-
-    return t
-
-
-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
 
     @classmethod
     def setOptions(cls, options: Options):
         if not isinstance(options.packageNames, list) and len(options.packageNames) > 0:
             raise ValueError("packageNames should be given in a list.")
         if options.Driver is not None and options.agent == "native":
-            print("[Warning] Can not use any Driver when runing native mode.", flush=True)
+            logger.warning("[Warning] Can not use any Driver when runing native mode.")
             options.Driver = None
         cls.options = options
 
@@ -331,7 +264,7 @@ class KeaTestRunner(TextTestRunner):
         self.collectAllProperties(test)
 
         if len(self.allProperties) == 0:
-            print("[Warning] No property has been found.", flush=True)
+            logger.warning("[Warning] No property has been found.")
 
         self._setOuputDir()
 
@@ -360,38 +293,44 @@ class KeaTestRunner(TextTestRunner):
                         message=r"Please use assert\w+ instead.",
                     )
 
-            t = activateFastbot(options=self.options)
             log_watcher = LogWatcher(LOGFILE)
-            if self.options.agent == "native":
-                t.join()
-            else:
+            fb = FastbotManager(self.options, LOGFILE)
+            fb.start()
+            
+            if self.options.agent == "u2":
                 # initialize the result.json file
                 result.flushResult(outfile=RESFILE)
                 # setUp for the u2 driver
                 self.scriptDriver = self.options.Driver.getScriptDriver()
-                check_alive(port=self.scriptDriver.lport)
+                fb.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
                 while self.stepsCount < self.options.maxStep:
 
                     self.stepsCount += 1
-                    print("[INFO] Sending monkeyEvent {}".format(
+                    logger.info("Sending monkeyEvent {}".format(
                         f"({self.stepsCount} / {self.options.maxStep})" if self.options.maxStep != float("inf")
                         else f"({self.stepsCount})"
                         )
-                    , flush=True)
+                    )
 
                     try:
                         xml_raw = self.stepMonkey()
-                        stat = self._getStat()
                         propsSatisfiedPrecond = self.getValidProperties(xml_raw, result)
                     except requests.ConnectionError:
-                        print(
-                            "[INFO] Exploration times up (--running-minutes)."
-                        , flush=True)
-                        end_by_remote = True
-                        break
+                        if fb.get_return_code() == 0:
+                            logger.info("[INFO] Exploration times up (--running-minutes).")
+                            end_by_remote = True
+                            break
+                        raise RuntimeError("Fastbot Aborted.")
+
+                    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)
 
@@ -420,20 +359,24 @@ class KeaTestRunner(TextTestRunner):
                     print("execute property %s." % execPropName, flush=True)
 
                     result.addExcuted(test)
+                    self._logScript(result.lastExecutedInfo)
                     try:
                         test(result)
                     finally:
                         result.printErrors()
 
+                    result.updateExectedInfo()
+                    self._logScript(result.lastExecutedInfo)
                     result.flushResult(outfile=RESFILE)
 
                 if not end_by_remote:
                     self.stopMonkey()
                 result.flushResult(outfile=RESFILE)
-
+                resultSyncer.close()
+                
+            fb.join()
             print(f"Finish sending monkey events.", flush=True)
             log_watcher.close()
-            self.tearDown()
 
         # Source code from unittest Runner
         # process the result
@@ -475,15 +418,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 +480,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,8 +520,8 @@ 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:
                 if isinstance(test, TestSuite):
@@ -577,17 +541,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 +572,94 @@ 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:
-                        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 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:
+                        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:
+            logger.debug("Generating test bug report")
+            report_generator = BugReportGenerator(self.options.output_dir)
+            report_generator.generate_report()
+        except Exception as e:
+            logger.error(f"Error generating bug report: {e}", flush=True)
+        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__":