Kea2-python 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

kea2/bug_report_generator.py

@@ -9,7 +9,7 @@ from concurrent.futures import ThreadPoolExecutor
 
 from PIL import Image, ImageDraw, ImageFont
 from jinja2 import Environment, FileSystemLoader, select_autoescape, PackageLoader
-from kea2.utils import getLogger
+from kea2.utils import getLogger, catchException
 
 logger = getLogger(__name__)
 
@@ -421,27 +421,24 @@ class BugReportGenerator:
         step_data["Info"] = json.loads(step_data["Info"])
         return step_data
 
+    @catchException("Error when marking screenshot")
     def _mark_screenshot(self, step_data: StepData):
-        try:
-            step_type = step_data["Type"]
-            screenshot_name = step_data["Screenshot"]
-            if not screenshot_name:
-                return
-
-            if step_type == "Monkey":
-                act = step_data["Info"].get("act")
-                pos = step_data["Info"].get("pos")
-                if act in ["CLICK", "LONG_CLICK"] or act.startswith("SCROLL"):
-                    self._mark_screenshot_interaction(step_type, screenshot_name, act, pos)
-
-            elif step_type == "Script":
-                act = step_data["Info"].get("method")
-                pos = step_data["Info"].get("params")
-                if act in ["click", "setText", "swipe"]:
-                    self._mark_screenshot_interaction(step_type, screenshot_name, act, pos)
+        step_type = step_data["Type"]
+        screenshot_name = step_data["Screenshot"]
+        if not screenshot_name:
+            return
 
-        except Exception as e:
-            logger.error(f"Error when marking screenshots: {e}")
+        if step_type == "Monkey":
+            act = step_data["Info"].get("act")
+            pos = step_data["Info"].get("pos")
+            if act in ["CLICK", "LONG_CLICK"] or act.startswith("SCROLL"):
+                self._mark_screenshot_interaction(step_type, screenshot_name, act, pos)
+
+        elif step_type == "Script":
+            act = step_data["Info"].get("method")
+            pos = step_data["Info"].get("params")
+            if act in ["click", "setText", "swipe"]:
+                self._mark_screenshot_interaction(step_type, screenshot_name, act, pos)
 
 
     def _mark_screenshot_interaction(self, step_type: str, screenshot_name: str, action_type: str, position: Union[List, Tuple]) -> bool:
@@ -528,65 +525,61 @@ class BugReportGenerator:
         img.save(screenshot_path)
         return True
 
+    @catchException("Error rendering template")
     def _generate_html_report(self, data: ReportData):
         """
         Generate HTML format bug report
         """
