cucu 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

cucu/cli/core.py

@@ -33,7 +33,12 @@ from cucu.cli import thread_dumper
 from cucu.cli.run import behave, behave_init, create_run
 from cucu.cli.steps import print_human_readable_steps, print_json_steps
 from cucu.config import CONFIG
-from cucu.db import consolidate_database_files, finish_worker_record
+from cucu.db import (
+    consolidate_database_files,
+    db,
+    finish_worker_record,
+    get_first_cucu_run_filepath,
+)
 from cucu.lint import linter
 from cucu.utils import generate_short_id
 
@@ -259,12 +264,11 @@ def run(
     os.environ["CUCU_LOGGING_LEVEL"] = logging_level.upper()
     logger.init_logging(logging_level.upper())
 
-    if not dry_run:
-        if not preserve_results:
-            if os.path.exists(results):
-                shutil.rmtree(results)
+    if not preserve_results:
+        if os.path.exists(results):
+            shutil.rmtree(results)
 
-        os.makedirs(results, exist_ok=True)
+    os.makedirs(results, exist_ok=True)
 
     if selenium_remote_url is not None:
         os.environ["CUCU_SELENIUM_REMOTE_URL"] = selenium_remote_url
@@ -299,8 +303,10 @@ def run(
     os.environ["WORKER_PARENT_ID"] = CONFIG["WORKER_RUN_ID"] = (
         generate_short_id(worker_id_seed)
     )
-    if not dry_run:
-        create_run(results, filepath)
+
+    os.environ["CUCU_FILEPATH"] = CONFIG["CUCU_FILEPATH"] = filepath
+
+    create_run(results, filepath)
 
     try:
         if workers is None or workers == 1:
@@ -491,7 +497,7 @@ def run(
         if dumper is not None:
             dumper.stop()
 
-        if not dry_run and os.path.exists(results):
+        if os.path.exists(results):
             finish_worker_record(worker_run_id=CONFIG.get("WORKER_PARENT_ID"))
             consolidate_database_files(results)
 
@@ -510,18 +516,6 @@ def _generate_report(
     only_failures: False,
     junit: str | None = None,
 ):
-    """
-    helper method to handle report generation so it can be used by the `cucu report`
-    command also the `cucu run` when told to generate a report. If junit is provided, it adds report
-    path to the JUnit files.
-
-
-    parameters:
-        results_dir(string): the results directory containing the previous test run
-        output(string): the directory where we'll generate the report
-        only_failures(bool, optional): if only report failures. The default is False.
-        junit(str|None, optional): the directory of the JUnit files. The default if None.
-    """
     if os.path.exists(output):
         shutil.rmtree(output)
 
@@ -530,6 +524,16 @@ def _generate_report(
     if os.path.exists(results_dir):
         consolidate_database_files(results_dir)
 
+    db_path = os.path.join(results_dir, "run.db")
+
+    try:
+        db.init(db_path)
+        db.connect(reuse_if_open=True)
+        filepath = get_first_cucu_run_filepath()
+        behave_init(filepath)
+    finally:
+        db.close()
+
     report_location = reporter.generate(
         results_dir, output, only_failures=only_failures
     )

cucu/cli/run.py

@@ -110,8 +110,10 @@ def behave(
     if dry_run:
         args += [
             "--dry-run",
-            # console formater
+            # console formatter
             "--format=cucu.formatter.cucu:CucuFormatter",
+            # run.db formatter
+            "--format=cucu.formatter.rundb:RundbFormatter",
         ]
 
     else:
@@ -128,6 +130,8 @@ def behave(
             # disable behave's junit output in favor of our own formatter
             "--no-junit",
             "--format=cucu.formatter.junit:CucuJUnitFormatter",
+            # run.db formatter
+            "--format=cucu.formatter.rundb:RundbFormatter",
         ]
 
     for tag in tags:

cucu/db.py

@@ -18,6 +18,7 @@ from peewee import (
     TextField,
 )
 from playhouse.sqlite_ext import JSONField, SqliteExtDatabase
+from tenacity import RetryError
 
 from cucu.config import CONFIG
 
@@ -36,6 +37,7 @@ class BaseModel(Model):
 class cucu_run(BaseModel):
     cucu_run_id = TextField(primary_key=True)
     full_arguments = JSONField()
+    filepath = TextField()
     date = TextField()
     start_at = DateTimeField()
     end_at = DateTimeField(null=True)
@@ -71,12 +73,13 @@ class feature(BaseModel):
         column_name="worker_run_id",
     )
     name = TextField()
-    filename = TextField()
-    description = TextField()
-    tags = TextField()
+    status = TextField(null=True)
     start_at = DateTimeField()
     end_at = DateTimeField(null=True)
     custom_data = JSONField(null=True)
+    tags = JSONField()
+    filename = TextField()
+    description = TextField()
 
 
 class scenario(BaseModel):
@@ -88,17 +91,17 @@ class scenario(BaseModel):
         column_name="feature_run_id",
     )
     name = TextField()
-    line_number = IntegerField()
-    seq = IntegerField()
-    tags = TextField()
+    seq = FloatField(null=True)
     status = TextField(null=True)
     duration = FloatField(null=True)
-    start_at = DateTimeField()
+    start_at = DateTimeField(null=True)
     end_at = DateTimeField(null=True)
-    log_files = JSONField(null=True)
-    cucu_config = JSONField(null=True)
-    browser_info = JSONField(null=True)
+    tags = JSONField()
     custom_data = JSONField(null=True)
+    browser_info = JSONField(null=True)
+    cucu_config = JSONField(null=True)
+    line_number = IntegerField()
+    log_files = JSONField(null=True)
 
 
 class step(BaseModel):
@@ -109,27 +112,32 @@ class step(BaseModel):
         backref="steps",
         column_name="scenario_run_id",
     )
-    seq = IntegerField()
     section_level = IntegerField(null=True)
+    seq = IntegerField()
     parent_seq = IntegerField(null=True)
-    keyword = TextField()
-    name = TextField()
-    text = TextField(null=True)
-    table_data = JSONField(null=True)
-    location = TextField()
     is_substep = BooleanField(null=True)  # info available after step ends
     has_substeps = BooleanField()
+    keyword = TextField()
+    name = TextField()
     status = TextField(null=True)
     duration = FloatField(null=True)
-    start_at = DateTimeField()
+    start_at = DateTimeField(null=True)
     end_at = DateTimeField(null=True)
+    stdout = JSONField(null=True)
+    stderr = JSONField(null=True)
+    error_message = JSONField(null=True)
+    exception = JSONField(null=True)
     debug_output = TextField(null=True)
-    browser_logs = TextField(null=True)
     browser_info = JSONField(null=True)
+    text = JSONField(null=True)
+    table_data = JSONField(null=True)
+    location = TextField()
+    browser_logs = TextField(null=True)
     screenshots = JSONField(null=True)
 
 
 def record_cucu_run():
+    filepath = CONFIG["CUCU_FILEPATH"]
     cucu_run_id_val = CONFIG["CUCU_RUN_ID"]
     worker_run_id = CONFIG["WORKER_RUN_ID"]
 
@@ -138,6 +146,7 @@ def record_cucu_run():
     cucu_run.create(
         cucu_run_id=cucu_run_id_val,
         full_arguments=sys.argv,
+        filepath=filepath,
         date=start_at,
         start_at=start_at,
     )
@@ -150,7 +159,6 @@ def record_cucu_run():
         else None,
         start_at=datetime.now().isoformat(),
     )
-    db.close()
     return str(db_filepath)
 
 
@@ -164,47 +172,48 @@ def record_feature(feature_obj):
         description="\n".join(feature_obj.description)
         if isinstance(feature_obj.description, list)
         else str(feature_obj.description),
-        tags=" ".join(feature_obj.tags),
+        tags=feature_obj.tags,
         start_at=datetime.now().isoformat(),
     )
