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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-test-framework
-Version: 0.2.1
+Version: 0.2.3
 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.3}/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.3",
+    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.3/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.3"
+__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.3/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.3/src/cli_test_framework/commands/__init__.py

@@ -0,0 +1,9 @@
+"""
+Command-line commands for the CLI Testing Framework
+"""
+
+from . import compare
+
+__all__ = [
+    'compare'
+] 

cli_test_framework-0.2.3/src/cli_test_framework/commands/compare.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+@file compare.py
+@brief Command for comparing files in cli-test-framework
+@author Xiaotong Wang
+@date 2024
+"""
+
+import sys
+import os
+import argparse
+import logging
+from pathlib import Path
+from ..file_comparator.factory import ComparatorFactory
+from ..file_comparator.result import ComparisonResult
+
+def configure_logging():
+    """Configure logging settings for the application"""
+    logger = logging.getLogger("cli_test_framework.file_comparator")
+    logger.setLevel(logging.INFO)
+    
+    ch = logging.StreamHandler()
+    ch.setLevel(logging.INFO)
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)
+    
+    return logger
+
+def parse_arguments():
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(description="Compare two files.")
+    parser.add_argument("file1", help="Path to the first file")
+    parser.add_argument("file2", help="Path to the second file")
+    parser.add_argument("--start-line", type=int, default=1, help="Starting line number (1-based)")
+    parser.add_argument("--end-line", type=int, help="Ending line number (1-based)")
+    parser.add_argument("--start-column", type=int, default=1, help="Starting column number (1-based)")
+    parser.add_argument("--end-column", type=int, help="Ending column number (1-based)")
+    parser.add_argument("--file-type", help="Type of the files to compare", default="auto")
+    parser.add_argument("--encoding", default="utf-8", help="File encoding for text files")
+    parser.add_argument("--chunk-size", type=int, default=8192, help="Chunk size for binary comparison")
+    parser.add_argument("--output-format", choices=["text", "json", "html"], default="text",
+                        help="Output format for the comparison result")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose output")
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode with detailed logging")
+    parser.add_argument("--similarity", action="store_true",
+                        help="When comparing binary files, compute and show similarity index")
+    parser.add_argument("--num-threads", type=int, default=4, help="Number of threads for parallel processing")
+    
+    # JSON comparison options
+    json_group = parser.add_argument_group('JSON comparison options')
+    json_group.add_argument("--json-compare-mode", choices=["exact", "key-based"], default="exact",
+                      help="JSON comparison mode: exact (default) or key-based")
+    json_group.add_argument("--json-key-field", help="Key field(s) to use for key-based JSON comparison")
+    
+    # H5 comparison options
+    h5_group = parser.add_argument_group('HDF5 comparison options')
+    h5_group.add_argument("--h5-table", help="Comma-separated list of table names to compare in HDF5 files")
+    h5_group.add_argument("--h5-table-regex", help="Regular expression pattern to match table names in HDF5 files")
+    h5_group.add_argument("--h5-structure-only", action="store_true", 
+                         help="Only compare HDF5 file structure without comparing content")
+    h5_group.add_argument("--h5-show-content-diff", action="store_true",
+                         help="Show detailed content differences when content differs")
+    h5_group.add_argument("--h5-rtol", type=float, default=1e-5,
+                         help="Relative tolerance for numerical comparison in HDF5 files")
+    h5_group.add_argument("--h5-atol", type=float, default=1e-8,
+                         help="Absolute tolerance for numerical comparison in HDF5 files")
+    
+    return parser.parse_args()
+
+def detect_file_type(file_path):
+    """Detect the type of file based on its extension"""
+    ext = file_path.suffix.lower()
+    if ext in ['.txt', '.py', '.md', '.json', '.xml', '.html', '.css', '.js']:
+        return 'text'
+    elif ext == '.json':
+        return 'json'
+    elif ext in ['.h5', '.hdf5']:
+        return 'h5'
+    else:
+        return 'binary'
+
+def format_result(result, output_format):
+    """Format the comparison result according to the specified output format"""
+    if output_format == "json":
+        return result.to_json()
+    elif output_format == "html":
+        return result.to_html()
+    else:
+        return str(result)
+
+def main():
+    """Main entry point for the compare-files command"""
+    logger = configure_logging()
+
+    try:
+        args = parse_arguments()
+        
+        if args.debug:
+            logger.setLevel(logging.DEBUG)
+            logger.debug("Debug mode enabled")
+
+        # Adjust for 0-based indexing
+        start_line = max(0, args.start_line - 1)
+        end_line = None if args.end_line is None else max(0, args.end_line - 1)
+        start_column = max(0, args.start_column - 1)
+        end_column = None if args.end_column is None else max(0, args.end_column - 1)
+
+        # Resolve file paths
+        file1_path = Path(args.file1).resolve()
+        file2_path = Path(args.file2).resolve()
+
+        if not file1_path.exists():
+            raise ValueError(f"File not found: {file1_path}")
+        if not file2_path.exists():
+            raise ValueError(f"File not found: {file2_path}")
+
+        # Determine file type
+        file_type = args.file_type
+        if file_type == "auto":
+            file_type = detect_file_type(file1_path)
+            logger.info(f"Auto-detected file type: {file_type}")
+
+        # Prepare comparator kwargs
+        comparator_kwargs = {
+            "encoding": args.encoding,
+            "chunk_size": args.chunk_size,
+            "verbose": args.verbose or args.debug,
+            "num_threads": args.num_threads
+        }
+        
+        # Add file type specific arguments
+        if file_type == "json":
+            comparator_kwargs["compare_mode"] = args.json_compare_mode
+            if args.json_key_field:
+                key_fields = [field.strip() for field in args.json_key_field.split(',')]
+                comparator_kwargs["key_field"] = key_fields[0] if len(key_fields) == 1 else key_fields
+        
+        if file_type == "h5":
+            if args.h5_table:
+                tables = [table.strip() for table in args.h5_table.split(',')]
+                comparator_kwargs["tables"] = tables
+            if args.h5_table_regex:
+                comparator_kwargs["table_regex"] = args.h5_table_regex
+            comparator_kwargs["structure_only"] = args.h5_structure_only
+            comparator_kwargs["show_content_diff"] = args.h5_show_content_diff
+            comparator_kwargs["rtol"] = args.h5_rtol
+            comparator_kwargs["atol"] = args.h5_atol
+        
+        if file_type == "binary":
+            comparator_kwargs["similarity"] = args.similarity
+
+        # Create comparator and perform comparison
+        comparator = ComparatorFactory.create_comparator(file_type, **comparator_kwargs)
+        result = comparator.compare_files(
+            file1_path,
+            file2_path,
+            start_line,
+            end_line,
+            start_column,
+            end_column
+        )
+
+        # Output result
+        output = format_result(result, args.output_format)
+        print(output)
+
+        sys.exit(0 if result.identical else 1)
+
+    except ValueError as ve:
+        logger.error(f"ValueError: {ve}")
+        sys.exit(1)
+    except Exception as e:
+        logger.exception(f"An unexpected error occurred")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

cli_test_framework-0.2.3/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.3/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.3/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.3/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