cli-test-framework 0.2.1__tar.gz → 0.2.2__tar.gz

{cli_test_framework-0.2.1/src/cli_test_framework.egg-info → cli_test_framework-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-test-framework
-Version: 0.2.1
+Version: 0.2.2
 Summary: A small command line testing framework in Python with file comparison capabilities.
 Home-page: https://github.com/yourusername/cli-test-framework
 Author: Xiaotong Wang

{cli_test_framework-0.2.1 → cli_test_framework-0.2.2}/setup.py

@@ -1,48 +1,48 @@
-from setuptools import setup, find_packages
-import os
-
-# Read the contents of the README file
-this_directory = os.path.abspath(os.path.dirname(__file__))
-with open(os.path.join(this_directory, 'README.md'), encoding='utf-8') as f:
-    long_description = f.read()
-
-setup(
-    name="cli-test-framework",
-    version="0.2.1",
-    author="Xiaotong Wang",
-    author_email="xiaotongwang98@gmail.com",
-    description="A small command line testing framework in Python with file comparison capabilities.",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/yourusername/cli-test-framework",
-    packages=find_packages(where="src"),
-    package_dir={"": "src"},
-    install_requires=[
-        "dukpy==0.5.0",
-        "h5py>=3.8.0",
-        "numpy>=2.0.1",
-        "setuptools>=75.8.0",
-        "wheel>=0.45.1"
-    ],
-    entry_points={
-        'console_scripts': [
-            'cli-test=cli_test_framework.cli:main',
-            'compare-files=cli_test_framework.commands.compare:main',
-        ],
-    },
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-        "Development Status :: 4 - Beta",
-        "Intended Audience :: Developers",
-        "Topic :: Software Development :: Testing",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-    ],
-    python_requires='>=3.6',
-    project_urls={
-        'Documentation': 'https://github.com/yourusername/cli-test-framework/docs/user_manual.md',
-        'Source': 'https://github.com/yourusername/cli-test-framework',
-        'Tracker': 'https://github.com/yourusername/cli-test-framework/issues',
-    },
+from setuptools import setup, find_packages
+import os
+
+# Read the contents of the README file
+this_directory = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(this_directory, 'README.md'), encoding='utf-8') as f:
+    long_description = f.read()
+
+setup(
+    name="cli-test-framework",
+    version="0.2.2",
+    author="Xiaotong Wang",
+    author_email="xiaotongwang98@gmail.com",
+    description="A small command line testing framework in Python with file comparison capabilities.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/cli-test-framework",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    install_requires=[
+        "dukpy==0.5.0",
+        "h5py>=3.8.0",
+        "numpy>=2.0.1",
+        "setuptools>=75.8.0",
+        "wheel>=0.45.1"
+    ],
+    entry_points={
+        'console_scripts': [
+            'cli-test=cli_test_framework.cli:main',
+            'compare-files=cli_test_framework.commands.compare:main',
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Testing",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+    ],
+    python_requires='>=3.6',
+    project_urls={
+        'Documentation': 'https://github.com/yourusername/cli-test-framework/docs/user_manual.md',
+        'Source': 'https://github.com/yourusername/cli-test-framework',
+        'Tracker': 'https://github.com/yourusername/cli-test-framework/issues',
+    },
 )

cli_test_framework-0.2.2/src/cli_test_framework/__init__.py

@@ -0,0 +1,21 @@
+"""
+CLI Test Framework - A powerful command-line testing framework
+
+This package provides tools for testing command-line applications and scripts
+with support for parallel execution and advanced file comparison capabilities.
+"""
+
+__version__ = "0.2.2"
+__author__ = "Xiaotong Wang"
+__email__ = "xiaotongwang98@gmail.com"
+
+# Import main classes for convenient access
+from .runners.json_runner import JSONRunner
+from .runners.parallel_json_runner import ParallelJSONRunner
+from .runners.yaml_runner import YAMLRunner
+
+__all__ = [
+    'JSONRunner',
+    'ParallelJSONRunner', 
+    'YAMLRunner',
+] 

cli_test_framework-0.2.2/src/cli_test_framework/cli.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+CLI Test Framework - Command Line Interface
+
+This module provides the main command-line interface for the CLI Testing Framework.
+"""
+
+import argparse
+import sys
+import os
+from pathlib import Path
+
+from .runners import JSONRunner, ParallelJSONRunner, YAMLRunner
+
+
+def create_parser():
+    """Create and configure the argument parser"""
+    parser = argparse.ArgumentParser(
+        description="CLI Testing Framework - A powerful tool for testing command-line applications",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  cli-test run test_cases.json
+  cli-test run test_cases.json --parallel --workers 4
+  cli-test run test_cases.yaml --workspace /path/to/project
+        """
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # Run command
+    run_parser = subparsers.add_parser('run', help='Run test cases from a configuration file')
+    run_parser.add_argument('config_file', help='Path to the test configuration file (JSON or YAML)')
+    run_parser.add_argument('--workspace', '-w', help='Working directory for test execution')
+    run_parser.add_argument('--parallel', '-p', action='store_true', help='Run tests in parallel')
+    run_parser.add_argument('--workers', type=int, help='Number of parallel workers (default: CPU count)')
+    run_parser.add_argument('--execution-mode', choices=['thread', 'process'], default='thread',
+                           help='Parallel execution mode (default: thread)')
+    run_parser.add_argument('--output-format', choices=['text', 'json', 'html'], default='text',
+                           help='Output format for test results')
+    run_parser.add_argument('--verbose', '-v', action='store_true', help='Enable verbose output')
+    run_parser.add_argument('--debug', action='store_true', help='Enable debug mode')
+    
+    return parser
+
+
+def run_tests(args):
+    """Run tests based on command line arguments"""
+    config_file = Path(args.config_file)
+    
+    if not config_file.exists():
+        print(f"Error: Configuration file not found: {config_file}")
+        return False
+    
+    # Determine file type
+    file_ext = config_file.suffix.lower()
+    
+    try:
+        if args.parallel:
+            # Use parallel runner
+            runner = ParallelJSONRunner(
+                config_file=str(config_file),
+                workspace=args.workspace,
+                max_workers=args.workers,
+                execution_mode=args.execution_mode
+            )
+        else:
+            # Use appropriate single-threaded runner
+            if file_ext in ['.json']:
+                runner = JSONRunner(
+                    config_file=str(config_file),
+                    workspace=args.workspace
+                )
+            elif file_ext in ['.yaml', '.yml']:
+                runner = YAMLRunner(
+                    config_file=str(config_file),
+                    workspace=args.workspace
+                )
+            else:
+                print(f"Error: Unsupported configuration file format: {file_ext}")
+                return False
+        
+        # Run tests
+        print(f"Running tests from: {config_file}")
+        if args.parallel:
+            print(f"Parallel mode: {args.execution_mode}, workers: {args.workers or 'auto'}")
+        
+        success = runner.run_tests()
+        
+        # Output results
+        if hasattr(runner, 'results'):
+            results = runner.results
+            print(f"\nTest Results:")
+            print(f"Total tests: {results.get('total_tests', 0)}")
+            print(f"Passed: {results.get('passed', 0)}")
+            print(f"Failed: {results.get('failed', 0)}")
+            
+            if args.verbose and 'details' in results:
+                print("\nDetailed Results:")
+                for result in results['details']:
+                    status_symbol = "✓" if result['status'] == 'passed' else "✗"
+                    print(f"  {status_symbol} {result['name']}: {result['status']}")
+                    if result['status'] == 'failed' and result.get('message'):
+                        print(f"    Error: {result['message']}")
+        
+        return success
+        
+    except Exception as e:
+        print(f"Error running tests: {e}")
+        if args.debug:
+            import traceback
+            traceback.print_exc()
+        return False
+
+
+def main():
+    """Main entry point for the CLI"""
+    parser = create_parser()
+    args = parser.parse_args()
+    
+    if args.command == 'run':
+        success = run_tests(args)
+        sys.exit(0 if success else 1)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main() 

cli_test_framework-0.2.2/src/cli_test_framework/core/__init__.py

@@ -0,0 +1,15 @@
+"""
+Core components for the CLI Testing Framework
+"""
+
+from .base_runner import BaseRunner
+from .parallel_runner import ParallelRunner
+from .test_case import TestCase
+from .assertions import Assertions
+
+__all__ = [
+    'BaseRunner',
+    'ParallelRunner', 
+    'TestCase',
+    'Assertions'
+]

{cli_test_framework-0.2.1/src → cli_test_framework-0.2.2/src/cli_test_framework}/core/assertions.py

@@ -1,32 +1,32 @@
-import re
-from typing import Any, Pattern
-
-class Assertions:
-    @staticmethod
-    def equals(actual: Any, expected: Any, message: str = "") -> bool:
-        if actual != expected:
-            raise AssertionError(f"{message} Expected: {expected}, but got: {actual}")
-        return True
-
-    @staticmethod
-    def contains(container: str, item: str, message: str = "") -> bool:
-        """
-        Check if the item is contained within the container string.
-        This method returns True if the item is found anywhere within the container,
-        even if the container contains other information.
-        """
-        if item not in container:
-            raise AssertionError(f"{message} Expected to contain: {item}")
-        return True
-
-    @staticmethod
-    def matches(text: str, pattern: str, message: str = "") -> bool:
-        if not re.search(pattern, text):
-            raise AssertionError(f"{message} Text does not match pattern: {pattern}")
-        return True
-
-    @staticmethod
-    def return_code_equals(actual: int, expected: int, message: str = "") -> bool:
-        if actual != expected:
-            raise AssertionError(f"{message} Expected return code: {expected}, got: {actual}")
+import re
+from typing import Any, Pattern
+
+class Assertions:
+    @staticmethod
+    def equals(actual: Any, expected: Any, message: str = "") -> bool:
+        if actual != expected:
+            raise AssertionError(f"{message} Expected: {expected}, but got: {actual}")
+        return True
+
+    @staticmethod
+    def contains(container: str, item: str, message: str = "") -> bool:
+        """
+        Check if the item is contained within the container string.
+        This method returns True if the item is found anywhere within the container,
+        even if the container contains other information.
+        """
+        if item not in container:
+            raise AssertionError(f"{message} Expected to contain: {item}")
+        return True
+
+    @staticmethod
+    def matches(text: str, pattern: str, message: str = "") -> bool:
+        if not re.search(pattern, text):
+            raise AssertionError(f"{message} Text does not match pattern: {pattern}")
+        return True
+
+    @staticmethod
+    def return_code_equals(actual: int, expected: int, message: str = "") -> bool:
+        if actual != expected:
+            raise AssertionError(f"{message} Expected return code: {expected}, got: {actual}")
         return True

cli_test_framework-0.2.2/src/cli_test_framework/file_comparator/__init__.py

@@ -0,0 +1,9 @@
+"""
+File comparison module for cli-test-framework.
+This module provides functionality for comparing different types of files.
+"""
+
+from .factory import ComparatorFactory
+from .result import ComparisonResult
+
+__all__ = ['ComparatorFactory', 'ComparisonResult'] 

cli_test_framework-0.2.2/src/cli_test_framework/file_comparator/base_comparator.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+@file base_comparator.py
+@brief Base abstract class for file comparison operations
+@author Xiaotong Wang
+@date 2025
+"""
+
+from abc import ABC, abstractmethod
+import logging
+from pathlib import Path
+from .result import ComparisonResult, Difference
+
+class BaseComparator(ABC):
+    """
+    @brief Base abstract class for all file comparators
+    @details This class defines the interface and common functionality for all file comparators.
+             It provides basic file comparison operations and logging capabilities.
+    """
+    
+    def __init__(self, encoding="utf-8", chunk_size=8192, verbose=False):
+        """
+        @brief Initialize the base comparator
+        @param encoding str: File encoding to use (default: "utf-8")
+        @param chunk_size int: Size of chunks for reading large files (default: 8192)
+        @param verbose bool: Enable verbose logging (default: False)
+        """
+        self.encoding = encoding
+        self.chunk_size = chunk_size
+        self.logger = logging.getLogger(f"file_comparator.{self.__class__.__name__}")
+        if verbose:
+            self.logger.setLevel(logging.DEBUG)
+    
+    @abstractmethod
+    def read_content(self, file_path, start_line=0, end_line=None, start_column=0, end_column=None):
+        """
+        @brief Read file content with specified range
+        @param file_path Path: Path to the file to read
+        @param start_line int: Starting line number (0-based)
+        @param end_line int: Ending line number (0-based, None for end of file)
+        @param start_column int: Starting column number (0-based)
+        @param end_column int: Ending column number (0-based, None for end of line)
+        @return object: File content in a format suitable for comparison
+        """
+        pass
+
+    @abstractmethod
+    def compare_content(self, content1, content2):
+        """
+        @brief Compare two content objects and return comparison details
+        @param content1 object: First content object to compare
+        @param content2 object: Second content object to compare
+        @return tuple: (bool, list) - (identical, differences)
+        """
+        pass
+
+    def compare_files(self, file1, file2, start_line=0, end_line=None, start_column=0, end_column=None):
+        """
+        @brief Compare two files with the specified parameters
+        @param file1 Path: Path to the first file
+        @param file2 Path: Path to the second file
+        @param start_line int: Starting line number (0-based)
+        @param end_line int: Ending line number (0-based, None for end of file)
+        @param start_column int: Starting column number (0-based)
+        @param end_column int: Ending column number (0-based, None for end of line)
+        @return ComparisonResult: Result object containing comparison details
+        """
+        result = ComparisonResult(
+            file1=str(file1),
+            file2=str(file2),
+            start_line=start_line,
+            end_line=end_line,
+            start_column=start_column,
+            end_column=end_column
+        )
+        
+        try:
+            self.logger.info(f"Comparing files: {file1} and {file2}")
+            
+            # Record file metadata
+            file1_path = Path(file1)
+            file2_path = Path(file2)
+            result.file1_size = file1_path.stat().st_size
+            result.file2_size = file2_path.stat().st_size
+            
+            # Read content with specified ranges
+            self.logger.debug(f"Reading content from files")
+            content1 = self.read_content(file1, start_line, end_line, start_column, end_column)
+            content2 = self.read_content(file2, start_line, end_line, start_column, end_column)
+            
+            # Compare content
+            self.logger.debug(f"Comparing content")
+            identical, differences = self.compare_content(content1, content2)
+            
+            # Update result
+            result.identical = identical
+            result.differences = differences
+            
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"Error during comparison: {str(e)}")
+            result.error = str(e)
+            result.identical = False
+            return result