-    db.close()
 
 
-def record_scenario(ctx):
+def record_scenario(scenario_obj):
     db.connect(reuse_if_open=True)
     scenario.create(
-        scenario_run_id=ctx.scenario.scenario_run_id,
-        feature_run_id=ctx.scenario.feature.feature_run_id,
-        name=ctx.scenario.name,
-        line_number=ctx.scenario.line,
-        seq=ctx.scenario_index,
-        tags=" ".join(ctx.scenario.tags),
-        start_at=ctx.scenario.start_at,
+        scenario_run_id=scenario_obj.scenario_run_id,
+        feature_run_id=scenario_obj.feature.feature_run_id,
+        name=scenario_obj.name,
+        line_number=scenario_obj.line,
+        seq=scenario_obj.seq,
+        tags=scenario_obj.tags,
+        start_at=getattr(scenario_obj, "start_at", None),
     )
-    db.close()
 
 
-def start_step_record(ctx, step_obj):
+def start_step_record(step_obj, scenario_run_id):
     db.connect(reuse_if_open=True)
-    if not step_obj.table:
-        table = None
-    else:
-        table = [step_obj.table.headings]
-        table.extend([row.cells for row in step_obj.table.rows])
+
+    table = None
+    if step_obj.table:
+        table = {
+            "headings": step_obj.table.headings,
+            "rows": [list(row) for row in step_obj.table.rows],
+        }
+
     step.create(
         step_run_id=step_obj.step_run_id,
-        scenario_run_id=ctx.scenario.scenario_run_id,
-        seq=step_obj.seq,
+        scenario_run_id=scenario_run_id,
+        seq=getattr(step_obj, "seq", -1),
         keyword=step_obj.keyword,
         name=step_obj.name,
-        text=step_obj.text if step_obj.text else None,
-        table_data=table if step_obj.table else None,
+        status=step_obj.status.name,
+        text=step_obj.text.splitlines() if step_obj.text else [],
+        table_data=table,
         location=str(step_obj.location),
-        has_substeps=step_obj.has_substeps,
+        is_substep=getattr(step_obj, "is_substep", False),
+        has_substeps=getattr(step_obj, "has_substeps", False),
         section_level=getattr(step_obj, "section_level", None),
-        start_at=step_obj.start_at,
     )
-    db.close()
 
 
 def finish_step_record(step_obj, duration):
@@ -221,27 +230,60 @@ def finish_step_record(step_obj, duration):
             }
             screenshot_infos.append(screenshot_info)
 
+    error_message = None
+    exception = []
+    if step.error_message and step_obj.status.name == "failed":
+        error_message = CONFIG.hide_secrets(step_obj.error_message)
+
+        if error := step_obj.exception:
+            if isinstance(error, RetryError):
+                error = error.last_attempt.exception()
+
+            if len(error.args) > 0 and isinstance(error.args[0], str):
+                error_class_name = error.__class__.__name__
+                redacted_error_msg = CONFIG.hide_secrets(error.args[0])
+                error_lines = redacted_error_msg.splitlines()
+                error_lines[0] = f"{error_class_name}: {error_lines[0]}"
+            else:
+                error_lines = [repr(error)]
+
+            exception = error_lines
+
     step.update(
-        section_level=getattr(step_obj, "section_level", None),
-        parent_seq=step_obj.parent_seq,
-        has_substeps=step_obj.has_substeps,
-        status=step_obj.status.name,
-        is_substep=step_obj.is_substep,
+        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=step_obj.end_at,
-        debug_output=step_obj.debug_output,
-        browser_logs=step_obj.browser_logs,
-        browser_info=step_obj.browser_info,
+        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,
+        section_level=getattr(step_obj, "section_level", None),
+        seq=step_obj.seq,
+        start_at=getattr(step_obj, "start_at", None),
+        status=step_obj.status.name,
+        stderr=getattr(step_obj, "stderr", []),
+        stdout=getattr(step_obj, "stdout", []),
     ).where(step.step_run_id == step_obj.step_run_id).execute()
-    db.close()
 
 
 def finish_scenario_record(scenario_obj):
     db.connect(reuse_if_open=True)
-    start_dt = datetime.fromisoformat(scenario_obj.start_at)
-    end_dt = datetime.fromisoformat(scenario_obj.end_at)
-    duration = (end_dt - start_dt).total_seconds()
+    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
+    if start_at and end_at:
+        duration = (end_at - start_at).total_seconds()
+    else:
+        duration = None
+
     scenario_logs_dir = CONFIG.get("SCENARIO_LOGS_DIR")
     if not scenario_logs_dir or not Path(scenario_logs_dir).exists():
         log_files_json = "[]"
@@ -253,26 +295,30 @@ def finish_scenario_record(scenario_obj):
             if file.is_file()
         ]
         log_files_json = sorted(log_files)
-    custom_data_json = scenario_obj.custom_data
+
+    if scenario_obj.hook_failed:
+        status = "errored"
+    else:
+        status = scenario_obj.status.name
+
     scenario.update(
-        status=scenario_obj.status.name,
+        status=status,
         duration=duration,
-        end_at=scenario_obj.end_at,
+        end_at=end_at,
         log_files=log_files_json,
-        cucu_config=scenario_obj.cucu_config_json,
-        browser_info=scenario_obj.browser_info,
-        custom_data=custom_data_json,
+        cucu_config=getattr(scenario_obj, "cucu_config_json", dict()),
+        browser_info=getattr(scenario_obj, "browser_info", dict()),
+        custom_data=getattr(scenario_obj, "custom_data", dict()),
     ).where(scenario.scenario_run_id == scenario_obj.scenario_run_id).execute()
