cucu 1.2.3__tar.gz → 1.2.5__tar.gz

{cucu-1.2.3 → cucu-1.2.5}/PKG-INFO

@@ -1,23 +1,18 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: cucu
-Version: 1.2.3
+Version: 1.2.5
 Summary: Easy BDD web testing
-Project-URL: Homepage, https://github.com/dominodatalab/cucu/wiki
-Project-URL: Download, https://pypi.org/project/cucu/
-Project-URL: Source Code, https://github.com/dominodatalab/cucu
+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>
-Maintainer-email: Domino Data Lab <open-source@dominodatalab.com>, Cedric Young <4129217+ccedricyoung@users.noreply.github.com>, Kevin Garton <71028750+ddl-kgarton@users.noreply.github.com>, Brian Colby <92048365+ddl-bcolby@users.noreply.github.com>
 License: The Clear BSD License
-License-File: LICENSE
-Keywords: behave,cucumber,selenium
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
 Classifier: Topic :: Software Development :: Testing :: BDD
-Requires-Python: >=3.10
 Requires-Dist: beautifulsoup4~=4.13.3
 Requires-Dist: behave==1.2.6
 Requires-Dist: chromedriver-autoinstaller~=0.6.2
@@ -33,10 +28,16 @@ Requires-Dist: mpire~=2.10.2
 Requires-Dist: psutil>=6.0
 Requires-Dist: pygls~=1.3.1
 Requires-Dist: pyyaml~=6.0.1
-Requires-Dist: requests<3.0.0,>=2.31.0
+Requires-Dist: requests>=2.31.0,<3.0.0
 Requires-Dist: selenium~=4.31
 Requires-Dist: tabulate~=0.9.0
 Requires-Dist: tenacity>=9.0
