contextsynapse 1.0.0__py3-none-any.whl

contextsynapse/tests/regression/setup_regression_data.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""
+Setup Regression Test Data
+Runs ingestion pipelines to create test data for regression tests.
+Supports multiple chunking strategies: recursive, fixed-size, semantic, section-based.
+"""
+import sys
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+# Add project root to path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from contextsynapse import AIContextDB
+from contextsynapse.aiql.engine import AIQLExecutor
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Regression test namespace
+REGRESSION_NAMESPACE = "tcs_regression_test"
+
+# Pipeline files
+PIPELINE_DIR = Path(__file__).parent / "pipelines"
+PIPELINES = {
+    "recursive": PIPELINE_DIR / "regression_ingestion_recursive.aiql",
+    "fixed_size": PIPELINE_DIR / "regression_ingestion_fixed_size.aiql",
+    "semantic": PIPELINE_DIR / "regression_ingestion_semantic.aiql",
+    "section": PIPELINE_DIR / "regression_ingestion_section.aiql",
+}
+
+
+def load_pipeline_query(pipeline_file: Path) -> str:
+    """Load pipeline query from file."""
+    try:
+        with open(pipeline_file, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        logger.error(f"Failed to load pipeline from {pipeline_file}: {e}")
+        return None
+
+
+def create_namespace(executor: AIQLExecutor, namespace: str) -> bool:
+    """Create namespace if it doesn't exist."""
+    try:
+        create_query = f"CREATE NAMESPACE {namespace}"
+        result = executor.execute(create_query)
+        logger.info(f"Created namespace: {namespace}")
+        return True
+    except Exception as e:
+        # Namespace might already exist
+        logger.debug(f"Namespace creation (may already exist): {e}")
+        return True
+
+
+def create_pipeline(executor: AIQLExecutor, pipeline_query: str) -> bool:
+    """Create pipeline from query."""
+    try:
+        # Set namespace first
+        use_query = f"USE NAMESPACE {REGRESSION_NAMESPACE}"
+        executor.execute(use_query)
+        
+        # Create pipeline
+        result = executor.execute(pipeline_query)
+        logger.info("Pipeline created successfully")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to create pipeline: {e}")
+        return False
+
+
+def run_pipeline(executor: AIQLExecutor, pipeline_name: str, input_file: str) -> bool:
+    """Run pipeline on input file."""
+    try:
+        # Set namespace first
+        use_query = f"USE NAMESPACE {REGRESSION_NAMESPACE}"
+        executor.execute(use_query)
+        
+        # Run pipeline
+        run_query = f'RUN PIPELINE {pipeline_name} ON "{input_file}"'
+        result = executor.execute(run_query)
+        logger.info(f"Pipeline {pipeline_name} executed successfully")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to run pipeline {pipeline_name}: {e}")
+        return False
+
+
+def setup_regression_data(
+    strategies: Optional[List[str]] = None,
+    input_file: Optional[str] = None,
+    create_only: bool = False
+) -> bool:
+    """
+    Setup regression test data by creating and optionally running ingestion pipelines.
+    
+    Args:
+        strategies: List of strategies to use (recursive, fixed_size, semantic, section).
+                   If None, uses all strategies.
+        input_file: Path to input PDF file. Required if create_only=False.
+        create_only: If True, only create pipelines without running them.
+    
+    Returns:
+        True if successful, False otherwise.
+    """
+    if strategies is None:
+        strategies = list(PIPELINES.keys())
+    
+    # Initialize executor
+    try:
+        graph = AIContextDB(REGRESSION_NAMESPACE, storage_backend='csr')
+        executor = AIQLExecutor(contextcore=graph)
+        executor.active_namespace = REGRESSION_NAMESPACE
+        
+        # Create namespace
+        if not create_namespace(executor, REGRESSION_NAMESPACE):
+            logger.error("Failed to create namespace")
+            return False
+        
+        # Create and optionally run pipelines
+        success_count = 0
+        for strategy in strategies:
+            if strategy not in PIPELINES:
+                logger.warning(f"Unknown strategy: {strategy}, skipping")
+                continue
+            
+            pipeline_file = PIPELINES[strategy]
+            logger.info(f"\n{'='*60}")
+            logger.info(f"Processing strategy: {strategy}")
+            logger.info(f"{'='*60}")
+            
+            # Load pipeline query
+            pipeline_query = load_pipeline_query(pipeline_file)
+            if not pipeline_query:
+                logger.error(f"Failed to load pipeline for {strategy}")
+                continue
+            
+            # Create pipeline
+            pipeline_name = f"regression_ingestion_{strategy}"
+            logger.info(f"Creating pipeline: {pipeline_name}")
+            if not create_pipeline(executor, pipeline_query):
+                logger.error(f"Failed to create pipeline: {pipeline_name}")
+                continue
+            
+            # Run pipeline if requested
+            if not create_only:
+                if not input_file:
+                    logger.error("input_file required when create_only=False")
+                    return False
+                
+                logger.info(f"Running pipeline: {pipeline_name} on {input_file}")
+                if run_pipeline(executor, pipeline_name, input_file):
+                    success_count += 1
+                else:
+                    logger.error(f"Failed to run pipeline: {pipeline_name}")
+            else:
+                logger.info(f"Pipeline {pipeline_name} created (not running)")
+                success_count += 1
+        
+        logger.info(f"\n{'='*60}")
+        logger.info(f"Setup complete: {success_count}/{len(strategies)} pipelines processed")
+        logger.info(f"{'='*60}")
+        
+        return success_count == len(strategies)
+    
+    except Exception as e:
+        logger.error(f"Setup failed: {e}")
+        return False
+
+
+def main():
+    """Main entry point."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Setup regression test data")
+    parser.add_argument(
+        "--strategies",
+        nargs="+",
+        choices=list(PIPELINES.keys()),
+        default=list(PIPELINES.keys()),
+        help="Chunking strategies to use (default: all)"
+    )
+    parser.add_argument(
+        "--input-file",
+        type=str,
+        help="Path to input PDF file (required if --create-only is not set)"
+    )
+    parser.add_argument(
+        "--create-only",
+        action="store_true",
+        help="Only create pipelines without running them"
+    )
+    
+    args = parser.parse_args()
+    
+    if not args.create_only and not args.input_file:
+        parser.error("--input-file is required when --create-only is not set")
+    
+    success = setup_regression_data(
+        strategies=args.strategies,
+        input_file=args.input_file,
+        create_only=args.create_only
+    )
+    
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()
+

contextsynapse/tests/regression/test_basic_only.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+Quick test runner for basic tests only (Level 0-2).
+"""
+import sys
+from pathlib import Path
+
+# Add parent to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from tests.regression.regression_runner import RegressionTestRunner
+import time
+
+def run_basic_tests():
+    """Run only Level 0-2 tests."""
+    print("=" * 80)
+    print("BASIC TESTS ONLY (Level 0-2)")
+    print("=" * 80)
+    
+    runner = RegressionTestRunner(mode="direct")
+    runner.load_test_cases()
+    
+    # Filter to only basic tests (priority 0-2)
+    basic_tests = [tc for tc in runner.test_cases if tc.priority <= 2]
+    
+    print(f"\nFound {len(basic_tests)} basic tests:")
+    for tc in basic_tests:
+        skip_status = " [WILL SKIP]" if tc.skip else ""
+        print(f"  - {tc.id}: {tc.name} (Priority {tc.priority}){skip_status}")
+    
+    print("\n" + "=" * 80)
+    print("EXECUTING TESTS...")
+    print("=" * 80 + "\n")
+    
+    results = []
+    for i, tc in enumerate(basic_tests, 1):
+        print(f"\n[{i}/{len(basic_tests)}] {tc.name} ({tc.id})")
+        print(f"  Priority: {tc.priority}")
+        print(f"  Namespace: {tc.namespace}")
+        
+        if tc.skip:
+            print(f"  Status: SKIPPED - {tc.skip_reason}")
+            continue
+        
+        # Execute test in direct mode only
+        start = time.time()
+        result = runner.execute_test_case(tc, mode="direct")
+        duration = time.time() - start
+        
+        results.append(result)
+        
+        if result.skipped:
+            print(f"  Status: SKIPPED - {result.skip_reason}")
+        elif result.passed:
+            print(f"  Status: [PASS] ({result.execution_time_ms:.0f}ms)")
+        else:
+            print(f"  Status: [FAIL] ({result.execution_time_ms:.0f}ms)")
+            if result.error:
+                print(f"  Error: {result.error[:200]}")
+    
+    print("\n" + "=" * 80)
+    print("SUMMARY")
+    print("=" * 80)
+    
+    passed = sum(1 for r in results if r.passed and not r.skipped)
+    failed = sum(1 for r in results if not r.passed and not r.skipped)
+    skipped = sum(1 for r in results if r.skipped)
+    
+    print(f"Total: {len(basic_tests)} tests")
+    print(f"Passed: {passed}")
+    print(f"Failed: {failed}")
+    print(f"Skipped: {skipped}")
+    
+    if failed + passed > 0:
+        pass_rate = (passed / (failed + passed)) * 100
+        print(f"Pass Rate: {pass_rate:.1f}%")
+    
+    print("=" * 80)
+    
+    return results
+
+if __name__ == '__main__':
+    run_basic_tests()
+

