cli-test-framework 0.4.5__tar.gz → 0.5.0__tar.gz

{cli_test_framework-0.4.5/src/cli_test_framework.egg-info → cli_test_framework-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-test-framework
-Version: 0.4.5
+Version: 0.5.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
@@ -18,8 +18,10 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: dukpy==0.5.0
-Requires-Dist: h5py>=3.8.0
-Requires-Dist: numpy>=1.21.0
+Requires-Dist: h5py<4.0.0,>=3.8.0; python_version < "3.12"
+Requires-Dist: h5py<4.0.0,>=3.10.0; python_version >= "3.12"
+Requires-Dist: numpy<2.0.0,>=1.21.0; python_version < "3.12"
+Requires-Dist: numpy<2.0.0,>=1.26.0; python_version >= "3.12"
 Requires-Dist: setuptools>=75.8.0
 Requires-Dist: wheel>=0.45.1
 Dynamic: author

{cli_test_framework-0.4.5 → cli_test_framework-0.5.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.4.5",
+    version="0.5.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.",
@@ -19,8 +19,10 @@ setup(
     package_dir={"": "src"},
     install_requires=[
         "dukpy==0.5.0",
-        "h5py>=3.8.0",
-        "numpy>=1.21.0",
+        "h5py>=3.8.0,<4.0.0; python_version<'3.12'",
+        "h5py>=3.10.0,<4.0.0; python_version>='3.12'",
+        "numpy>=1.21.0,<2.0.0; python_version<'3.12'",
+        "numpy>=1.26.0,<2.0.0; python_version>='3.12'",
         "setuptools>=75.8.0",
         "wheel>=0.45.1"
     ],
@@ -45,4 +47,4 @@ setup(
         'Source': 'https://github.com/ozil111/cli-test-framework',
         'Tracker': 'https://github.com/ozil111/cli-test-framework/issues',
     },
-)
+)

{cli_test_framework-0.4.5 → cli_test_framework-0.5.0}/src/cli_test_framework/core/base_runner.py

@@ -4,6 +4,7 @@ from typing import List, Dict, Any, Optional
 from .test_case import TestCase
 from .assertions import Assertions
 from .setup import SetupManager, EnvironmentSetup
+from .execution import execute_single_test_case
 
 class BaseRunner(ABC):
     def __init__(self, config_file: str, workspace: Optional[str] = None):
@@ -75,6 +76,68 @@ class BaseRunner(ABC):
             # 确保teardown总是被执行
             self.setup_manager.teardown_all()
 
+    def _run_sequence(self, case: TestCase) -> Dict[str, Any]:
+        """Run a sequence test case with multiple steps (fail-fast)."""
+        combined_output = ""
+        total_duration = 0.0
+        all_passed = True
+        last_result = None
+        failed_step = None
+
+        for i, step in enumerate(case.steps):
+            step_name = f"{case.name} [step {i+1}/{len(case.steps)}]"
+            case_data = {
+                "name": step_name,
+                "command": step.command,
+                "args": step.args,
+                "expected": step.expected,
+                "description": None,
+                "timeout": step.timeout,
+                "resources": None,
+            }
+
+            command_preview = f"{step.command} {' '.join(step.args)}".strip()
+            print(f"  Executing step {i+1}/{len(case.steps)}: {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}")
+
+            combined_output += result["output"]
+            total_duration += result["duration"]
+            last_result = result
+
+            if result["status"] != "passed":
+                all_passed = False
+                failed_step = i + 1
+                if result.get("message"):
+                    print(f"  Error at step {i+1}: {result['message']}")
+                break
+
+        status = "passed" if all_passed else last_result["status"]
+        message = ""
+        if not all_passed:
+            message = f"Failed at step {failed_step}/{len(case.steps)}: {last_result['message']}"
+
+        command_summary = " -> ".join(
+            f"{s.command} {' '.join(s.args)}".strip() for s in case.steps
+        )
+
+        return {
+            "name": case.name,
+            "status": status,
+            "message": message,
+            "command": command_summary,
+            "output": combined_output,
+            "return_code": last_result["return_code"] if last_result else None,
+            "duration": total_duration,
+        }
+
     @abstractmethod
     def run_single_test(self, case: TestCase) -> Dict[str, str]:
         """Run a single test case and return the result"""

{cli_test_framework-0.4.5 → cli_test_framework-0.5.0}/src/cli_test_framework/core/parallel_runner.py

@@ -61,7 +61,16 @@ class ParallelRunner(BaseRunner):
                                 "args": case.args,
                                 "expected": case.expected,
                                 "timeout": case.timeout,
-                                "resources": case.resources
+                                "resources": case.resources,
+                                "steps": [
+                                    {
+                                        "command": s.command,
+                                        "args": s.args,
+                                        "expected": s.expected,
+                                        "timeout": s.timeout,
+                                    }
+                                    for s in case.steps
+                                ] if case.steps else None,
                             },
                             str(self.workspace) if self.workspace else None
                         ): (i, case) 

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

