Kea2-python 1.1.0b1__py3-none-any.whl

kea2/fastbotManager.py

@@ -0,0 +1,269 @@
+import itertools
+import requests
+
+from time import sleep
+from dataclasses import asdict
+from pathlib import Path
+
+from retry import retry
+from retry.api import retry_call
+from uiautomator2.core import HTTPResponse, _http_request
+from packaging.version import parse as parse_version
+
+from .utils import getLogger, getProjectRoot
+from .adbUtils import ADBDevice, ADBStreamShell_V2
+
+
+from typing import IO, TYPE_CHECKING, Dict
+if TYPE_CHECKING:
+    from .keaUtils import Options
+    from .typedefs import PropertyExecutionInfo
+
+
+logger = getLogger(__name__)
+
+
+class FastbotManager:
+    def __init__(self, options: "Options", log_file: str):
+        self.options:"Options" = options
+        self.log_file: str = log_file
+        self.port = None
+        self.thread = None
+        self._device_output_dir = None
+        ADBDevice.setDevice(options.serial, options.transport_id)
+        self.dev = ADBDevice()
+        self.android_release = parse_version(self.dev.getprop("ro.build.version.release"))
+        self.executed_prop = False
+
+    def _activateFastbot(self) -> ADBStreamShell_V2:
+        """
+        activate fastbot.
+        :params: options: the running setting for fastbot
+        :params: port: the listening port for script driver
+        :return: the fastbot daemon thread
+        """
+
+        self._push_libs()
+        t = self._startFastbotService()
+        logger.info("Running Fastbot...")
+        return t
+
+    def check_alive(self):
+        """
+        check if the script driver and proxy server are alive.
+        """
+        def _check_alive_request():
+            _http_request(dev=self.dev, device_port=8090, method="GET", path="/ping")
+
+        try:
+            logger.info("Connecting to fastbot server...")
+            retry_call(_check_alive_request, tries=10, delay=2, logger=logger)
+            logger.info("Connected to fastbot server.")
+        except requests.ConnectionError:
+            raise RuntimeError("Failed to connect fastbot")
+
+    def request(self, method: str, path: str, data: Dict=None, timeout: int=10) -> HTTPResponse:
+        return _http_request(self.dev, 8090, method, path, data, timeout)
+
+    @retry(Exception, tries=2, delay=2)
+    def init(self, options: "Options", stamp):
+        post_data = {
+            "takeScreenshots": options.take_screenshots,
+            "preFailureScreenshots": options.pre_failure_screenshots,
+            "postFailureScreenshots": options.post_failure_screenshots,
+            "logStamp": stamp,
+            "deviceOutputRoot": options.device_output_root,
+        }
+        r = _http_request(
+            self.dev,
+            device_port=8090,
+            method="POST",
+            path="/init",
+            data=post_data
+        )
+        print(f"[INFO] Init fastbot: {post_data}", flush=True)
+        import re
+        self._device_output_dir = re.match(r"outputDir:(.+)", r.text).group(1)
+        print(f"[INFO] Fastbot initiated. outputDir: {r.text}", flush=True)
+    
+    @retry(Exception, tries=2, delay=2)
+    def stepMonkey(self, monkeyStepInfo):
+        r = self.request(
+            method="POST",
+            path="/stepMonkey",
+            data=monkeyStepInfo
+        )
+        return r.json()["result"]
+
+    @retry(Exception, tries=2, delay=2)
+    def stopMonkey(self):
+        """
+        send a stop monkey request to the server.
+        """
+        r = self.request(
+            method="GET",
+            path="/stopMonkey",
+        )
+
+        print(f"[Server INFO] {r.text}", flush=True)
+    
+    @retry(Exception, tries=2, delay=2)
+    def logScript(self, execution_info: "PropertyExecutionInfo"):
+        r = self.request(
+            method="POST",
+            path="/logScript",
+            data={
+                "propName": execution_info.propName,
+                "startStepsCount": execution_info.startStepsCount,
+                "kind": execution_info.kind,
+                "state": execution_info.state,
+            }
+        )
+        res = r.text
+        if res != "OK":
+            print(f"[ERROR] Error when logging script: {execution_info}", flush=True)
+    
+    @retry(Exception, tries=2, delay=2)
+    def dumpHierarchy(self):
+        sleep(self.options.throttle / 1000)
+        r = self.request(
+            method="GET",
+            path="/dumpHierarchy",
+        )
+        return r.json()['result']
+    
+    @retry(Exception, tries=2, delay=2)
+    def sendInfo(self, info: str):
+        r = self.request(
+            method="POST",
+            path="/sendInfo",
+            data=info
+        )
+
+    @property
+    def device_output_dir(self):
+        return self._device_output_dir
+    
+    def _push_libs(self):
+        logger.info("Pushing Fastbot libraries to device...")
+        cur_dir = Path(__file__).parent
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/monkeyq.jar"),
+            "/sdcard/monkeyq.jar"
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot-thirdpart.jar"),
+            "/sdcard/fastbot-thirdpart.jar",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/kea2-thirdpart.jar"),
+            "/sdcard/kea2-thirdpart.jar",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/framework.jar"),
+            "/sdcard/framework.jar",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot_libs/arm64-v8a/libfastbot_native.so"),
+            "/data/local/tmp/arm64-v8a/libfastbot_native.so",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot_libs/armeabi-v7a/libfastbot_native.so"),
+            "/data/local/tmp/armeabi-v7a/libfastbot_native.so",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot_libs/x86/libfastbot_native.so"),
+            "/data/local/tmp/x86/libfastbot_native.so",
+        )
+        self.dev.sync.push(
+            Path.joinpath(cur_dir, "assets/fastbot_libs/x86_64/libfastbot_native.so"),
+            "/data/local/tmp/x86_64/libfastbot_native.so",
+        )
+
+        cwd = getProjectRoot()
+        whitelist = self.options.act_whitelist_file
+        blacklist = self.options.act_blacklist_file
+        if bool(whitelist) ^ bool(blacklist):
+            if whitelist:
+                file_to_push = cwd / 'configs' / 'awl.strings'
+                remote_path = whitelist
+            else:
+                file_to_push = cwd / 'configs' / 'abl.strings'
+                remote_path = blacklist
+
+            self.dev.sync.push(
+                file_to_push,
+                remote_path
+            )
+
+    def _startFastbotService(self) -> ADBStreamShell_V2:
+        shell_command = [
+            "CLASSPATH="
+            "/sdcard/monkeyq.jar:"
+            "/sdcard/framework.jar:"
+            "/sdcard/fastbot-thirdpart.jar:"
+            "/sdcard/kea2-thirdpart.jar",
+            "exec", "app_process",
+            "/system/bin", "com.android.commands.monkey.Monkey",
+            "--agent-u2" if self.options.agent == "u2" else "--agent",
+            "reuseq",
+            "--running-minutes", f"{self.options.running_mins}",
+            "--throttle", f"{self.options.throttle}",
+            "--bugreport",
+            "--output-directory", f"{self.options.device_output_root}/output_{self.options.log_stamp}",
+        ]
+
+        pkgs = itertools.chain.from_iterable(["-p", pkg] for pkg in self.options.packageNames)
+        shell_command.extend(pkgs)
+
+        if self.options.profile_period:
+            shell_command += ["--profile-period", f"{self.options.profile_period}"]
+
+        whitelist = self.options.act_whitelist_file
+        blacklist = self.options.act_blacklist_file
+        if bool(whitelist) ^ bool(blacklist):
+            if whitelist:
+                shell_command += ["--act-whitelist-file", f"{whitelist}"]
+            else:
+                shell_command += ["--act-blacklist-file", f"{blacklist}"]
+
+        shell_command += ["-v", "-v", "-v"]
+
+        if self.options.extra_args:
+            shell_command += self.options.extra_args
+
+        full_cmd = ["adb"] + (["-s", self.options.serial] if self.options.serial else []) + ["shell"] + shell_command
+
+
+        outfile = open(self.log_file, "w", encoding="utf-8", buffering=1)
+
+        logger.info("Options info: {}".format(asdict(self.options)))
+        logger.info("Launching fastbot with shell command:\n{}".format(" ".join(full_cmd)))
+        logger.info("Fastbot log will be saved to {}".format(outfile.name))
+
+        t = self.dev.stream_shell(shell_command, stdout=outfile, stderr=outfile)
+        return t
+
+    def close_on_exit(self, proc: ADBStreamShell_V2, f: IO):
+        self.return_code = proc.wait()
+        f.close()
+        if self.return_code != 0:
+            raise RuntimeError(f"Fastbot Error: Terminated with [code {self.return_code}] See {self.log_file} for details.")
+
+    def get_return_code(self):
+        if self.thread.is_running():
+            logger.info("Waiting for Fastbot to exit.")
+            return self.thread.wait()
+        return self.thread.poll() if self.android_release >= parse_version("7.0") else 0
+
+    def start(self):
+        # kill the fastbot process if runing.
+        self.dev.kill_proc("com.android.commands.monkey")
+        self.thread = self._activateFastbot()
+
+    def join(self):
+        self.thread.join()
+
+
+
+