contextsynapse/tests/regression/test_namespace_creation.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""Test namespace creation."""
+from contextsynapse.core.hybrid_graph_storage import AIContextDB
+from contextsynapse.aiql.engine import AIQLExecutor
+
+graph = AIContextDB('regression_test', storage_backend='csr')
+executor = AIQLExecutor(contextcore=graph)
+
+# Try different namespace creation syntaxes
+queries = [
+    "CREATE NAMESPACE regression_test",
+    "CREATE NAMESPACE regression_test MODE PERSISTENT",
+    "CREATE NAMESPACE IF NOT EXISTS regression_test",
+]
+
+for query in queries:
+    print(f"\nTrying: {query}")
+    result = executor.execute(query)
+    print(f"Success: {result.get('success')}")
+    print(f"Error: {result.get('error', 'None')}")
+    if result.get('success'):
+        break
+
+# Now try USE NAMESPACE
+print("\nTrying USE NAMESPACE regression_test")
+result = executor.execute("USE NAMESPACE regression_test")
+print(f"Success: {result.get('success')}")
+print(f"Error: {result.get('error', 'None')}")
+

contextsynapse/tests/regression/test_single_fix.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""Test if USE NAMESPACE fix works."""
+from contextsynapse.core.hybrid_graph_storage import AIContextDB
+from contextsynapse.core.registry import GraphRegistry
+from contextsynapse.aiql.engine import AIQLExecutor
+
+print("Testing USE NAMESPACE fix...")
+
+# Create graph registry
+gr = GraphRegistry()
+
+# Get graph for namespace
+graph = gr.get_graph('test_fix', load_if_missing=True)
+if not graph:
+    graph = AIContextDB(name='test_fix', storage_backend='csr')
+
+# Create executor
+executor = AIQLExecutor(contextcore=graph)
+executor.graph_registry = gr
+executor.active_namespace = 'test_fix'
+
+# Test 1: Create namespace
+print("\n1. Creating namespace...")
+result1 = executor.execute("CREATE NAMESPACE test_fix MODE PERSISTENT")
+print(f"   Success: {result1.get('success')}")
+if not result1.get('success'):
+    print(f"   Error: {result1.get('error', 'None')[:200]}")
+
+# Test 2: USE NAMESPACE (this was failing before)
+print("\n2. Using namespace...")
+result2 = executor.execute("USE NAMESPACE test_fix")
+print(f"   Success: {result2.get('success')}")
+if not result2.get('success'):
+    print(f"   Error: {result2.get('error', 'None')[:200]}")
+else:
+    print(f"   Message: {result2.get('data', {}).get('message', 'None')[:200]}")
+
+# Test 3: Create node
+print("\n3. Creating node...")
+result3 = executor.execute("CREATE NODE TestNode { name: 'test', value: 42 }")
+print(f"   Success: {result3.get('success')}")
+if not result3.get('success'):
+    print(f"   Error: {result3.get('error', 'None')[:200]}")
+
+# Test 4: Select node
+print("\n4. Selecting node...")
+result4 = executor.execute("SELECT * FROM TestNode WHERE name = 'test'")
+# result4 could be a list or dict depending on the executor
+if isinstance(result4, list):
+    print(f"   Success: True")
+    print(f"   Found {len(result4)} node(s)")
+else:
+    print(f"   Success: {result4.get('success')}")
+    if not result4.get('success'):
+        print(f"   Error: {result4.get('error', 'None')[:200]}")
+    else:
+        nodes = result4.get('nodes', [])
+        print(f"   Found {len(nodes)} node(s)")
+
+print("\n✅ All tests completed!")
+

