cucu 1.2.8__tar.gz → 1.3.1__tar.gz

{cucu-1.2.8 → cucu-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cucu
-Version: 1.2.8
+Version: 1.3.1
 Summary: Easy BDD web testing
 Keywords: cucumber,selenium,behave
 Author: Domino Data Lab, Rodney Gomes, Cedric Young, Xin Dong, Kavya, Kevin Garton, Joy Liao
@@ -25,6 +25,7 @@ Requires-Dist: jellyfish>=1.1
 Requires-Dist: jinja2~=3.1.3
 Requires-Dist: lsprotocol~=2023.0.1
 Requires-Dist: mpire~=2.10.2
+Requires-Dist: peewee>=3.18.2
 Requires-Dist: psutil>=6.0
 Requires-Dist: pygls~=1.3.1
 Requires-Dist: pyyaml~=6.0.1

{cucu-1.2.8 → cucu-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cucu"
-version = "1.2.8"
+version = "1.3.1"
 description = "Easy BDD web testing"
 readme = "README.md"
 license = { text = "The Clear BSD License" }
@@ -47,6 +47,7 @@ dependencies = [
     "jinja2~=3.1.3",
     "lsprotocol~=2023.0.1",
     "mpire~=2.10.2",
+    "peewee>=3.18.2",
     "psutil>=6.0",
     "pygls~=1.3.1",
     "pyyaml~=6.0.1",
@@ -84,6 +85,7 @@ dev-dependencies = [
     "pre-commit>=3.8.0",
     "pytest~=8.4.0",
     "pytest-check>=2.5.3",
+    "pytest-sugar>=1.0.0",
     "ruff>=0.6.4",
 ]
 

{cucu-1.2.8 → cucu-1.3.1}/src/cucu/cli/core.py

@@ -33,6 +33,7 @@ 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.lint import linter
 from cucu.utils import generate_short_id
 
@@ -240,6 +241,8 @@ def run(
 ):
     """
     run a set of feature files
+
+    Note: All the os.environ variables are set to be available in the child processes
     """
     init_global_hook_variables()
     dumper = None
@@ -299,7 +302,9 @@ def run(
         os.environ["CUCU_RECORD_ENV_VARS"] = "true"
 
     os.environ["CUCU_RUN_ID"] = CONFIG["CUCU_RUN_ID"] = generate_short_id()
-    CONFIG["WORKER_RUN_ID"] = "parent"
+    os.environ["WORKER_PARENT_ID"] = CONFIG["WORKER_RUN_ID"] = (
+        generate_short_id()
+    )
     if not dry_run:
         create_run(results, filepath)
 
@@ -492,6 +497,10 @@ def run(
         if dumper is not None:
             dumper.stop()
 
+        if not dry_run and os.path.exists(results):
+            finish_worker_record(worker_run_id=CONFIG.get("WORKER_PARENT_ID"))
+            consolidate_database_files(results)
+
         if generate_report:
             _generate_report(
                 results,
@@ -524,6 +533,9 @@ def _generate_report(
 
     os.makedirs(output)
 
+    if os.path.exists(results_dir):
+        consolidate_database_files(results_dir)
+
     report_location = reporter.generate(
         results_dir, output, only_failures=only_failures
     )

{cucu-1.2.8 → cucu-1.3.1}/src/cucu/cli/run.py

@@ -13,6 +13,7 @@ from cucu import (
 )
 from cucu.browser import selenium
 from cucu.config import CONFIG
+from cucu.db import create_database_file, record_cucu_run
 from cucu.page_checks import init_page_checks
 
 
@@ -204,3 +205,8 @@ def create_run(results, filepath):
     run_json_filepath.write_text(
         json.dumps(run_details, indent=2, sort_keys=True), encoding="utf8"
     )
+    CONFIG["RUN_DB_PATH"] = run_db_path = results_path / "run.db"
+    if not run_db_path.exists():
+        create_database_file(run_db_path)
+
+    record_cucu_run()

cucu-1.3.1/src/cucu/db.py

@@ -0,0 +1,370 @@
+"""
+Database creation and management utilities for cucu.
+"""
+
+import logging
+import sqlite3
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from peewee import (
+    BooleanField,
+    DateTimeField,
+    FloatField,
+    ForeignKeyField,
+    IntegerField,
+    Model,
+    TextField,
+)
+from playhouse.sqlite_ext import JSONField, SqliteExtDatabase
+
+from cucu.config import CONFIG
+
+db_filepath = CONFIG["RUN_DB_PATH"]
+db = SqliteExtDatabase(db_filepath)
+
+logger = logging.getLogger("peewee")
+logger.setLevel(logging.WARNING)  # Only show warnings and errors
+
+
+class BaseModel(Model):
+    class Meta:
+        database = db
+
+
+class cucu_run(BaseModel):
+    cucu_run_id = TextField(primary_key=True)
+    full_arguments = JSONField()
+    date = TextField()
+    start_at = DateTimeField()
+    end_at = DateTimeField(null=True)
+
+
+class worker(BaseModel):
+    worker_run_id = TextField(primary_key=True)
+    cucu_run_id = ForeignKeyField(
+        cucu_run,
+        field="cucu_run_id",
+        backref="workers",
+        column_name="cucu_run_id",
+        null=True,
+    )
+    parent_id = ForeignKeyField(
+        "self",
+        field="worker_run_id",
+        backref="child_workers",
+        column_name="parent_id",
+        null=True,
+    )
+    start_at = DateTimeField()
+    end_at = DateTimeField(null=True)
+    custom_data = JSONField(null=True)
+
+
+class feature(BaseModel):
+    feature_run_id = TextField(primary_key=True)
+    worker_run_id = ForeignKeyField(
+        worker,
+        field="worker_run_id",
+        backref="features",
+        column_name="worker_run_id",
+    )
+    name = TextField()
+    filename = TextField()
+    description = TextField()
+    tags = TextField()
+    start_at = DateTimeField()
+    end_at = DateTimeField(null=True)
+    custom_data = JSONField(null=True)
+
+
+class scenario(BaseModel):
+    scenario_run_id = TextField(primary_key=True)
+    feature_run_id = ForeignKeyField(
+        feature,
+        field="feature_run_id",
+        backref="scenarios",
+        column_name="feature_run_id",
+    )
+    name = TextField()
+    line_number = IntegerField()
+    seq = IntegerField()
+    tags = TextField()
+    status = TextField(null=True)
+    duration = FloatField(null=True)
+    start_at = DateTimeField()
+    end_at = DateTimeField(null=True)
+    log_files = JSONField(null=True)
+    cucu_config = JSONField(null=True)
+    browser_info = JSONField(null=True)
+    custom_data = JSONField(null=True)
+
+
+class step(BaseModel):
+    step_run_id = TextField(primary_key=True)
+    scenario_run_id = ForeignKeyField(
+        scenario,
+        field="scenario_run_id",
+        backref="steps",
+        column_name="scenario_run_id",
+    )
+    seq = IntegerField()
+    section_level = IntegerField(null=True)
+    parent_seq = IntegerField(null=True)
+    keyword = TextField()
+    name = TextField()
+    text = TextField(null=True)
+    table_data = JSONField(null=True)
+    location = TextField()
+    is_substep = BooleanField()
+    has_substeps = BooleanField()
+    status = TextField(null=True)
+    duration = FloatField(null=True)
+    start_at = DateTimeField()
+    end_at = DateTimeField(null=True)
+    debug_output = TextField(null=True)
+    browser_logs = TextField(null=True)
+    browser_info = JSONField(null=True)
+    screenshots = JSONField(null=True)
+
+
+def record_cucu_run():
+    cucu_run_id_val = CONFIG["CUCU_RUN_ID"]
+    worker_run_id = CONFIG["WORKER_RUN_ID"]
+
+    db.connect(reuse_if_open=True)
+    start_at = datetime.now().isoformat()
+    cucu_run.create(
+        cucu_run_id=cucu_run_id_val,
+        full_arguments=sys.argv,
+        date=start_at,
+        start_at=start_at,
+    )
+
+    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,
+        start_at=datetime.now().isoformat(),
+    )
+    db.close()
+    return str(db_filepath)
+
+
+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"],
+        name=feature_obj.name,
+        filename=feature_obj.filename,
+        description="\n".join(feature_obj.description)
+        if isinstance(feature_obj.description, list)
+        else str(feature_obj.description),
+        tags=" ".join(feature_obj.tags),
+        start_at=datetime.now().isoformat(),
+    )
+    db.close()
+
+
+def record_scenario(ctx):
+    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,
+    )
+    db.close()
+
+
+def start_step_record(ctx, step_obj):
+    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])
+    step.create(
+        step_run_id=step_obj.step_run_id,
+        scenario_run_id=ctx.scenario.scenario_run_id,
+        seq=step_obj.seq,
+        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,
+        location=str(step_obj.location),
+        is_substep=step_obj.is_substep,
+        has_substeps=step_obj.has_substeps,
+        section_level=getattr(step_obj, "section_level", None),
+        start_at=step_obj.start_at,
+    )
+    db.close()
+
+
+def finish_step_record(step_obj, duration):
+    db.connect(reuse_if_open=True)
+    screenshot_infos = []
+    if hasattr(step_obj, "screenshots") and step_obj.screenshots:
+        for screenshot in step_obj.screenshots:
+            screenshot_info = {
+                "step_name": screenshot.get("step_name"),
+                "label": screenshot.get("label"),
+                "location": screenshot.get("location"),
+                "size": screenshot.get("size"),
+                "filepath": screenshot.get("filepath"),
+            }
+            screenshot_infos.append(screenshot_info)
+
+    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,
+        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,
+        screenshots=screenshot_infos,
+    ).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()
+    scenario_logs_dir = CONFIG.get("SCENARIO_LOGS_DIR")
+    if not scenario_logs_dir or not Path(scenario_logs_dir).exists():
+        log_files_json = "[]"
+    else:
+        logs_path = Path(scenario_logs_dir)
+        log_files = [
+            str(file.relative_to(logs_path))
+            for file in logs_path.rglob("*")
+            if file.is_file()
+        ]
+        log_files_json = sorted(log_files)
+    custom_data_json = scenario_obj.custom_data
+    scenario.update(
+        status=scenario_obj.status.name,
+        duration=duration,
+        end_at=scenario_obj.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,
+    ).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(
+        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):
+    db.connect(reuse_if_open=True)
+    target_worker_run_id = worker_run_id or CONFIG["WORKER_RUN_ID"]
+    worker.update(
+        end_at=datetime.now().isoformat(),
+        custom_data=custom_data,
+    ).where(worker.worker_run_id == target_worker_run_id).execute()
+    db.close()
+
+
+def finish_cucu_run_record():
+    db.connect(reuse_if_open=True)
+    cucu_run.update(
+        end_at=datetime.now().isoformat(),
+    ).where(cucu_run.cucu_run_id == CONFIG["CUCU_RUN_ID"]).execute()
+    db.close()
+
+
+def create_database_file(db_filepath):
+    db.init(db_filepath)
+    db.connect(reuse_if_open=True)
+    db.create_tables([cucu_run, worker, feature, scenario, step])
+    db.execute_sql("""
+            CREATE VIEW IF NOT EXISTS flat AS
+            SELECT
+                w.cucu_run_id,
+                s.start_at,
+                s.duration,
+                f.name AS feature_name,
+                s.name AS scenario_name,
+                f.tags || ' ' || s.tags AS tags,
+                s.log_files
+            FROM scenario s
+            JOIN feature f ON s.feature_run_id = f.feature_run_id
+            JOIN worker w ON f.worker_run_id = w.worker_run_id
+        """)
+    db.execute_sql("""
+            CREATE VIEW IF NOT EXISTS flat_scenario AS
+            SELECT
+                s.scenario_run_id,
+                f.name AS feature_name,
+                s.name AS scenario_name,
+                f.tags || ' ' || s.tags AS tags,
+                f.filename || ':' || s.line_number AS feature_file_line,
+                s.status,
+                (
+                    SELECT json_group_array(json_object(
+                        'status', st.status,
+                        'duration', st.duration,
+                        'name', st.name
+                    ))
+                    FROM step st
+                    WHERE st.scenario_run_id = s.scenario_run_id
+                    ORDER BY st.seq
+                ) AS steps,
+                (
+                    SELECT st.debug_output
+                    FROM step st
+                    WHERE st.scenario_run_id = s.scenario_run_id
+                    ORDER BY st.seq DESC
+                    LIMIT 1
+                ) AS last_step_debug_log
+            FROM scenario s
+            JOIN feature f ON s.feature_run_id = f.feature_run_id
+        """)
+    db.close()
+
+
+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"
+    db_files = [
+        db for db in results_path.glob("**/*.db") if db.name != "run.db"
+    ]
+    tables_to_copy = ["cucu_run", "worker", "feature", "scenario", "step"]
+    with sqlite3.connect(target_db_path) as target_conn:
+        target_cursor = target_conn.cursor()
+        for db_file in db_files:
+            with sqlite3.connect(db_file) as source_conn:
+                source_cursor = source_conn.cursor()
+                for table_name in tables_to_copy:
+                    source_cursor.execute(f"SELECT * FROM {table_name}")
+                    rows = source_cursor.fetchall()
+                    source_cursor.execute(f"PRAGMA table_info({table_name})")
+                    columns = [col[1] for col in source_cursor.fetchall()]
+                    placeholders = ",".join(["?" for _ in columns])
+                    target_cursor.executemany(
+                        f"INSERT OR REPLACE INTO {table_name} VALUES ({placeholders})",
+                        rows,
+                    )
+                    target_conn.commit()
+            db_file.unlink()

{cucu-1.2.8 → cucu-1.3.1}/src/cucu/environment.py

@@ -9,6 +9,18 @@ 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,
@@ -47,7 +59,21 @@ def before_all(ctx):
     ctx.check_browser_initialized = partial(check_browser_initialized, ctx)
     ctx.worker_custom_data = {}
 
-    CONFIG["WORKER_RUN_ID"] = generate_short_id()
+    if CONFIG["WORKER_RUN_ID"] != CONFIG["WORKER_PARENT_ID"]:
+        logger.debug(
+            "Create a new worker db since this isn't the parent process"
+        )
+        CONFIG["WORKER_RUN_ID"] = generate_short_id()
+
+        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"
+        )
+        create_database_file(run_db_path)
+        record_cucu_run()
+
     CONFIG.snapshot("before_all")
 
     for hook in CONFIG["__CUCU_BEFORE_ALL_HOOKS"]:
