cucu 1.3.12__tar.gz → 1.3.13__tar.gz

{cucu-1.3.12 → cucu-1.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cucu
-Version: 1.3.12
+Version: 1.3.13
 Summary: Easy BDD web testing
 Keywords: cucumber,selenium,behave
 Author: Domino Data Lab, Rodney Gomes, Cedric Young, Xin Dong, Kavya Yakkati, Kevin Garton, Joy Liao

{cucu-1.3.12 → cucu-1.3.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cucu"
-version = "1.3.12"
+version = "1.3.13"
 description = "Easy BDD web testing"
 readme = "README.md"
 license = { text = "The Clear BSD License" }

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/cli/core.py

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-import glob
 import json
 import os
 import shutil
@@ -54,7 +53,9 @@ def main():
 
 
 @main.command()
-@click.argument("filepath")
+@click.argument(
+    "filepath", default="features", type=click.Path(path_type=Path)
+)
 @click.option(
     "-b",
     "--browser",
@@ -110,6 +111,7 @@ def main():
     default=None,
     help="specify the output directory for JUnit XML files, default is "
     "the same location as --results",
+    type=click.Path(path_type=Path),
 )
 @click.option(
     "--junit-with-stacktrace",
@@ -150,6 +152,7 @@ def main():
     "--report",
     default="report",
     help="the location to put the test report when --generate-report is used",
+    type=click.Path(path_type=Path),
 )
 @click.option(
     "--report-only-failures",
@@ -162,6 +165,7 @@ def main():
     "--results",
     default="results",
     help="the results directory used by cucu",
+    type=click.Path(path_type=Path),
 )
 @click.option(
     "--runtime-timeout",
@@ -247,7 +251,7 @@ def run(
         # when cucu is already running it means that we're running inside
         # another cucu process and therefore we should make sure the results
         # directory isn't the default one and throw an exception otherwise
-        if results == "results":
+        if results == Path("results"):
             raise Exception(
                 "running within cucu but --results was not used, "
                 "this would lead to some very difficult to debug "
@@ -263,10 +267,10 @@ def run(
     logger.init_logging(logging_level.upper())
 
     if not preserve_results:
-        if os.path.exists(results):
+        if results.exists():
             shutil.rmtree(results)
 
-    os.makedirs(results, exist_ok=True)
+    results.mkdir(parents=True, exist_ok=True)
 
     if selenium_remote_url is not None:
         os.environ["CUCU_SELENIUM_REMOTE_URL"] = selenium_remote_url
@@ -302,12 +306,15 @@ def run(
         generate_short_id(worker_id_seed)
     )
 
-    os.environ["CUCU_FILEPATH"] = CONFIG["CUCU_FILEPATH"] = filepath
+    os.environ["CUCU_FILEPATH"] = CONFIG["CUCU_FILEPATH"] = str(filepath)
 
     create_run(results, filepath)
 
     try:
         if workers is None or workers == 1:
+            logger.debug(
+                f"Starting cucu_run {CONFIG['CUCU_RUN_ID']} with single worker"
+            )
             if runtime_timeout:
                 logger.debug("setting up runtime timeout timer")
 
@@ -347,9 +354,11 @@ def run(
                 raise ClickException("test run failed, see above for details")
 
         else:
-            if os.path.isdir(filepath):
-                basepath = os.path.join(filepath, "**/*.feature")
-                feature_filepaths = list(glob.iglob(basepath, recursive=True))
+            logger.debug(
+                f"Starting cucu_run {CONFIG['CUCU_RUN_ID']} with multiple workers: {workers}"
+            )
+            if filepath.is_dir():
+                feature_filepaths = list(filepath.rglob("*.feature"))
             else:
                 feature_filepaths = [filepath]
 
@@ -486,8 +495,10 @@ def run(
                 task_failed.update(async_results)
 
                 if task_failed:
-                    failing_features = "\n".join(task_failed.keys())
-                    logger.error(f"Failing Features:\n{failing_features}")
+                    failing_features = [str(x) for x in task_failed.keys()]
+                    logger.error(
+                        f"Failing Features:\n{'\n'.join(failing_features)}"
+                    )
                     raise RuntimeError(
                         "there are failures, see above for details"
                     )
@@ -495,60 +506,58 @@ def run(
         if dumper is not None:
             dumper.stop()
 
-        if os.path.exists(results):
+        if results.exists():
             finish_worker_record(worker_run_id=CONFIG.get("WORKER_PARENT_ID"))
             consolidate_database_files(results)
 
         if generate_report:
             _generate_report(
-                results,
-                report,
+                results_dir=results,
+                report_folder=report,
                 only_failures=report_only_failures,
-                junit=junit,
+                junit_folder=junit,
             )
 
 
 def _generate_report(
-    results_dir: str,
-    output: str,
+    results_dir: Path,
+    report_folder: Path,
     only_failures: False,
-    junit: str | None = None,
+    junit_folder: Path | None = None,
 ):
-    if os.path.exists(output):
-        shutil.rmtree(output)
+    if report_folder.exists():
+        shutil.rmtree(report_folder)
 
-    os.makedirs(output)
+    report_folder.mkdir(parents=True, exist_ok=True)
 
-    if os.path.exists(results_dir):
+    if results_dir.exists():
         consolidate_database_files(results_dir)
 
     report_location = reporter.generate(
-        results_dir, output, only_failures=only_failures
+        results_dir, report_folder, only_failures=only_failures
     )
     print(f"HTML test report at {report_location}")
 
-    if junit:
-        _add_report_path_in_junit(junit, output)
-
-
-def _add_report_path_in_junit(junit_folder, report_folder):
-    for junit_file in glob.glob(f"{junit_folder}/*.xml", recursive=True):
-        junit = ET.parse(junit_file)
-        test_suite = junit.getroot()
-        ts_folder = test_suite.get("foldername")
-        for test_case in test_suite.iter("testcase"):
-            report_path = os.path.join(
-                report_folder,
-                ts_folder,
-                test_case.get("foldername"),
-                "index.html",
-            )
-            test_case.set("report_path", report_path)
-        junit.write(junit_file, encoding="utf-8", xml_declaration=False)
+    if junit_folder:
+        for junit_file in junit_folder.rglob("*.xml"):
+            junit = ET.parse(junit_file)
+            test_suite = junit.getroot()
+            ts_folder = test_suite.get("foldername")
+            for test_case in test_suite.iter("testcase"):
+                report_path = os.path.join(
+                    report_folder,
+                    ts_folder,
+                    test_case.get("foldername"),
+                    "index.html",
+                )
+                test_case.set("report_path", report_path)
+            junit.write(junit_file, encoding="utf-8", xml_declaration=False)
 
 
 @main.command()
-@click.argument("results_dir", default="results")
+@click.argument(
+    "results_dir", default="results", type=click.Path(path_type=Path)
+)
 @click.option(
     "--only-failures",
     default=False,
@@ -567,21 +576,27 @@ def _add_report_path_in_junit(junit_folder, report_folder):
     is_flag=True,
     help="when set skips are shown",
 )
-@click.option("-o", "--output", default="report")
+@click.option(
+    "-o",
+    "--output",
+    default="report",
+    type=click.Path(path_type=Path),
+)
 @click.option(
     "-j",
     "--junit",
     default=None,
     help="specify the output directory for JUnit XML files, default is "
     "the same location as --results",
+    type=click.Path(path_type=Path),
 )
 def report(
-    results_dir,
+    results_dir: Path,
     only_failures,
     logging_level,
     show_skips,
-    output,
-    junit,
+    output: Path,
+    junit: Path,
 ):
     """
     generate a test report from a results directory
@@ -594,7 +609,7 @@ def report(
     if show_skips:
         os.environ["CUCU_SHOW_SKIPS"] = "true"
 
-    run_details_filepath = os.path.join(results_dir, "run_details.json")
+    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
@@ -608,12 +623,17 @@ def report(
         behave_init(run_details["filepath"])
 
     _generate_report(
-        results_dir, output, only_failures=only_failures, junit=junit
+        results_dir=results_dir,
+        report_folder=output,
+        only_failures=only_failures,
+        junit_folder=junit,
     )
 
 
 @main.command()
-@click.argument("filepath", default="features")
+@click.argument(
+    "filepath", default="features", type=click.Path(path_type=Path)
+)
 @click.option(
     "-f",
     "--format",
@@ -639,7 +659,7 @@ def steps(filepath, format):
 
 
 @main.command()
-@click.argument("filepath", nargs=-1)
+@click.argument("filepath", type=click.Path(path_type=Path), nargs=-1)
 @click.option(
     "--fix/--no-fix", default=False, help="fix lint violations, default: False"
 )
@@ -741,7 +761,9 @@ def lsp(logging_level, port):
 
 
 @main.command()
-@click.argument("filepath", default="features")
+@click.argument(
+    "filepath", default="features", type=click.Path(path_type=Path)
+)
 def vars(filepath):
     """
     print built-in cucu variables
@@ -766,14 +788,14 @@ def vars(filepath):
 
 
 @main.command()
-@click.argument("filepath", default="")
+@click.argument("repo_dir", default="", type=click.Path(path_type=Path))
 @click.option(
     "-l",
     "--logging-level",
     default="INFO",
     help="set logging level to one of debug, warn or info (default)",
 )
-def init(filepath, logging_level):
+def init(repo_dir, logging_level):
     """
     initialize cucu in the current directory
 
@@ -785,10 +807,9 @@ def init(filepath, logging_level):
     init_data_dir = Path(__file__).parent.parent / "init_data"
 
     logger.debug(f"cucu init: copy example directory from {init_data_dir=}")
-    repo_dir = filepath if filepath.strip() else os.path.join(os.getcwd())
 
-    features_dir = os.path.join(repo_dir, "features")
-    if os.path.exists(features_dir):
+    features_dir = repo_dir / "features"
+    if features_dir.exists():
         answer = input("Overwrite existing files? [y/N]:")
         if answer.lower() != "y":
             print("Aborted!")
@@ -874,9 +895,7 @@ def tags(filepath, logging_level):
     if not filepath.exists() or not feature_files:
         raise ClickException("No feature files found.")
 
-    file_locations = [
-        FileLocation(os.path.abspath(str(f))) for f in feature_files
-    ]
+    file_locations = [FileLocation(f.absolute()) for f in feature_files]
     features = parse_features(file_locations)
     tag_scenarios = Counter()
 

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/cli/run.py

@@ -85,8 +85,8 @@ def behave(
     if debug_on_failure:
         os.environ["CUCU_DEBUG_ON_FAILURE"] = "true"
 
-    os.environ["CUCU_RESULTS_DIR"] = results
-    os.environ["CUCU_JUNIT_DIR"] = junit
+    os.environ["CUCU_RESULTS_DIR"] = str(results)
+    os.environ["CUCU_JUNIT_DIR"] = str(junit)
 
     if secrets:
         os.environ["CUCU_SECRETS"] = secrets
@@ -123,7 +123,7 @@ def behave(
             "--no-logcapture",
             # generate a JSON file containing the exact details of the whole run
             "--format=cucu.formatter.json:CucuJSONFormatter",
-            f"--outfile={Path(results) / run_json_filename}",
+            f"--outfile={results / run_json_filename}",
             # console formatter
             "--format=cucu.formatter.cucu:CucuFormatter",
             f"--logging-level={os.environ['CUCU_LOGGING_LEVEL'].upper()}",
@@ -154,7 +154,7 @@ def behave(
         if redirect_output:
             feature_name = get_feature_name(filepath)
             log_filename = f"{feature_name}.log"
-            log_filepath = Path(results) / log_filename
+            log_filepath = results / log_filename
 
             CONFIG["__CUCU_PARENT_STDOUT"] = sys.stdout
 
@@ -185,8 +185,7 @@ def behave(
     return result
 
 
-def create_run(results, filepath):
-    results_path = Path(results)
+def create_run(results_path: Path, filepath: Path):
     run_json_filepath = results_path / "run_details.json"
 
     if run_json_filepath.exists():
@@ -200,7 +199,7 @@ def create_run(results, filepath):
 
     run_details = {
         "cucu_run_id": CONFIG["CUCU_RUN_ID"],
-        "filepath": filepath,
+        "filepath": str(filepath),
         "full_arguments": sys.argv,
         "env": env_values,
         "date": datetime.now().isoformat(),

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/cli/steps.py

@@ -131,7 +131,7 @@ def print_human_readable_steps(filepath=None):
 
     for step_name in steps:
         if steps[step_name] is not None:
-            if filepath in steps[step_name]["location"]["filepath"]:
+            if str(filepath) in steps[step_name]["location"]["filepath"]:
                 print(f"custom: {step_name}")
             else:
                 print(f"cucu:   {step_name}")

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/config.py

@@ -3,6 +3,7 @@ import logging
 import os
 import re
 import socket
+from pathlib import Path
 
 import yaml
 
@@ -100,7 +101,7 @@ class Config(dict):
                 else:
                     self[key] = config[key]
 
-    def load_cucurc_files(self, filepath):
+    def load_cucurc_files(self, filepath: Path):
         """
         load in order the ~/.cucurc.yml and then subsequent config files
         starting from the current working directory to the filepath provided

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/db.py

@@ -38,16 +38,16 @@ 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)
+    db_path = TextField(null=True)
+    run_info = JSONField(null=True)
 
 
 class worker(BaseModel):
     worker_run_id = TextField(primary_key=True)
-    cucu_run_id = ForeignKeyField(
+    cucu_run = ForeignKeyField(
         cucu_run,
-        field="cucu_run_id",
         backref="workers",
         column_name="cucu_run_id",
         null=True,
@@ -56,7 +56,7 @@ class worker(BaseModel):
         "self",
         field="worker_run_id",
         backref="child_workers",
-        column_name="parent_id",
+        column_name="parent_run_id",
         null=True,
     )
     start_at = DateTimeField()
@@ -66,9 +66,8 @@ class worker(BaseModel):
 
 class feature(BaseModel):
     feature_run_id = TextField(primary_key=True)
-    worker_run_id = ForeignKeyField(
+    worker = ForeignKeyField(
         worker,
-        field="worker_run_id",
         backref="features",
         column_name="worker_run_id",
     )
@@ -84,9 +83,8 @@ class feature(BaseModel):
 
 class scenario(BaseModel):
     scenario_run_id = TextField(primary_key=True)
-    feature_run_id = ForeignKeyField(
+    feature = ForeignKeyField(
         feature,
-        field="feature_run_id",
         backref="scenarios",
         column_name="feature_run_id",
     )
@@ -106,9 +104,8 @@ class scenario(BaseModel):
 
 class step(BaseModel):
     step_run_id = TextField(primary_key=True)
-    scenario_run_id = ForeignKeyField(
+    scenario = ForeignKeyField(
         scenario,
-        field="scenario_run_id",
         backref="steps",
         column_name="scenario_run_id",
     )
@@ -147,18 +144,21 @@ def record_cucu_run():
         cucu_run_id=cucu_run_id_val,
         full_arguments=sys.argv,
         filepath=filepath,
-        date=start_at,
         start_at=start_at,
     )
 
+    parent_id = (
+        CONFIG.get("WORKER_PARENT_ID")
+        if CONFIG.get("WORKER_PARENT_ID") != worker_run_id
+        else None
+    )
     worker.create(
         worker_run_id=worker_run_id,
         cucu_run_id=cucu_run_id_val,
-        parent_id=CONFIG.get("WORKER_PARENT_ID")
-        if CONFIG.get("WORKER_PARENT_ID") != worker_run_id
-        else None,
+        parent_id=parent_id,
         start_at=datetime.now().isoformat(),
     )
+
     return str(db_filepath)
 
 
@@ -166,7 +166,7 @@ def record_feature(feature_obj):
     db.connect(reuse_if_open=True)
     feature.create(
         feature_run_id=feature_obj.feature_run_id,
-        worker_run_id=CONFIG["WORKER_RUN_ID"],
+        worker=CONFIG["WORKER_RUN_ID"],
         name=feature_obj.name,
         filename=feature_obj.filename,
         description="\n".join(feature_obj.description)
@@ -419,7 +419,7 @@ def consolidate_database_files(results_dir):
         create_database_file(target_db_path)
 
     db_files = [
-        db for db in results_path.glob("**/*.db") if db.name != "run.db"
+        db for db in results_path.glob("**/run*.db") if db.name != "run.db"
     ]
     tables_to_copy = ["cucu_run", "worker", "feature", "scenario", "step"]
     with sqlite3.connect(target_db_path) as target_conn:
@@ -432,13 +432,28 @@ def consolidate_database_files(results_dir):
                     rows = source_cursor.fetchall()
                     source_cursor.execute(f"PRAGMA table_info({table_name})")
                     columns = [col[1] for col in source_cursor.fetchall()]
+
+                    # prep cucu_run for combining multiple runs
+                    if table_name == "cucu_run":
+                        db_path_index = columns.index("db_path")
+                        rows = [
+                            tuple(
+                                item if idx != db_path_index else str(db_file)
+                                for idx, item in enumerate(row)
+                            )
+                            for row in rows
+                        ]
+
                     placeholders = ",".join(["?" for _ in columns])
                     target_cursor.executemany(
                         f"INSERT OR REPLACE INTO {table_name} VALUES ({placeholders})",
                         rows,
                     )
                     target_conn.commit()
-            db_file.unlink()
+
+            if db_file.name != "run.db":
+                # remove the worker db files
+                db_file.unlink()
 
 
 def init_html_report_db(db_path):

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/fuzzy/core.py

@@ -107,9 +107,9 @@ def find(
 
     fuzzy_return = search_in_all_frames(browser, execute_fuzzy_find)
     if fuzzy_return is None:
-        logger.info("Fuzzy found no element.")
+        logger.debug("Fuzzy found no element.")
         return None
-    logger.info(
+    logger.debug(
         "Fuzzy found element by search term {}".format(fuzzy_return[1])
     )
     return fuzzy_return[0]

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/reporter/html.py

@@ -10,13 +10,10 @@ from xml.sax.saxutils import escape as escape_
 
 import jinja2
 
+import cucu.db as db
 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
 
 
@@ -68,15 +65,19 @@ def generate(results, basepath, only_failures=False):
 
     db_path = os.path.join(results, "run.db")
     try:
-        init_html_report_db(db_path)
+        db.init_html_report_db(db_path)
         features = []
 
-        db_features = FeatureModel.select().order_by(FeatureModel.start_at)
+        db_features = db.feature.select().order_by(db.feature.start_at)
         logger.info(
             f"Starting to process {len(db_features)} features for report"
         )
 
         for db_feature in db_features:
+            feature_results_dir = results
+            if db_path := db_feature.worker.cucu_run.db_path:
+                feature_results_dir = os.path.dirname(db_path)
+
             feature_dict = {
                 "name": db_feature.name,
                 "filename": db_feature.filename,
@@ -84,14 +85,13 @@ def generate(results, basepath, only_failures=False):
                 "tags": db_feature.tags if db_feature.tags else [],
                 "status": db_feature.status,
                 "elements": [],
+                "results_dir": feature_results_dir,
             }
 
             db_scenarios = (
-                ScenarioModel.select()
-                .where(
-                    ScenarioModel.feature_run_id == db_feature.feature_run_id
-                )
-                .order_by(ScenarioModel.seq)
+                db.scenario.select()
+                .where(db.scenario.feature_run_id == db_feature.feature_run_id)
+                .order_by(db.scenario.seq)
             )
 
             feature_has_failures = False
@@ -113,12 +113,11 @@ def generate(results, basepath, only_failures=False):
                     feature_has_failures = True
 
                 db_steps = (
-                    StepModel.select()
+                    db.step.select()
                     .where(
-                        StepModel.scenario_run_id
-                        == db_scenario.scenario_run_id
+                        db.step.scenario_run_id == db_scenario.scenario_run_id
                     )
-                    .order_by(StepModel.seq)
+                    .order_by(db.step.seq)
                 )
 
                 for db_step in db_steps:
@@ -166,7 +165,7 @@ def generate(results, basepath, only_failures=False):
             features.append(feature_dict)
 
     finally:
-        close_html_report_db()
+        db.close_html_report_db()
 
     cucu_dir = os.path.dirname(sys.modules["cucu"].__file__)
     external_dir = os.path.join(cucu_dir, "reporter", "external")
@@ -208,14 +207,21 @@ def generate(results, basepath, only_failures=False):
         if feature["status"] not in ["skipped", "untested"]:
             # copy each feature directories contents over to the report directory
             src_feature_filepath = os.path.join(
-                results, feature["folder_name"]
+                feature["results_dir"], feature["folder_name"]
             )
             dst_feature_filepath = os.path.join(
                 basepath, feature["folder_name"]
             )
-            shutil.copytree(
-                src_feature_filepath, dst_feature_filepath, dirs_exist_ok=True
-            )
+            if os.path.exists(src_feature_filepath):
+                shutil.copytree(
+                    src_feature_filepath,
+                    dst_feature_filepath,
+                    dirs_exist_ok=True,
+                )
+            else:
+                logger.warning(
+                    f"Feature directory not found, skipping copy: {src_feature_filepath}"
+                )
 
         for scenario in scenarios:
             CONFIG.restore()
@@ -364,8 +370,8 @@ def generate(results, basepath, only_failures=False):
                 step_index += 1
             logs_dir = os.path.join(scenario_filepath, "logs")
 
+            log_files = []
             if os.path.exists(logs_dir):
-                log_files = []
                 for log_file in glob.iglob(os.path.join(logs_dir, "*.*")):
                     log_filepath = log_file.removeprefix(
                         f"{scenario_filepath}/"
@@ -434,9 +440,10 @@ def generate(results, basepath, only_failures=False):
         "total_scenarios_failed",
         "total_scenarios_skipped",
         "total_scenarios_errored",
+        "total_steps",
         "duration",
     ]
-    grand_totals = {}
+    grand_totals = {"total_features": len(reported_features)}
     for k in keys:
         grand_totals[k] = sum([float(x[k]) for x in reported_features])
 

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/reporter/templates/flat.html

@@ -18,11 +18,11 @@
         <thead>
             <tr class="align-text-top">
                 <th class="text-center">Started at</th>
-                <th>Feature</th>
-                <th>Scenario</th>
-                <th class="text-center">Total Steps</th>
+                <th>Features<br/>{{ grand_totals['total_features'] | int }}</th>
+                <th>Scenarios<br/>{{ grand_totals['total_scenarios'] | int }}</th>
+                <th class="text-center">Steps<br/>{{ grand_totals['total_steps'] | int }}</th>
                 <th class="text-center">Status</th>
-                <th class="text-center">Duration (s)</th>
+                <th class="text-center">Duration<br/>{{ grand_totals['duration'] | int }}s</th>
             </tr>
         </thead>
         {% for feature in features %}

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/reporter/templates/index.html

@@ -18,14 +18,14 @@
         <thead>
             <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'] | int }}</th>
+                <th>Features<br/>{{ grand_totals['total_features'] | int }}</th>
+                <th class="text-center">Scenarios<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/>{{ grand_totals['duration'] | int }}s</th>
+                <th class="text-center">Duration<br/>{{ grand_totals['duration'] | int }}s</th>
             </tr>
         </thead>
         {% for feature in features %}

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/reporter/templates/scenario.html

@@ -134,30 +134,44 @@
                 <tr class="row"><td style="min-width: 0;" class="col-12 collapse multi-collapse" id="collapsable-row-{{ loop.index }}" colspan="2">
 
                 {% if step['result']['stdout'] %}
-                    <p>stdout ({{ step['result']['stdout']|length }} lines)</p>
-                    <pre style="color: darkgray; margin: 0;">{{ escape("\n".join(step['result']['stdout'])) }}</pre>
+                <details open>
+                    <summary style="color: dimgray;">stdout ({{ step['result']['stdout']|length }} lines)</summary>
+                    <pre style="color: darkgray;">{{ escape("\n".join(step['result']['stdout'])) }}</pre>
+                </details>
                 {% endif %}
                 {% if step['result']['stderr'] %}
-                    <p>stderr ({{ step['result']['stderr']|length }} lines)</p>
-                    <pre style="color: darkgray; margin: 0;">{{ escape("\n".join(step['result']['stderr'])) }}</pre>
+                <details open>
+                    <summary style="color: dimgray;">stderr ({{ step['result']['stderr']|length }} lines)</summary>
+                    <pre style="color: darkgray;">{{ escape("\n".join(step['result']['stderr'])) }}</pre>
+                </details>
                 {% endif %}
                 {% if step['images'] %}
-                    <p>images ({{ step['images']|length }} images)</p>
-                    {% for image in step['images'] %}
-                        <img class="mx-auto d-block img-fluid shadow bg-white rounded" style="margin-bottom:15px" alt='{{ image["label"] }}' title='{{ image["label"] }}' src='{{ image["src"] }}'></img>
-                    {% endfor %}
+                <details open>
+                    <summary style="color: dimgray;">images ({{ step['images']|length }} images)</summary>
+                    <div style="margin: 10px 0 0 0;">
+                        {% for image in step['images'] %}
+                            <img class="mx-auto d-block img-fluid shadow bg-white rounded" style="margin-bottom:15px" alt='{{ image["label"] }}' title='{{ image["label"] }}' src='{{ image["src"] }}'></img>
+                        {% endfor %}
+                    </div>
+                </details>
                 {% endif %}
                 {% if step['result']['error_message'] %}
-                    <p>error message ({{ step['result']['error_message']|length }} lines)</p>
-                    <pre style="color: gray; margin: 0">{{ escape("\n".join(step['result']['error_message'])) }}</pre>
+                <details open>
+                    <summary style="color: dimgray;">error message ({{ step['result']['error_message']|length }} lines)</summary>
+                    <pre style="color: darkgray;">{{ escape("\n".join(step['result']['error_message'])) }}</pre>
+                </details>
                 {% endif %}
                 {% if step['result']['browser_logs'] %}
-                    <p>browser logs ({{ step['result']['browser_logs']|length }} lines)</p>
-                    <pre style="color: gray; margin: 0;">{{ escape("\n".join(step['result']['browser_logs'])) }}</pre>
+                <details open>
+                    <summary style="color: dimgray;">browser logs ({{ step['result']['browser_logs']|length }} lines)</summary>
+                    <pre style="color: darkgray;">{{ escape("\n".join(step['result']['browser_logs'])) }}</pre>
+                </details>
                 {% endif %}
                 {% if step['result']['debug_output'] %}
-                    <p>debug output ({{ step['result']['debug_output']|length }} lines)</p>
-                    <pre style="color: gray; margin: 0;">{{ escape("\n".join(step['result']['debug_output'])) }}</pre>
+                <details open>
+                    <summary style="color: dimgray;">debug output ({{ step['result']['debug_output']|length }} lines)</summary>
+                    <pre style="color: darkgray;">{{ escape("\n".join(step['result']['debug_output'])) }}</pre>
+                </details>
                 {% endif %}
 
                 </td></tr>

{cucu-1.3.12 → cucu-1.3.13}/src/cucu/steps/table_steps.py

@@ -70,18 +70,15 @@ def check_table_matches_table(table, expected_table):
     check if table matches the regex patterns in expected table
     """
 
-    if len(table) == len(expected_table):
-        table_matched = True
-
+    table_matched = bool(len(table) == len(expected_table))
+    if table_matched:
         for expected_row, row in zip(expected_table, table):
             for expected_value, value in zip(expected_row, row):
                 if not re.match(expected_value, value):
                     table_matched = False
+                    break
 
-        if table_matched:
-            return True
-
-    return False
+    return table_matched
 
 
 def check_table_contains_table(table, expected_table):