kea2/kea2_api.py

@@ -0,0 +1,166 @@
+from typing import Optional, List, Callable, Any, Union, Dict
+from pathlib import Path
+import unittest
+import os
+import inspect
+from .keaUtils import KeaTestRunner, Options
+from .u2Driver import U2Driver
+from .utils import getLogger, TimeStamp, setCustomProjectRoot
+from .adbUtils import ADBDevice
+
+logger = getLogger(__name__)
+
+
+class Kea2Tester:
+    """
+    Kea2 property tester
+    
+    This class allows users to directly launch Kea2 property tests in existing test scripts.
+    
+    Environment Variables:
+        KEA2_HYBRID_MODE: Controls whether to enable Kea2 testing
+            - "kea2": Enable Kea2 testing, trigger a breakpoint after testing is completed
+            - Other values or not set: Skip Kea2 testing, continue executing the original script
+            
+    """
+    
+    def __init__(self):
+        self.options: Optional[Options] = None
+        self.properties: List[unittest.TestCase] = []
+        self._caller_info: Optional[Dict[str, str]] = None
+    
+    def run_kea2_testing(self, option: Options, configs_path: Optional[Union[str, Path]] = None) -> Dict[str, Any]:
+        """
+        Launch kea2 property test
+        
+        Args:
+            option: Kea2 and Fastbot configuration options
+            configs_path: Your configs directory (absolute or relative path)
+        
+        Returns:
+            dict: Test result dictionary containing the following keys:
+                - executed (bool): Whether Kea2 testing was executed
+                - skipped (bool): Whether Kea2 testing was skipped (KEA2_HYBRID_MODE != kea2)
+                - caller_info (Dict|None): Caller information (file, class, method name)
+                - output_dir (Path|None): Test output directory
+                - bug_report (Path|None): Bug report HTML file path
+                - result_json (Path|None): Test result JSON file path
+                - log_file (Path|None): Fastbot log file path
+        
+        """
+
+        self._caller_info = self._get_caller_info()
+        
+        logger.info("Starting Kea2 property testing...")
+        logger.info(f"Kea2 test launch location:")
+        if self._caller_info:
+            logger.info(f"   File: {self._caller_info['file']}")
+            logger.info(f"   Class: {self._caller_info['class']}")
+            logger.info(f"   Method: {self._caller_info['method']}")
+
+        self.options = option
+        if self.options is None:
+            raise ValueError("Please set up the option config first.")
+
+        from kea2.utils import getProjectRoot
+        previous_root = getProjectRoot()
+        if configs_path is not None:
+            configs_dir = Path(configs_path).expanduser() 
+            if not configs_dir.exists() or not configs_dir.is_dir():
+                raise FileNotFoundError(f"Configs directory not found in the specified path: {configs_dir}")
+            else:
+                setCustomProjectRoot(configs_path)
+        
+        KeaTestRunner.setOptions(self.options)
+        argv = ["python3 -m unittest"] + self.options.propertytest_args
+        
+        logger.info("Starting Kea2 property test...")
+        runner = KeaTestRunner()
+        unittest.main(module=None, argv=argv, testRunner=runner, exit=False)
+        logger.info("Kea2 property test completed.")
+
+        if configs_path is not None:
+            setCustomProjectRoot(previous_root)
+        
+        result = self._build_test_result()
+        
+        return result
+    
+    def _build_test_result(self) -> Dict[str, Any]:
+        """
+        build test result dict
+        
+        Returns:
+            dict: Dictionary containing output directory and paths to various report files
+        """
+        if self.options is None:
+            return {
+                'executed': False,
+                'skipped': False,
+                'caller_info': self._caller_info,
+                'output_dir': None,
+                'bug_report': None,
+                'result_json': None,
+                'log_file': None
+            }
+        
+        output_dir = self.options.output_dir
+        
+        from .keaUtils import STAMP, LOGFILE, RESFILE
+        
+        bug_report_path = output_dir / "bug_report.html"
+        result_json_path = output_dir / RESFILE.name if hasattr(RESFILE, 'name') else output_dir / f"result_{STAMP}.json"
+        log_file_path = output_dir / LOGFILE.name if hasattr(LOGFILE, 'name') else output_dir / f"fastbot_{STAMP}.log"
+        
+        return {
+            'executed': True,
+            'skipped': False,
+            'caller_info': self._caller_info,
+            'output_dir': output_dir,
+            'bug_report': bug_report_path if bug_report_path.exists() else None,
+            'result_json': result_json_path if result_json_path.exists() else None,
+            'log_file': log_file_path if log_file_path.exists() else None
+        }
+    
+    def _get_caller_info(self) -> Dict[str, str]:
+        """
+        Get caller information (file, class, method name)
+        
+        Returns:
+            dict: Dictionary containing file, class, method
+        """
+        try:
+            frame = inspect.currentframe()
+            caller_frame = frame.f_back.f_back
+            
+            while caller_frame:
+                frame_info = inspect.getframeinfo(caller_frame)
+                if 'kea2_api.py' not in frame_info.filename:
+                    # find caller
+                    file_path = frame_info.filename
+                    method_name = frame_info.function
+                    
+                    # get class name
+                    class_name = None
+                    if 'self' in caller_frame.f_locals:
+                        class_name = caller_frame.f_locals['self'].__class__.__name__
+                    
+                    return {
+                        'file': file_path,
+                        'class': class_name or 'N/A',
+                        'method': method_name
+                    }
+                caller_frame = caller_frame.f_back
+            
+            return {
+                'file': 'Unknown',
+                'class': 'N/A',
+                'method': 'Unknown'
+            }
+        except Exception as e:
+            logger.warning(f"Failed to get caller info: {e}")
+            return {
+                'file': 'Unknown',
+                'class': 'N/A',
+                'method': 'Unknown'
+            }