cucu 1.3.15__py3-none-any.whl → 1.3.20__py3-none-any.whl

cucu/browser/core.py

@@ -67,6 +67,9 @@ class Browser:
     def switch_to_tab_that_matches_regex(self, text):
         raise RuntimeError("implement me")
 
+    def get_session_id(self):
+        raise RuntimeError("implement me")
+
     def quit(self):
         raise RuntimeError("implement me")
 

cucu/browser/selenium.py

@@ -195,6 +195,13 @@ class Selenium(Browser):
             raise Exception(f"unknown browser {browser}")
 
         self.driver.set_window_size(width, height)
+        session_id = self.get_session_id()
+        logger.debug(f"cucu started Selenium session with ID: {session_id}")
+
+    def get_session_id(self):
+        if self.driver:
+            return getattr(self.driver, "session_id", None)
+        return None
 
     def get_log(self):
         if config.CONFIG["CUCU_BROWSER"] == "firefox":

cucu/cli/core.py

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
-import json
 import os
 import shutil
 import signal
+import sqlite3
 import sys
 import time
 import xml.etree.ElementTree as ET
@@ -154,12 +154,6 @@ def main():
     help="the location to put the test report when --generate-report is used",
     type=click.Path(path_type=Path),
 )
-@click.option(
-    "--report-only-failures",
-    default=False,
-    is_flag=True,
-    help="when set the HTML test report will only contain the failed test results",
-)
 @click.option(
     "-r",
     "--results",
@@ -228,7 +222,6 @@ def run(
     preserve_results,
     record_env_vars,
     report,
-    report_only_failures,
     results,
     runtime_timeout,
     feature_timeout,
@@ -291,9 +284,6 @@ def run(
     if junit_with_stacktrace:
         os.environ["CUCU_JUNIT_WITH_STACKTRACE"] = "true"
 
-    if report_only_failures:
-        os.environ["CUCU_REPORT_ONLY_FAILURES"] = "true"
-
     if record_env_vars:
         os.environ["CUCU_RECORD_ENV_VARS"] = "true"
 
@@ -514,7 +504,6 @@ def run(
             _generate_report(
                 results_dir=results,
                 report_folder=report,
-                only_failures=report_only_failures,
                 junit_folder=junit,
             )
 
@@ -522,7 +511,6 @@ def run(
 def _generate_report(
     results_dir: Path,
     report_folder: Path,
-    only_failures: False,
     junit_folder: Path | None = None,
     combine: bool = False,
 ):
@@ -534,9 +522,7 @@ def _generate_report(
     if results_dir.exists():
         consolidate_database_files(results_dir, combine)
 
-    report_location = reporter.generate(
-        results_dir, report_folder, only_failures=only_failures
-    )
+    report_location = reporter.generate(results_dir, report_folder)
     print(f"HTML test report at {report_location}")
 
     if junit_folder:
@@ -559,12 +545,6 @@ def _generate_report(
 @click.argument(
     "results_dir", default="results", type=click.Path(path_type=Path)
 )
-@click.option(
-    "--only-failures",
-    default=False,
-    is_flag=True,
-    help="when set the HTML test report will only contain the failed test results",
-)
 @click.option(
     "-l",
     "--logging-level",
@@ -599,7 +579,6 @@ def _generate_report(
 )
 def report(
     results_dir: Path,
-    only_failures,
     logging_level,
     show_skips,
     output: Path,
@@ -617,23 +596,23 @@ def report(
     if show_skips:
         os.environ["CUCU_SHOW_SKIPS"] = "true"
 
-    run_details_filepath = results_dir / "run_details.json"
-
-    if os.path.exists(run_details_filepath):
-        # load the run details at the time of execution for the provided results
-        # directory
-        run_details = {}
-
-        with open(run_details_filepath, encoding="utf8") as _input:
-            run_details = json.loads(_input.read())
-
-        # initialize any underlying custom step code things
-        behave_init(run_details["filepath"])
+    run_db_path = results_dir / "run.db"
+    if run_db_path.exists():
+        # query cucu_run to get the original filepath used during the run
+        with sqlite3.connect(run_db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT filepath FROM cucu_run ORDER BY start_at DESC LIMIT 1"
+            )
+            row = cursor.fetchone()
+            if row:
+                filepath = row[0]
+                # initialize any underlying custom step code things
+                behave_init(filepath)
 
     _generate_report(
         results_dir=results_dir,
         report_folder=output,
-        only_failures=only_failures,
         junit_folder=junit,
         combine=combine,
     )

cucu/db.py

@@ -5,7 +5,6 @@ Database creation and management utilities for cucu.
 import logging
 import sqlite3
 import sys
-from datetime import datetime
 from pathlib import Path
 
 from peewee import (
@@ -20,7 +19,9 @@ from peewee import (
 from playhouse.sqlite_ext import JSONField, SqliteExtDatabase
 from tenacity import RetryError
 
+from cucu import logger as cucu_logger
 from cucu.config import CONFIG
+from cucu.utils import get_iso_timestamp_with_ms, parse_iso_timestamp
 
 db_filepath = CONFIG["RUN_DB_PATH"]
 db = SqliteExtDatabase(db_filepath)
@@ -89,7 +90,7 @@ class scenario(BaseModel):
         column_name="feature_run_id",
     )
     name = TextField()
-    seq = FloatField(null=True)
+    seq = IntegerField(null=True)
     status = TextField(null=True)
     duration = FloatField(null=True)
     start_at = DateTimeField(null=True)
@@ -124,13 +125,14 @@ class step(BaseModel):
     stderr = JSONField()
     error_message = JSONField(null=True)
     exception = JSONField(null=True)
-    debug_output = TextField()
+    debug_output = JSONField()
     browser_info = JSONField()
     text = JSONField(null=True)
     table_data = JSONField(null=True)
     location = TextField()
-    browser_logs = TextField()
-    screenshots = JSONField(null=True)
+    browser_logs = JSONField()
+    screenshots = JSONField()
+    image_dir = TextField(null=True)
 
 
 def record_cucu_run():
@@ -139,12 +141,11 @@ def record_cucu_run():
     worker_run_id = CONFIG["WORKER_RUN_ID"]
 
     db.connect(reuse_if_open=True)
-    start_at = datetime.now().isoformat()
     cucu_run.create(
         cucu_run_id=cucu_run_id_val,
         full_arguments=sys.argv,
         filepath=filepath,
-        start_at=start_at,
+        start_at=parse_iso_timestamp(get_iso_timestamp_with_ms()),
     )
 
     parent_id = (
@@ -156,7 +157,7 @@ def record_cucu_run():
         worker_run_id=worker_run_id,
         cucu_run_id=cucu_run_id_val,
         parent_id=parent_id,
-        start_at=datetime.now().isoformat(),
+        start_at=parse_iso_timestamp(get_iso_timestamp_with_ms()),
     )
 
     return str(db_filepath)
@@ -173,7 +174,7 @@ def record_feature(feature_obj):
         if isinstance(feature_obj.description, list)
         else str(feature_obj.description),
         tags=feature_obj.tags,
-        start_at=datetime.now().isoformat(),
+        start_at=parse_iso_timestamp(get_iso_timestamp_with_ms()),
     )
 
 
@@ -186,7 +187,7 @@ def record_scenario(scenario_obj):
         line_number=scenario_obj.line,
         seq=scenario_obj.seq,
         tags=scenario_obj.tags,
-        start_at=getattr(scenario_obj, "start_at", None),
+        start_at=parse_iso_timestamp(getattr(scenario_obj, "start_at", None)),
     )
 
 
@@ -214,31 +215,25 @@ def start_step_record(step_obj, scenario_run_id):
         has_substeps=getattr(step_obj, "has_substeps", False),
         section_level=getattr(step_obj, "section_level", None),
         browser_info="",
-        browser_logs="",
-        debug_output="",
+        browser_logs=[],
+        error_message=[],
+        debug_logs=[],
+        debug_output=[],
         stderr=[],
         stdout=[],
+        screenshots=[],
     )
 
 
 def finish_step_record(step_obj, duration):
     db.connect(reuse_if_open=True)
-    screenshot_infos = []
-    if hasattr(step_obj, "screenshots") and step_obj.screenshots:
-        for screenshot in step_obj.screenshots:
-            screenshot_info = {
-                "step_name": screenshot.get("step_name"),
-                "label": screenshot.get("label"),
-                "location": screenshot.get("location"),
-                "size": screenshot.get("size"),
-                "filepath": screenshot.get("filepath"),
-            }
-            screenshot_infos.append(screenshot_info)
-
-    error_message = None
+
+    error_message = []
     exception = []
     if step.error_message and step_obj.status.name == "failed":
-        error_message = CONFIG.hide_secrets(step_obj.error_message)
+        error_message = CONFIG.hide_secrets(
+            step_obj.error_message
+        ).splitlines()
 
         if error := step_obj.exception:
             if isinstance(error, RetryError):
@@ -255,35 +250,30 @@ def finish_step_record(step_obj, duration):
             exception = error_lines
 
     step.update(
-        browser_info=getattr(step_obj, "browser_info", ""),
-        browser_logs=getattr(step_obj, "browser_logs", ""),
-        debug_output=getattr(step_obj, "debug_output", ""),
+        browser_info=getattr(step_obj, "browser_info", {}),
+        browser_logs=getattr(step_obj, "browser_logs", []),
+        debug_output=getattr(step_obj, "debug_output", []),
         duration=duration,
         end_at=getattr(step_obj, "end_at", None),
         error_message=error_message,
         exception=exception,
         has_substeps=getattr(step_obj, "has_substeps", False),
         parent_seq=getattr(step_obj, "parent_seq", None),
-        screenshots=screenshot_infos,
+        screenshots=getattr(step_obj, "screenshots", []),
         section_level=getattr(step_obj, "section_level", None),
         seq=step_obj.seq,
-        start_at=getattr(step_obj, "start_at", None),
+        start_at=parse_iso_timestamp(getattr(step_obj, "start_at", None)),
         status=step_obj.status.name,
         stderr=getattr(step_obj, "stderr", []),
         stdout=getattr(step_obj, "stdout", []),
+        image_dir=getattr(step_obj, "step_image_dir", None),
     ).where(step.step_run_id == step_obj.step_run_id).execute()
 
 
 def finish_scenario_record(scenario_obj):
     db.connect(reuse_if_open=True)
-    if getattr(scenario_obj, "start_at", None):
-        start_at = datetime.fromisoformat(scenario_obj.start_at)
-    else:
-        start_at = None
-    if getattr(scenario_obj, "end_at", None):
-        end_at = datetime.fromisoformat(scenario_obj.end_at)
-    else:
-        end_at = None
+    start_at = parse_iso_timestamp(getattr(scenario_obj, "start_at", None))
+    end_at = parse_iso_timestamp(getattr(scenario_obj, "end_at", None))
     if start_at and end_at:
         duration = (end_at - start_at).total_seconds()
     else:
@@ -321,7 +311,7 @@ def finish_feature_record(feature_obj):
     db.connect(reuse_if_open=True)
     feature.update(
         status=feature_obj.status.name,
-        end_at=datetime.now().isoformat(),
+        end_at=parse_iso_timestamp(get_iso_timestamp_with_ms()),
         custom_data=feature_obj.custom_data,
     ).where(feature.feature_run_id == feature_obj.feature_run_id).execute()
 
@@ -330,7 +320,7 @@ def finish_worker_record(custom_data=None, worker_run_id=None):
     db.connect(reuse_if_open=True)
     target_worker_run_id = worker_run_id or CONFIG["WORKER_RUN_ID"]
     worker.update(
-        end_at=datetime.now().isoformat(),
+        end_at=parse_iso_timestamp(get_iso_timestamp_with_ms()),
         custom_data=custom_data,
     ).where(worker.worker_run_id == target_worker_run_id).execute()
 
@@ -338,7 +328,7 @@ def finish_worker_record(custom_data=None, worker_run_id=None):
 def finish_cucu_run_record():
     db.connect(reuse_if_open=True)
     cucu_run.update(
-        end_at=datetime.now().isoformat(),
+        end_at=parse_iso_timestamp(get_iso_timestamp_with_ms()),
     ).where(cucu_run.cucu_run_id == CONFIG["CUCU_RUN_ID"]).execute()
 
 
@@ -351,6 +341,57 @@ def create_database_file(db_filepath):
     db.init(db_filepath)
     db.connect(reuse_if_open=True)
     db.create_tables([cucu_run, worker, feature, scenario, step])
+    db.execute_sql("""
+            CREATE VIEW IF NOT EXISTS flat_all AS
+            WITH scenario_with_steps AS (
+                SELECT
+                    *,
+                    COUNT(st.step_run_id) AS steps
+                FROM scenario s
+                LEFT JOIN step st ON s.scenario_run_id = st.scenario_run_id
+                GROUP BY s.scenario_run_id
+            )
+            SELECT
+                COUNT(DISTINCT s.feature_run_id) AS features,
+                COUNT(s.scenario_run_id) AS scenarios,
+                SUM(CASE WHEN s.status = 'passed' THEN 1 ELSE 0 END) AS passed,
+                SUM(CASE WHEN s.status = 'failed' THEN 1 ELSE 0 END) AS failed,
+                SUM(CASE WHEN s.status = 'skipped' THEN 1 ELSE 0 END) AS skipped,
+                SUM(CASE WHEN s.status = 'errored' THEN 1 ELSE 0 END) AS errored,
+                SUM(s.duration) AS duration,
+                SUM(s.steps) AS steps
+            FROM scenario_with_steps s
+        """)
+    db.execute_sql("""
+            CREATE VIEW IF NOT EXISTS flat_feature AS
+            WITH feature_first_level AS (
+                SELECT
+                    w.cucu_run_id,
+                    f.start_at,
+                    f.name AS feature_name,
+                    COUNT(s.scenario_run_id) AS scenarios,
+                    SUM(CASE WHEN s.status = 'passed' THEN 1 ELSE 0 END) AS passed,
+                    SUM(CASE WHEN s.status = 'failed' THEN 1 ELSE 0 END) AS failed,
+                    SUM(CASE WHEN s.status = 'skipped' THEN 1 ELSE 0 END) AS skipped,
+                    SUM(CASE WHEN s.status = 'errored' THEN 1 ELSE 0 END) AS errored,
+                    SUM(s.duration) AS duration
+                FROM cucu_run r
+                JOIN worker w ON r.cucu_run_id = w.cucu_run_id
+                JOIN feature f ON w.worker_run_id = f.worker_run_id
+                JOIN scenario s ON f.feature_run_id = s.feature_run_id
+                GROUP BY f.feature_run_id
+            )
+            SELECT
+                *,
+                CASE
+                    WHEN failed  > 0 THEN 'failed'
+                    WHEN errored > 0 THEN 'errored'
+                    WHEN passed  > 0 THEN 'passed'
+                    WHEN skipped > 0 THEN 'skipped'
+                END AS status
+            FROM feature_first_level
+            ORDER BY start_at ASC
+        """)
     db.execute_sql("""
             CREATE VIEW IF NOT EXISTS flat AS
             SELECT
@@ -416,7 +457,12 @@ def consolidate_database_files(results_dir, combine=False):
     results_path = Path(results_dir)
     target_db_path = results_path / "run.db"
     if not target_db_path.exists():
+        cucu_logger.info(
+            f"Creating new consolidated database at {target_db_path}"
+        )
         create_database_file(target_db_path)
+    else:
+        cucu_logger.debug(f"Found existing database at {target_db_path}")
 
     if not combine:
         db_files = [
@@ -428,6 +474,14 @@ def consolidate_database_files(results_dir, combine=False):
             db for db in results_path.rglob("run*.db") if db != Path("run.db")
         ]
 
+    if not db_files:
+        cucu_logger.debug("No database files found to consolidate.")
+        return
+    else:
+        cucu_logger.debug(
+            f"Found {len(db_files)} database files to consolidate."
+        )
+
     tables_to_copy = ["cucu_run", "worker", "feature", "scenario", "step"]
     with sqlite3.connect(target_db_path) as target_conn:
         target_cursor = target_conn.cursor()

cucu/environment.py

@@ -1,4 +1,3 @@
-import datetime
 import json
 import sys
 import traceback
@@ -13,6 +12,8 @@ from cucu.page_checks import init_page_checks
 from cucu.utils import (
     TeeStream,
     ellipsize_filename,
+    get_iso_timestamp_with_ms,
+    parse_iso_timestamp,
     take_screenshot,
 )
 
@@ -90,7 +91,7 @@ def before_scenario(ctx, scenario):
 
     # reset the step timer dictionary
     ctx.step_timers = {}
-    scenario.start_at = datetime.datetime.now().isoformat()[:-3]
+    scenario.start_at = get_iso_timestamp_with_ms()
 
     if config.CONFIG["CUCU_RESULTS_DIR"] is not None:
         ctx.scenario_dir = ctx.feature_dir / ellipsize_filename(scenario.name)
@@ -173,10 +174,10 @@ def after_scenario(ctx, scenario):
                 "current_tab_index": tab_info["index"],
                 "all_tabs": all_tabs,
                 "browser_type": ctx.browser.driver.name,
+                "session_id": ctx.browser.get_session_id(),
             }
         except Exception as e:
             logger.error(f"Error getting browser info: {e}")
-
     scenario.browser_info = browser_info
 
     run_after_scenario_hook(ctx, scenario, download_mht_data)
@@ -205,7 +206,7 @@ def after_scenario(ctx, scenario):
         CONFIG.to_yaml_without_secrets()
     )
 
-    scenario.end_at = datetime.datetime.now().isoformat()[:-3]
+    scenario.end_at = get_iso_timestamp_with_ms()
 
 
 def download_mht_data(ctx):
@@ -237,7 +238,7 @@ def cleanup_browsers(ctx):
 
 
 def before_step(ctx, step):
-    step.start_at = datetime.datetime.now().isoformat()[:-3]
+    step.start_at = get_iso_timestamp_with_ms()
 
     sys.stdout.captured()
     sys.stderr.captured()
@@ -268,16 +269,16 @@ def after_step(ctx, step):
 
     # Capture debug output from the TeeStream for this step
     if hasattr(ctx, "scenario_debug_log_tee"):
-        step.debug_output = ctx.scenario_debug_log_tee.getvalue()
+        step.debug_output = ctx.scenario_debug_log_tee.getvalue().splitlines()
     else:
-        step.debug_output = ""
+        step.debug_output = []
 
-    step.end_at = datetime.datetime.now().isoformat()[:-3]
+    step.end_at = get_iso_timestamp_with_ms()
 
     # calculate duration from ISO timestamps
-    start_at = datetime.datetime.fromisoformat(step.start_at)
-    end_at = datetime.datetime.fromisoformat(step.end_at)
-    ctx.scenario.previous_step_duration = (end_at - start_at).total_seconds()
+    ctx.scenario.previous_step_duration = (
+        parse_iso_timestamp(step.end_at) - parse_iso_timestamp(step.start_at)
+    ).total_seconds()
 
     # when set this means we're running in parallel mode using --workers and
     # we want to see progress reported using simply dots
@@ -325,16 +326,13 @@ def after_step(ctx, step):
         hook(ctx)
 
     # Capture browser logs and info for this step
-    step.browser_logs = ""
-
+    step.browser_logs = []
     browser_info = {"has_browser": False}
     if ctx.browser:
-        browser_logs = []
         for log in ctx.browser.get_log():
             log_entry = json.dumps(log)
-            browser_logs.append(log_entry)
+            step.browser_logs.append(log)
             ctx.browser_log_tee.write(f"{log_entry}\n")
-        step.browser_logs = "\n".join(browser_logs)
 
         tab_info = ctx.browser.get_tab_info()
 

cucu/formatter/rundb.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import
 
-import datetime
 import os
 import time
 from pathlib import Path
@@ -26,6 +25,7 @@ from cucu.db import (
 )
 from cucu.utils import (
     generate_short_id,
+    get_iso_timestamp_with_ms,
 )
 
 
@@ -125,7 +125,7 @@ class RundbFormatter(Formatter):
         for index, step in enumerate(self.this_steps):
             if getattr(step, "seq", -1) == -1:
                 step.seq = index + 1  # 1-based sequence
-                finish_step_record(step, None)
+                finish_step_record(step, 0)
 
         finish_scenario_record(self.this_scenario)
 
@@ -137,7 +137,7 @@ class RundbFormatter(Formatter):
 
         self.this_scenario = scenario
         self.this_steps = []
-        self.next_start_at = datetime.datetime.now().isoformat()[:-3]
+        self.next_start_at = get_iso_timestamp_with_ms()
         scenario_run_id_seed = (
             f"{scenario.feature.feature_run_id}_{time.perf_counter()}"
         )
@@ -185,9 +185,7 @@ class RundbFormatter(Formatter):
     def result(self, step):
         """Called after processing a step result is known, applies to executed/skipped too."""
         step.start_at = self.next_start_at
-        self.next_start_at = step.end_at = datetime.datetime.now().isoformat()[
-            :-3
-        ]
+        self.next_start_at = step.end_at = get_iso_timestamp_with_ms()
         previous_step_duration = getattr(
             self.this_scenario, "previous_step_duration", 0
         )