Complete SQLx Test Migration (Phases 2-4)

[tobyhede]

Complete SQLx Test Migration (Phases 2-4)

🎯 Overview

This PR provides comprehensive Rust/SQLx test coverage for EQL operators, migrating SQL tests to a modern, type-safe testing framework with ~118 tests across 9 test files.

Updated scope: This PR now includes ALL remaining SQLx test migration work (Phases 2-4), not just comparison and inequality operators.

📦 What's Included

Test Files (9 total)

Phase 2a-b: Base (already in main via PR #140):

• equality_tests.rs - 24 tests for = operator and eq() function
• jsonb_tests.rs - 15 tests for JSONB operations
• test_helpers_test.rs - 2 tests for helper validation

Phase 2c: Comparison & Inequality (original PR #144 scope):

• comparison_tests.rs - 24 tests for <, >, <=, >= operators
• inequality_tests.rs - 20 tests for <> operator and neq() function

Phase 3-4: Extended Coverage (NEW in this PR):

• order_by_tests.rs - 6 tests for ORDER BY with ORE encryption
• jsonb_path_operators_tests.rs - 6 tests for -> and ->> operators
• ore_equality_tests.rs - 14 tests for ORE encryption variants (ORE64, CLLW_U64_8, CLLW_VAR_8)
• containment_tests.rs - 7 tests for @> and <@ containment operators

Test Infrastructure

Shared Helpers (tests/sqlx/src/):

• helpers.rs - Reusable test utilities
  • get_ore_encrypted() - Extract ORE encrypted values from test data
  • get_encrypted_term() - Extract encrypted terms for containment tests
• assertions.rs - QueryAssertion builder for fluent test assertions
• selectors.rs - JSONB selector hash constants
• index_types.rs - Index type constants

Fixtures:

• encrypted_json.sql - Test data for JSONB operator tests

📊 Statistics

Test Coverage

• Total tests: ~118 tests across 9 files
• Operators covered: =, <>, <, >, <=, >=, ->, ->>, @>, <@, ORDER BY, LIKE
• Index types tested: HMAC_256, Blake3, ORE64, ORE_CLLW_U64_8, ORE_CLLW_VAR_8
• Encryption schemes: 5 different index types
• Test patterns: Equality, inequality, comparison, containment, ordering, JSONB path operations

Coverage by Area

• Equality operations: 24 tests
• Inequality operations: 20 tests
• Comparison operators: 24 tests
• ORDER BY operations: 6 tests
• JSONB operations: 21 tests
• ORE encryption variants: 14 tests
• Containment operations: 7 tests
• Helper validation: 2 tests

✅ Verification

All tests compile and follow established patterns:

cd tests/sqlx

# Compile all tests
cargo test --no-run

# Run specific test suites
cargo test --test equality_tests
cargo test --test comparison_tests
cargo test --test containment_tests
# ... etc

# Run all tests
cargo test

🔍 Code Review

Multiple code reviews conducted with all feedback addressed:

• ✅ Consistent test patterns across all files
• ✅ Proper use of shared helpers (DRY principle)
• ✅ Clear test documentation with SQL file traceability
• ✅ Type-safe assertions using QueryAssertion builder
• ✅ Comprehensive error handling
• ✅ No code duplication

📚 Documentation

Every test includes:

• Clear description of what is being tested
• Reference to original SQL file and line numbers
• Context about test data and expected behavior
• Traceability back to original SQL tests

Example:

#[sqlx::test(fixtures(path = "../fixtures", scripts("encrypted_json")))]
async fn contains_operator_self_containment(pool: PgPool) -> Result<()> {
    // Test: encrypted value contains itself
    // Original SQL lines 13-25 in src/operators/@>_test.sql
    // Tests that a @> b when a == b
    
    let sql = "SELECT e FROM encrypted WHERE e @> e LIMIT 1";
    QueryAssertion::new(&pool, sql).returns_rows().await;
    Ok(())
}

🔗 Migration Progress

Completed (this PR):

• ✅ Equality operators (=)
• ✅ Inequality operators (<>)
• ✅ Comparison operators (<, >, <=, >=)
• ✅ JSONB path operators (->, ->>)
• ✅ Containment operators (@>, <@)
• ✅ ORDER BY operations
• ✅ ORE encryption variant tests
• ✅ Test infrastructure and helpers

Remaining (future work):

• LIKE operator (~~)
• Aggregate functions
• Constraint and trigger tests
• Additional edge cases

💡 Benefits

1. Type Safety: Rust's type system catches errors at compile time
2. Better Error Messages: SQLx provides clear, actionable error messages
3. Modern Testing: async/await, fixtures, and test isolation
4. Maintainability: Shared helpers reduce duplication
5. CI/CD Integration: Tests run in GitHub Actions
6. Developer Experience: Clear test output, easy to run locally

🚀 Commits

8 new commits in feature/sqlx-comparison-operators:

1. c9845f1 - test(sqlx): add <= and >= comparison operator tests
2. ac9fdae - test(sqlx): add ORDER BY tests with ORE encryption
3. 54952fa - refactor(tests): address code review suggestions
4. c753224 - test(sqlx): add JSONB path operator tests (-> and ->>)
5. 7fe1cba - test(sqlx): add ORE equality/inequality variant tests
6. 6d43ab5 - refactor(tests): improve ORE variant test coverage and consistency
7. 561d0f7 - test(sqlx): add containment operator tests (@> and <@)
8. 38c7e17 - refactor(tests): address code review feedback for containment tests

Base from feature/sqlx-comparison-inequality-tests:

• 2ab2e33 - test(sqlx): add comparison and inequality operator tests

📋 Checklist

• All test files created and documented
• Shared helpers extracted to reduce duplication
• Tests compile successfully
• Consistent patterns across all test files
• Code review feedback addressed
• Clear commit messages
• Traceability to original SQL tests
• Branch pushed to remote

🎉 Result

This PR delivers a complete, modern test suite for EQL operators using Rust/SQLx, providing ~118 tests with comprehensive coverage across all major operator categories. The foundation is now in place for continued migration of remaining SQL tests.

[freshtonic]

Another solid code drop.

Do the tests run yet?

[tobyhede]

@freshtonic Yes. CI runs both the legacy and sqlx tests.