Kea2-python 0.0.1b3__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,129 +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_funcs: Dict[Literal["widgets", "trees"], List[Callable]] = None
-    # _block_trees_funcs = 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
 
@@ -332,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()
 
@@ -361,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)
 
@@ -421,17 +359,22 @@ 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()
 
@@ -537,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
@@ -560,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):
@@ -654,8 +614,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 +651,15 @@ class KeaTestRunner(TextTestRunner):
     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:
@@ -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)