Kea2-python 0.3.6__py3-none-any.whl → 1.0.1__py3-none-any.whl

kea2/__init__.py

@@ -1 +1 @@
-from .keaUtils import KeaTestRunner, precondition, prob, max_tries, Options
+from .keaUtils import KeaTestRunner, precondition, prob, max_tries, Options, interruptable,HybridTestRunner,kea2_breakpoint

kea2/assets/config_version.json

@@ -0,0 +1,16 @@
+{
+  "compatibility infos": [
+    {
+      "name": "previous version",
+      "description": "The default initial version, <=0.3.6",
+      "from": "0.0.0",
+      "to": "0.3.6"
+    },
+    {
+      "name": "Hybrid test version 1.0.0",
+      "description": "Hybrid test was added in version 1.0.0. hybrid_test_config.py is required.",
+      "from": "1.0.0",
+      "to": ""
+    }
+  ]
+}

kea2/assets/fastbot_configs/teardown.py

@@ -0,0 +1,18 @@
+from uiautomator2 import Device
+import time
+
+
+class HybridTestCase:
+    d: Device
+
+PACKAGE_NAME = "it.feio.android.omninotes.alpha"
+MAIN_ACTIVITY = "it.feio.android.omninotes.MainActivity"
+
+
+def setUp(self: HybridTestCase):
+    self.d.app_start(PACKAGE_NAME, MAIN_ACTIVITY)
+    time.sleep(2)
+
+
+def tearDown(self: HybridTestCase):
+    self.d.app_stop(PACKAGE_NAME)

kea2/assets/quicktest.py

@@ -9,9 +9,27 @@ from kea2.u2Driver import U2Driver
 class Omni_Notes_Sample(unittest.TestCase):
 
     def setUp(self):
-        self.d = u2.connect()
+        self.d = u2.connect() 
+    
+    @prob(0.2)
+    @precondition(
+        lambda self: self.d(description="Navigate up").exists
+    )
+    def test_goBack(self):
+        print("Navigate back")
+        self.d(description="Navigate up").click()
+        sleep(0.5)
+    
+    @prob(0.2)
+    @precondition(
+        lambda self: self.d(description="drawer closed").exists
+    )
+    def test_openDrawer(self):
+        print("Open drawer")
+        self.d(description="drawer closed").click()
+        sleep(0.5)
 
-    @prob(0.7)  # The probability of executing the function when precondition is satisfied.
+    @prob(0.5)  # The probability of executing the function when precondition is satisfied.
     @precondition(
         lambda self: self.d(text="Omni Notes Alpha").exists
         and self.d(text="Settings").exists
@@ -45,6 +63,7 @@ class Omni_Notes_Sample(unittest.TestCase):
         assertion:
             The search input box is still being opened
         """
+        print("rotate the device")
         self.d.set_orientation("l")
         sleep(2)
         self.d.set_orientation("n")

kea2/bug_report_generator.py

@@ -375,21 +375,32 @@ class BugReportGenerator:
                 minutes, seconds = divmod(remainder, 60)
                 data["total_testing_time"] = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
 
-        # Calculate bug count directly from result data
+        # Enrich property statistics with derived metrics and calculate bug count
+        enriched_property_stats = {}
         for property_name, test_result in self.test_result.items():
             # Check if failed or error
-            if test_result["fail"] > 0 or test_result["error"] > 0:
+            if test_result.get("fail", 0) > 0 or test_result.get("error", 0) > 0:
                 data["bugs_found"] += 1
 
-        # Store the raw result data for direct use in HTML template
-        data["property_stats"] = self.test_result
+            executed_count = test_result.get("executed", 0)
+            fail_count = test_result.get("fail", 0)
+            error_count = test_result.get("error", 0)
+            pass_count = max(executed_count - fail_count - error_count, 0)
+
+            enriched_property_stats[property_name] = {
+                **test_result,
+                "pass_count": pass_count
+            }
+
+        # Store the enriched result data for direct use in HTML template
+        data["property_stats"] = enriched_property_stats
 
         # Calculate properties statistics
         data["all_properties_count"] = len(self.test_result)
         data["executed_properties_count"] = sum(1 for result in self.test_result.values() if result.get("executed", 0) > 0)
 
         # Calculate detailed property statistics for table headers
-        property_stats_summary = self._calculate_property_stats_summary(self.test_result)
+        property_stats_summary = self._calculate_property_stats_summary(enriched_property_stats)
         data["property_stats_summary"] = property_stats_summary
 
         # Process coverage data
@@ -415,6 +426,11 @@ class BugReportGenerator:
 
         # Load crash and ANR events from crash-dump.log
         crash_events, anr_events = self._load_crash_dump_data()
+
+        # Add screenshot ID information to crash and ANR events
+        self._add_screenshot_ids_to_events(crash_events)
+        self._add_screenshot_ids_to_events(anr_events)
+
         data["crash_events"] = crash_events
         data["anr_events"] = anr_events
 
@@ -460,10 +476,14 @@ class BugReportGenerator:
         """
         screenshot_path: Path = self.data_path.screenshots_dir / screenshot_name
         if not screenshot_path.exists():
-            logger.error(f"Screenshot file {screenshot_path} not exists.")
+            logger.debug(f"Screenshot file {screenshot_path} not exists.")
             return False
 
-        img = Image.open(screenshot_path).convert("RGB")
+        try:
+            img = Image.open(screenshot_path).convert("RGB")
+        except OSError as e:
+            logger.debug(f"Error opening image {screenshot_path}: {e}")
+            return False
         draw = ImageDraw.Draw(img)
         line_width = 5
 
@@ -572,6 +592,8 @@ class BugReportGenerator:
             'activity_count_history': data["activity_count_history"],
             'crash_events': data["crash_events"],
             'anr_events': data["anr_events"],
+            'triggered_crash_count': len(data["crash_events"]),
+            'triggered_anr_count': len(data["anr_events"]),
             'property_stats_summary': data["property_stats_summary"]
         }
 