@@ -0,0 +1,111 @@
+"""
+进程工作器模块
+用于多进程并行测试执行，避免序列化问题
+"""
+
+from typing import Dict, Any, List
+from .execution import execute_single_test_case
+from .types import TestCaseData
+
+def _run_sequence_in_process(test_index: int, case_data: Dict[str, Any], workspace: str = None) -> Dict[str, Any]:
+    """Run a sequence test case with multiple steps (fail-fast) in a process worker."""
+    steps: List[Dict[str, Any]] = case_data["steps"]
+    combined_output = ""
+    total_duration = 0.0
+    all_passed = True
+    last_result = None
+    failed_step = None
+
+    for i, step in enumerate(steps):
+        step_name = f"{case_data['name']} [step {i+1}/{len(steps)}]"
+        step_case: TestCaseData = {
+            "name": step_name,
+            "command": step["command"],
+            "args": step["args"],
+            "expected": step["expected"],
+            "description": None,
+            "timeout": step.get("timeout"),
+            "resources": None,
+        }
+
+        command_preview = f"{step['command']} {' '.join(step['args'])}".strip()
+        print(f"  [Process Worker {test_index}] Executing step {i+1}/{len(steps)}: {command_preview}")
+
+        result = execute_single_test_case(step_case, workspace)
+
+        if result["output"].strip():
+            print(f"  [Process Worker {test_index}] Command output for {step_name}:")
+            for line in result["output"].splitlines():
+                print(f"    {line}")
+
+        combined_output += result["output"]
+        total_duration += result["duration"]
+        last_result = result
+
+        if result["status"] != "passed":
+            all_passed = False
+            failed_step = i + 1
+            if result.get("message"):
+                print(f"  [Process Worker {test_index}] Error at step {i+1}: {result['message']}")
+            break
+
+    status = "passed" if all_passed else last_result["status"]
+    message = ""
+    if not all_passed:
+        message = f"Failed at step {failed_step}/{len(steps)}: {last_result['message']}"
+
+    command_summary = " -> ".join(
+        f"{s['command']} {' '.join(s['args'])}".strip() for s in steps
+    )
+
+    return {
+        "name": case_data["name"],
+        "status": status,
+        "message": message,
+        "command": command_summary,
+        "output": combined_output,
+        "return_code": last_result["return_code"] if last_result else None,
+        "duration": total_duration,
+    }
+
+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:
+        测试结果字典
+    """
+    # Sequence mode
+    if case_data.get("steps"):
+        return _run_sequence_in_process(test_index, case_data, workspace)
+
+    # Single command mode
+    case: TestCaseData = {
+        "name": case_data["name"],
+        "command": case_data["command"],
+        "args": case_data["args"],
+        "expected": case_data["expected"],
+        "description": case_data.get("description"),
+        "timeout": case_data.get("timeout"),
+        "resources": case_data.get("resources"),
+    }
+
+    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.5.0/src/cli_test_framework/core/test_case.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+
+@dataclass
+class TestCaseStep:
+    """A single step within a sequence test case."""
+    command: str
+    args: List[str]
+    expected: Dict[str, Any]
+    timeout: Optional[float] = None
+
+@dataclass
+class TestCase:
+    name: str
+    command: str = ""
+    args: List[str] = field(default_factory=list)
+    expected: Dict[str, Any] = field(default_factory=dict)
+    description: str = ""
+    timeout: Optional[float] = None
+    resources: Optional[Dict[str, Any]] = None
+    steps: Optional[List[TestCaseStep]] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert test case to dictionary format"""
+        print("Convert test case to dictionary format")
+        print(self.command)
+        result = {
+            "name": self.name,
+            "command": self.command,
+            "args": self.args,
+            "expected": self.expected,
+            "timeout": self.timeout,
+            "resources": self.resources,
+        }
+        if self.steps is not None:
+            result["steps"] = [
+                {
+                    "command": s.command,
+                    "args": s.args,
+                    "expected": s.expected,
+                    "timeout": s.timeout,
+                }
+                for s in self.steps
+            ]
+        return result

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