-    db.close()
 
 
 def finish_feature_record(feature_obj):
     db.connect(reuse_if_open=True)
     feature.update(
+        status=feature_obj.status.name,
         end_at=datetime.now().isoformat(),
         custom_data=feature_obj.custom_data,
     ).where(feature.feature_run_id == feature_obj.feature_run_id).execute()
-    db.close()
 
 
 def finish_worker_record(custom_data=None, worker_run_id=None):
@@ -282,7 +328,6 @@ def finish_worker_record(custom_data=None, worker_run_id=None):
         end_at=datetime.now().isoformat(),
         custom_data=custom_data,
     ).where(worker.worker_run_id == target_worker_run_id).execute()
-    db.close()
 
 
 def finish_cucu_run_record():
@@ -290,7 +335,11 @@ def finish_cucu_run_record():
     cucu_run.update(
         end_at=datetime.now().isoformat(),
     ).where(cucu_run.cucu_run_id == CONFIG["CUCU_RUN_ID"]).execute()
-    db.close()
+
+
+def close_db():
+    if not db.is_closed():
+        db.close()
 
 
 def create_database_file(db_filepath):
@@ -305,7 +354,12 @@ def create_database_file(db_filepath):
                 s.duration,
                 f.name AS feature_name,
                 s.name AS scenario_name,
-                f.tags || ' ' || s.tags AS tags,
+                CASE
+                    WHEN f.tags = '[]' AND s.tags = '[]' THEN JSON('[]')
+                    WHEN f.tags = '[]' THEN s.tags
+                    WHEN s.tags = '[]' THEN f.tags
+                    ELSE JSON(REPLACE(f.tags, ']', '') || ',' || REPLACE(s.tags, '[', ''))
+                END as tags,
                 s.log_files
             FROM scenario s
             JOIN feature f ON s.feature_run_id = f.feature_run_id
@@ -317,7 +371,12 @@ def create_database_file(db_filepath):
                 s.scenario_run_id,
                 f.name AS feature_name,
                 s.name AS scenario_name,
