comfy-test 0.0.1__py3-none-any.whl

comfy_test/__init__.py

@@ -0,0 +1,94 @@
+"""
+comfy-test: Installation testing infrastructure for ComfyUI custom nodes.
+
+This package provides:
+- Multi-platform installation testing (Linux, Windows, Windows Portable)
+- Workflow execution verification
+- GitHub Actions integration
+
+## Quick Start
+
+    from comfy_test import run_tests, verify_nodes
+
+    # Run all tests from config
+    results = run_tests()
+
+    # Or verify nodes only
+    results = verify_nodes()
+
+## CLI
+
+    comfy-test run              # Run installation tests
+    comfy-test verify           # Verify node registration
+    comfy-test info             # Show configuration
+    comfy-test init-ci          # Generate GitHub Actions workflow
+
+## Configuration
+
+Create comfy-test.toml in your custom node directory:
+
+    [test]
+    name = "MyNode"
+    expected_nodes = ["MyNode1", "MyNode2"]
+
+    [test.workflow]
+    file = "tests/workflows/smoke_test.json"
+
+## GitHub Actions
+
+Add this workflow to your repository:
+
+    # .github/workflows/test-install.yml
+    name: Test Installation
+    on: [push, pull_request]
+
+    jobs:
+      test:
+        uses: PozzettiAndrea/comfy-test/.github/workflows/test-matrix.yml@main
+        with:
+          config-file: "comfy-test.toml"
+"""
+
+__version__ = "0.0.1"
+
+from .test.config import TestConfig, WorkflowConfig, PlatformTestConfig
+from .test.config_file import load_config, discover_config, CONFIG_FILE_NAMES
+from .test.manager import TestManager, TestResult
+from .errors import (
+    TestError,
+    ConfigError,
+    SetupError,
+    ServerError,
+    WorkflowError,
+    VerificationError,
+    TimeoutError,
+    DownloadError,
+)
+
+# Convenience functions
+from .runner import run_tests, verify_nodes
+
+__all__ = [
+    # Config
+    "TestConfig",
+    "WorkflowConfig",
+    "PlatformTestConfig",
+    "load_config",
+    "discover_config",
+    "CONFIG_FILE_NAMES",
+    # Manager
+    "TestManager",
+    "TestResult",
+    # Errors
+    "TestError",
+    "ConfigError",
+    "SetupError",
+    "ServerError",
+    "WorkflowError",
+    "VerificationError",
+    "TimeoutError",
+    "DownloadError",
+    # Convenience
+    "run_tests",
+    "verify_nodes",
+]

comfy_test/cli.py