-        try:
-            # Format timestamp for display
-            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-            # Ensure coverage_trend has data
-            if not data["coverage_trend"]:
-                logger.warning("No coverage trend data")
-                # Use the same field names as in coverage.log file
-                data["coverage_trend"] = [{"stepsCount": 0, "coverage": 0, "testedActivitiesCount": 0}]
-
-            # Convert coverage_trend to JSON string, ensuring all data points are included
-            coverage_trend_json = json.dumps(data["coverage_trend"])
-            logger.debug(f"Number of coverage trend data points: {len(data['coverage_trend'])}")
-
-            # Prepare template data
-            template_data = {
-                'timestamp': timestamp,
-                'bugs_found': data["bugs_found"],
-                'total_testing_time': data["total_testing_time"],
-                'executed_events': data["executed_events"],
-                'coverage_percent': round(data["coverage"], 2),
-                'total_activities_count': data["total_activities_count"],
-                'tested_activities_count': data["tested_activities_count"],
-                'tested_activities': data["tested_activities"],
-                'total_activities': data["total_activities"],
-                'all_properties_count': data["all_properties_count"],
-                'executed_properties_count': data["executed_properties_count"],
-                'items_per_page': 10,  # Items to display per page
-                'screenshots': self.screenshots,
-                'property_violations': data["property_violations"],
-                'property_stats': data["property_stats"],
-                'property_error_details': data["property_error_details"],
-                'coverage_data': coverage_trend_json,
-                'take_screenshots': self.take_screenshots,  # Pass screenshot setting to template
-                'property_execution_trend': data["property_execution_trend"],
-                'property_execution_data': json.dumps(data["property_execution_trend"]),
-                'activity_count_history': data["activity_count_history"],
-                'crash_events': data["crash_events"],
-                'anr_events': data["anr_events"]
-            }
-
-            # Check if template exists, if not create it
-            template_path = Path(__file__).parent / "templates" / "bug_report_template.html"
-            if not template_path.exists():
-                logger.warning("Template file does not exist, creating default template...")
+        # Format timestamp for display
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        # Ensure coverage_trend has data
+        if not data["coverage_trend"]:
+            logger.warning("No coverage trend data")
+            # Use the same field names as in coverage.log file
+            data["coverage_trend"] = [{"stepsCount": 0, "coverage": 0, "testedActivitiesCount": 0}]
+
+        # Convert coverage_trend to JSON string, ensuring all data points are included
+        coverage_trend_json = json.dumps(data["coverage_trend"])
+        logger.debug(f"Number of coverage trend data points: {len(data['coverage_trend'])}")
+
+        # Prepare template data
+        template_data = {
+            'timestamp': timestamp,
+            'bugs_found': data["bugs_found"],
+            'total_testing_time': data["total_testing_time"],
+            'executed_events': data["executed_events"],
+            'coverage_percent': round(data["coverage"], 2),
+            'total_activities_count': data["total_activities_count"],
+            'tested_activities_count': data["tested_activities_count"],
+            'tested_activities': data["tested_activities"],
+            'total_activities': data["total_activities"],
+            'all_properties_count': data["all_properties_count"],
+            'executed_properties_count': data["executed_properties_count"],
+            'items_per_page': 10,  # Items to display per page
+            'screenshots': self.screenshots,
+            'property_violations': data["property_violations"],
+            'property_stats': data["property_stats"],
+            'property_error_details': data["property_error_details"],
+            'coverage_data': coverage_trend_json,
+            'take_screenshots': self.take_screenshots,  # Pass screenshot setting to template
+            'property_execution_trend': data["property_execution_trend"],
+            'property_execution_data': json.dumps(data["property_execution_trend"]),
+            'activity_count_history': data["activity_count_history"],
+            'crash_events': data["crash_events"],
+            'anr_events': data["anr_events"]
+        }
 
-            # Use Jinja2 to render template
-            template = self.jinja_env.get_template("bug_report_template.html")
-            html_content = template.render(**template_data)
+        # Check if template exists, if not create it
+        template_path = Path(__file__).parent / "templates" / "bug_report_template.html"
+        if not template_path.exists():
+            logger.warning("Template file does not exist, creating default template...")
 
-            return html_content
+        # Use Jinja2 to render template
+        template = self.jinja_env.get_template("bug_report_template.html")
+        html_content = template.render(**template_data)
 
-        except Exception as e:
-            logger.error(f"Error rendering template: {e}")
-            raise
+        return html_content
 
     def _add_screenshot_info(self, step_data: StepData, step_index: int, data: Dict):
         """
@@ -697,9 +690,7 @@ class BugReportGenerator:
                     data["property_violations"].append({
                         "index": index,
                         "property_name": property_name,
-                        "precondition_page": start_step,
-                        "interaction_pages": [start_step, end_step],
-                        "postcondition_page": end_step
+                        "interaction_pages": [start_step, end_step]
                     })
                     index += 1
 

kea2/fastbotManager.py

@@ -3,7 +3,7 @@ from retry.api import retry_call
 from dataclasses import asdict
 import requests
 from time import sleep
-
+from pkg_resources import parse_version
 
 from uiautomator2.core import HTTPResponse, _http_request
 from kea2.adbUtils import ADBDevice, ADBStreamShell_V2
@@ -28,6 +28,7 @@ class FastbotManager:
         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"))
 
     def _activateFastbot(self) -> ADBStreamShell_V2:
         """