-                f.tags || ' ' || s.tags AS tags,
+                CASE
+                    WHEN f.tags = '[]' AND s.tags = '[]' THEN JSON('[]')
+                    WHEN f.tags = '[]' THEN s.tags
+                    WHEN s.tags = '[]' THEN f.tags
+                    ELSE JSON(REPLACE(f.tags, ']', '') || ',' || REPLACE(s.tags, '[', ''))
+                END as tags,
                 f.filename || ':' || s.line_number AS feature_file_line,
                 s.status,
                 (
@@ -340,13 +399,20 @@ def create_database_file(db_filepath):
             FROM scenario s
             JOIN feature f ON s.feature_run_id = f.feature_run_id
         """)
-    db.close()
+
+
+def get_first_cucu_run_filepath():
+    run_record = cucu_run.select().first()
+    return run_record.filepath
 
 
 def consolidate_database_files(results_dir):
     # This function would need a more advanced approach with peewee, so for now, keep using sqlite3 for consolidation
     results_path = Path(results_dir)
     target_db_path = results_path / "run.db"
+    if not target_db_path.exists():
+        create_database_file(target_db_path)
+
     db_files = [
         db for db in results_path.glob("**/*.db") if db.name != "run.db"
     ]
@@ -368,3 +434,12 @@ def consolidate_database_files(results_dir):
                     )
                     target_conn.commit()
             db_file.unlink()
+
+
+def init_html_report_db(db_path):
+    db.init(db_path)
+    db.connect(reuse_if_open=True)
+
+
+def close_html_report_db():
+    db.close()

cucu/environment.py

@@ -1,8 +1,6 @@
 import datetime
 import json
-import os
 import sys
-import time
 import traceback
 from functools import partial
 from pathlib import Path
@@ -11,23 +9,10 @@ import yaml
 
 from cucu import config, init_scenario_hook_variables, logger
 from cucu.config import CONFIG
-from cucu.db import (
-    create_database_file,
-    finish_cucu_run_record,
-    finish_feature_record,
-    finish_scenario_record,
-    finish_step_record,
-    finish_worker_record,
-    record_cucu_run,
-    record_feature,
-    record_scenario,
-    start_step_record,
-)
 from cucu.page_checks import init_page_checks
 from cucu.utils import (
     TeeStream,
     ellipsize_filename,
-    generate_short_id,
     take_screenshot,
 )
 
@@ -61,27 +46,6 @@ def before_all(ctx):
     ctx.check_browser_initialized = partial(check_browser_initialized, ctx)
     ctx.worker_custom_data = {}
 
-    if CONFIG["WORKER_RUN_ID"] != CONFIG["WORKER_PARENT_ID"]:
-        logger.debug(
-            "Create a new worker db since this isn't the parent process"
-        )
-        # use seed unique enough for multiple cucu_runs to be combined but predictable within the same run
-        worker_id_seed = f"{CONFIG['WORKER_PARENT_ID']}_{os.getpid()}"
-        CONFIG["WORKER_RUN_ID"] = generate_short_id(worker_id_seed)
-
-        results_path = Path(CONFIG["CUCU_RESULTS_DIR"])
-        worker_run_id = CONFIG["WORKER_RUN_ID"]
-        cucu_run_id = CONFIG["CUCU_RUN_ID"]
-        CONFIG["RUN_DB_PATH"] = run_db_path = (
-            results_path / f"run_{cucu_run_id}_{worker_run_id}.db"
-        )
-        if not run_db_path.exists():
-            logger.debug(
-                f"Creating new run database file: {run_db_path} for {worker_id_seed}"
-            )
-            create_database_file(run_db_path)
-            record_cucu_run()
-
     CONFIG.snapshot("before_all")
 
     for hook in CONFIG["__CUCU_BEFORE_ALL_HOOKS"]:
@@ -93,29 +57,22 @@ def after_all(ctx):
     for hook in CONFIG["__CUCU_AFTER_ALL_HOOKS"]:
         hook(ctx)
 
-    finish_worker_record(ctx.worker_custom_data)
-    finish_cucu_run_record()
     CONFIG.restore(with_pop=True)
 
 
 def before_feature(ctx, feature):
-    feature_run_id_seed = f"{CONFIG['WORKER_RUN_ID']}_{time.perf_counter()}"
-    feature.feature_run_id = generate_short_id(feature_run_id_seed)
-    feature.custom_data = {}
-    record_feature(feature)
-
     if config.CONFIG["CUCU_RESULTS_DIR"] is not None:
         results_dir = Path(config.CONFIG["CUCU_RESULTS_DIR"])
         ctx.feature_dir = results_dir / ellipsize_filename(feature.name)
 
 
 def after_feature(ctx, feature):
-    finish_feature_record(feature)
+    pass
 
 
 def before_scenario(ctx, scenario):
     # we want every scenario to start with the exact same reinitialized config
-    # values and not really bleed values between scenario runs
+    # values and not bleed values between scenario runs
     CONFIG.restore()
 
     # we should load any cucurc.yml files in the path to the feature file
@@ -125,10 +82,8 @@ def before_scenario(ctx, scenario):
 
     init_scenario_hook_variables()
 
-    scenario.custom_data = {}
     ctx.scenario = scenario
     ctx.step_index = 0
-    ctx.scenario_index = ctx.feature.scenarios.index(scenario) + 1
     ctx.browsers = []
     ctx.browser = None
     ctx.section_step_stack = []
@@ -172,14 +127,6 @@ def before_scenario(ctx, scenario):
         )
         ctx.browser_log_tee = TeeStream(ctx.browser_log_file)
 
-    scenario_run_id_seed = (
-        f"{ctx.feature.feature_run_id}_{time.perf_counter()}"
-    )
-    CONFIG["SCENARIO_RUN_ID"] = scenario.scenario_run_id = generate_short_id(
-        scenario_run_id_seed
-    )
-    record_scenario(ctx)
-
     # run before all scenario hooks
     for hook in CONFIG["__CUCU_BEFORE_SCENARIO_HOOKS"]:
         try:
@@ -215,6 +162,23 @@ def after_scenario(ctx, scenario):
     for timer_name in ctx.step_timers:
         logger.warning(f'timer "{timer_name}" was never stopped/recorded')
 
+    browser_info = {"has_browser": False}
+
+    if len(ctx.browsers) != 0:
+        try:
+            tab_info = ctx.browser.get_tab_info()
+            all_tabs = ctx.browser.get_all_tabs_info()
+            browser_info = {
+                "has_browser": True,
+                "current_tab_index": tab_info["index"],
+                "all_tabs": all_tabs,
+                "browser_type": ctx.browser.driver.name,
+            }
+        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)
 
     # run after all scenario hooks in 'lifo' order.
@@ -227,23 +191,12 @@ def after_scenario(ctx, scenario):
 
     CONFIG["__CUCU_AFTER_THIS_SCENARIO_HOOKS"] = []
 
-    browser_info = {"has_browser": False}
     if CONFIG.true("CUCU_KEEP_BROWSER_ALIVE"):
         logger.debug("keeping browser alive between sessions")
     elif len(ctx.browsers) != 0:
-        tab_info = ctx.browser.get_tab_info()
-        all_tabs = ctx.browser.get_all_tabs_info()
-        browser_info = {
-            "current_tab_index": tab_info["index"],
-            "all_tabs": all_tabs,
-            "browser_type": ctx.browser.driver.name,
-        }
-
         logger.debug("quitting browser between sessions")
         run_after_scenario_hook(ctx, scenario, cleanup_browsers)
 
-    scenario.browser_info = browser_info
-
     cucu_config_path = ctx.scenario_logs_dir / "cucu.config.yaml.txt"
     with open(cucu_config_path, "w") as config_file:
         config_file.write(CONFIG.to_yaml_without_secrets())
@@ -253,7 +206,6 @@ def after_scenario(ctx, scenario):
     )
 
     scenario.end_at = datetime.datetime.now().isoformat()[:-3]
-    finish_scenario_record(scenario)
 
 
 def download_mht_data(ctx):
@@ -285,10 +237,6 @@ def cleanup_browsers(ctx):
 
 
 def before_step(ctx, step):
-    step_run_id_seed = f"{ctx.scenario.scenario_run_id}_{ctx.step_index}_{time.perf_counter()}"
-    step.step_run_id = generate_short_id(
-        step_run_id_seed, length=10
-    )  # up to 10 characters to give two orders of magnitude less chance of collision
     step.start_at = datetime.datetime.now().isoformat()[:-3]
 
     sys.stdout.captured()
@@ -299,7 +247,8 @@ def before_step(ctx, step):
         ctx.scenario_debug_log_tee.clear()
 
     ctx.current_step = step
-    ctx.current_step.has_substeps = False
+    step.is_substep = getattr(step, "is_substep", False)
+    step.has_substeps = getattr(step, "has_substeps", False)
     ctx.section_level = None
     step.seq = ctx.step_index + 1
     step.parent_seq = (
@@ -308,8 +257,6 @@ def before_step(ctx, step):
 
     CONFIG["__STEP_SCREENSHOT_COUNT"] = 0
 
-    start_step_record(ctx, step)
-
     # run before all step hooks
     for hook in CONFIG["__CUCU_BEFORE_STEP_HOOKS"]:
         hook(ctx)
@@ -330,7 +277,7 @@ def after_step(ctx, step):
     # calculate duration from ISO timestamps
     start_at = datetime.datetime.fromisoformat(step.start_at)
     end_at = datetime.datetime.fromisoformat(step.end_at)
-    ctx.previous_step_duration = (end_at - start_at).total_seconds()
+    ctx.scenario.previous_step_duration = (end_at - 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
@@ -355,8 +302,8 @@ def after_step(ctx, step):
         logger.debug(log_message)
 
         # Add tab info to step.stdout so it shows up in the HTML report
-        step.stdout += (
-            f"\ntab({current_tab} of {total_tabs}): {title}\nurl: {url}\n"
+        step.stdout.extend(
+            [f"tab({current_tab} of {total_tabs}): {title}", "url: {url}"]
         )
 
     # if the step has substeps from using `run_steps` then we already moved
@@ -400,5 +347,3 @@ def after_step(ctx, step):
         }
 
     step.browser_info = browser_info
-
-    finish_step_record(step, ctx.previous_step_duration)

cucu/formatter/cucu.py

@@ -101,8 +101,8 @@ class CucuFormatter(Formatter):
 
     def insert_step(self, step, index=-1):
         # used to determine how to better handle console output
-        step.has_substeps = False
-        step.is_substep = False
+        step.has_substeps = getattr(step, "has_substeps", False)
+        step.is_substep = getattr(step, "is_substep", False)
 
         if index == -1:
             self.steps.append(step)

cucu/formatter/rundb.py

@@ -0,0 +1,207 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import datetime
+import os
+import time
+from pathlib import Path
+
+from behave.formatter.base import Formatter
+from behave.model import ScenarioOutline
+
+from cucu import logger
+from cucu.config import CONFIG
+from cucu.db import (
+    close_db,
+    create_database_file,
+    finish_cucu_run_record,
+    finish_feature_record,
+    finish_scenario_record,
+    finish_step_record,
+    finish_worker_record,
+    record_cucu_run,
+    record_feature,
+    record_scenario,
+    start_step_record,
+)
+from cucu.utils import (
+    generate_short_id,
+)
+
+
+class RundbFormatter(Formatter):
+    """
+    Record to the database using the Formatter Behave API.
+    This is different from hooks as we don't have access to context (ctx) here.
+    Instead we use this class's data and add some data to the passed in objects: feature, scenario, step.
+    Another difference is that we can't rely on hooks to execute, as the step/scenario/feature may be skipped.
+    Also, use cucu's CONFIG for global data since we don't have context (ctx).
+
+    ## Just for reference:
+    Processing Logic (simplified, without ScenarioOutline and skip logic)::
+
+        for feature in runner.features:
+            formatter = make_formatters(...)
+            formatter.uri(feature.filename)
+            formatter.feature(feature)
+            for scenario in feature.scenarios:
+                formatter.scenario(scenario)
+                for step in scenario.all_steps:
+                    formatter.step(step)
+                    step_match = step_registry.find_match(step)
+                    formatter.match(step_match)
+                    if step_match:
+                        step_match.run()
+                    else:
+                        step.status = Status.undefined
+                    formatter.result(step.status)
+            formatter.eof() # -- FEATURE-END
+        formatter.close()
+    """
+
+    # -- FORMATTER API:
+    name = "rundb"
+    description = "records the results of the run to the run.db database"
+
+    def __init__(self, stream_opener, config):
+        super(RundbFormatter, self).__init__(stream_opener, config)
+        # We don't actually use the stream provided by Behave, so don't open it.
+        # self.stream = self.open()
+        self.config = config
+
+        if (
+            not CONFIG["RUN_DB_PATH"]
+            or CONFIG["WORKER_RUN_ID"] != CONFIG["WORKER_PARENT_ID"]
+        ):
+            logger.debug(
+                "Create a new worker db since this isn't the parent process"
+            )
+            # use seed unique enough for multiple cucu_runs to be combined but predictable within the same run
+            worker_id_seed = f"{CONFIG['WORKER_PARENT_ID']}_{os.getpid()}"
+            CONFIG["WORKER_RUN_ID"] = generate_short_id(worker_id_seed)
+
+            results_path = Path(CONFIG["CUCU_RESULTS_DIR"])
+            worker_run_id = CONFIG["WORKER_RUN_ID"]
+            cucu_run_id = CONFIG["CUCU_RUN_ID"]
+            CONFIG["RUN_DB_PATH"] = run_db_path = (
+                results_path / f"run_{cucu_run_id}_{worker_run_id}.db"
+            )
+
+            if not run_db_path.exists():
+                logger.debug(
+                    f"Creating new run database file: {run_db_path} for {worker_id_seed}"
+                )
+                create_database_file(run_db_path)
+                record_cucu_run()
+
+    def uri(self, uri):
+        # nothing to do, but we need to implement the method for behave
+        pass
+
+    def feature(self, feature):
+        """Called before a feature is executed."""
+        self.this_feature = feature
+        self.this_scenario = None
+        self.this_background = None
+        self.next_start_at = None
+
+        feature_run_id_seed = (
+            f"{CONFIG['WORKER_RUN_ID']}_{time.perf_counter()}"
+        )
+        feature.feature_run_id = generate_short_id(feature_run_id_seed)
+        feature.custom_data = {}
+
+        record_feature(feature)
+
+    def background(self, background):
+        # nothing to do, but we need to implement the method for behave
+        pass
+
+    def _finish_scenario(self):
+        if self.this_scenario is None:
+            return
+
+        # ensure non-executed steps have correct seq
+        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_scenario_record(self.this_scenario)
+
+    def scenario(self, scenario):
+        """Called before a scenario is executed (or ScenarioOutline scenarios)."""
+        self._finish_scenario()
+
+        self.this_scenario = scenario
+        self.this_steps = []
+        self.next_start_at = datetime.datetime.now().isoformat()[:-3]
+        scenario_run_id_seed = (
+            f"{scenario.feature.feature_run_id}_{time.perf_counter()}"
+        )
+        scenario.scenario_run_id = generate_short_id(scenario_run_id_seed)
+        scenario.custom_data = {}
+
+        # feature.scenarios is a mix of Scenario and ScenarioOutline objects with their own scenarios list
+        for index, feature_scenario in enumerate(scenario.feature.scenarios):
+            if feature_scenario == scenario:
+                scenario.seq = index + 1
+                break
+
+            # Scenarios belonging to a Scenario Outline are included under their Scenario Outline sequence.
+            # Add a suffix to preserve ordering within the Scenario Outline.
+            if isinstance(feature_scenario, ScenarioOutline):
+                for sub_index, sub_scenario in enumerate(
+                    feature_scenario._scenarios
+                ):
+                    if sub_scenario == scenario:
+                        scenario.seq = index + 1 + (sub_index + 1) / 10
+                        break
+
+        record_scenario(scenario)
+
+    def step(self, step):
+        """Called before a step is executed (and matched)."""
+        self.insert_step(step, index=-1)
+
+    def insert_step(self, step, index):
+        """cucu specific step insertion method used to add steps here and dynamically"""
+        next_index = index if index != -1 else len(self.this_steps)
+        step_run_id_seed = f"{self.this_scenario.scenario_run_id}_{next_index}_{time.perf_counter()}"
+        step.step_run_id = generate_short_id(
+            step_run_id_seed, length=10
+        )  # up to 10 characters to give two orders of magnitude less chance of collision
+        self.this_steps.insert(next_index, step)
+        start_step_record(step, self.this_scenario.scenario_run_id)
+
+    def match(self, match):
+        # nothing to do, but we need to implement the method for behave
+        pass
+
+    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
+        ]
+        previous_step_duration = getattr(
+            self.this_scenario, "previous_step_duration", 0
+        )
+        if step.status.name in ("untested", "undefined"):
+            step.seq = self.this_steps.index(step) + 1
+
+        finish_step_record(step, previous_step_duration)
+
+    def eof(self):
+        """Called after processing a feature (or a feature file)."""
+        # need to finish the last scenario
+        self._finish_scenario()
+        finish_feature_record(self.this_feature)
+
+    def close(self):
+        """Called before the formatter is no longer used
+        (stream/io compatibility).
+        """
+        finish_worker_record(None)
+        finish_cucu_run_record()
+        close_db()

cucu/reporter/html.py

@@ -1,5 +1,4 @@
 import glob
-import json
 import os
 import shutil
 import sys
@@ -14,6 +13,10 @@ import jinja2
 from cucu import format_gherkin_table, logger
 from cucu.ansi_parser import parse_log_to_html
 from cucu.config import CONFIG
+from cucu.db import close_html_report_db, init_html_report_db
+from cucu.db import feature as FeatureModel
+from cucu.db import scenario as ScenarioModel
+from cucu.db import step as StepModel
 from cucu.utils import ellipsize_filename, get_step_image_dir
 
 
@@ -63,21 +66,101 @@ def generate(results, basepath, only_failures=False):
 
     features = []
 
-    run_json_filepaths = list(glob.iglob(os.path.join(results, "*run.json")))
-    logger.info(
-        f"Starting to process {len(run_json_filepaths)} files for report"
-    )
+    db_path = os.path.join(results, "run.db")
+    try:
+        init_html_report_db(db_path)
+        features = []
+
+        db_features = FeatureModel.select().order_by(FeatureModel.start_at)
+        logger.info(
+            f"Starting to process {len(db_features)} features for report"
+        )
+
+        for db_feature in db_features:
+            feature_dict = {
+                "name": db_feature.name,
+                "filename": db_feature.filename,
+                "description": db_feature.description,
+                "tags": db_feature.tags if db_feature.tags else [],
+                "status": db_feature.status,
+                "elements": [],
+            }
+
+            db_scenarios = (
+                ScenarioModel.select()
+                .where(
+                    ScenarioModel.feature_run_id == db_feature.feature_run_id
+                )
+                .order_by(ScenarioModel.seq)
+            )
 
-    for run_json_filepath in run_json_filepaths:
-        with open(run_json_filepath, "rb") as index_input:
-            try:
-                features += json.loads(index_input.read())
-            except Exception as exception:
-                logger.warning(
-                    f"unable to read file {run_json_filepath}, got error: {exception}"
+            feature_has_failures = False
+
+            if len(db_scenarios) == 0:
+                logger.debug(f"Feature {db_feature.name} has no scenarios")
+                continue
+
+            for db_scenario in db_scenarios:
+                scenario_dict = {
+                    "name": db_scenario.name,
+                    "line": db_scenario.line_number,
+                    "tags": db_scenario.tags if db_scenario.tags else [],
+                    "status": db_scenario.status or "passed",
+                    "steps": [],
+                }
+
+                if db_scenario.status == "failed":
+                    feature_has_failures = True
+
+                db_steps = (
+                    StepModel.select()
+                    .where(
+                        StepModel.scenario_run_id
+                        == db_scenario.scenario_run_id
+                    )
+                    .order_by(StepModel.seq)
                 )
 
-    # copy the external dependencies to the reports destination directory
+                for db_step in db_steps:
+                    step_dict = {
+                        "keyword": db_step.keyword,
+                        "name": db_step.name,
+                        "result": {
+                            "status": db_step.status or "passed",
+                            "duration": db_step.duration or 0,
+                            "timestamp": db_step.end_at or "",
+                        },
+                        "substep": db_step.is_substep,
+                    }
+
+                    if db_step.text:
+                        step_dict["text"] = db_step.text
+
+                    if db_step.table_data:
+                        step_dict["table"] = db_step.table_data
+
+                    step_dict["result"]["error_message"] = [
+                        db_step.error_message
+                    ]
+
+                    step_dict["result"]["exception"] = db_step.exception
+
+                    step_dict["result"]["stdout"] = db_step.stdout
+                    step_dict["result"]["stderr"] = db_step.stderr
+                    scenario_dict["steps"].append(step_dict)
+
+                feature_dict["elements"].append(scenario_dict)
+
+            if feature_has_failures:
+                feature_dict["status"] = "failed"
+            elif only_failures and not feature_has_failures:
+                continue
+
+            features.append(feature_dict)
+
+    finally:
+        close_html_report_db()
+
     cucu_dir = os.path.dirname(sys.modules["cucu"].__file__)
     external_dir = os.path.join(cucu_dir, "reporter", "external")
     shutil.copytree(external_dir, os.path.join(basepath, "external"))
@@ -223,18 +306,24 @@ def generate(results, basepath, only_failures=False):
 
                 if "result" in step:
                     if step["result"]["status"] in ["failed", "passed"]:
-                        timestamp = datetime.fromisoformat(
-                            step["result"]["timestamp"]
-                        )
-                        step["result"]["timestamp"] = timestamp
-
-                        if scenario_started_at is None:
-                            scenario_started_at = timestamp
-                            scenario["started_at"] = timestamp
-                        time_offset = datetime.utcfromtimestamp(
-                            (timestamp - scenario_started_at).total_seconds()
-                        )
-                        step["result"]["time_offset"] = time_offset
+                        if step["result"]["timestamp"]:
+                            timestamp = datetime.fromisoformat(
+                                step["result"]["timestamp"]
+                            )
+                            step["result"]["timestamp"] = timestamp
+
+                            if scenario_started_at is None:
+                                scenario_started_at = timestamp
+                                scenario["started_at"] = timestamp
+                            time_offset = datetime.utcfromtimestamp(
+                                (
+                                    timestamp - scenario_started_at
+                                ).total_seconds()
+                            )
+                            step["result"]["time_offset"] = time_offset
+                        else:
+                            step["result"]["timestamp"] = ""
+                            step["result"]["time_offset"] = ""
 
                     scenario_duration += step["result"]["duration"]
 

cucu/reporter/templates/index.html

@@ -19,13 +19,13 @@
             <tr class="align-text-top">
                 <th class="text-center">Started at</th>
                 <th>Feature</th>
-                <th class="text-center">Total<br/>{{ grand_totals['total_scenarios'] }}</th>
-                <th class="text-center">Passed<br/>{{ grand_totals['total_scenarios_passed'] }}</th>
-                <th class="text-center">Failed<br/>{{ grand_totals['total_scenarios_failed'] }}</th>
-                <th class="text-center">Skipped<br/>{{ grand_totals['total_scenarios_skipped'] }}</th>
-                <th class="text-center">Errored<br/>{{ grand_totals['total_scenarios_errored'] }}</th>
+                <th class="text-center">Total<br/>{{ grand_totals['total_scenarios'] | int }}</th>
+                <th class="text-center">Passed<br/>{{ grand_totals['total_scenarios_passed'] | int}}</th>
+                <th class="text-center">Failed<br/>{{ grand_totals['total_scenarios_failed'] | int }}</th>
+                <th class="text-center">Skipped<br/>{{ grand_totals['total_scenarios_skipped'] | int }}</th>
+                <th class="text-center">Errored<br/>{{ grand_totals['total_scenarios_errored'] | int }}</th>
                 <th class="text-center">Status<br/>&nbsp;</th>
-                <th class="text-center">Duration (s)<br/>{{ '{:.3f}'.format(grand_totals['duration']) }}s</th>
+                <th class="text-center">Duration (s)<br/>{{ grand_totals['duration'] | int }}s</th>
             </tr>
         </thead>
         {% for feature in features %}
@@ -38,7 +38,7 @@
             <td class="text-center">{{ feature['total_scenarios_skipped'] }}</td>
             <td class="text-center">{{ feature['total_scenarios_errored'] }}</td>
             <td class="text-center"><span class="status-{{ feature['status'] }}">{{ feature['status'] }}</span></td>
-            <td class="text-center">{{ feature['duration'] }}</td>
+            <td class="text-center">{{ '{:.1f}'.format(feature['duration'] | float ) }}</td>
         </tr>
         {% endfor %}
     </table>

cucu/reporter/templates/scenario.html

@@ -87,7 +87,7 @@
             {% endif %}
             {% if step['result'] is defined %}
                 {% set step_status = step['result']['status'] %}
-                {% if step['result']['status'] == 'failed' or step['result']['status'] == 'passed' %}
+                {% if step['result']['status'] in ('failed', 'passed') and step["result"]["timestamp"] %}
                     {% set step_timing = "{} for {:.3f}s".format(step["result"]["timestamp"].strftime("%H:%M:%S"), step["result"]["duration"]) %}
                     {% set step_start = step["result"]["timestamp"] %}
                 {% endif %}

cucu/steps/flow_control_steps.py

@@ -32,17 +32,17 @@ def expect_the_following_step_to_fail(ctx, message):
 
 @step('I should see the previous step took less than "{seconds}" seconds')
 def should_see_previous_step_took_less_than(ctx, seconds):
-    if ctx.previous_step_duration > float(seconds):
+    if ctx.scenario.previous_step_duration > float(seconds):
         raise RuntimeError(
-            f"previous step took {ctx.previous_step_duration}, which is more than {seconds}"
+            f"previous step took {ctx.scenario.previous_step_duration}, which is more than {seconds}"
         )
 
 
 @step('I should see the previous step took more than "{seconds}" seconds')
 def should_see_previous_step_took_more_than(ctx, seconds):
-    if ctx.previous_step_duration < float(seconds):
+    if ctx.scenario.previous_step_duration < float(seconds):
         raise RuntimeError(
-            f"previous step took {ctx.previous_step_duration}, which is less than {seconds}"
+            f"previous step took {ctx.scenario.previous_step_duration}, which is less than {seconds}"
         )
 
 

{cucu-1.3.5.dist-info → cucu-1.3.7.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: cucu
-Version: 1.3.5
+Version: 1.3.7
 Summary: Easy BDD web testing
 Keywords: cucumber,selenium,behave
-Author: Domino Data Lab, Rodney Gomes, Cedric Young, Xin Dong, Kavya, Kevin Garton, Joy Liao
-Author-email: Domino Data Lab <open-source@dominodatalab.com>, Rodney Gomes <107359+rlgomes@users.noreply.github.com>, Cedric Young <4129217+ccedricyoung@users.noreply.github.com>, Xin Dong <104880864+ddl-xin@users.noreply.github.com>, Kavya <91882851+ddl-kavya@users.noreply.github.com>, Kevin Garton <71028750+ddl-kgarton@users.noreply.github.com>, Joy Liao <107583686+ddl-joy-liao@users.noreply.github.com>
+Author: Domino Data Lab, Rodney Gomes, Cedric Young, Xin Dong, Kavya Yakkati, Kevin Garton, Joy Liao
+Author-email: Domino Data Lab <open-source@dominodatalab.com>, Rodney Gomes <107359+rlgomes@users.noreply.github.com>, Cedric Young <4129217+ccedricyoung@users.noreply.github.com>, Xin Dong <104880864+ddl-xin@users.noreply.github.com>, Kavya Yakkati <91882851+ddl-kavya@users.noreply.github.com>, Kevin Garton <71028750+ddl-kgarton@users.noreply.github.com>, Joy Liao <107583686+ddl-joy-liao@users.noreply.github.com>
 License: The Clear BSD License
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console

{cucu-1.3.5.dist-info → cucu-1.3.7.dist-info}/RECORD

@@ -7,21 +7,22 @@ cucu/browser/frames.py,sha256=IW7kzRJn5PkbMaovIelAeCWO-T-2sOTwqaYBw-0-LKU,3545
 cucu/browser/selenium.py,sha256=eUC2DZkhUIZi70sVTaNE_0AhanGTceyx_pCLIT7PN6o,13299
 cucu/browser/selenium_tweaks.py,sha256=oUIhWVhBZbc9qsmQUJMpIr9uUWKxtgZBcnySWU6Yttk,879
 cucu/cli/__init__.py,sha256=uXX5yVG1konJ_INdlrcfMg-Tt_5_cSx29Ed8R8v908A,62
-cucu/cli/core.py,sha256=pRKTQwwaT9Uv6DMXPRHspt970cfkkikRHqVi4ATS6fI,27244
-cucu/cli/run.py,sha256=pIymhrx3w-dCkvh-YqSH9HldCPEgMB0MxDNHgS-RvFY,5935
+cucu/cli/core.py,sha256=On0i9QzGoJ6ZFEYwt1Ae50i8YZFAAqeB__ULW8jcXc4,26950
+cucu/cli/run.py,sha256=XIGIACPieywM5Mi3k_CycM9eiRElzGNZdHlV0_TDSVY,6118
 cucu/cli/steps.py,sha256=lg5itVH_C-0_3RelWXv9X2qQUHggdxuxLCGwH5l1bf4,4210
 cucu/cli/thread_dumper.py,sha256=Z3XnYSxidx6pqjlQ7zu-TKMIYZWk4z9c5YLdPkcemiU,1593
 cucu/config.py,sha256=5AE6GrkqzjNhzzrB-eZrINgeztV7CCGuSdWJ-5GtWhk,14939
-cucu/db.py,sha256=hQg54M7LvCIO-5Pluw5CR0jvC_0MXxrUAyhctoLCGKU,11865
+cucu/db.py,sha256=iJ5NXECcqVbPdqozuQrdRGpCX1EgEENwDEGEsLUxpRs,14513
 cucu/edgedriver_autoinstaller/README.md,sha256=tDkAWIqgRdCjt-oX1nYqikIC_FfiOEM2-pc5S5VbRLo,84
 cucu/edgedriver_autoinstaller/__init__.py,sha256=fo6xJJPvcc5Xvni8epXfxDoPxJH5_b6Vk2jD9JTwfRs,969
 cucu/edgedriver_autoinstaller/utils.py,sha256=iRKTww77CGaTAntt_QDvxlKPxpMU4otx95OeD97khcM,6802
-cucu/environment.py,sha256=snMpafsBsBGRQwzf2MwfccQuZjDGkzUtnOicHyy6hQw,13714
+cucu/environment.py,sha256=eeUERL4nUaFLlEv-UftQ99SfSSs7-3oaFkFM7YPqET0,11728
 cucu/external/jquery/jquery-3.5.1.min.js,sha256=9_aliU8dGd2tb6OSsuzixeV4y_faTqgFtohetphbbj0,89476
 cucu/formatter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cucu/formatter/cucu.py,sha256=jHi6W9STRQjDy0j1P_HLLlBTPsS6EvUyvqeUjtWs3vM,9291
+cucu/formatter/cucu.py,sha256=NRLFsd6xl3uwUk45ihKN2OEioOeAqeTURrcQgscDGnU,9351
 cucu/formatter/json.py,sha256=fJ1dZBGwYD4OkhQFDE49MRKGNzsrhDzQYq-dUfsYh94,10589
 cucu/formatter/junit.py,sha256=aJ9dGLbamMH-wUi_msF66_-_c_YUq07-8_wCNEjUju4,10129
+cucu/formatter/rundb.py,sha256=7gKVPbSg7bCuAt972XRs5vRjeowLzVZPaOHCIxUazrE,7668
 cucu/fuzzy/__init__.py,sha256=ce4JRmaBF6oab6U99Qbpt7DrD3elhH32__-ND6fw5xc,104
 cucu/fuzzy/core.py,sha256=tmQKX_Ni-2ohoxzctRUg2x7zMeEW8MlJJmpU3PfTmvQ,3153
 cucu/fuzzy/fuzzy.js,sha256=ee-TytISLyUo7cMAkuVI5qbLXdt0eoFWczTsoU4zYhg,11618
@@ -55,12 +56,12 @@ cucu/reporter/external/jquery-3.5.1.min.js,sha256=9_aliU8dGd2tb6OSsuzixeV4y_faTq
 cucu/reporter/external/jquery.dataTables.min.js,sha256=XNhaB1tBOSFMHu96BSAJpZOJzfZ4SZI1nwAbnwry2UY,90265
 cucu/reporter/external/popper.min.js,sha256=pS96pU17yq-gVu4KBQJi38VpSuKN7otMrDQprzf_DWY,19188
 cucu/reporter/favicon.png,sha256=9ikXLAmzfQzy2NQps_8CGaZog2FvQrOX8nnSZ0e1UmM,2161
-cucu/reporter/html.py,sha256=jaaLFi5KU2RYHvqJyLZJ6APJ4MQn1Nz_sOK2q_mYz7U,15967
+cucu/reporter/html.py,sha256=2BAZMYbB-xMZdQXZeE8FgWJdWmScGY8JHWaQqiBP03I,19143
 cucu/reporter/templates/feature.html,sha256=IBkwGiul-sRO5lT8q8VFXMUJx1owsAd1YbdDzziSjKw,3645
 cucu/reporter/templates/flat.html,sha256=JGsMq-IWz6YUpJX9hcN65-15HxcX3NJclOmMDtW3HZE,2358
-cucu/reporter/templates/index.html,sha256=LFth3SS__9881NKvPIIFdnrQEIcDTXWvToSWKNtjyKI,2726
+cucu/reporter/templates/index.html,sha256=xgPYNU-sozN-iOaEzyymoQ4LDRI75eHXngbAP0xDYls,2770
 cucu/reporter/templates/layout.html,sha256=2iDRbm8atO8mgHWgijIvDCrBMKvcP6YHrmr95WtJiE4,4561
-cucu/reporter/templates/scenario.html,sha256=vTDBDTftFGodtNozfVt7Ol-fppTqPh1bW31_ENc1CWQ,10115
+cucu/reporter/templates/scenario.html,sha256=Vgl8A2O_hwG2W6JD5XtJi7xmTTWRe4XyqgfjfB1QmgM,10119
 cucu/steps/__init__.py,sha256=seSmASBlWu6-6wbFbvEbPwigBcRXiYP18C4X_2cW8Ng,753
 cucu/steps/base_steps.py,sha256=0fPvdaKoan8lMAKrDnK0-zrALpxm11P1zVAY5CN7iXA,1893
 cucu/steps/browser_steps.py,sha256=iTRl5ffpf2YrFk5qh655WFHAeSOwoE3HFhmXhjsZtao,12687
@@ -71,7 +72,7 @@ cucu/steps/draggable_steps.py,sha256=lnQLicp0GZJaxD_Qm2P13ruUZAsl3mptwaI5-SQ6XJ0
 cucu/steps/dropdown_steps.py,sha256=abykG--m79kDQ4LU1tm73fNLFPmrKDavyFzJb2MYCu0,15601
 cucu/steps/file_input_steps.py,sha256=LLMAozVpceLMD-kJOE-auKHAdWLbNprH8eCfVQuNoGg,5523
 cucu/steps/filesystem_steps.py,sha256=8l37A-yPxT4Mzdi1JNSTShZkwyFxgSwnh6C0V-hM_RA,4741
-cucu/steps/flow_control_steps.py,sha256=vlW0CsphVS9NvrOnpT8wSS2ngHmO3Z87H9siKIQwsAw,6365
+cucu/steps/flow_control_steps.py,sha256=UV-rWKOF1OqLaDKhMfSAqAm5TF81T5_j_e3eYGpE6QE,6401
 cucu/steps/image_steps.py,sha256=4X6bdumsIybcJBuao83TURxWAIshZyCvKi1uTJEoy1k,941
 cucu/steps/input_steps.py,sha256=TYQhkmke-W5dJt4EsU-JHjRwnbd7zvXnhEjw5PQ4Wxs,9679
 cucu/steps/link_steps.py,sha256=MQLxyjCbiF2dOsmj6IrKKlRYhaqJjxDUNTf5Cau4J0w,1625
@@ -87,7 +88,7 @@ cucu/steps/text_steps.py,sha256=Jj_GHoHeemNwVdUOdqcehArNp7WM-WMjljA4w0pLXuw,2576
 cucu/steps/variable_steps.py,sha256=WSctH3_xcxjijGPYZlxp-foC_SIAAKtF__saNtgZJbk,2966
 cucu/steps/webserver_steps.py,sha256=wWkpSvcSMdiskPkh4cqlepWx1nkvEpTU2tRXQmPDbyo,1410
 cucu/utils.py,sha256=LCcs8sMzvdvH05N8P5QYO4lO6j-_PQC530mEAD96go8,10957
-cucu-1.3.5.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
-cucu-1.3.5.dist-info/entry_points.txt,sha256=11WRIhQM7LuUnQg1lAoZQoNvvBvYNN1maDgQS4djwJo,40
-cucu-1.3.5.dist-info/METADATA,sha256=Z21XbbuwgJdBjh_x_anWZZTrPDKnqCGTw31VVkmuJBQ,16705
-cucu-1.3.5.dist-info/RECORD,,
+cucu-1.3.7.dist-info/WHEEL,sha256=-neZj6nU9KAMg2CnCY6T3w8J53nx1kFGw_9HfoSzM60,79
+cucu-1.3.7.dist-info/entry_points.txt,sha256=11WRIhQM7LuUnQg1lAoZQoNvvBvYNN1maDgQS4djwJo,40
+cucu-1.3.7.dist-info/METADATA,sha256=odrZlSjtaYwYeWjol9l24U6-UFjMCw3WbSQ_X5dgAEw,16721
+cucu-1.3.7.dist-info/RECORD,,

{cucu-1.3.5.dist-info → cucu-1.3.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.13
+Generator: uv 0.8.22
 Root-Is-Purelib: true
 Tag: py3-none-any