@@ -612,6 +634,13 @@ class BugReportGenerator:
             caption = f"{prop_name}: {state}" if prop_name else f"{state}"
 
         screenshot_name = step_data["Screenshot"]
+
+        # Check if the screenshot file actually exists
+        screenshot_file_path = self.data_path.screenshots_dir / screenshot_name
+        if not screenshot_file_path.exists():
+            # Skip adding this screenshot if the file doesn't exist
+            return
+
         # Use relative path string instead of Path object
         relative_screenshot_path = f"output_{self.log_timestamp}/screenshots/{screenshot_name}"
 
@@ -841,20 +870,28 @@ class BugReportGenerator:
             "total_properties": 0,
             "total_precond_satisfied": 0,
             "total_executed": 0,
+            "total_passes": 0,
             "total_fails": 0,
             "total_errors": 0,
             "properties_with_errors": 0
         }
 
         for property_name, result in test_result.items():
+            executed_count = result.get("executed", result.get("executed_total", 0))
+            fail_count = result.get("fail", 0)
+            error_count = result.get("error", 0)
+            pass_count = result.get("pass_count",
+                                    max(executed_count - fail_count - error_count, 0))
+
             stats_summary["total_properties"] += 1
             stats_summary["total_precond_satisfied"] += result.get("precond_satisfied", 0)
-            stats_summary["total_executed"] += result.get("executed", 0)
-            stats_summary["total_fails"] += result.get("fail", 0)
-            stats_summary["total_errors"] += result.get("error", 0)
+            stats_summary["total_executed"] += executed_count
+            stats_summary["total_passes"] += pass_count
+            stats_summary["total_fails"] += fail_count
+            stats_summary["total_errors"] += error_count
 
             # Count properties that have errors or fails
-            if result.get("fail", 0) > 0 or result.get("error", 0) > 0:
+            if fail_count > 0 or error_count > 0:
                 stats_summary["properties_with_errors"] += 1
 
         return stats_summary
@@ -877,11 +914,11 @@ class BugReportGenerator:
             with open(self.data_path.crash_dump_log, "r", encoding="utf-8") as f:
                 content = f.read()
 
-            # Parse crash events
-            crash_events = self._parse_crash_events(content)
+            # Parse crash events with screenshot mapping
+            crash_events = self._parse_crash_events_with_screenshots(content)
 
-            # Parse ANR events
-            anr_events = self._parse_anr_events(content)
+            # Parse ANR events with screenshot mapping
+            anr_events = self._parse_anr_events_with_screenshots(content)
 
             logger.debug(f"Found {len(crash_events)} crash events and {len(anr_events)} ANR events")
 
@@ -889,26 +926,29 @@ class BugReportGenerator:
 
         except Exception as e:
             logger.error(f"Error reading crash dump file: {e}")
+            return crash_events, anr_events
 
-
-    def _parse_crash_events(self, content: str) -> List[Dict]:
+    def _parse_crash_events_with_screenshots(self, content: str) -> List[Dict]:
         """
-        Parse crash events from crash-dump.log content
+        Parse crash events from crash-dump.log content with screenshot mapping
 
         Args:
             content: Content of crash-dump.log file
 
         Returns:
-            List[Dict]: List of crash event dictionaries
+            List[Dict]: List of crash event dictionaries with screenshot information
         """
         crash_events = []
 