@@ -59,12 +85,15 @@ 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.feature_run_id = generate_short_id()
     feature.custom_data = {}
+    record_feature(feature)
 
     if config.CONFIG["CUCU_RESULTS_DIR"] is not None:
         results_dir = Path(config.CONFIG["CUCU_RESULTS_DIR"])
@@ -72,7 +101,7 @@ def before_feature(ctx, feature):
 
 
 def after_feature(ctx, feature):
-    pass
+    finish_feature_record(feature)
 
 
 def before_scenario(ctx, scenario):
@@ -135,6 +164,7 @@ def before_scenario(ctx, scenario):
         ctx.browser_log_tee = TeeStream(ctx.browser_log_file)
 
     CONFIG["SCENARIO_RUN_ID"] = scenario.scenario_run_id = generate_short_id()
+    record_scenario(ctx)
 
     # run before all scenario hooks
     for hook in CONFIG["__CUCU_BEFORE_SCENARIO_HOOKS"]:
@@ -183,23 +213,33 @@ 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")
-    else:
-        if len(ctx.browsers) != 0:
-            logger.debug("quitting browser 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,
+        }
 
-        run_after_scenario_hook(ctx, scenario, download_browser_log)
+        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())
 
-    scenario.cucu_config_json = json.dumps(
-        yaml.safe_load(CONFIG.to_yaml_without_secrets())
+    scenario.cucu_config_json = yaml.safe_load(
+        CONFIG.to_yaml_without_secrets()
     )
 
     scenario.end_at = datetime.datetime.now().isoformat()[:-3]
+    finish_scenario_record(scenario)
 
 
 def download_mht_data(ctx):
@@ -217,7 +257,7 @@ def download_mht_data(ctx):
             browser.download_mht(mht_pathname)
 
 
-def download_browser_log(ctx):
+def cleanup_browsers(ctx):
     # close the browser unless someone has set the keep browser alive
     # environment variable which allows tests to reuse the same browser
     # session
@@ -251,6 +291,8 @@ 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)
@@ -341,3 +383,5 @@ def after_step(ctx, step):
         }
 
     step.browser_info = browser_info
+
+    finish_step_record(step, ctx.previous_step_duration)