@@ -0,0 +1,277 @@
+"""CLI for comfy-test."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .test.config_file import discover_config, load_config, CONFIG_FILE_NAMES
+from .test.manager import TestManager
+from .errors import TestError, ConfigError
+
+
+def cmd_run(args) -> int:
+    """Run installation tests."""
+    try:
+        # Load config
+        if args.config:
+            config = load_config(args.config)
+        else:
+            config = discover_config()
+
+        # Create manager
+        manager = TestManager(config)
+
+        # Run tests
+        if args.platform:
+            results = [manager.run_platform(args.platform, args.dry_run)]
+        else:
+            results = manager.run_all(args.dry_run)
+
+        # Report results
+        print(f"\n{'='*60}")
+        print("RESULTS")
+        print(f"{'='*60}")
+
+        all_passed = True
+        for result in results:
+            status = "PASS" if result.success else "FAIL"
+            print(f"  {result.platform}: {status}")
+            if not result.success:
+                all_passed = False
+                if result.error:
+                    print(f"    Error: {result.error}")
+
+        return 0 if all_passed else 1
+
+    except ConfigError as e:
+        print(f"Configuration error: {e.message}", file=sys.stderr)
+        if e.details:
+            print(f"Details: {e.details}", file=sys.stderr)
+        return 1
+    except TestError as e:
+        print(f"Test error: {e.message}", file=sys.stderr)
+        return 1
+
+
+def cmd_verify(args) -> int:
+    """Verify node registration only."""
+    try:
+        if args.config:
+            config = load_config(args.config)
+        else:
+            config = discover_config()
+
+        manager = TestManager(config)
+        results = manager.verify_only(args.platform)
+
+        all_passed = all(r.success for r in results)
+        for result in results:
+            status = "PASS" if result.success else "FAIL"
+            print(f"{result.platform}: {status}")
+            if not result.success and result.error:
+                print(f"  Error: {result.error}")
+
+        return 0 if all_passed else 1
+
+    except (ConfigError, TestError) as e:
+        print(f"Error: {e.message}", file=sys.stderr)
+        return 1
+
+
+def cmd_info(args) -> int:
+    """Show configuration and environment info."""
+    try:
+        if args.config:
+            config = load_config(args.config)
+            config_path = args.config
+        else:
+            try:
+                config = discover_config()
+                config_path = "auto-discovered"
+            except ConfigError:
+                print("No configuration file found.")
+                print(f"Searched for: {', '.join(CONFIG_FILE_NAMES)}")
+                return 1
+
+        print(f"Configuration: {config_path}")
+        print(f"  Name: {config.name}")
+        print(f"  ComfyUI Version: {config.comfyui_version}")
+        print(f"  Python Version: {config.python_version}")
+        print(f"  CPU Only: {config.cpu_only}")
+        print(f"  Timeout: {config.timeout}s")
+        print()
+        print("Platforms:")
+        print(f"  Linux: {'enabled' if config.linux.enabled else 'disabled'}")
+        print(f"  Windows: {'enabled' if config.windows.enabled else 'disabled'}")
+        print(f"  Windows Portable: {'enabled' if config.windows_portable.enabled else 'disabled'}")
+        print()
+        print("Verification:")
+        if config.expected_nodes:
+            print(f"  Expected nodes ({len(config.expected_nodes)}):")
+            for node in config.expected_nodes:
+                print(f"    - {node}")
+        else:
+            print("  No expected nodes configured")
+        print()
+        print("Workflow:")
+        if config.workflow.file:
+            print(f"  File: {config.workflow.file}")
+            print(f"  Timeout: {config.workflow.timeout}s")
+        else:
+            print("  No workflow configured")
+
+        return 0
+
+    except ConfigError as e:
+        print(f"Error: {e.message}", file=sys.stderr)
+        return 1
+
+
+def cmd_init_ci(args) -> int:
+    """Generate GitHub Actions workflow file."""
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    workflow_content = '''name: Test Installation
+on: [push, pull_request]
+
+jobs:
+  test:
+    uses: PozzettiAndrea/comfy-test/.github/workflows/test-matrix.yml@main
+    with:
+      config-file: "comfy-test.toml"
+'''
+
+    with open(output_path, "w") as f:
+        f.write(workflow_content)
+
+    print(f"Generated GitHub Actions workflow: {output_path}")
+    print()
+    print("Make sure to:")
+    print("  1. Create a comfy-test.toml in your repository root")
+    print("  2. Commit both files to your repository")
+    print()
+    print("Example comfy-test.toml:")
+    print('''
+[test]
+name = "MyNode"
+python_version = "3.10"
+
+[test.verification]
+expected_nodes = ["MyNode1", "MyNode2"]
+''')
+
+    return 0
+
+
+def cmd_download_portable(args) -> int:
+    """Download ComfyUI Portable for testing."""
+    from .test.platform.windows_portable import WindowsPortableTestPlatform
+
+    platform = WindowsPortableTestPlatform()
+
+    version = args.version
+    if version == "latest":
+        version = platform._get_latest_release_tag()
+
+    output_path = Path(args.output)
+    archive_path = output_path / f"ComfyUI_portable_{version}.7z"
+
+    output_path.mkdir(parents=True, exist_ok=True)
+    platform._download_portable(version, archive_path)
+
+    print(f"Downloaded to: {archive_path}")
+    return 0
+
+
+def main(args=None) -> int:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="comfy-test",
+        description="Installation testing for ComfyUI custom nodes",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # run command
+    run_parser = subparsers.add_parser(
+        "run",
+        help="Run installation tests",
+    )
+    run_parser.add_argument(
+        "--config", "-c",
+        help="Path to config file (default: auto-discover)",
+    )
+    run_parser.add_argument(
+        "--platform", "-p",
+        choices=["linux", "windows", "windows-portable"],
+        help="Run on specific platform only",
+    )
+    run_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be done without doing it",
+    )
+    run_parser.set_defaults(func=cmd_run)
+
+    # verify command
+    verify_parser = subparsers.add_parser(
+        "verify",
+        help="Verify node registration only",
+    )
+    verify_parser.add_argument(
+        "--config", "-c",
+        help="Path to config file",
+    )
+    verify_parser.add_argument(
+        "--platform", "-p",
+        choices=["linux", "windows", "windows-portable"],
+        help="Platform to verify on",
+    )
+    verify_parser.set_defaults(func=cmd_verify)
+
+    # info command
+    info_parser = subparsers.add_parser(
+        "info",
+        help="Show configuration info",
+    )
+    info_parser.add_argument(
+        "--config", "-c",
+        help="Path to config file",
+    )
+    info_parser.set_defaults(func=cmd_info)
+
+    # init-ci command
+    init_ci_parser = subparsers.add_parser(
+        "init-ci",
+        help="Generate GitHub Actions workflow",
+    )
+    init_ci_parser.add_argument(
+        "--output", "-o",
+        default=".github/workflows/test-install.yml",
+        help="Output file path",
+    )
+    init_ci_parser.set_defaults(func=cmd_init_ci)
+
+    # download-portable command
+    download_parser = subparsers.add_parser(
+        "download-portable",
+        help="Download ComfyUI Portable",
+    )
+    download_parser.add_argument(
+        "--version", "-v",
+        default="latest",
+        help="Version to download (default: latest)",
+    )
+    download_parser.add_argument(
+        "--output", "-o",
+        default=".",
+        help="Output directory",
+    )
+    download_parser.set_defaults(func=cmd_download_portable)
+
+    parsed_args = parser.parse_args(args)
+    return parsed_args.func(parsed_args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

comfy_test/comfyui/__init__.py

@@ -0,0 +1,11 @@
+"""ComfyUI server interaction utilities."""
+
+from .api import ComfyUIAPI
+from .server import ComfyUIServer
+from .workflow import WorkflowRunner
+
+__all__ = [
+    "ComfyUIAPI",
+    "ComfyUIServer",
+    "WorkflowRunner",
+]

comfy_test/comfyui/api.py

@@ -0,0 +1,184 @@
+"""ComfyUI REST API client."""
+
+import json
+from typing import Any, Dict, List, Optional
+
+import requests
+
+from ..errors import ServerError, VerificationError
+
+
+class ComfyUIAPI:
+    """Client for ComfyUI REST API.
+
+    Provides methods to interact with a running ComfyUI server.
+
+    Args:
+        base_url: Base URL of the ComfyUI server (e.g., "http://127.0.0.1:8188")
+        timeout: Request timeout in seconds
+
+    Example:
+        >>> api = ComfyUIAPI("http://127.0.0.1:8188")
+        >>> nodes = api.get_object_info()
+        >>> print(list(nodes.keys())[:5])
+    """
+
+    def __init__(self, base_url: str = "http://127.0.0.1:8188", timeout: int = 30):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = requests.Session()
+
+    def health_check(self) -> bool:
+        """Check if the server is responsive.
+
+        Returns:
+            True if server responds, False otherwise
+        """
+        try:
+            response = self.session.get(
+                f"{self.base_url}/system_stats",
+                timeout=self.timeout,
+            )
+            return response.status_code == 200
+        except requests.RequestException:
+            return False
+
+    def get_object_info(self) -> Dict[str, Any]:
+        """Get information about all registered nodes.
+
+        Returns:
+            Dictionary mapping node names to their info
+
+        Raises:
+            ServerError: If request fails
+        """
+        try:
+            response = self.session.get(
+                f"{self.base_url}/object_info",
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            raise ServerError(
+                "Failed to get object_info from ComfyUI",
+                str(e)
+            )
+
+    def verify_nodes(self, expected_nodes: List[str]) -> None:
+        """Verify that expected nodes are registered.
+
+        Args:
+            expected_nodes: List of node names that must exist
+
+        Raises:
+            VerificationError: If any expected nodes are missing
+        """
+        nodes = self.get_object_info()
+        missing = [name for name in expected_nodes if name not in nodes]
+
+        if missing:
+            raise VerificationError(
+                f"Expected nodes not found: {', '.join(missing)}",
+                missing_nodes=missing,
+            )
+
+    def queue_prompt(self, workflow: Dict[str, Any]) -> str:
+        """Queue a workflow for execution.
+
+        Args:
+            workflow: Workflow definition (the "prompt" part of a workflow JSON)
+
+        Returns:
+            Prompt ID for tracking execution
+
+        Raises:
+            ServerError: If request fails
+        """
+        try:
+            response = self.session.post(
+                f"{self.base_url}/prompt",
+                json={"prompt": workflow},
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data["prompt_id"]
+        except requests.RequestException as e:
+            raise ServerError(
+                "Failed to queue prompt",
+                str(e)
+            )
+        except KeyError:
+            raise ServerError(
+                "Invalid response from /prompt endpoint",
+                "Missing prompt_id in response"
+            )
+
+    def get_history(self, prompt_id: str) -> Optional[Dict[str, Any]]:
+        """Get execution history for a prompt.
+
+        Args:
+            prompt_id: ID from queue_prompt
+
+        Returns:
+            History data if available, None if prompt hasn't started
+
+        Raises:
+            ServerError: If request fails
+        """
+        try:
+            response = self.session.get(
+                f"{self.base_url}/history/{prompt_id}",
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            data = response.json()
+            return data.get(prompt_id)
+        except requests.RequestException as e:
+            raise ServerError(
+                f"Failed to get history for prompt {prompt_id}",
+                str(e)
+            )
+
+    def get_queue(self) -> Dict[str, Any]:
+        """Get current queue status.
+
+        Returns:
+            Queue data with 'queue_running' and 'queue_pending'
+
+        Raises:
+            ServerError: If request fails
+        """
+        try:
+            response = self.session.get(
+                f"{self.base_url}/queue",
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            raise ServerError(
+                "Failed to get queue status",
+                str(e)
+            )
+
+    def interrupt(self) -> None:
+        """Interrupt currently running workflow."""
+        try:
+            self.session.post(
+                f"{self.base_url}/interrupt",
+                timeout=self.timeout,
+            )
+        except requests.RequestException:
+            pass  # Best effort
+
+    def close(self) -> None:
+        """Close the session."""
+        self.session.close()
+
+    def __enter__(self) -> "ComfyUIAPI":
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()