+Maintainer: Domino Data Lab, Cedric Young, Kevin Garton, Brian Colby
+Maintainer-email: Domino Data Lab <open-source@dominodatalab.com>, Cedric Young <4129217+ccedricyoung@users.noreply.github.com>, Kevin Garton <71028750+ddl-kgarton@users.noreply.github.com>, Brian Colby <92048365+ddl-bcolby@users.noreply.github.com>
+Requires-Python: >=3.10
+Project-URL: Download, https://pypi.org/project/cucu/
+Project-URL: Homepage, https://github.com/dominodatalab/cucu/wiki
+Project-URL: Source Code, https://github.com/dominodatalab/cucu
 Description-Content-Type: text/markdown
 
 [![pypi](https://img.shields.io/pypi/v/cucu.svg)](https://pypi.org/project/cucu/)

{cucu-1.2.3 → cucu-1.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cucu"
-version = "1.2.3"
+version = "1.2.5"
 description = "Easy BDD web testing"
 readme = "README.md"
 license = { text = "The Clear BSD License" }
@@ -65,8 +65,8 @@ Download  = "https://pypi.org/project/cucu/"
 cucu = "cucu.cli:main"
 
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+requires = ["uv_build>=0.8.0,<0.9.0"]
+build-backend = "uv_build"
 
 [tool.hatch.build.targets.sdist]
 include = [
@@ -83,6 +83,7 @@ exclude = [
 dev-dependencies = [
     "pre-commit>=3.8.0",
     "pytest~=8.4.0",
+    "pytest-check>=2.5.3",
     "ruff>=0.6.4",
 ]
 

{cucu-1.2.3 → cucu-1.2.5}/src/cucu/browser/selenium.py

@@ -258,18 +258,22 @@ class Selenium(Browser):
         }
 
     def get_all_tabs_info(self):
+        window_handles = self.driver.window_handles
+        current_window = self.driver.current_window_handle
         tabs_info = []
-        handles = self.driver.window_handles
-        for idx, handle in enumerate(handles):
+
+        for handle in window_handles:
             self.driver.switch_to.window(handle)
             tabs_info.append(
                 {
-                    "index": idx,
                     "title": self.driver.title,
                     "url": self.driver.current_url,
                 }
             )
 
+        # Switch back to the original window
+        self.driver.switch_to.window(current_window)
+
         return tabs_info
 
     def back(self):

{cucu-1.2.3 → cucu-1.2.5}/src/cucu/cli/core.py

@@ -30,10 +30,11 @@ from cucu import (
     reporter,
 )
 from cucu.cli import thread_dumper
-from cucu.cli.run import behave, behave_init, write_run_details
+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.lint import linter
+from cucu.utils import generate_short_id
 
 # will start coverage tracking once COVERAGE_PROCESS_START is set
 coverage.process_startup()
@@ -297,8 +298,12 @@ def run(
     if record_env_vars:
         os.environ["CUCU_RECORD_ENV_VARS"] = "true"
 
+    os.environ["CUCU_RUN_ID"] = CONFIG["CUCU_RUN_ID"] = generate_short_id()
+    CONFIG["WORKER_RUN_ID"] = "parent"
     if not dry_run:
-        write_run_details(results, filepath)
+        create_run(results, filepath)
+
+    CONFIG.snapshot("core_run")
 
     try:
         if workers is None or workers == 1:
@@ -486,6 +491,8 @@ def run(
                         "there are failures, see above for details"
                     )
     finally:
+        CONFIG.restore(with_pop=True)
+
         if dumper is not None:
             dumper.stop()
 
@@ -499,7 +506,10 @@ def run(
 
 
 def _generate_report(
-    filepath: str, output: str, only_failures: False, junit: str | None = None
+    results_dir: str,
+    output: str,
+    only_failures: False,
+    junit: str | None = None,
 ):
     """
     helper method to handle report generation so it can be used by the `cucu report`
@@ -508,7 +518,7 @@ def _generate_report(
 
 
     parameters:
-        filepath(string): the results directory containing the previous test run
+        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.
@@ -519,7 +529,7 @@ def _generate_report(
     os.makedirs(output)
 
     report_location = reporter.generate(
-        filepath, output, only_failures=only_failures
+        results_dir, output, only_failures=only_failures
     )
     print(f"HTML test report at {report_location}")
 

{cucu-1.2.3 → cucu-1.2.5}/src/cucu/cli/run.py

@@ -4,6 +4,7 @@ import os
 import socket
 import sys
 from datetime import datetime
+from pathlib import Path
 
 from cucu import (
     behave_tweaks,
@@ -16,13 +17,12 @@ from cucu.page_checks import init_page_checks
 
 
 def get_feature_name(file_path):
-    with open(file_path, "r") as file:
-        text = file.read()
-        lines = text.split("\n")
-        for line in lines:
-            if "Feature:" in line:
-                feature_name = line.replace("Feature:", "").strip()
-                return feature_name
+    text = Path(file_path).read_text(encoding="utf8")
+    lines = text.split("\n")
+    for line in lines:
+        if "Feature:" in line:
+            feature_name = line.replace("Feature:", "").strip()
+            return feature_name
 
 
 def behave_init(filepath="features"):
@@ -104,7 +104,7 @@ def behave(
     run_json_filename = "run.json"
     if redirect_output:
         feature_name = get_feature_name(filepath)
-        run_json_filename = f"{feature_name + '-run.json'}"
+        run_json_filename = f"{feature_name}-run.json"
 
     if dry_run:
         args += [
@@ -120,7 +120,7 @@ def behave(
             "--no-logcapture",
             # generate a JSON file containing the exact details of the whole run
             "--format=cucu.formatter.json:CucuJSONFormatter",
-            f"--outfile={results}/{run_json_filename}",
+            f"--outfile={Path(results) / run_json_filename}",
             # console formatter
             "--format=cucu.formatter.cucu:CucuFormatter",
             f"--logging-level={os.environ['CUCU_LOGGING_LEVEL'].upper()}",
@@ -148,8 +148,8 @@ def behave(
     try:
         if redirect_output:
             feature_name = get_feature_name(filepath)
-            log_filename = f"{feature_name + '.log'}"
-            log_filepath = os.path.join(results, log_filename)
+            log_filename = f"{feature_name}.log"
+            log_filepath = Path(results) / log_filename
 
             CONFIG["__CUCU_PARENT_STDOUT"] = sys.stdout
 
@@ -161,7 +161,7 @@ def behave(
             # provide progress feedback on screen
             register_before_retry_hook(retry_progress)
 
-            with open(log_filepath, "w", encoding="utf8") as output:
+            with log_filepath.open("w", encoding="utf8") as output:
                 with contextlib.redirect_stderr(output):
                     with contextlib.redirect_stdout(output):
                         # intercept the stdout/stderr so we can do things such
@@ -180,28 +180,27 @@ def behave(
     return result
 
 
-def write_run_details(results, filepath):
-    """
-    writes a JSON file with run details to the results directory which can be
-    used to figure out any runtime details that would otherwise be lost and
-    difficult to figure out.
-    """
-    run_details_filepath = os.path.join(results, "run_details.json")
+def create_run(results, filepath):
+    results_path = Path(results)
+    run_json_filepath = results_path / "run_details.json"
 
-    if os.path.exists(run_details_filepath):
+    if run_json_filepath.exists():
         return
 
-    if CONFIG["CUCU_RECORD_ENV_VARS"]:
-        env_values = dict(os.environ)
-    else:
-        env_values = "To enable use the --record-env-vars flag"
+    env_values = (
+        dict(os.environ)
+        if CONFIG["CUCU_RECORD_ENV_VARS"]
+        else "To enable use the --record-env-vars flag"
+    )
 
     run_details = {
+        "cucu_run_id": CONFIG["CUCU_RUN_ID"],
         "filepath": filepath,
         "full_arguments": sys.argv,
         "env": env_values,
         "date": datetime.now().isoformat(),
     }
 
-    with open(run_details_filepath, "w", encoding="utf8") as output:
-        output.write(json.dumps(run_details, indent=2, sort_keys=True))
+    run_json_filepath.write_text(
+        json.dumps(run_details, indent=2, sort_keys=True), encoding="utf8"
+    )

{cucu-1.2.3 → cucu-1.2.5}/src/cucu/config.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 import re
 import socket
@@ -15,6 +16,7 @@ class Config(dict):
         self.resolving = False
         self.defined_variables = {}
         self.variable_lookups = {}
+        self.snapshots = []
 
     def define(self, name, description, default=None):
         """
@@ -255,19 +257,37 @@ class Config(dict):
 
         return string
 
-    def snapshot(self):
-        """
-        make a shallow copy of the current config values which can later be
-        restored using the `restore` method.
-        """
-        self.snapshot_data = self.copy()
+    def snapshot(self, name=None):
+        if name is None:
+            name = f"snapshot_{len(self.snapshots)}"
+
+        snapshot_data = {"name": name, "config": self.copy()}
+        self.snapshots.append(snapshot_data)
+
+        logging.debug(
+            f"CONFIG: snapshot taken '{name}' (stack depth: {len(self.snapshots)})"
+        )
+
+    def restore(self, with_pop=False):
+        if not self.snapshots:
+            return
+
+        if with_pop:
+            latest_snapshot = self.snapshots.pop()
+            action = "popped and restored"
+        else:
+            latest_snapshot = self.snapshots[-1]
+            action = "restored to"
 
-    def restore(self):
-        """
-        restore a previous `snapshot`
-        """
         self.clear()
-        self.update(**self.snapshot_data)
+        self.update(**latest_snapshot["config"])
+
+        logging.debug(
+            f"CONFIG: {action} snapshot '{latest_snapshot['name']}' (stack depth: {len(self.snapshots)})"
+        )
+
+    def list_snapshots(self):
+        return [snapshot["name"] for snapshot in self.snapshots]
 
     def register_custom_variable_handling(self, regex, lookup):
         """
@@ -313,7 +333,14 @@ class Config(dict):
                     v = f"'{v}'"
                 config[k] = v
 
-        return yaml.dump(config)
+        # Resolve non-atomic classes to their string representation
+        yaml.representer.SafeRepresenter.add_representer(
+            None,
+            lambda dumper, data: dumper.represent_scalar(
+                "tag:yaml.org,2002:str", str(data)
+            ),
+        )
+        return yaml.safe_dump(config)
 
 
 # global config object

{cucu-1.2.3 → cucu-1.2.5}/src/cucu/environment.py

@@ -1,22 +1,22 @@
-import datetime
-import hashlib
 import json
-import os
 import sys
-import time
 import traceback
+from datetime import datetime
 from functools import partial
+from pathlib import Path
+
+import yaml
 
 from cucu import config, init_scenario_hook_variables, logger
 from cucu.config import CONFIG
 from cucu.page_checks import init_page_checks
-from cucu.utils import ellipsize_filename, take_screenshot
-
-CONFIG.define(
-    "FEATURE_RESULTS_DIR",
-    "the results directory for the currently executing feature",
-    default=None,
+from cucu.utils import (
+    TeeStream,
+    ellipsize_filename,
+    generate_short_id,
+    take_screenshot,
 )
+
 CONFIG.define(
     "SCENARIO_RESULTS_DIR",
     "the results directory for the currently executing scenario",
@@ -44,8 +44,12 @@ def check_browser_initialized(ctx):
 
 def before_all(ctx):
     CONFIG["__CUCU_CTX"] = ctx
-    CONFIG.snapshot()
     ctx.check_browser_initialized = partial(check_browser_initialized, ctx)
+    ctx.worker_custom_data = {}
+
+    CONFIG["WORKER_RUN_ID"] = generate_short_id()
+    CONFIG.snapshot("before_all")
+
     for hook in CONFIG["__CUCU_BEFORE_ALL_HOOKS"]:
         hook(ctx)
 
@@ -55,14 +59,16 @@ def after_all(ctx):
     for hook in CONFIG["__CUCU_AFTER_ALL_HOOKS"]:
         hook(ctx)
 
+    CONFIG.restore(with_pop=True)
+
 
 def before_feature(ctx, feature):
+    feature.feature_run_id = generate_short_id()
+    feature.custom_data = {}
+
     if config.CONFIG["CUCU_RESULTS_DIR"] is not None:
-        results_dir = config.CONFIG["CUCU_RESULTS_DIR"]
-        ctx.feature_dir = os.path.join(
-            results_dir, ellipsize_filename(feature.name)
-        )
-        CONFIG["FEATURE_RESULTS_DIR"] = ctx.feature_dir
+        results_dir = Path(config.CONFIG["CUCU_RESULTS_DIR"])
+        ctx.feature_dir = results_dir / ellipsize_filename(feature.name)
 
 
 def after_feature(ctx, feature):
@@ -81,50 +87,54 @@ 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 = []
 
     # reset the step timer dictionary
     ctx.step_timers = {}
+    scenario.start_at = datetime.now().isoformat()[:-3]
 
     if config.CONFIG["CUCU_RESULTS_DIR"] is not None:
-        ctx.scenario_dir = os.path.join(
-            ctx.feature_dir, ellipsize_filename(scenario.name)
-        )
+        ctx.scenario_dir = ctx.feature_dir / ellipsize_filename(scenario.name)
         CONFIG["SCENARIO_RESULTS_DIR"] = ctx.scenario_dir
-        os.makedirs(ctx.scenario_dir, exist_ok=True)
+        ctx.scenario_dir.mkdir(parents=True, exist_ok=True)
 
-        ctx.scenario_downloads_dir = os.path.join(
-            ctx.scenario_dir, "downloads"
-        )
+        ctx.scenario_downloads_dir = ctx.scenario_dir / "downloads"
         CONFIG["SCENARIO_DOWNLOADS_DIR"] = ctx.scenario_downloads_dir
-        os.makedirs(ctx.scenario_downloads_dir, exist_ok=True)
+        ctx.scenario_downloads_dir.mkdir(parents=True, exist_ok=True)
 
-        ctx.scenario_logs_dir = os.path.join(ctx.scenario_dir, "logs")
+        ctx.scenario_logs_dir = ctx.scenario_dir / "logs"
         CONFIG["SCENARIO_LOGS_DIR"] = ctx.scenario_logs_dir
-        os.makedirs(ctx.scenario_logs_dir, exist_ok=True)
+        ctx.scenario_logs_dir.mkdir(parents=True, exist_ok=True)
 
-        cucu_debug_filepath = os.path.join(
-            ctx.scenario_logs_dir, "cucu.debug.console.log"
-        )
+        cucu_debug_log_path = ctx.scenario_logs_dir / "cucu.debug.console.log"
         ctx.scenario_debug_log_file = open(
-            cucu_debug_filepath, "w", encoding=sys.stdout.encoding
+            cucu_debug_log_path, "w", encoding=sys.stdout.encoding
         )
+        ctx.scenario_debug_log_tee = TeeStream(ctx.scenario_debug_log_file)
 
         # redirect stdout, stderr and setup a logger at debug level to fill
         # the scenario cucu.debug.log file which makes it possible to have
         # debug logging for every single scenario run without polluting the
         # console logs at runtime.
-        sys.stdout.set_other_stream(ctx.scenario_debug_log_file)
-        sys.stderr.set_other_stream(ctx.scenario_debug_log_file)
-        logger.init_debug_logger(ctx.scenario_debug_log_file)
+        sys.stdout.set_other_stream(ctx.scenario_debug_log_tee)
+        sys.stderr.set_other_stream(ctx.scenario_debug_log_tee)
+        logger.init_debug_logger(ctx.scenario_debug_log_tee)
+
+        # capture browser logs using TeeStream since each call clears the log
+        ctx.browser_log_file = open(
+            ctx.scenario_logs_dir / "browser_console.log.txt",
+            "w",
+            encoding="utf-8",
+        )
+        ctx.browser_log_tee = TeeStream(ctx.browser_log_file)
 
-    # internal cucu config variables
-    CONFIG["SCENARIO_RUN_ID"] = hashlib.sha256(
-        str(time.perf_counter()).encode("utf-8")
-    ).hexdigest()[:7]
+    CONFIG["SCENARIO_RUN_ID"] = scenario.scenario_run_id = generate_short_id()
 
     # run before all scenario hooks
     for hook in CONFIG["__CUCU_BEFORE_SCENARIO_HOOKS"]:
@@ -179,14 +189,18 @@ def after_scenario(ctx, scenario):
         if len(ctx.browsers) != 0:
             logger.debug("quitting browser between sessions")
 
-        run_after_scenario_hook(ctx, scenario, download_browser_logs)
+        run_after_scenario_hook(ctx, scenario, download_browser_log)
 
-    cucu_config_filepath = os.path.join(
-        ctx.scenario_logs_dir, "cucu.config.yaml.txt"
-    )
-    with open(cucu_config_filepath, "w") as config_file:
+    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())
 
+    scenario.cucu_config_json = json.dumps(
+        yaml.safe_load(CONFIG.to_yaml_without_secrets())
+    )
+
+    scenario.end_at = datetime.now().isoformat()[:-3]
+
 
 def download_mht_data(ctx):
     if not ctx.browsers:
@@ -198,45 +212,42 @@ def download_mht_data(ctx):
             mht_filename = (
                 f"browser{index if len(ctx.browsers) > 1 else ''}_snapshot.mht"
             )
-            mht_pathname = os.path.join(
-                CONFIG["SCENARIO_LOGS_DIR"],
-                mht_filename,
-            )
+            mht_pathname = CONFIG["SCENARIO_LOGS_DIR"] / mht_filename
             logger.debug(f"Saving MHT webpage snapshot: {mht_filename}")
             browser.download_mht(mht_pathname)
 
 
-def download_browser_logs(ctx):
+def download_browser_log(ctx):
     # close the browser unless someone has set the keep browser alive
     # environment variable which allows tests to reuse the same browser
     # session
 
     for browser in ctx.browsers:
-        # save the browser logs to the current scenarios results directory
-        browser_log_filepath = os.path.join(
-            ctx.scenario_logs_dir, "browser_console.log.txt"
-        )
-
-        os.makedirs(os.path.dirname(browser_log_filepath), exist_ok=True)
-        with open(browser_log_filepath, "w") as output:
-            for log in browser.get_log():
-                output.write(f"{json.dumps(log)}\n")
-
         browser.quit()
 
+    ctx.browser_log_file.close()
+
     ctx.browsers = []
 
 
 def before_step(ctx, step):
-    # trims the last 3 digits of the microseconds
-    step.start_timestamp = datetime.datetime.now().isoformat()[:-3]
+    step.step_run_id = generate_short_id()
+    step.start_at = datetime.now().isoformat()[:-3]
 
     sys.stdout.captured()
     sys.stderr.captured()
 
+    # Reset the debug log buffer for this step
+    if hasattr(ctx, "scenario_debug_log_tee"):
+        ctx.scenario_debug_log_tee.clear()
+
     ctx.current_step = step
     ctx.current_step.has_substeps = False
-    ctx.start_time = time.monotonic()
+    ctx.section_level = None
+    step.seq = ctx.step_index + 1
+    step.parent_seq = (
+        ctx.section_step_stack[-1].seq if ctx.section_step_stack else 0
+    )
 
     CONFIG["__STEP_SCREENSHOT_COUNT"] = 0
 
@@ -249,8 +260,18 @@ def after_step(ctx, step):
     step.stdout = sys.stdout.captured()
     step.stderr = sys.stderr.captured()
 
-    ctx.end_time = time.monotonic()
-    ctx.previous_step_duration = ctx.end_time - ctx.start_time
+    # 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()
+    else:
+        step.debug_output = ""
+
+    step.end_at = datetime.now().isoformat()[:-3]
+
+    # calculate duration from ISO timestamps
+    start_at = datetime.fromisoformat(step.start_at)
+    end_at = datetime.fromisoformat(step.end_at)
+    ctx.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
@@ -296,3 +317,26 @@ def after_step(ctx, step):
     # run after all step hooks
     for hook in CONFIG["__CUCU_AFTER_STEP_HOOKS"]:
         hook(ctx)
+
+    # Capture browser logs and info for this step
+    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)
+            ctx.browser_log_tee.write(f"{log_entry}\n")
+        step.browser_logs = "\n".join(browser_logs)
+
+        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,
+        }
+
+    step.browser_info = json.dumps(browser_info)

{cucu-1.2.3 → cucu-1.2.5}/src/cucu/formatter/cucu.py

@@ -185,7 +185,7 @@ class CucuFormatter(Formatter):
             max_line_length = self.calculate_max_line_length()
             status_text = ""
             if self.show_timings:
-                start = step.start_timestamp
+                start = step.start_at
                 duration = f"{step.duration:.3f}"
                 status_text += f" # started at {start} took {duration}s"
 

{cucu-1.2.3 → cucu-1.2.5}/src/cucu/formatter/json.py

@@ -157,7 +157,7 @@ class CucuJSONFormatter(Formatter):
 
         timestamp = None
         if step.status.name in ["passed", "failed"]:
-            timestamp = step.start_timestamp
+            timestamp = step.start_at
 
             step_variables = CONFIG.expand(step.name)
 

{cucu-1.2.3 → cucu-1.2.5}/src/cucu/reporter/templates/scenario.html

@@ -75,7 +75,7 @@
                 {% endif %}
             </td>
             <td style="text-align: right; margin-top: auto;" class="col-2">
-                <pre style="display: inline; color: gray;">Offset and Duration (s)</pre>
+                <pre style="display: inline; color: gray;">Start Time and Duration (s)</pre>
             </td>
         </tr>
         {% for step in steps %}
@@ -88,7 +88,7 @@
             {% if step['result'] is defined %}
                 {% set step_status = step['result']['status'] %}
                 {% if step['result']['status'] == 'failed' or step['result']['status'] == 'passed' %}
-                    {% set step_timing = "{} for {:.3f}s".format(step["result"]["time_offset"].strftime("%H:%M:%S"), step["result"]["duration"]) %}
+                    {% set step_timing = "{} for {:.3f}s".format(step["result"]["timestamp"].strftime("%H:%M:%S"), step["result"]["duration"]) %}
                     {% set step_start = step["result"]["timestamp"] %}
                 {% endif %}
             {% else %}