cli-test-framework 0.3.7__tar.gz → 0.4.0__tar.gz

{cli_test_framework-0.3.7/src/cli_test_framework.egg-info → cli_test_framework-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-test-framework
-Version: 0.3.7
+Version: 0.4.0
 Summary: A powerful command line testing framework in Python with setup modules, parallel execution, and file comparison capabilities.
 Home-page: https://github.com/ozil111/cli-test-framework
 Author: Xiaotong Wang

{cli_test_framework-0.3.7 → cli_test_framework-0.4.0}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, 'README.md'), encoding='utf-8') as f:
 
 setup(
     name="cli-test-framework",
-    version="0.3.7",
+    version="0.4.0",
     author="Xiaotong Wang",
     author_email="xiaotongwang98@gmail.com",
     description="A powerful command line testing framework in Python with setup modules, parallel execution, and file comparison capabilities.",

cli_test_framework-0.4.0/src/cli_test_framework/core/execution.py

@@ -0,0 +1,67 @@
+import subprocess
+import time
+from typing import Optional
+
+from .assertions import Assertions
+from .types import ExpectedResult, TestCaseData, TestResultData
+
+
+def validate_result(expected: ExpectedResult, actual: TestResultData) -> None:
+    """
+    Pure validation logic. Raises AssertionError on mismatch.
+    """
+    assertions = Assertions()
+
+    if "return_code" in expected:
+        assertions.return_code_equals(actual["return_code"], expected["return_code"])
+
+    if "output_contains" in expected:
+        for text in expected["output_contains"]:
+            assertions.contains(actual["output"], text)
+
+    if "output_matches" in expected and expected["output_matches"]:
+        assertions.matches(actual["output"], expected["output_matches"])
+
+
+def execute_single_test_case(case: TestCaseData, workspace: Optional[str] = None) -> TestResultData:
+    """
+    Stateless execution of a single test case.
+    """
+    start_time = time.time()
+    full_command = f"{case['command']} {' '.join(case['args'])}".strip()
+
+    result: TestResultData = {
+        "name": case["name"],
+        "status": "failed",
+        "message": "",
+        "command": full_command,
+        "output": "",
+        "return_code": None,
+        "duration": 0.0,
+    }
+
+    try:
+        process = subprocess.run(
+            full_command,
+            cwd=workspace if workspace else None,
+            capture_output=True,
+            text=True,
+            check=False,
+            shell=True,
+        )
+
+        output = process.stdout + process.stderr
+        result["output"] = output
+        result["return_code"] = process.returncode
+
+        validate_result(case["expected"], result)
+        result["status"] = "passed"
+    except AssertionError as exc:
+        result["message"] = str(exc)
+    except Exception as exc:
+        result["message"] = f"Execution error: {str(exc)}"
+    finally:
+        result["duration"] = time.time() - start_time
+
+    return result
+

cli_test_framework-0.4.0/src/cli_test_framework/core/process_worker.py

@@ -0,0 +1,43 @@
+"""
+进程工作器模块
+用于多进程并行测试执行，避免序列化问题
+"""
+
+from typing import Dict, Any
+from .execution import execute_single_test_case
+from .types import TestCaseData
+
+def run_test_in_process(test_index: int, case_data: Dict[str, Any], workspace: str = None) -> Dict[str, Any]:
+    """
+    在独立进程中运行单个测试用例
+    
+    Args:
+        test_index: 测试索引
+        case_data: 测试用例数据字典
+        workspace: 工作目录
+    
+    Returns:
+        测试结果字典
+    """
+    case: TestCaseData = {
+        "name": case_data["name"],
+        "command": case_data["command"],
+        "args": case_data["args"],
+        "expected": case_data["expected"],
+        "description": case_data.get("description"),
+    }
+
+    command_preview = f"{case['command']} {' '.join(case['args'])}".strip()
+    print(f"  [Process Worker {test_index}] Executing command: {command_preview}")
+
+    result = execute_single_test_case(case, workspace)
+
+    if result["output"].strip():
+        print(f"  [Process Worker {test_index}] Command output for {case['name']}:")
+        for line in result["output"].splitlines():
+            print(f"    {line}")
+
+    if result["status"] != "passed" and result.get("message"):
+        print(f"  [Process Worker {test_index}] Error for {case['name']}: {result['message']}")
+
+    return result 

cli_test_framework-0.4.0/src/cli_test_framework/core/types.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class ExpectedResult(TypedDict, total=False):
+    """Expectation configuration for a single test case."""
+
+    return_code: Optional[int]
+    output_contains: List[str]
+    output_matches: Optional[str]
+
+
+class TestCaseData(TypedDict):
+    """Input data shape for a test case after解析/路径处理."""
+
+    name: str
+    command: str
+    args: List[str]
+    expected: ExpectedResult
+    description: Optional[str]
+
+
+class SetupConfig(TypedDict):
+    """Setup configuration (currently environment variables only)."""
+
+    environment_variables: Dict[str, str]
+
+
+class TestSuiteConfig(TypedDict):
+    """Top-level configuration for a suite loaded from JSON/YAML."""
+
+    setup: Optional[SetupConfig]
+    test_cases: List[TestCaseData]
+
+
+class TestResultData(TypedDict):
+    """Normalized result produced by executing a single test case."""
+
+    name: str
+    status: str  # 'passed', 'failed'
+    message: str
+    command: str
+    output: str
+    return_code: Optional[int]
+    duration: float
+

{cli_test_framework-0.3.7 → cli_test_framework-0.4.0}/src/cli_test_framework/file_comparator/json_comparator.py

@@ -53,8 +53,8 @@ class JsonComparator(TextComparator):
         json_text = ''.join(text_content)
         try:
             json_data = json.loads(json_text)
-            if self.key_field:
-                # Only keep the specified key field(s)
+            if self.key_field and isinstance(json_data, dict):
+                # Only keep the specified key field(s) when top-level is a mapping
                 key_fields = self.key_field if isinstance(self.key_field, list) else [self.key_field]
                 filtered_data = {key: json_data[key] for key in key_fields if key in json_data}
                 return filtered_data
@@ -79,8 +79,9 @@ class JsonComparator(TextComparator):
             self._compare_json_key_based(content1, content2, "", differences)
         else:
             self._compare_json_exact(content1, content2, "", differences)
-            
-        return False, differences
+        
+        identical = len(differences) == 0
+        return identical, differences
 
     def _compare_json_exact(self, obj1, obj2, path, differences, max_diffs=10):
         """

cli_test_framework-0.4.0/src/cli_test_framework/runners/json_runner.py

@@ -0,0 +1,63 @@
+from typing import Optional, Dict, Any
+from ..core.base_runner import BaseRunner
+from ..core.test_case import TestCase
+from ..core.execution import execute_single_test_case
+from ..core.types import TestCaseData
+from ..utils.path_resolver import PathResolver, parse_command_string, resolve_paths
+import json
+import sys
+
+class JSONRunner(BaseRunner):
+    def __init__(self, config_file="test_cases.json", workspace: Optional[str] = None):
+        super().__init__(config_file, workspace)
+        # Backward-compatible attribute for tests that patch path_resolver
+        self.path_resolver = PathResolver(self.workspace)
+
+    def load_test_cases(self) -> None:
+        """Load test cases from a JSON file."""
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+
+            # 加载setup配置
+            self.load_setup_from_config(config)
+
+            required_fields = ["name", "command", "args", "expected"]
+            for case in config["test_cases"]:
+                if not all(field in case for field in required_fields):
+                    raise ValueError(f"Test case {case.get('name', 'unnamed')} is missing required fields")
+
+                # 使用智能命令解析，正确处理包含空格的路径
+                # Use resolver attribute (keeps backward compatibility with tests monkeypatching it)
+                case["command"] = self.path_resolver.parse_command_string(case["command"])
+                case["args"] = self.path_resolver.resolve_paths(case["args"])
+                self.test_cases.append(TestCase(**case))
+
+            print(f"Successfully loaded {len(self.test_cases)} test cases")
+            # print(self.test_cases)
+        except Exception as e:
+            sys.exit(f"Failed to load configuration file: {str(e)}")
+
+    def run_single_test(self, case: TestCase) -> Dict[str, str]:
+        case_data: TestCaseData = {
+            "name": case.name,
+            "command": case.command,
+            "args": case.args,
+            "expected": case.expected,
+            "description": case.description or None,
+        }
+
+        command_preview = f"{case_data['command']} {' '.join(case_data['args'])}".strip()
+        print(f"  Executing command: {command_preview}")
+
+        result = execute_single_test_case(case_data, str(self.workspace) if self.workspace else None)
+
+        if result["output"].strip():
+            print("  Command output:")
+            for line in result["output"].splitlines():
+                print(f"    {line}")
+
+        if result["status"] != "passed" and result.get("message"):
+            print(f"  Error: {result['message']}")
+
+        return result

cli_test_framework-0.4.0/src/cli_test_framework/runners/parallel_json_runner.py

@@ -0,0 +1,79 @@
+from typing import Optional, Dict, Any
+from ..core.parallel_runner import ParallelRunner
+from ..core.test_case import TestCase
+from ..core.execution import execute_single_test_case
+from ..core.types import TestCaseData
+from ..utils.path_resolver import PathResolver, parse_command_string, resolve_paths
+import json
+import sys
+import threading
+
+class ParallelJSONRunner(ParallelRunner):
+    """并行JSON测试运行器"""
+    
+    def __init__(self, config_file="test_cases.json", workspace: Optional[str] = None,
+                 max_workers: Optional[int] = None, execution_mode: str = "thread"):
+        """
+        初始化并行JSON运行器
+        
+        Args:
+            config_file: JSON配置文件路径
+            workspace: 工作目录
+            max_workers: 最大并发数
+            execution_mode: 执行模式，'thread' 或 'process'
+        """
+        super().__init__(config_file, workspace, max_workers, execution_mode)
+        # Backward-compatible attribute for potential external patches/tests
+        self.path_resolver = PathResolver(self.workspace)
+        self._print_lock = threading.Lock()  # 用于控制输出顺序
+
+    def load_test_cases(self) -> None:
+        """从JSON文件加载测试用例"""
+        try:
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+
+            # 加载setup配置
+            self.load_setup_from_config(config)
+
+            required_fields = ["name", "command", "args", "expected"]
+            for case in config["test_cases"]:
+                if not all(field in case for field in required_fields):
+                    raise ValueError(f"Test case {case.get('name', 'unnamed')} is missing required fields")
+
+                # Use resolver attribute (keeps backward compatibility with tests monkeypatching it)
+                case["command"] = self.path_resolver.parse_command_string(case["command"])
+                case["args"] = self.path_resolver.resolve_paths(case["args"])
+                self.test_cases.append(TestCase(**case))
+
+            print(f"Successfully loaded {len(self.test_cases)} test cases")
+        except Exception as e:
+            sys.exit(f"Failed to load configuration file: {str(e)}")
+
+    def run_single_test(self, case: TestCase) -> Dict[str, Any]:
+        """运行单个测试用例（线程安全版本）"""
+        case_data: TestCaseData = {
+            "name": case.name,
+            "command": case.command,
+            "args": case.args,
+            "expected": case.expected,
+            "description": case.description or None,
+        }
+
+        command_preview = f"{case_data['command']} {' '.join(case_data['args'])}".strip()
+        with self._print_lock:
+            print(f"  [Worker] Executing command: {command_preview}")
+
+        result = execute_single_test_case(case_data, str(self.workspace) if self.workspace else None)
+
+        if result["output"].strip():
+            with self._print_lock:
+                print(f"  [Worker] Command output for {case.name}:")
+                for line in result["output"].splitlines():
+                    print(f"    {line}")
+
+        if result["status"] != "passed" and result.get("message"):
+            with self._print_lock:
+                print(f"  [Worker] Error for {case.name}: {result['message']}")
+
+        return result 

cli_test_framework-0.4.0/src/cli_test_framework/runners/yaml_runner.py

@@ -0,0 +1,62 @@
+from typing import Optional, Dict, Any
+from ..core.base_runner import BaseRunner
+from ..core.test_case import TestCase
+from ..core.execution import execute_single_test_case
+from ..core.types import TestCaseData
+from ..utils.path_resolver import PathResolver, parse_command_string, resolve_paths
+import sys
+
+class YAMLRunner(BaseRunner):
+    def __init__(self, config_file="test_cases.yaml", workspace: Optional[str] = None):
+        super().__init__(config_file, workspace)
+        # Backward-compatible attribute for tests that patch path_resolver
+        self.path_resolver = PathResolver(self.workspace)
+
+    def load_test_cases(self):
+        """Load test cases from a YAML file."""
+        try:
+            import yaml
+            with open(self.config_path, 'r', encoding='utf-8') as f:
+                config = yaml.safe_load(f)
+                
+            # 加载setup配置
+            self.load_setup_from_config(config)
+                
+            required_fields = ["name", "command", "args", "expected"]
+            for case in config["test_cases"]:
+                if not all(field in case for field in required_fields):
+                    raise ValueError(f"Test case {case.get('name', 'unnamed')} is missing required fields")
+                
+                # Use resolver attribute (keeps backward compatibility with tests monkeypatching it)
+                case["command"] = self.path_resolver.parse_command_string(case["command"])
+                case["args"] = self.path_resolver.resolve_paths(case["args"])
+                self.test_cases.append(TestCase(**case))
+                
+            print(f"Successfully loaded {len(self.test_cases)} test cases")
+        except Exception as e:
+            sys.exit(f"Failed to load configuration file: {str(e)}")
+
+    def run_single_test(self, case: TestCase) -> Dict[str, Any]:
+        """Run a single test case and return the result"""
+        case_data: TestCaseData = {
+            "name": case.name,
+            "command": case.command,
+            "args": case.args,
+            "expected": case.expected,
+            "description": case.description or None,
+        }
+
+        command_preview = f"{case_data['command']} {' '.join(case_data['args'])}".strip()
+        print(f"  Executing command: {command_preview}")
+
+        result = execute_single_test_case(case_data, str(self.workspace) if self.workspace else None)
+
+        if result["output"].strip():
+            print("  Command output:")
+            for line in result["output"].splitlines():
+                print(f"    {line}")
+
+        if result["status"] != "passed" and result.get("message"):
+            print(f"  Error: {result['message']}")
+
+        return result

cli_test_framework-0.4.0/src/cli_test_framework/utils/__init__.py

@@ -0,0 +1,19 @@
+# File: /python-test-framework/python-test-framework/src/utils/__init__.py
+
+"""
+Utility functions for the CLI Testing Framework
+"""
+
+from .path_resolver import (
+    PathResolver,
+    parse_command_string,
+    resolve_paths,
+    resolve_command,
+)
+
+__all__ = [
+    'PathResolver',
+    'parse_command_string',
+    'resolve_paths',
+    'resolve_command',
+]

cli_test_framework-0.4.0/src/cli_test_framework/utils/path_resolver.py

@@ -0,0 +1,229 @@
+from pathlib import Path
+from typing import List, Union
+import shlex
+import os
+import shutil
+
+WorkspaceLike = Union[str, Path]
+
+
+def _as_workspace_path(workspace: WorkspaceLike) -> Path:
+    return workspace if isinstance(workspace, Path) else Path(workspace)
+
+
+def resolve_paths(args: List[str], workspace: WorkspaceLike) -> List[str]:
+    """Resolve relative paths in args against the workspace."""
+    workspace_path = _as_workspace_path(workspace)
+    resolved_args = []
+    for arg in args:
+        if not arg.startswith("--"):
+            if not Path(arg).is_absolute():
+                resolved_args.append(str(workspace_path / arg))
+            else:
+                resolved_args.append(arg)
+        else:
+            resolved_args.append(arg)
+    return resolved_args
+
+
+def resolve_command(command: str, workspace: WorkspaceLike) -> str:
+    """
+    Resolve command path:
+    - absolute path: keep
+    - available in PATH: keep
+    - known system command: keep
+    - otherwise treat as relative to workspace
+    """
+    workspace_path = _as_workspace_path(workspace)
+
+    if Path(command).is_absolute():
+        return command
+
+    if shutil.which(command) is not None:
+        return command
+
+    system_commands = {
+        'echo', 'ping', 'dir', 'ls', 'cat', 'grep', 'find', 'sort',
+        'head', 'tail', 'wc', 'curl', 'wget', 'git', 'python', 'node',
+        'npm', 'pip', 'java', 'javac', 'gcc', 'make', 'cmake', 'docker',
+        'kubectl', 'helm', 'terraform', 'ansible', 'ssh', 'scp', 'rsync'
+    }
+
+    if command in system_commands:
+        return command
+
+    return str(workspace_path / command)
+
+
+def parse_command_string(command_string: str, workspace: WorkspaceLike) -> str:
+    """
+    Parse command string with smart handling of quoted paths and relative segments.
+    """
+    workspace_path = _as_workspace_path(workspace)
+
+    if '"' in command_string or "'" in command_string:
+        try:
+            parts = shlex.split(command_string, posix=True)
+
+            if not parts:
+                return command_string
+
+            command_part = parts[0]
+            remaining_parts = parts[1:]
+
+            if Path(command_part).is_absolute():
+                resolved_command = command_part
+            else:
+                resolved_command = resolve_command(command_part, workspace_path)
+
+            # Preserve scripts passed via "-c" as a single argument to avoid losing quotes
+            resolved_parts = []
+            if "-c" in remaining_parts:
+                c_index = remaining_parts.index("-c")
+                before_c = remaining_parts[:c_index]
+                script_body = " ".join(remaining_parts[c_index + 1 :])
+                for part in before_c:
+                    if part.startswith("-"):
+                        resolved_parts.append(part)
+                    elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+                        if not Path(part).is_absolute():
+                            resolved_parts.append(str(workspace_path / part))
+                        else:
+                            resolved_parts.append(part)
+                    else:
+                        resolved_parts.append(part)
+                resolved_parts.append("-c")
+                resolved_parts.append(script_body)
+            else:
+                for part in remaining_parts:
+                    if part.startswith('-'):
+                        resolved_parts.append(part)
+                    elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+                        if not Path(part).is_absolute():
+                            resolved_parts.append(str(workspace_path / part))
+                        else:
+                            resolved_parts.append(part)
+                    else:
+                        resolved_parts.append(part)
+
+            return f"{resolved_command} {' '.join(resolved_parts)}"
+
+        except ValueError:
+            pass
+
+    if _starts_with_absolute_path(command_string):
+        return _parse_absolute_path_command(command_string, workspace_path)
+    else:
+        parts = command_string.split()
+        if not parts:
+            return command_string
+
+        if len(parts) == 1:
+            return resolve_command(parts[0], workspace_path)
+        else:
+            command_part = parts[0]
+            remaining_parts = parts[1:]
+
+            resolved_command = resolve_command(command_part, workspace_path)
+
+            if "-c" in remaining_parts:
+                c_index = remaining_parts.index("-c")
+                before_c = remaining_parts[:c_index]
+                script_body = " ".join(remaining_parts[c_index + 1 :])
+                resolved_parts = before_c + ["-c", script_body]
+            else:
+                resolved_parts = []
+                for part in remaining_parts:
+                    if part.startswith('-'):
+                        resolved_parts.append(part)
+                    elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+                        if not Path(part).is_absolute():
+                            resolved_parts.append(str(workspace_path / part))
+                        else:
+                            resolved_parts.append(part)
+                    else:
+                        resolved_parts.append(part)
+
+            return f"{resolved_command} {' '.join(resolved_parts)}"
+
+
+def _starts_with_absolute_path(command_string: str) -> bool:
+    """检查命令字符串是否以绝对路径开头"""
+    if os.name == 'nt':
+        return (len(command_string) >= 3 and
+                command_string[1:3] == ':\\') or command_string.startswith('\\\\')
+    else:
+        return command_string.startswith('/')
+
+
+def _parse_absolute_path_command(command_string: str, workspace: WorkspaceLike) -> str:
+    workspace_path = _as_workspace_path(workspace)
+
+    if os.name == 'nt':
+        exe_extensions = ['.exe', '.bat', '.cmd', '.com']
+
+        for ext in exe_extensions:
+            if ext in command_string:
+                ext_pos = command_string.find(ext)
+                if ext_pos != -1:
+                    command_end = ext_pos + len(ext)
+                    command_part = command_string[:command_end]
+                    remaining = command_string[command_end:].strip()
+
+                    if remaining:
+                        remaining_parts = remaining.split()
+                        resolved_parts = []
+
+                        for part in remaining_parts:
+                            if part.startswith('-'):
+                                resolved_parts.append(part)
+                            elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+                                if not Path(part).is_absolute():
+                                    resolved_parts.append(str(workspace_path / part))
+                                else:
+                                    resolved_parts.append(part)
+                            else:
+                                resolved_parts.append(part)
+
+                        return f"{command_part} {' '.join(resolved_parts)}"
+                    else:
+                        return command_part
+
+    parts = command_string.split()
+    if not parts:
+        return command_string
+
+    command_part = parts[0]
+    remaining_parts = parts[1:]
+
+    resolved_parts = []
+    for part in remaining_parts:
+        if part.startswith('-'):
+            resolved_parts.append(part)
+        elif ('.' in part or '/' in part or '\\' in part) and not part.isdigit():
+            if not Path(part).is_absolute():
+                resolved_parts.append(str(workspace_path / part))
+            else:
+                resolved_parts.append(part)
+        else:
+            resolved_parts.append(part)
+
+    return f"{command_part} {' '.join(resolved_parts)}"
+
+
+class PathResolver:
+    """
+    Backwards-compatible wrapper; delegates to pure functions.
+    """
+
+    def __init__(self, workspace: Path):
+        self.workspace = workspace
+
+    def resolve_paths(self, args: List[str]) -> List[str]:
+        return resolve_paths(args, self.workspace)
+
+    def resolve_command(self, command: str) -> str:
+        return resolve_command(command, self.workspace)
+
+    def parse_command_string(self, command_string: str) -> str:
+        return parse_command_string(command_string, self.workspace)

{cli_test_framework-0.3.7 → cli_test_framework-0.4.0/src/cli_test_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-test-framework
-Version: 0.3.7
+Version: 0.4.0
 Summary: A powerful command line testing framework in Python with setup modules, parallel execution, and file comparison capabilities.
 Home-page: https://github.com/ozil111/cli-test-framework
 Author: Xiaotong Wang