@@ -219,7 +220,7 @@ class FastbotManager:
         if self.thread.is_running():
             logger.info("Waiting for Fastbot to exit.")
             return self.thread.wait()
-        return self.thread.poll()
+        return self.thread.poll() if self.android_release >= parse_version("7.0") else 0
 
     def start(self):
         # kill the fastbot process if runing.

kea2/keaUtils.py

@@ -4,7 +4,7 @@ import os
 from pathlib import Path
 import traceback
 import time
-from typing import Callable, Any, Deque, Dict, List, Literal, NewType, TypedDict, Union
+from typing import Callable, Any, Deque, Dict, List, Literal, NewType, Union
 from unittest import TextTestRunner, registerResult, TestSuite, TestCase, TextTestResult
 import random
 import warnings
@@ -14,8 +14,8 @@ from functools import wraps
 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.utils import TimeStamp, catchException, getProjectRoot, getLogger, timer
+from kea2.u2Driver import StaticU2UiObject, StaticXpathUiObject
 from kea2.fastbotManager import FastbotManager
 from kea2.adbUtils import ADBDevice
 import uiautomator2 as u2
@@ -640,13 +640,10 @@ class KeaTestRunner(TextTestRunner):
                     _widgets = func(self.options.Driver.getStaticChecker())
                     _widgets = _widgets if isinstance(_widgets, list) else [_widgets]
                     for w in _widgets:
-                        if isinstance(w, StaticU2UiObject):
+                        if isinstance(w, (StaticU2UiObject, StaticXpathUiObject)):
                             xpath = w.selector_to_xpath(w.selector)
                             if xpath != '//error':
                                 blocked_set.add(xpath)
-                        elif isinstance(w, u2.xpath.XPathSelector):
-                            xpath = w._parent.xpath
-                            blocked_set.add(xpath)
                         else:
                             logger.error(f"block widget defined in {func.__name__} Not supported.")
                 except Exception as e:
@@ -673,6 +670,12 @@ class KeaTestRunner(TextTestRunner):
 
         return result
 
+    @timer(r"Generating bug report cost %cost_time seconds.")
+    @catchException("Error when generating bug report")
+    def _generate_bug_report(self):
+        logger.info("Generating bug report")
+        report_generator = BugReportGenerator(self.options.output_dir)
+        report_generator.generate_report()
 
     def __del__(self):
         """tearDown method. Cleanup the env.
@@ -680,16 +683,4 @@ class KeaTestRunner(TextTestRunner):
         if self.options.Driver:
             self.options.Driver.tearDown()
 
-        try:
-            start_time = time.time()
-            logger.info("Generating bug report")
-            report_generator = BugReportGenerator(self.options.output_dir)
-            report_generator.generate_report()
-
-            end_time = time.time()
-            generation_time = end_time - start_time
-
-            logger.info(f"Bug report generation completed in {generation_time:.2f} seconds")
-            
-        except Exception as e:
-            logger.error(f"Error generating bug report: {e}", flush=True)
+        self._generate_bug_report()

kea2/report_merger.py

@@ -3,7 +3,7 @@ import os
 import re
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Tuple, Union
 from collections import defaultdict
 
 from kea2.utils import getLogger
@@ -49,12 +49,12 @@ class TestReportMerger:
             logger.debug(f"Merging {len(self.result_dirs)} test result directories...")
             
             # Merge different types of data
-            merged_property_stats = self._merge_property_results()
+            merged_property_stats, property_source_mapping = self._merge_property_results()
             merged_coverage_data = self._merge_coverage_data()
             merged_crash_anr_data = self._merge_crash_dump_data()
 
             # Calculate final statistics
-            final_data = self._calculate_final_statistics(merged_property_stats, merged_coverage_data, merged_crash_anr_data)
+            final_data = self._calculate_final_statistics(merged_property_stats, merged_coverage_data, merged_crash_anr_data, property_source_mapping)
             
             # Add merge information to final data
             final_data['merge_info'] = {
@@ -86,12 +86,14 @@ class TestReportMerger:
             
             logger.debug(f"Validated result directory: {result_dir}")
     
-    def _merge_property_results(self) -> Dict[str, Dict]:
+    def _merge_property_results(self) -> Tuple[Dict[str, Dict], Dict[str, List[str]]]:
         """
         Merge property test results from all directories
