Kea2-python 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

kea2/fastbotManager.py

@@ -13,7 +13,7 @@ from kea2.utils import getLogger
 
 from typing import IO, TYPE_CHECKING, Dict
 if TYPE_CHECKING:
-    from .keaUtils import Options
+    from .keaUtils import Options, PropertyExecutionInfo
 
 
 logger = getLogger(__name__)
@@ -70,6 +70,21 @@ class FastbotManager:
             "/data/local/tmp/x86_64/libfastbot_native.so",
         )
 
+        whitelist = self.options.act_whitelist_file
+        blacklist = self.options.act_blacklist_file
+        if bool(whitelist) ^ bool(blacklist):
+            if whitelist:
+                file_to_push = cur_dir.parent / 'configs' / 'awl.strings'
+                remote_path = whitelist
+            else:
+                file_to_push = cur_dir.parent / 'configs' / 'abl.strings'
+                remote_path = blacklist
+
+            self.dev.sync.push(
+                file_to_push,
+                remote_path
+            )
+
         t = self._startFastbotService()
         logger.info("Running Fastbot...")
 
@@ -132,11 +147,15 @@ class FastbotManager:
         print(f"[Server INFO] {r.text}", flush=True)
     
     @retry(Exception, tries=2, delay=2)
-    def logScript(self, execution_info: Dict):
+    def logScript(self, execution_info: "PropertyExecutionInfo"):
         r = self.request(
             method="POST",
             path="/logScript",
-            data=execution_info
+            data={
+                "propName": execution_info.propName,
+                "startStepsCount": execution_info.startStepsCount,
+                "state": execution_info.state,
+            }
         )
         res = r.text
         if res != "OK":
@@ -167,6 +186,14 @@ class FastbotManager:
         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"]
 
         full_cmd = ["adb"] + (["-s", self.options.serial] if self.options.serial else []) + ["shell"] + shell_command

kea2/keaUtils.py

@@ -1,22 +1,23 @@
+from collections import deque
 import json
 import os
 from pathlib import Path
 import traceback
 import time
-from typing import Callable, Any, Dict, List, Literal, NewType, TypedDict, Union
+from typing import Callable, Any, Deque, Dict, List, Literal, NewType, TypedDict, Union
 from unittest import TextTestRunner, registerResult, TestSuite, TestCase, TextTestResult
 import random
 import warnings
 from dataclasses import dataclass, asdict
-import requests
-from .absDriver import AbstractDriver
+from kea2.absDriver import AbstractDriver
 from functools import wraps
-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 .fastbotManager import FastbotManager
+from kea2.bug_report_generator import BugReportGenerator
+from kea2.resultSyncer import ResultSyncer
+from kea2.logWatcher import LogWatcher
+from kea2.utils import TimeStamp, getProjectRoot, getLogger
+from kea2.u2Driver import StaticU2UiObject
+from kea2.fastbotManager import FastbotManager
+from kea2.adbUtils import ADBDevice
 import uiautomator2 as u2
 import types
 
@@ -30,14 +31,12 @@ 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: str
 RESFILE: str