-        # Pattern to match crash blocks
-        crash_pattern = r'(\d{14})\ncrash:\n(.*?)\n// crash end'
+        # Pattern to match crash blocks with optional screenshot information
+        # Look for StepsCount and CrashScreen before the timestamp
+        crash_pattern = r'(?:StepsCount:\s*(\d+)\s*\nCrashScreen:\s*([^\n]+)\s*\n)?(\d{14})\ncrash:\n(.*?)\n// crash end'
 
         for match in re.finditer(crash_pattern, content, re.DOTALL):
-            timestamp_str = match.group(1)
-            crash_content = match.group(2)
+            steps_count = match.group(1)
+            crash_screen = match.group(2)
+            timestamp_str = match.group(3)
+            crash_content = match.group(4)
 
             # Parse timestamp (format: YYYYMMDDHHMMSS)
             try:
@@ -924,31 +964,35 @@ class BugReportGenerator:
                 "time": formatted_time,
                 "exception_type": crash_info.get("exception_type", "Unknown"),
                 "process": crash_info.get("process", "Unknown"),
-                "stack_trace": crash_info.get("stack_trace", "")
+                "stack_trace": crash_info.get("stack_trace", ""),
+                "steps_count": steps_count,
+                "crash_screen": crash_screen.strip() if crash_screen else None
             }
 
             crash_events.append(crash_event)
 
         return crash_events
 
-    def _parse_anr_events(self, content: str) -> List[Dict]:
+    def _parse_anr_events_with_screenshots(self, content: str) -> List[Dict]:
         """
-        Parse ANR events from crash-dump.log content
+        Parse ANR events from crash-dump.log content with screenshot mapping
 
         Args:
             content: Content of crash-dump.log file
 
         Returns:
-            List[Dict]: List of ANR event dictionaries
+            List[Dict]: List of ANR event dictionaries with screenshot information
         """
         anr_events = []
 
-        # Pattern to match ANR blocks
-        anr_pattern = r'(\d{14})\nanr:\n(.*?)\nanr end'
+        # Pattern to match ANR blocks with optional screenshot information
+        anr_pattern = r'(?:StepsCount:\s*(\d+)\s*\nCrashScreen:\s*([^\n]+)\s*\n)?(\d{14})\nanr:\n(.*?)\nanr end'
 
         for match in re.finditer(anr_pattern, content, re.DOTALL):
-            timestamp_str = match.group(1)
-            anr_content = match.group(2)
+            steps_count = match.group(1)
+            crash_screen = match.group(2)
+            timestamp_str = match.group(3)
+            anr_content = match.group(4)
 
             # Parse timestamp (format: YYYYMMDDHHMMSS)
             try:
@@ -964,13 +1008,51 @@ class BugReportGenerator:
                 "time": formatted_time,
                 "reason": anr_info.get("reason", "Unknown"),
                 "process": anr_info.get("process", "Unknown"),
-                "trace": anr_info.get("trace", "")
+                "trace": anr_info.get("trace", ""),
+                "steps_count": steps_count,
+                "crash_screen": crash_screen.strip() if crash_screen else None
             }
 
             anr_events.append(anr_event)
 
         return anr_events
 