-        
+
         Returns:
-            Merged property execution results
+            Tuple of (merged_property_results, property_source_mapping)
+            - merged_property_results: Merged property execution results
+            - property_source_mapping: Maps property names to list of source directories with fail/error
         """
         merged_results = defaultdict(lambda: {
             "precond_satisfied": 0,
@@ -99,31 +101,40 @@ class TestReportMerger:
             "fail": 0,
             "error": 0
         })
-        
+
+        # Track which directories have fail/error for each property
+        property_source_mapping = defaultdict(list)
+
         for result_dir in self.result_dirs:
             result_files = list(result_dir.glob("result_*.json"))
             if not result_files:
                 logger.warning(f"No result file found in {result_dir}")
                 continue
-                
+
             result_file = result_files[0]  # Take the first (should be only one)
-            
+            dir_name = result_dir.name  # Get the directory name (e.g., res_2025072011_5048015228)
+
             try:
                 with open(result_file, 'r', encoding='utf-8') as f:
                     test_results = json.load(f)
-                
+
                 # Merge results for each property
                 for prop_name, prop_result in test_results.items():
                     for key in ["precond_satisfied", "executed", "fail", "error"]:
                         merged_results[prop_name][key] += prop_result.get(key, 0)
-                
+
+                    # Track source directories for properties with fail/error
+                    if prop_result.get('fail', 0) > 0 or prop_result.get('error', 0) > 0:
+                        if dir_name not in property_source_mapping[prop_name]:
+                            property_source_mapping[prop_name].append(dir_name)
+
                 logger.debug(f"Merged results from: {result_file}")
-                
+
             except Exception as e:
                 logger.error(f"Error reading result file {result_file}: {e}")
                 continue
-        
-        return dict(merged_results)
+
+        return dict(merged_results), dict(property_source_mapping)
     
     def _merge_coverage_data(self) -> Dict:
         """
@@ -234,7 +245,7 @@ class TestReportMerger:
             "total_anr_count": len(unique_anr_events)
         }
     
-    def _parse_crash_dump_file(self, crash_dump_file: Path) -> tuple[List[Dict], List[Dict]]:
+    def _parse_crash_dump_file(self, crash_dump_file: Path) -> Tuple[List[Dict], List[Dict]]:
         """
         Parse crash and ANR events from crash-dump.log file
 
@@ -529,7 +540,7 @@ class TestReportMerger:
 
         return unique_anrs
 
-    def _calculate_final_statistics(self, property_stats: Dict, coverage_data: Dict, crash_anr_data: Dict = None) -> Dict:
+    def _calculate_final_statistics(self, property_stats: Dict, coverage_data: Dict, crash_anr_data: Dict = None, property_source_mapping: Dict = None) -> Dict:
         """
         Calculate final statistics for template rendering
 
@@ -540,6 +551,7 @@ class TestReportMerger:
             property_stats: Merged property statistics
             coverage_data: Merged coverage data
             crash_anr_data: Merged crash and ANR data (optional)
+            property_source_mapping: Maps property names to source directories with fail/error (optional)
 
         Returns:
             Complete data for template rendering
@@ -576,6 +588,7 @@ class TestReportMerger:
             'all_properties_count': all_properties_count,
             'executed_properties_count': executed_properties_count,
             'property_stats': property_stats,
+            'property_source_mapping': property_source_mapping or {},
             'crash_events': crash_events,
             'anr_events': anr_events,
             'total_crash_count': total_crash_count,