Added some more tests

markmclaren · markmclaren · commit 5e758530445c · 2025-10-03T11:53:19.000+01:00
diff --git a/tests/analyze_new_invalid_queries.py b/tests/analyze_new_invalid_queries.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+
+# Add the src directory to Python path to import the checker
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from overpass_ql_checker.checker import OverpassQLSyntaxChecker
+
+def analyze_invalid_queries():
+    """Analyze the invalid queries from invalid_queries_comments.txt"""
+    
+    # Read the queries from the file
+    queries_file = os.path.join(os.path.dirname(__file__), '..', 'invalid_queries_comments.txt')
+    
+    with open(queries_file, 'r', encoding='utf-8') as f:
+        queries = [line.strip() for line in f if line.strip()]
+    
+    print(f"Found {len(queries)} queries to analyze\n")
+    
+    checker = OverpassQLSyntaxChecker()
+    
+    valid_count = 0
+    invalid_count = 0
+    error_patterns = {}
+    
+    for i, query in enumerate(queries, 1):
+        print(f"Query {i}: {query[:80]}{'...' if len(query) > 80 else ''}")
+        
+        try:
+            result = checker.check_syntax(query)
+            is_valid = result['valid']
+            if is_valid:
+                print("  ✓ Current checker considers this VALID")
+                valid_count += 1
+            else:
+                print("  ✗ Current checker considers this INVALID")
+                invalid_count += 1
+                
+                # Get detailed error info
+                errors = result.get('errors', [])
+                if errors:
+                    for error in errors[:2]:  # Show first 2 errors
+                        print(f"    Error: {error}")
+                        
+                        # Categorize error patterns by type of error message
+                        if "Expected" in error:
+                            error_type = "Expected Token"
+                        elif "Unexpected" in error:
+                            error_type = "Unexpected Token"
+                        elif "Invalid" in error:
+                            error_type = "Invalid Syntax"
+                        elif "Unknown" in error:
+                            error_type = "Unknown Element"
+                        else:
+                            error_type = "Other Error"
+                            
+                        if error_type not in error_patterns:
+                            error_patterns[error_type] = 0
+                        error_patterns[error_type] += 1
+                    
+        except Exception as e:
+            print(f"  ! Exception during validation: {e}")
+            invalid_count += 1
+            
+        print()
+    
+    print("\n=== Summary ===")
+    print(f"Total queries: {len(queries)}")
+    print(f"Currently detected as valid: {valid_count}")
+    print(f"Currently detected as invalid: {invalid_count}")
+    
+    if error_patterns:
+        print("\nError pattern distribution:")
+        for pattern, count in sorted(error_patterns.items()):
+            print(f"  {pattern}: {count}")
+
+if __name__ == "__main__":
+    analyze_invalid_queries()
diff --git a/tests/categorize_error_patterns.py b/tests/categorize_error_patterns.py
@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+
+# Add the src directory to Python path to import the checker
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from overpass_ql_checker.checker import OverpassQLSyntaxChecker
+
+def categorize_invalid_query_errors():
+    """Categorize the specific types of errors in the invalid queries"""
+    
+    # Read the queries from the file
+    queries_file = os.path.join(os.path.dirname(__file__), '..', 'invalid_queries_comments.txt')
+    
+    with open(queries_file, 'r', encoding='utf-8') as f:
+        queries = [line.strip() for line in f if line.strip()]
+    
+    print(f"Analyzing error patterns in {len(queries)} invalid queries\n")
+    
+    checker = OverpassQLSyntaxChecker()
+    
+    # Categories of errors we'll track
+    error_categories = {
+        'arrow_operator': [],  # Issues with -> operator
+        'output_format': [],   # Invalid output formats
+        'date_format': [],     # Date format issues  
+        'set_names': [],       # Set name parsing issues
+        'foreach_loops': [],   # Issues with foreach syntax
+        'area_parameters': [], # Area parameter issues
+        'convert_statement': [], # Issues with convert statements
+        'other': []           # Other unclassified errors
+    }
+    
+    for i, query in enumerate(queries, 1):
+        print(f"\nQuery {i}:")
+        print(f"  {query[:100]}{'...' if len(query) > 100 else ''}")
+        
+        result = checker.check_syntax(query)
+        errors = result.get('errors', [])
+        
+        for error in errors[:1]:  # Look at first error for categorization
+            error_lower = error.lower()
+            
+            if 'unexpected token: ->' in error_lower or 'expected ), got .' in error_lower:
+                error_categories['arrow_operator'].append((i, query, error))
+                print(f"  → ARROW OPERATOR: {error}")
+            elif 'invalid output format' in error_lower:
+                error_categories['output_format'].append((i, query, error))
+                print(f"  → OUTPUT FORMAT: {error}")
+            elif 'invalid date format' in error_lower:
+                error_categories['date_format'].append((i, query, error))
+                print(f"  → DATE FORMAT: {error}")
+            elif 'expected set name after' in error_lower:
+                error_categories['set_names'].append((i, query, error))
+                print(f"  → SET NAMES: {error}")
+            elif 'foreach' in error_lower:
+                error_categories['foreach_loops'].append((i, query, error))
+                print(f"  → FOREACH: {error}")
+            elif 'expected area parameter' in error_lower:
+                error_categories['area_parameters'].append((i, query, error))
+                print(f"  → AREA PARAM: {error}")
+            elif 'convert' in error_lower:
+                error_categories['convert_statement'].append((i, query, error))
+                print(f"  → CONVERT: {error}")
+            else:
+                error_categories['other'].append((i, query, error))
+                print(f"  → OTHER: {error}")
+    
+    print("\n" + "="*60)
+    print("ERROR CATEGORY SUMMARY")
+    print("="*60)
+    
+    for category, errors in error_categories.items():
+        if errors:
+            print(f"\n{category.upper().replace('_', ' ')} ({len(errors)} queries):")
+            for query_num, query, error in errors:
+                print(f"  Query {query_num}: {error}")
+    
+    # Analysis of what might need fixing
+    print("\n" + "="*60)
+    print("POTENTIAL IMPROVEMENTS NEEDED")
+    print("="*60)
+    
+    if error_categories['arrow_operator']:
+        print(f"\n• Arrow operator parsing ({len(error_categories['arrow_operator'])} cases)")
+        print("  Many queries use complex arrow syntax that might be valid in real Overpass QL")
+        
+    if error_categories['output_format']:
+        print(f"\n• Output format support ({len(error_categories['output_format'])} cases)")
+        print("  Missing support for: osm, xlsx, pjsonl formats")
+        
+    if error_categories['date_format']:
+        print(f"\n• Date format parsing ({len(error_categories['date_format'])} cases)")
+        print("  Missing support for timezone suffixes like +09:00")
+        
+    if error_categories['set_names']:
+        print(f"\n• Set name handling ({len(error_categories['set_names'])} cases)")
+        print("  Issues with foreach loops and set operations")
+        
+    if error_categories['area_parameters']:
+        print(f"\n• Area parameter parsing ({len(error_categories['area_parameters'])} cases)")
+        print("  Issues with complex area expressions")
+
+if __name__ == "__main__":
+    categorize_invalid_query_errors()
diff --git a/tests/test_comprehensive_invalid_patterns.py b/tests/test_comprehensive_invalid_patterns.py
@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+
+# Add the src directory to Python path to import the checker
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from overpass_ql_checker.checker import OverpassQLSyntaxChecker
+
+
+def test_invalid_output_formats():
+    """Test that invalid output formats are properly rejected"""
+    checker = OverpassQLSyntaxChecker()
+    
+    invalid_formats = [
+        '[out:osm];node[name="test"];out;',
+        '[out:xlsx];node[name="test"];out;', 
+        '[out:pjsonl];way[highway];out;',
+        '[timeout:25][out:osm];node["place"];out;',
+    ]
+    
+    print("Testing invalid output formats...")
+    for i, query in enumerate(invalid_formats, 1):
+        result = checker.check_syntax(query)
+        assert not result['valid'], f"Query {i} should be invalid: {query}"
+        assert any("Invalid output format" in error for error in result['errors']), \
+            f"Query {i} should have output format error"
+        print(f"  ✓ Query {i}: Correctly rejected invalid output format")
+
+
+def test_invalid_date_formats():
+    """Test that invalid date formats with timezone suffixes are rejected"""
+    checker = OverpassQLSyntaxChecker()
+    
+    invalid_dates = [
+        '[date:"2014-05-13T00:00:00H"];node["building"];out;',
+        '[date:"2020-03-01T00:00:00+09:00"];node["amenity"];out;',
+        '[date:"2020-04-01T00:00:00+09:00"];way["highway"];out;',
+        '[date:"2020-05-01T00:00:00+09:00"];relation["type"];out;',
+    ]
+    
+    print("Testing invalid date formats...")
+    for i, query in enumerate(invalid_dates, 1):
+        result = checker.check_syntax(query)
+        assert not result['valid'], f"Query {i} should be invalid: {query}"
+        assert any("Invalid date format" in error for error in result['errors']), \
+            f"Query {i} should have date format error"
+        print(f"  ✓ Query {i}: Correctly rejected invalid date format")
+
+
+def test_complex_arrow_operator_issues():
+    """Test complex arrow operator syntax issues"""
+    checker = OverpassQLSyntaxChecker()
+    
+    arrow_issues = [
+        'relation["route"~"^hiking$"]({{bbox}});>->.r;((way["colour"]({{bbox}});-way.r;);>->.x;<;);out;',
+        'way["waterway"="stream"]({{bbox}})->.CurrentWaterWay;node(w.CurrentWaterWay)->.NodesOfCurrentWaterWay;.NodesOfCurrentWaterWay out;for.NodesOfCurrentWaterWay->.z(id()){make debug Nodes=z.val;out;if(..count_members==..count_members){}.z->.lastNode;}make debug enters="------------";out;.lastNode out;',
+        '((way["highway"]["colour"]["area"!~"."](area:3601473946);way(165060349););(._;>->.x;<;);out;',
+    ]
+    
+    print("Testing complex arrow operator issues...")
+    for i, query in enumerate(arrow_issues, 1):
+        result = checker.check_syntax(query)
+        assert not result['valid'], f"Query {i} should be invalid: {query}"
+        # These should have syntax errors related to arrow operators or unexpected tokens
+        has_arrow_error = any("Unexpected token: ->" in error or "Expected ), got ." in error 
+                             for error in result['errors'])
+        assert has_arrow_error, f"Query {i} should have arrow operator error"
+        print(f"  ✓ Query {i}: Correctly rejected complex arrow syntax")
+
+
+def test_foreach_and_set_issues():
+    """Test foreach loop and set name parsing issues"""
+    checker = OverpassQLSyntaxChecker()
+    
+    set_issues = [
+        'relation(416351);foreach->.rel{way["wikidata"](r.rel)->.ways;relation.rel;out;}',
+        'way["wikidata"]({{bbox}});foreach->.rel{way.all(r.rel)->.ways;relation.rel;out;}',
+        'area[name="test"];relation["boundary"](area);map_to_area;foreach->.rel{relation.rel;out;}',
+    ]
+    
+    print("Testing foreach and set name issues...")
+    for i, query in enumerate(set_issues, 1):
+        result = checker.check_syntax(query)
+        assert not result['valid'], f"Query {i} should be invalid: {query}"
+        # These should have syntax errors related to set names
+        has_set_error = any("Expected set name after" in error or "Expected ;, got" in error 
+                           for error in result['errors'])
+        assert has_set_error, f"Query {i} should have set name error"
+        print(f"  ✓ Query {i}: Correctly rejected set name syntax")
+
+
+def test_area_parameter_issues():
+    """Test area parameter and geocode syntax issues"""
+    checker = OverpassQLSyntaxChecker()
+    
+    area_issues = [
+        '[date:"2014-05-13T00:00:00H"];{{geocodeArea:"El Segundo"}}->.searchArea;(node["building"](area.searchArea);way["building"](area.searchArea);relation["building"](area.searchArea););out qt geom;',
+        '[out:json][timeout:25];{{geocodeArea:"Duisburg"}}->.searchArea;(node["memorial:type"="stolperstein"](area.searchArea);area(area.searchArea););out;>;out skel qt;',
+    ]
+    
+    print("Testing area parameter issues...")
+    for i, query in enumerate(area_issues, 1):
+        result = checker.check_syntax(query)
+        assert not result['valid'], f"Query {i} should be invalid: {query}"
+        print(f"  ✓ Query {i}: Correctly rejected area syntax issue")
+
+
+def test_convert_statement_issues():
+    """Test convert statement syntax issues"""
+    checker = OverpassQLSyntaxChecker()
+    
+    convert_issues = [
+        '[out:json][timeout:1000];node["public_transport"="stop_position"]["name"]["bus"="yes"](around:100,45.1933211,5.7326121)->.bus_stop;foreach.bus_stop->.stop{(node.bus_stop;<;)->.bus_way_rel;relation.bus_way_rel["route"="bus"]["ref"]->.bus_rel;convert bus_stop_info ::=id(),!lines;out;}(node.bus_stop;<;)->.bus_way_rel;relation.bus_way_rel["route"="bus"]["ref"]->.bus_rel;.bus_rel out count;.bus_rel out;.bus_stop out count;.bus_stop out;',
+    ]
+    
+    print("Testing convert statement issues...")
+    for i, query in enumerate(convert_issues, 1):
+        result = checker.check_syntax(query)
+        assert not result['valid'], f"Query {i} should be invalid: {query}"
+        print(f"  ✓ Query {i}: Correctly rejected convert statement syntax")
+
+
+def test_all_invalid_query_samples():
+    """Test all 30 invalid queries from the file to ensure they're caught"""
+    checker = OverpassQLSyntaxChecker()
+    
+    # Read the queries from the file
+    queries_file = os.path.join(os.path.dirname(__file__), '..', 'invalid_queries_comments.txt')
+    
+    with open(queries_file, 'r', encoding='utf-8') as f:
+        queries = [line.strip() for line in f if line.strip()]
+    
+    print(f"Testing all {len(queries)} invalid queries from file...")
+    
+    for i, query in enumerate(queries, 1):
+        result = checker.check_syntax(query)
+        assert not result['valid'], f"Query {i} should be invalid: {query[:50]}..."
+        assert len(result['errors']) > 0, f"Query {i} should have error messages"
+        
+    print(f"  ✓ All {len(queries)} queries correctly identified as invalid")
+
+
+def run_comprehensive_invalid_tests():
+    """Run all invalid query tests"""
+    print("="*60)
+    print("COMPREHENSIVE INVALID QUERY TESTS")
+    print("="*60)
+    
+    test_invalid_output_formats()
+    print()
+    
+    test_invalid_date_formats()
+    print()
+    
+    test_complex_arrow_operator_issues()
+    print()
+    
+    test_foreach_and_set_issues()
+    print()
+    
+    test_area_parameter_issues()
+    print()
+    
+    test_convert_statement_issues()
+    print()
+    
+    test_all_invalid_query_samples()
+    print()
+    
+    print("="*60)
+    print("✅ ALL TESTS PASSED!")
+    print("The checker correctly identifies all invalid query patterns.")
+    print("="*60)
+
+
+if __name__ == "__main__":
+    run_comprehensive_invalid_tests()
