utils_devops 0.1.157__tar.gz → 0.1.158__tar.gz

{utils_devops-0.1.157 → utils_devops-0.1.158}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utils_devops
-Version: 0.1.157
+Version: 0.1.158
 Summary: Lightweight DevOps utilities for automation scripts: config editing (YAML/JSON/INI/.env), templating, diffing, and CLI tools
 License: MIT
 Keywords: devops,automation,nginx,cli,jinja2,yaml,config,diff,templating,logging,docker,compose,file-ops

{utils_devops-0.1.157 → utils_devops-0.1.158}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "utils_devops"
-version = "0.1.157"  # Bumped for new string features + diffing
+version = "0.1.158"  # Bumped for new string features + diffing
 description = "Lightweight DevOps utilities for automation scripts: config editing (YAML/JSON/INI/.env), templating, diffing, and CLI tools"
 authors = ["Hamed Sheikhan <sh.sheikhan.m@gmail.com>"]
 license = "MIT"

{utils_devops-0.1.157 → utils_devops-0.1.158}/src/utils_devops/extras/docker_ops.py

@@ -2200,6 +2200,233 @@ def push_compose(
         logger.error(f"💥 Push {push_id} failed: {e}")
         return result
 
+def playwright_test_compose(
+    compose_file: str,
+    playwright_compose_file: str,
+    # Environment configuration
+    env_file: str = '.env',
+    update_version: bool = False,
+    version_source: str = 'git',
+    # Services selection
+    services: Optional[List[str]] = None,
+    playwright_services: Optional[List[str]] = None,
+    # Health / timing
+    health_timeout: int = 500,
+    health_interval: int = 10,
+    # Logging
+    capture_logs: bool = True,
+    log_tail: int = 200,
+    # Compose startup options (delegated to test_compose)
+    pull_missing: bool = True,
+    no_build: bool = True,
+    no_pull: bool = True,
+    keep_up: bool = False,
+    # Keep services up after each test_compose call so we can sequence them
+    dry_run: bool = False,
+    project_name: Optional[str] = None,
+    logger: Optional[logger] = None,
+) -> Dict[str, Any]:
+    """
+    Specialized workflow to run a Playwright-driven integration test that depends on an
+    application compose and a separate Playwright compose. This function reuses the
+    existing `test_compose` function to perform validation, startup and health checks for
+    the application compose.
+
+    Behavior summary:
+    1. Validate inputs and (optionally) update version as in test_compose.
+    2. Set STATIC_CAPTCHA=true in the system process environment (without modifying the file).
+    3. Call test_compose(...) against `compose_file` with keep_compose_up=True
+       so the primary application stack is up and healthy.
+    4. Run compose_up on the Playwright compose file to start the test runner.
+    5. Follow logs (simulating -f) for the Playwright service(s) while polling the compose state
+       to detect completion, and determine pass/fail from exit status and log patterns.
+    6. Return a detailed result dict similar in structure to test_compose.
+
+    Notes:
+    - Reuses `test_compose` for application startup and health checks.
+    - Sets STATIC_CAPTCHA in the process environment only (os.environ).
+    - Does not automatically bring services down; that is left to the caller.
+    - Success is determined by all containers exiting with code 0 and/or presence of success patterns in logs.
+
+    Returns:
+        Dict with keys: test_id, success, steps, app_result, logs_captured, duration, error
+    """
+    logger = logger or DEFAULT_LOGGER
+    test_id = str(uuid.uuid4())[:8]
+    start_time = dt_ops.current_datetime()
+    result = {
+        "test_id": test_id,
+        "success": False,
+        "steps": {},
+        "app_result": None,
+        "logs_captured": {},
+        "duration": 0.0,
+        "error": None,
+    }
+    try:
+        logger.info(f"▶️ Playwright test workflow starting ({test_id})")
+        logger.info(f" Compose files: app={compose_file} playwright={playwright_compose_file}")
+        # Step 0: Basic validation
+        logger.info("Step 0: validating compose and env files")
+        if not files.file_exists(compose_file):
+            raise DockerOpsError(f"Application compose file not found: {compose_file}")
+        if not files.file_exists(playwright_compose_file):
+            raise DockerOpsError(f"Playwright compose file not found: {playwright_compose_file}")
+        # Step 1: Optional version update
+        if update_version and not dry_run:
+            logger.info("Step 1: updating version in env (requested)")
+            new_version = _update_env_version(env_file=env_file, source=version_source, logger=logger)
+            if new_version:
+                logger.info(f" Version updated to {new_version}")
+                # make sure runtime env sees new values
+                envs.import_env_to_system(get_env_compose(env_file))
+        elif update_version and dry_run:
+            logger.info("Step 1: version update skipped (dry run)")
+        else:
+            logger.info("Step 1: version update not requested")
+        # Step 2: Set STATIC_CAPTCHA=true in system process env
+        logger.info("Step 2: setting STATIC_CAPTCHA=true in process environment")
+        if not dry_run:
+            envs.set_system_env(key='STATIC_CAPTCHA', value='true')
+        else:
+            logger.info("Step 2: env set skipped (dry run)")
+        # Step 3: Start application compose using test_compose but keep services up
+        logger.info("Step 3: bringing up application stack (health checks via test_compose)")
+        if not dry_run:
+            app_result = test_compose(
+                compose_file=compose_file,
+                env_file=env_file,
+                update_version=False,  # already handled
+                services=services,
+                health_timeout=health_timeout,
+                health_interval=health_interval,
+                capture_logs=capture_logs,
+                log_tail=log_tail,
+                pull_missing=pull_missing,
+                no_build=no_build,
+                no_pull=no_pull,
+                keep_compose_up=True,  # DO NOT tear down
+                project_name=project_name,
+                dry_run=dry_run,
+                logger=logger,
+            )
+            result['app_result'] = app_result
+            if not app_result.get('success'):
+                raise DockerOpsError("Application compose failed to start or pass health checks")
+            logger.info(" Application stack is up and healthy")
+        else:
+            logger.info("Step 3: application start skipped (dry run)")
+        # Step 4: Start Playwright compose using compose_up
+        logger.info("Step 4: bringing up Playwright runner stack with compose_up")
+        if not dry_run:
+            up_success = compose_up(
+                playwright_compose_file,
+                services=playwright_services,
+                project_name=project_name,
+                # Assume detached by default or add param if needed; help shows no param for detached, perhaps always detached
+            )
+            if not up_success:
+                raise DockerOpsError("Playwright compose_up failed")
+            logger.info(" Playwright stack started - now following logs until completion")
+        else:
+            logger.info("Step 4: playwright start skipped (dry run)")
+        # Step 5: Follow logs and wait for completion (simulate logs -f with polling)
+        if not dry_run and capture_logs:
+            logger.info("Step 5: following Playwright logs and waiting for completion")
+            pw_services = playwright_services or list(read_compose_file(playwright_compose_file, env_file).get('services', {}).keys())
+            logs_acc = {s: [] for s in pw_services}
+            deadline = time.time() + health_timeout
+            finished = False
+            timed_out = False
+            while not finished and not timed_out:
+                # Fetch current log snapshot
+                for svc in pw_services:
+                    try:
+                        lines = [l.text for l in compose_logs(playwright_compose_file, services=[svc], tail=log_tail)]
+                    except Exception as e:
+                        lines = [f"Error fetching logs: {str(e)}"]
+                    # Append new unique lines
+                    for ln in lines:
+                        if ln not in logs_acc[svc]:
+                            logs_acc[svc].append(ln)
+                            logger.info(f"[{svc}] {ln}")  # Simulate real-time logging
+                # Check if all services have exited
+                ps = compose_ps(playwright_compose_file, project_name=project_name)
+                running = any(
+                    'running' in (c.status or '').lower() or 'up' in (c.status or '').lower()
+                    for c in ps if (c.service or '') in pw_services
+                )
+                if not running:
+                    finished = True
+                if time.time() > deadline:
+                    timed_out = True
+                if not finished and not timed_out:
+                    time.sleep(health_interval)
+            result['logs_captured'] = logs_acc
+            result['steps']['playwright_logs'] = {
+                'finished': finished,
+                'timed_out': timed_out,
+            }
+            if timed_out:
+                raise DockerOpsError("Playwright runner timed out")
+        else:
+            if dry_run:
+                logger.info("Step 5: log following skipped (dry run)")
+        # Step 6: Analyze outcome
+        logger.info("Step 6: analyzing Playwright runner outcome")
+        if not dry_run:
+            # Get exit codes
+            ps = compose_ps(playwright_compose_file, project_name=project_name)
+            exit_codes = {}
+            for c in ps:
+                if (c.service or '') in pw_services:
+                    exit_code = getattr(c, 'exit_code', None) or 1  # Assume non-zero if missing
+                    exit_codes[c.service] = exit_code
+            all_success = all(code == 0 for code in exit_codes.values())
+            # Log analysis
+            aggregated_logs = '\n'.join(' '.join(v) for v in logs_acc.values())
+            failed = any(re.search(pat, aggregated_logs, re.I) for pat in ['FAILED', 'FAIL', 'ERROR', 'AssertionError', 'Test Failed'])
+            passed = any(re.search(pat, aggregated_logs, re.I) for pat in ['All tests passed', 'Tests passed', 'PASS'])
+            if all_success and (passed or not failed):
+                result['success'] = True
+                logger.info(f"Playwright run successful ({test_id})")
+            else:
+                result['success'] = False
+                result['error'] = 'Playwright tests failed based on exit codes or logs'
+                logger.error(f"Playwright run failed ({test_id})")
+            result['steps']['analysis'] = {
+                'exit_codes': exit_codes,
+                'passed_patterns': passed,
+                'failed_patterns': failed,
+            }
+        else:
+            result['success'] = True  # Assume success in dry run
+        result['duration'] = (dt_ops.current_datetime() - start_time).total_seconds()
+        if not keep_up :
+            compose_down(
+                compose_file=playwright_compose_file,
+            )
+            logger.info("Playwright compose down")
+            compose_down(
+                compose_file=compose_file,
+            )
+            logger.info("all servise compose down")
+        return result
+    except Exception as e:
+        result['duration'] = (dt_ops.current_datetime() - start_time).total_seconds()
+        result['error'] = str(e)
+        logger.error(f"Playwright test workflow failed ({test_id}): {e}")
+        if not keep_up :
+            compose_down(
+                compose_file=playwright_compose_file,
+            )
+            logger.info("Playwright compose down")
+            compose_down(
+                compose_file=compose_file,
+            )
+            logger.info("all servise compose down")
+        return result
+
 
 def test_compose(
     compose_file: str,