+    def _find_screenshot_id_by_filename(self, screenshot_filename: str) -> str:
+        """
+        Find screenshot ID by filename in the screenshots list
+
+        Args:
+            screenshot_filename: Name of the screenshot file
+
+        Returns:
+            str: Screenshot ID if found, empty string otherwise
+        """
+        if not screenshot_filename:
+            return ""
+
+        for screenshot in self.screenshots:
+            # Extract filename from path
+            screenshot_path = screenshot.get('path', '')
+            if screenshot_path.endswith(screenshot_filename):
+                return str(screenshot.get('id', ''))
+
+        return ""
+
+    def _add_screenshot_ids_to_events(self, events: List[Dict]):
+        """
+        Add screenshot ID information to crash/ANR events
+
+        Args:
+            events: List of crash or ANR event dictionaries
+        """
+        for event in events:
+            crash_screen = event.get('crash_screen')
+            if crash_screen:
+                screenshot_id = self._find_screenshot_id_by_filename(crash_screen)
+                event['screenshot_id'] = screenshot_id
+            else:
+                event['screenshot_id'] = ""
+
     def _extract_crash_info(self, crash_content: str) -> Dict:
         """
         Extract crash information from crash content
@@ -1109,8 +1191,8 @@ class BugReportGenerator:
 if __name__ == "__main__":
     print("Generating bug report")
     # OUTPUT_PATH = "<Your output path>"
-    OUTPUT_PATH = "P:/Python/Kea2/output/res_2025072011_5048015228"
+    OUTPUT_PATH = "/Users/drifter327/Code/Kea2/output/res_2025090122_1216279438"
 
     report_generator = BugReportGenerator()
     report_path = report_generator.generate_report(OUTPUT_PATH)
-    print(f"bug report generated: {report_path}")
+    print(f"bug report generated: {report_path}")

kea2/cli.py

@@ -2,9 +2,11 @@
 # cli.py
 
 from __future__ import absolute_import, print_function
+from datetime import datetime
 import sys
 from .utils import getProjectRoot, getLogger
 from .kea_launcher import run
+from .version_manager import check_config_compatibility, get_cur_version
 import argparse
 
 import os
@@ -15,8 +17,7 @@ logger = getLogger(__name__)
 
 
 def cmd_version(args):
-    from importlib.metadata import version
-    print(version("Kea2-python"), flush=True)
+    print(get_cur_version(), flush=True)
 
 
 def cmd_init(args):
@@ -36,9 +37,16 @@ def cmd_init(args):
         src = Path(__file__).parent / "assets" / "quicktest.py"
         dst = cwd / "quicktest.py"
         shutil.copyfile(src, dst)
+    
+    def save_version():
+        import json
+        version_file = configs_dir / "version.json"
+        with open(version_file, "w") as fp:
+            json.dump({"version": get_cur_version(), "init date": datetime.now().strftime("%Y-%m-%d %H:%M:%S")}, fp, indent=4)
 
     copy_configs()
     copy_samples()
+    save_version()
     logger.info("Kea2 project initialized.")
 
 
@@ -94,11 +102,9 @@ def cmd_merge(args):
         for path in args.paths:
             path_obj = Path(path)
             if not path_obj.exists():
-                logger.error(f"Test report path does not exist: {path}")
-                return
+                raise FileNotFoundError(f"{path_obj}")
             if not path_obj.is_dir():
-                logger.error(f"Path is not a directory: {path}")
-                return
+                raise NotADirectoryError(f"{path_obj}")
 
         logger.debug(f"Merging {len(args.paths)} test report directories...")
 
@@ -118,7 +124,7 @@ def cmd_merge(args):
         print(f"📈 Merged {merge_summary.get('merged_directories', 0)} directories", flush=True)
 
     except Exception as e:
-        logger.error(f"Error during merge operation: {e}")
+        logger.error(f"Error during merge operation: {e}")      
 
 
 def cmd_run(args):
@@ -126,6 +132,9 @@ def cmd_run(args):
     if base_dir is None:
         logger.error("kea2 project not initialized. Use `kea2 init`.")
         return
+
+    check_config_compatibility()
+
     run(args)
 
 
@@ -210,9 +219,10 @@ def main():
     args = parser.parse_args()
 
     import logging
-    logging.basicConfig(level=logging.INFO)
+    from .utils import LoggingLevel
+    LoggingLevel.set_level(logging.INFO)
     if args.debug:
-        logging.basicConfig(level=logging.DEBUG)
+        LoggingLevel.set_level(logging.DEBUG)
         logger.debug("args: %s", args)
 
     if args.subparser:

kea2/fastbotManager.py

@@ -1,8 +1,10 @@
+import itertools
 from retry import retry
 from retry.api import retry_call
 from dataclasses import asdict
 import requests
 from packaging.version import parse as parse_version
+from time import sleep
 
 from uiautomator2.core import HTTPResponse, _http_request
 from kea2.adbUtils import ADBDevice, ADBStreamShell_V2
@@ -28,6 +30,7 @@ class FastbotManager:
         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:
         """
@@ -100,7 +103,9 @@ class FastbotManager:
             _http_request(dev=self.dev, device_port=8090, method="GET", path="/ping")
 
         try:
-            retry_call(_check_alive_request, tries=10, delay=2)
+            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")
 
@@ -111,7 +116,8 @@ class FastbotManager:
     def init(self, options: "Options", stamp):
         post_data = {
             "takeScreenshots": options.take_screenshots,
-            "Stamp": stamp,
+            "preFailureScreenshots": options.pre_failure_screenshots,
+            "logStamp": stamp,
             "deviceOutputRoot": options.device_output_root,
         }
         r = _http_request(
@@ -161,6 +167,15 @@ class FastbotManager:
         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']
 
     @property
     def device_output_dir(self):
@@ -173,10 +188,8 @@ class FastbotManager:
             "/sdcard/framework.jar:"
             "/sdcard/fastbot-thirdpart.jar:"
             "/sdcard/kea2-thirdpart.jar",
-
             "exec", "app_process",
             "/system/bin", "com.android.commands.monkey.Monkey",
-            "-p", *self.options.packageNames,
             "--agent-u2" if self.options.agent == "u2" else "--agent",
             "reuseq",
             "--running-minutes", f"{self.options.running_mins}",
@@ -185,6 +198,9 @@ class FastbotManager:
             "--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}"]