Kea2-python 0.3.1__py3-none-any.whl → 0.3.3__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__)
 
@@ -388,6 +388,10 @@ class BugReportGenerator:
         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)
+        data["property_stats_summary"] = property_stats_summary
+
         # Process coverage data
         data["coverage_trend"] = self.cov_trend
 
@@ -421,27 +425,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 +529,62 @@ 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"],
+            'property_stats_summary': data["property_stats_summary"]
+        }
 
-            # 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 +695,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
 
@@ -831,6 +827,38 @@ class BugReportGenerator:
         
         return property_execution_trend
 
+    def _calculate_property_stats_summary(self, test_result: TestResult) -> Dict[str, int]:
+        """
+        Calculate summary statistics for property checking table headers
+
+        Args:
+            test_result: Test result data containing property statistics
+
+        Returns:
+            Dict: Summary statistics for each column
+        """
+        stats_summary = {
+            "total_properties": 0,
+            "total_precond_satisfied": 0,
+            "total_executed": 0,
+            "total_fails": 0,
+            "total_errors": 0,
+            "properties_with_errors": 0
+        }
+
+        for property_name, result in test_result.items():
+            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)
+
+            # Count properties that have errors or fails
+            if result.get("fail", 0) > 0 or result.get("error", 0) > 0:
+                stats_summary["properties_with_errors"] += 1
+
+        return stats_summary
+
     def _load_crash_dump_data(self) -> Tuple[List[Dict], List[Dict]]:
         """
         Load crash and ANR events from crash-dump.log file

kea2/keaUtils.py

@@ -198,6 +198,9 @@ class PropStatistic:
     executed: int = 0
     fail: int = 0
     error: int = 0
+    
+
+PBTTestResult = NewType("PBTTestResult", Dict[PropName, PropStatistic])
 
 
 PropertyExecutionInfoStore = NewType("PropertyExecutionInfoStore", Deque["PropertyExecutionInfo"])
@@ -209,11 +212,6 @@ class PropertyExecutionInfo:
     tb: str
 
 
-class PBTTestResult(dict):
-    def __getitem__(self, key) -> PropStatistic:
-        return super().__getitem__(key)
-
-
 def getFullPropName(testCase: TestCase):
     return ".".join([
         testCase.__module__,
@@ -277,10 +275,15 @@ class JsonResult(TextTestResult):
             self.lastExecutedInfo.state = "pass"
 
         self.executionInfoStore.append(self.lastExecutedInfo)
-        
 
     def getExcuted(self, test: TestCase):
         return self.res[getFullPropName(test)].executed
+    
+    def logSummary(self):
+        fails = sum(_.fail for _ in self.res.values())
+        errors = sum(_.error for _ in self.res.values())
+
+        logger.info(f"[Property Exectution Summary] Errors:{errors}, Fails:{fails}")
 
 
 class KeaTestRunner(TextTestRunner):
@@ -465,6 +468,8 @@ class KeaTestRunner(TextTestRunner):
         else:
             self.stream.write("\n")
         self.stream.flush()
+        
+        result.logSummary()
         return result
 
     @property

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,