contextsynapse/tests/regression/test_single_query.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+"""Test a single query to diagnose issues."""
+from contextsynapse.core.hybrid_graph_storage import AIContextDB
+from contextsynapse.aiql.engine import AIQLExecutor
+
+query = """USE NAMESPACE regression_test;
+CREATE NODE TestNode { name: "regression_test", value: 42, active: true }"""
+
+graph = AIContextDB('regression_test', storage_backend='csr')
+executor = AIQLExecutor(contextcore=graph)
+executor.active_namespace = 'regression_test'
+
+print(f"Query: {query}")
+print("Executing...")
+result = executor.execute(query)
+print(f"Success: {result.get('success')}")
+print(f"Error: {result.get('error', 'None')}")
+print(f"Result keys: {list(result.keys())}")
+print(f"Full result: {result}")
+

contextsynapse/tests/regression/validate_test_syntax.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+AIQL Test Syntax Validator
+
+Validates all regression test queries against the current AIQL grammar.
+Run this BEFORE executing tests to catch syntax errors early.
+
+Purpose: Prevent grammar drift and ensure test consistency.
+"""
+import sys
+from pathlib import Path
+import yaml
+from typing import Dict, List, Tuple
+
+# Add parent to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from contextsynapse.aiql.aiql_parser import AIQLParser
+
+
+class TestSyntaxValidator:
+    """Validates test queries against AIQL grammar."""
+    
+    def __init__(self, test_dir: str = "tests/regression/cases"):
+        self.test_dir = Path(test_dir)
+        self.parser = AIQLParser()
+        self.results = {
+            'valid': [],
+            'invalid': [],
+            'skipped': []
+        }
+    
+    def validate_query(self, query: str, test_id: str) -> Tuple[bool, str]:
+        """
+        Validate a single query.
+        
+        Returns:
+            (is_valid, error_message)
+        """
+        try:
+            # Try to parse the query
+            self.parser.parse(query)
+            return True, ""
+        except Exception as e:
+            error_msg = str(e)
+            # Extract just the relevant error info
+            if "No terminal matches" in error_msg:
+                lines = error_msg.split('\n')
+                error_msg = lines[0] if lines else error_msg
+            return False, error_msg
+    
+    def validate_all_tests(self) -> Dict:
+        """Validate all test files."""
+        print("=" * 80)
+        print("AIQL TEST SYNTAX VALIDATOR")
+        print("=" * 80)
+        print(f"Validating tests in: {self.test_dir}")
+        print()
+        
+        test_files = sorted(self.test_dir.glob("test_*.yaml"))
+        
+        for test_file in test_files:
+            try:
+                with open(test_file, 'r', encoding='utf-8') as f:
+                    data = yaml.safe_load(f)
+                
+                test_id = data.get('id', test_file.stem)
+                test_name = data.get('name', 'Unknown')
+                query = data.get('query', '')
+                skip = data.get('skip', False)
+                
+                # Check if test is intentionally skipped
+                if skip:
+                    self.results['skipped'].append({
+                        'id': test_id,
+                        'name': test_name,
+                        'file': test_file.name,
+                        'reason': data.get('skip_reason', 'Not specified')
+                    })
+                    continue
+                
+                # Validate query syntax
+                is_valid, error = self.validate_query(query, test_id)
+                
+                if is_valid:
+                    self.results['valid'].append({
+                        'id': test_id,
+                        'name': test_name,
+                        'file': test_file.name
+                    })
+                    print(f"[VALID] {test_file.name}: {test_name}")
+                else:
+                    self.results['invalid'].append({
+                        'id': test_id,
+                        'name': test_name,
+                        'file': test_file.name,
+                        'query': query[:100] + '...' if len(query) > 100 else query,
+                        'error': error
+                    })
+                    print(f"[INVALID] {test_file.name}: {test_name}")
+                    print(f"   Error: {error[:150]}")
+                    print()
+            
+            except Exception as e:
+                print(f"[WARNING] {test_file.name}: Error loading file - {e}")
+        
+        return self.results
+    
+    def print_summary(self):
+        """Print validation summary."""
+        print("\n" + "=" * 80)
+        print("VALIDATION SUMMARY")
+        print("=" * 80)
+        
+        total = len(self.results['valid']) + len(self.results['invalid']) + len(self.results['skipped'])
+        valid = len(self.results['valid'])
+        invalid = len(self.results['invalid'])
+        skipped = len(self.results['skipped'])
+        
+        print(f"Total Tests: {total}")
+        print(f"[VALID] Valid Syntax: {valid}")
+        print(f"[INVALID] Invalid Syntax: {invalid}")
+        print(f"[SKIP] Skipped (Intentional): {skipped}")
+        
+        if invalid > 0:
+            print(f"\n[WARNING] {invalid} tests have SYNTAX ERRORS and need fixing!")
+            print("\nInvalid Tests:")
+            for test in self.results['invalid']:
+                print(f"  - {test['file']}: {test['name']}")
+                print(f"    ID: {test['id']}")
+                print(f"    Error: {test['error'][:100]}")
+                print()
+        else:
+            print("\n[SUCCESS] All runnable tests have valid syntax!")
+        
+        if valid > 0:
+            runnable_pass_rate = (valid / (valid + invalid)) * 100 if (valid + invalid) > 0 else 0
+            print(f"\n[STATS] Syntax Validity Rate: {runnable_pass_rate:.1f}% ({valid}/{valid + invalid} runnable tests)")
+        
+        print("=" * 80)
+        
+        return invalid == 0
+    
+    def save_report(self, output_file: str = "syntax_validation_report.json"):
+        """Save validation report to JSON."""
+        import json
+        from datetime import datetime
+        
+        report = {
+            'timestamp': datetime.now().isoformat(),
+            'summary': {
+                'total': len(self.results['valid']) + len(self.results['invalid']) + len(self.results['skipped']),
+                'valid': len(self.results['valid']),
+                'invalid': len(self.results['invalid']),
+                'skipped': len(self.results['skipped'])
+            },
+            'results': self.results
+        }
+        
+        with open(output_file, 'w') as f:
+            json.dump(report, f, indent=2)
+        
+        print(f"\n[REPORT] Report saved to: {output_file}")
+
+
+def main():
+    """Main entry point."""
+    validator = TestSyntaxValidator()
+    validator.validate_all_tests()
+    all_valid = validator.print_summary()
+    validator.save_report()
+    
+    # Exit with error code if any tests have syntax errors
+    sys.exit(0 if all_valid else 1)
+
+
+if __name__ == '__main__':
+    main()
+