@@ -0,0 +1,93 @@
+from typing import Optional, Dict, Any
+from ..core.base_runner import BaseRunner
+from ..core.test_case import TestCase, TestCaseStep
+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)
+
+            for case in config["test_cases"]:
+                if "steps" in case:
+                    # Sequence mode: case has ordered steps
+                    steps = []
+                    for step in case["steps"]:
+                        step_required = ["command", "args", "expected"]
+                        if not all(field in step for field in step_required):
+                            raise ValueError(
+                                f"Step in test case '{case.get('name', 'unnamed')}' is missing required fields"
+                            )
+                        step["command"] = self.path_resolver.parse_command_string(step["command"])
+                        step["args"] = self.path_resolver.resolve_paths(step["args"])
+                        steps.append(TestCaseStep(**{
+                            "command": step["command"],
+                            "args": step["args"],
+                            "expected": step["expected"],
+                            "timeout": step.get("timeout"),
+                        }))
+                    self.test_cases.append(TestCase(
+                        name=case["name"],
+                        steps=steps,
+                        description=case.get("description", ""),
+                        resources=case.get("resources"),
+                    ))
+                else:
+                    # Single command mode (backward compatible)
+                    required_fields = ["name", "command", "args", "expected"]
+                    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]:
+        if case.steps:
+            return self._run_sequence(case)
+
+        case_data: TestCaseData = {
+            "name": case.name,
+            "command": case.command,
+            "args": case.args,
+            "expected": case.expected,
+            "description": case.description or None,
+            "timeout": case.timeout,
+            "resources": case.resources,
+        }
+
+        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.5 → cli_test_framework-0.5.0}/src/cli_test_framework/runners/parallel_json_runner.py

@@ -1,6 +1,6 @@
 from typing import Optional, Dict, Any
 from ..core.parallel_runner import ParallelRunner
-from ..core.test_case import TestCase
+from ..core.test_case import TestCase, TestCaseStep
 from ..core.execution import execute_single_test_case
 from ..core.types import TestCaseData
 from ..utils.path_resolver import PathResolver, parse_command_string, resolve_paths
@@ -85,15 +85,40 @@ class ParallelJSONRunner(ParallelRunner):
             # 加载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")
+                if "steps" in case:
+                    # Sequence mode: case has ordered steps
+                    steps = []
+                    for step in case["steps"]:
+                        step_required = ["command", "args", "expected"]
+                        if not all(field in step for field in step_required):
+                            raise ValueError(
+                                f"Step in test case '{case.get('name', 'unnamed')}' is missing required fields"
+                            )
+                        step["command"] = self.path_resolver.parse_command_string(step["command"])
+                        step["args"] = self.path_resolver.resolve_paths(step["args"])
+                        steps.append(TestCaseStep(**{
+                            "command": step["command"],
+                            "args": step["args"],
+                            "expected": step["expected"],
+                            "timeout": step.get("timeout"),
+                        }))
+                    self.test_cases.append(TestCase(
+                        name=case["name"],
+                        steps=steps,
+                        description=case.get("description", ""),
+                        resources=case.get("resources"),
+                    ))
+                else:
+                    # Single command mode (backward compatible)
+                    required_fields = ["name", "command", "args", "expected"]
+                    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))
+                    # 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")
 
@@ -113,6 +138,71 @@ class ParallelJSONRunner(ParallelRunner):
         except Exception as e:
             sys.exit(f"Failed to load configuration file: {str(e)}")
 