+PROP_EXEC_RESFILE: str
 
 def precondition(precond: Callable[[Any], bool]) -> Callable:
     """the decorator @precondition
@@ -133,6 +132,10 @@ class Options:
     device_output_root: str = "/sdcard"
     # the debug mode
     debug: bool = False
+    # Activity WhiteList File
+    act_whitelist_file: str = None
+    # Activity BlackList File
+    act_blacklist_file: str = None
 
     def __setattr__(self, name, value):
         if value is None:
@@ -142,6 +145,7 @@ class Options:
     def __post_init__(self):
         import logging
         logging.basicConfig(level=logging.DEBUG if self.debug else logging.INFO)
+        
         if self.Driver:
             target_device = dict()
             if self.serial:
@@ -149,7 +153,9 @@ class Options:
             if self.transport_id:
                 target_device["transport_id"] = self.transport_id
             self.Driver.setDevice(target_device)
-        global LOGFILE, RESFILE, STAMP
+            ADBDevice.setDevice(self.serial, self.transport_id)
+            
+        global LOGFILE, RESFILE, PROP_EXEC_RESFILE, STAMP
         if self.log_stamp:
             illegal_chars = ['/', '\\', ':', '*', '?', '"', '<', '>', '|', '\n', '\r', '\t', '\0']
             for char in illegal_chars:
@@ -158,9 +164,11 @@ class Options:
                         f"char: `{char}` is illegal in --log-stamp. current stamp: {self.log_stamp}"
                     )
             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"
+        PROP_EXEC_RESFILE = f"property_exec_info_{STAMP}.json"
 
         self.profile_period = int(self.profile_period)
         if self.profile_period < 1:
@@ -170,12 +178,11 @@ class Options:
         if self.throttle < 0:
             raise ValueError("--throttle should be greater than or equal to 0")
 
-        _check_package_installation(self.serial, self.packageNames)
+        _check_package_installation(self.packageNames)
 
 
-def _check_package_installation(serial, packageNames):
-    from .adbUtils import get_packages
-    installed_packages = get_packages(device=serial)
+def _check_package_installation(packageNames):
+    installed_packages = set(ADBDevice().list_packages())
 
     for package in packageNames:
         if package not in installed_packages:
@@ -190,6 +197,16 @@ class PropStatistic:
     fail: int = 0
     error: int = 0
 
+
+PropertyExecutionInfoStore = NewType("PropertyExecutionInfoStore", Deque["PropertyExecutionInfo"])
+@dataclass
+class PropertyExecutionInfo:
+    startStepsCount: int
+    propName: PropName
+    state: Literal["start", "pass", "fail", "error"]
+    tb: str
+
+
 class PBTTestResult(dict):
     def __getitem__(self, key) -> PropStatistic:
         return super().__getitem__(key)
@@ -202,13 +219,12 @@ def getFullPropName(testCase: TestCase):
         testCase._testMethodName
     ])
 
+
 class JsonResult(TextTestResult):
-    res: PBTTestResult
     
-    lastExecutedInfo: PropertyExecutionInfo = {
-        "propName": "",
-        "state": "",
-    }
+    res: PBTTestResult
+    lastExecutedInfo: PropertyExecutionInfo
+    executionInfoStore: PropertyExecutionInfoStore = deque()
 
     @classmethod
     def setProperties(cls, allProperties: Dict):
@@ -216,19 +232,28 @@ class JsonResult(TextTestResult):
         for testCase in allProperties.values():
             cls.res[getFullPropName(testCase)] = PropStatistic()
 
-    def flushResult(self, outfile):
+    def flushResult(self):
+        global RESFILE, PROP_EXEC_RESFILE
         json_res = dict()
         for propName, propStatitic in self.res.items():
             json_res[propName] = asdict(propStatitic)
-        with open(outfile, "w", encoding="utf-8") as fp:
+        with open(RESFILE, "w", encoding="utf-8") as fp:
             json.dump(json_res, fp, indent=4)
 
-    def addExcuted(self, test: TestCase):
+        while self.executionInfoStore:
+            execInfo = self.executionInfoStore.popleft()
+            with open(PROP_EXEC_RESFILE, "a", encoding="utf-8") as fp:
+                fp.write(f"{json.dumps(asdict(execInfo))}\n")
+
+    def addExcuted(self, test: TestCase, stepsCount: int):
         self.res[getFullPropName(test)].executed += 1
-        self.lastExecutedInfo = {
-            "propName": getFullPropName(test),
-            "state": "start",
-        }
+
+        self.lastExecutedInfo = PropertyExecutionInfo(
+            propName=getFullPropName(test),
+            state="start",
+            tb="",
+            startStepsCount=stepsCount
+        )
 
     def addPrecondSatisfied(self, test: TestCase):
         self.res[getFullPropName(test)].precond_satisfied += 1
@@ -236,16 +261,21 @@ class JsonResult(TextTestResult):
     def addFailure(self, test, err):
         super().addFailure(test, err)
         self.res[getFullPropName(test)].fail += 1
-        self.lastExecutedInfo["state"] = "fail"
+        self.lastExecutedInfo.state = "fail"
+        self.lastExecutedInfo.tb = self._exc_info_to_string(err, test)
 
     def addError(self, test, err):
         super().addError(test, err)
         self.res[getFullPropName(test)].error += 1
-        self.lastExecutedInfo["state"] = "error"
+        self.lastExecutedInfo.state = "error"
+        self.lastExecutedInfo.tb = self._exc_info_to_string(err, test)
 
     def updateExectedInfo(self):
-        if self.lastExecutedInfo["state"] == "start":
-            self.lastExecutedInfo["state"] = "pass"
+        if self.lastExecutedInfo.state == "start":
+            self.lastExecutedInfo.state = "pass"
+
+        self.executionInfoStore.append(self.lastExecutedInfo)
+        
 
     def getExcuted(self, test: TestCase):
         return self.res[getFullPropName(test)].executed
@@ -270,11 +300,13 @@ class KeaTestRunner(TextTestRunner):
     def _setOuputDir(self):
         output_dir = Path(self.options.output_dir).absolute()
         output_dir.mkdir(parents=True, exist_ok=True)
-        global LOGFILE, RESFILE
+        global LOGFILE, RESFILE, PROP_EXEC_RESFILE
         LOGFILE = output_dir / Path(LOGFILE)
         RESFILE = output_dir / Path(RESFILE)
+        PROP_EXEC_RESFILE = output_dir / Path(PROP_EXEC_RESFILE)
         logger.info(f"Log file: {LOGFILE}")
         logger.info(f"Result file: {RESFILE}")
+        logger.info(f"Property execution info file: {PROP_EXEC_RESFILE}")
 
     def run(self, test):
 
@@ -318,7 +350,7 @@ class KeaTestRunner(TextTestRunner):
             
             if self.options.agent == "u2":
                 # initialize the result.json file
-                result.flushResult(outfile=RESFILE)
+                result.flushResult()
                 # setUp for the u2 driver
                 self.scriptDriver = self.options.Driver.getScriptDriver()
                 fb.check_alive()
@@ -342,7 +374,7 @@ class KeaTestRunner(TextTestRunner):
                     try:
                         xml_raw = fb.stepMonkey(self._monkeyStepInfo)
                         propsSatisfiedPrecond = self.getValidProperties(xml_raw, result)
-                    except requests.ConnectionError:
+                    except u2.HTTPError:
                         logger.info("Connection refused by remote.")
                         if fb.get_return_code() == 0:
                             logger.info("Exploration times up (--running-minutes).")
@@ -377,7 +409,7 @@ class KeaTestRunner(TextTestRunner):
                     setattr(test, self.options.driverName, self.scriptDriver)
                     print("execute property %s." % execPropName, flush=True)
 
-                    result.addExcuted(test)
+                    result.addExcuted(test, self.stepsCount)
                     fb.logScript(result.lastExecutedInfo)
                     try:
                         test(result)
@@ -386,11 +418,11 @@ class KeaTestRunner(TextTestRunner):
 
                     result.updateExectedInfo()
                     fb.logScript(result.lastExecutedInfo)
-                    result.flushResult(outfile=RESFILE)
+                    result.flushResult()
 
                 if not end_by_remote:
                     fb.stopMonkey()
-                result.flushResult(outfile=RESFILE)
+                result.flushResult()
                 resultSyncer.close()
                 
             fb.join()
@@ -433,30 +465,6 @@ class KeaTestRunner(TextTestRunner):
         self.stream.flush()
         return result
 
-    # def stepMonkey(self) -> str:
-    #     """
-    #     send a step monkey request to the server and get the xml string.
-    #     """
-    #     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_trees": block_trees
-    #         }
-    #     )
-
-    #     res = json.loads(r.content)
-    #     xml_raw = res["result"]
-    #     return xml_raw
-
     @property
     def _monkeyStepInfo(self):
         r = self._get_block_widgets()

kea2/kea_launcher.py

@@ -122,6 +122,22 @@ def _set_runner_parser(subparsers: "argparse._SubParsersAction[argparse.Argument
         help="Take screenshots for every step.",
     )
 
+    parser.add_argument(
+        "--act-whitelist-file",
+        dest="act_whitelist_file",
+        required=False,
+        type=str,
+        help="Add Activity Whitelist File.",
+    )
+
+    parser.add_argument(
+        "--act-blacklist-file",
+        dest="act_blacklist_file",
+        required=False,
+        type=str,
+        help="Add Activity Blacklist File.",
+    )
+
     parser.add_argument(
         "extra",
         nargs=argparse.REMAINDER,
@@ -195,7 +211,9 @@ def run(args=None):
         log_stamp=args.log_stamp,
         profile_period=args.profile_period,
         take_screenshots=args.take_screenshots,
-        device_output_root=args.device_output_root
+        device_output_root=args.device_output_root,
+        act_whitelist_file = args.act_whitelist_file,
+        act_blacklist_file=args.act_blacklist_file
     )
 
     KeaTestRunner.setOptions(options)

kea2/logWatcher.py

@@ -24,7 +24,7 @@ class LogWatcher:
     def watcher(self, poll_interval=3):
         self.last_pos = 0
 
-        with open(self.log_file, "r") as fp:
+        with open(self.log_file, "r", encoding="utf-8") as fp:
             while not self.end_flag:
                 self.read_log(fp)
                 time.sleep(poll_interval)
@@ -51,9 +51,10 @@ class LogWatcher:
                 )
         
         statistic_match = PATTERN_STATISTIC.search(content)
-        if statistic_match:
+        if statistic_match and not self.statistic_printed:
             statistic_body = statistic_match.group(1).strip()
             if statistic_body:
+                self.statistic_printed = True
                 print(
                     "[INFO] Fastbot exit:\n" + 
                     statistic_body
@@ -63,6 +64,7 @@ class LogWatcher:
         logger.info(f"Watching log: {log_file}")
         self.log_file = log_file
         self.end_flag = False
+        self.statistic_printed = False
 
         threading.excepthook = thread_excepthook
         self.t = threading.Thread(target=self.watcher, daemon=True)