+    def _run_sequence(self, case: TestCase) -> Dict[str, Any]:
+        """Run a sequence test case with multiple steps (fail-fast, thread-safe printing)."""
+        combined_output = ""
+        total_duration = 0.0
+        all_passed = True
+        last_result = None
+        failed_step = None
+
+        for i, step in enumerate(case.steps):
+            step_name = f"{case.name} [step {i+1}/{len(case.steps)}]"
+            case_data = {
+                "name": step_name,
+                "command": step.command,
+                "args": step.args,
+                "expected": step.expected,
+                "description": None,
+                "timeout": step.timeout,
+                "resources": None,
+            }
+
+            command_preview = f"{step.command} {' '.join(step.args)}".strip()
+            with self._print_lock:
+                print(f"  [Worker] Executing step {i+1}/{len(case.steps)}: {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 {step_name}:")
+                    for line in result["output"].splitlines():
+                        print(f"    {line}")
+
+            combined_output += result["output"]
+            total_duration += result["duration"]
+            last_result = result
+
+            if result["status"] != "passed":
+                all_passed = False
+                failed_step = i + 1
+                if result.get("message"):
+                    with self._print_lock:
+                        print(f"  [Worker] Error at step {i+1}: {result['message']}")
+                break
+
+        status = "passed" if all_passed else last_result["status"]
+        message = ""
+        if not all_passed:
+            message = f"Failed at step {failed_step}/{len(case.steps)}: {last_result['message']}"
+
+        command_summary = " -> ".join(
+            f"{s.command} {' '.join(s.args)}".strip() for s in case.steps
+        )
+
+        return {
+            "name": case.name,
+            "status": status,
+            "message": message,
+            "command": command_summary,
+            "output": combined_output,
+            "return_code": last_result["return_code"] if last_result else None,
+            "duration": total_duration,
+        }
+
     def run_single_test(self, case: TestCase) -> Dict[str, Any]:
         """
         运行单个测试用例（线程安全版本，支持资源感知调度）
@@ -160,38 +250,42 @@ class ParallelJSONRunner(ParallelRunner):
                 with self._print_lock:
                     print(f"  [Scheduler] Warning: Failed to acquire resources for '{case.name}': {e}")
         
-        # 准备测试用例数据
-        case_data: TestCaseData = {
-            "name": case.name,
-            "command": case.command,
-            "args": case.args,
-            "expected": case.expected,
-            "description": case.description or None,
-            "timeout": case.timeout,
-            "resources": case.resources,
-        }
+        # 4. 执行测试（支持 sequence 和单命令两种模式）
+        if case.steps:
+            result = self._run_sequence(case)
+        else:
+            # 准备测试用例数据
+            case_data: TestCaseData = {
+                "name": case.name,
+                "command": case.command,
+                "args": case.args,
+                "expected": case.expected,
+                "description": case.description or None,
+                "timeout": case.timeout,
+                "resources": case.resources,
+            }
 
-        command_preview = f"{case_data['command']} {' '.join(case_data['args'])}".strip()
-        with self._print_lock:
-            if self.execution_mode != "thread" or self.cpu_semaphore is None:
-                print(f"  [Worker] Executing command: {command_preview}")
+            command_preview = f"{case_data['command']} {' '.join(case_data['args'])}".strip()
+            with self._print_lock:
+                if self.execution_mode != "thread" or self.cpu_semaphore is None:
+                    print(f"  [Worker] Executing command: {command_preview}")
 
-        # 4. 执行测试 (传入 env)
-        result = execute_single_test_case(
-            case_data, 
-            str(self.workspace) if self.workspace else None,
-            env=task_env  # 注入环境变量
-        )
+            # 执行测试 (传入 env)
+            result = execute_single_test_case(
+                case_data, 
+                str(self.workspace) if self.workspace else None,
+                env=task_env  # 注入环境变量
+            )
 
-        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["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']}")
+            if result["status"] != "passed" and result.get("message"):
+                with self._print_lock:
+                    print(f"  [Worker] Error for {case.name}: {result['message']}")
         
         # 5. 归还资源
         if self.execution_mode == "thread" and self.cpu_semaphore is not None and tokens_acquired > 0: