docs: update Phase 2 migration plan with corrections and improvements

- Fix assertion count: 513 total (was incorrectly 558)
- Fix migrated count: 56 assertions (equality + JSONB, not 40)
- Recalculate all coverage percentages with correct totals
- Split Task 15 into 8 incremental sub-tasks (15.1-15.9)
- Add index type constants module (tests/sqlx/src/index_types.rs)
- Add fixture schema documentation (tests/sqlx/fixtures/FIXTURE_SCHEMA.md)
- Update success criteria and performance expectations
- Remaining: 457/513 assertions (89.1%) to migrate

Author: tobyhede

CODE_REVIEW_BATCH_1.md

@@ -0,0 +1,369 @@
+# Code Review: SQLx Test Migration - Batch 1 (Equality Tests)
+
+**Reviewer**: Claude Code (code-reviewer agent)
+**Date**: 2025-10-24
+**Branch**: feature/rust-test-framework-poc
+**Commits Reviewed**: 3d200c2, 2d347e1, f6ee68f, 7393e10
+**Author**: Toby Hede <[email protected]>
+
+---
+
+## Executive Summary
+
+**Verdict**: ⚠️ **CONDITIONAL APPROVAL - Minor fix required**
+
+Batch 1 successfully migrates all 16 equality test assertions (100% coverage) from SQL to Rust/SQLx with consistent patterns and comprehensive test coverage. All 27 tests pass. However, one **BLOCKING issue** was identified: Blake3 JSONB equality tests deviate from the original SQL implementation in a semantically significant way.
+
+**Key Metrics**:
+- ✅ All 27 tests pass (15 equality + 11 JSONB + 1 helper)
+- ✅ 100% equality test coverage achieved (16/16 assertions)
+- ⚠️ 1 BLOCKING issue (Blake3 JSONB test behavior mismatch)
+- ✅ 0 NON-BLOCKING issues
+- ✅ Conventional commit format followed
+- ✅ Coverage documentation comprehensive and accurate
+
+---
+
+## Test Execution Results
+
+```bash
+mise run test:sqlx
+```
+
+**Results**:
+```
+✅ equality_tests.rs: 15/15 passed
+✅ jsonb_tests.rs: 11/11 passed
+✅ test_helpers_test.rs: 1/1 passed
+```
+
+**Total**: 27/27 tests passing (100% pass rate)
+
+---
+
+## BLOCKING Issues
+
+### 1. Blake3 JSONB Equality Tests Don't Match Original SQL Behavior
+
+**Severity**: BLOCKING
+**Location**: `tests/sqlx/tests/equality_tests.rs` lines 227-293
+**Commits**: f6ee68f
+
+**Issue**:
+
+The Blake3 JSONB equality tests remove the 'ob' field, but the original SQL tests do NOT:
+
+**Original SQL** (src/operators/=_test.sql line 171):
+```sql
+e := create_encrypted_json(i, 'b3');  -- NO removal of 'ob'
+```
+
+**Rust Implementation** (equality_tests.rs line 232):
+```rust
+let sql_create = "SELECT (create_encrypted_json(1, 'b3')::jsonb - 'ob')::text";
+                                                           ^^^^^^^^^ REMOVES 'ob'
+```
+
+**Comparison with HMAC**:
+- HMAC JSONB tests (SQL line 72): `create_encrypted_json(i)::jsonb-'ob'` ✅ Removes 'ob'
+- Blake3 JSONB tests (SQL line 171): `create_encrypted_json(i, 'b3')` ❌ Does NOT remove 'ob'
+
+**Why This Matters**:
+
+The 'ob' field contains ORE (Order-Revealing Encryption) index data. The original SQL distinguishes between:
+1. HMAC tests: Remove 'ob' to test equality without ORE data
+2. Blake3 tests: Keep 'ob' to test equality with complete encrypted payload
+
+This distinction tests different code paths and has semantic significance.
+
+**Evidence**:
+
+All 4 Blake3 JSONB tests are affected:
+- `equality_operator_encrypted_equals_jsonb_blake3` (line 227)
+- `equality_operator_jsonb_equals_encrypted_blake3` (line 244)
+- `equality_operator_encrypted_equals_jsonb_no_match_blake3` (line 261)
+- `equality_operator_jsonb_equals_encrypted_no_match_blake3` (line 278)
+
+**Why Tests Still Pass**:
+
+The tests pass because the equality operators work with or without 'ob' field. However, passing tests don't mean we're testing the RIGHT behavior.
+
+**Plan Discrepancy**:
+
+The implementation plan (docs/plans/2025-10-24-complete-sqlx-test-migration.md line 264) correctly specifies:
+```rust
+let sql_create = "SELECT create_encrypted_json(1, 'b3')::text";
+```
+
+But the implementation deviated from the plan without documented justification.
+
+**Required Fix**:
+
+Remove `- 'ob'` from all 4 Blake3 JSONB test functions:
+
+```diff
+- let sql_create = "SELECT (create_encrypted_json(1, 'b3')::jsonb - 'ob')::text";
++ let sql_create = "SELECT create_encrypted_json(1, 'b3')::text";
+```
+
+Apply to lines: 232, 249, 266, 283
+
+**Verification**:
+
+After fix, re-run tests to ensure they still pass:
+```bash
+cd tests/sqlx
+cargo test equality_operator.*blake3.*jsonb -- --nocapture
+```
+
+---
+
+## NON-BLOCKING Observations
+
+### Positive Observations
+
+✅ **Excellent Code Documentation**
+- Every test function has clear comments referencing original SQL line numbers
+- Comments explain the purpose and behavior of each test
+- Helper function `create_encrypted_json_with_index` is well-documented
+
+✅ **Consistent Test Patterns**
+- All tests follow the same structure: setup → execute → assert
+- Matching and no-match scenarios covered for all operators
+- Both directions tested for JSONB equality (e=jsonb and jsonb=e)
+
+✅ **Proper Error Handling in Helper**
+- `create_encrypted_json_with_index` has comprehensive panic messages
+- Clear error context for debugging test failures
+- Unwraps are intentional and appropriate for tests
+
+✅ **Commit Message Quality**
+- All 4 commits follow conventional commit format
+- Commit bodies provide clear context and reference SQL source
+- Coverage progression is well documented
+
+✅ **Coverage Documentation Excellence**
+- TEST_MIGRATION_COVERAGE.md is comprehensive and accurate
+- Clear mapping between SQL blocks and Rust tests
+- Honest assessment of loop iteration strategy differences
+
+### Code Quality Observations
+
+**Well-Structured Tests**:
+- Tests use SQLx fixtures appropriately (`encrypted_json`)
+- QueryAssertion helper provides consistent verification pattern
+- Test names are descriptive and follow consistent naming convention
+
+**Maintainability**:
+- Helper function reduces duplication
+- Format strings are clear and readable
+- Tests are isolated and run in parallel safely
+
+---
+
+## Coverage Analysis
+
+### Equality Tests: 100% Complete ✅
+
+All 16 SQL assertions successfully migrated:
+
+| Category | Tests | Status |
+|----------|-------|--------|
+| HMAC `e = e` operator | 2 (match + no-match) | ✅ Complete |
+| HMAC `eq()` function | 2 (match + no-match) | ✅ Complete |
+| HMAC JSONB operators | 4 (both directions + no-match) | ✅ Complete |
+| Blake3 `e = e` operator | 2 (match + no-match) | ✅ Complete |
+| Blake3 `eq()` function | 2 (match + no-match) | ✅ Complete |
+| Blake3 JSONB operators | 4 (both directions + no-match) | ⚠️ Complete (fix required) |
+
+**Total**: 16/16 assertions (100%)
+
+### Overall Project Status
+
+- **Equality Tests**: 16/16 (100%)
+- **JSONB Tests**: 11/24 (46%)
+- **Overall**: 27/40 (67.5%)
+
+Coverage tracking is accurate and matches test execution results.
+
+---
+
+## Implementation vs Plan Analysis
+
+### What Matches Plan
+
+✅ All 3 tasks (Tasks 1-3) completed as specified
+✅ Test structure and assertions match plan
+✅ Commit messages follow plan templates
+✅ Coverage documentation updated correctly
+✅ All tests pass
+
+### What Deviates from Plan
+
+⚠️ **Blake3 JSONB tests**: Implementation removes 'ob' field, plan specifies NOT removing it
+- Plan (line 264): `SELECT create_encrypted_json(1, 'b3')::text`
+- Implementation (line 232): `SELECT (create_encrypted_json(1, 'b3')::jsonb - 'ob')::text`
+
+**Root Cause**: Likely copy-paste from HMAC tests without adjusting for Blake3 differences
+
+---
+
+## Conventional Commit Compliance
+
+All 4 commits follow conventional commit format correctly:
+
+1. ✅ `3d200c2` - `test(sqlx): add Blake3 eq() function tests`
+2. ✅ `2d347e1` - `test(sqlx): add HMAC JSONB equality operator tests`
+3. ✅ `f6ee68f` - `test(sqlx): add Blake3 JSONB equality operator tests`
+4. ✅ `7393e10` - `docs(testing): update coverage to reflect 100% equality test migration`
+
+**Format Analysis**:
+- Type prefixes: Correct (`test`, `docs`)
+- Scope: Appropriate (`sqlx`, `testing`)
+- Subject: Clear, imperative, under 72 chars
+- Body: Comprehensive, references SQL sources
+- No Breaking changes: Correct (additive changes only)
+
+---
+
+## Comparison with Original SQL Tests
+
+### Assertion Accuracy
+
+**HMAC Tests**: ✅ Perfect match
+- Operator tests correctly test `e = e` equality
+- Function tests correctly call `eql_v2.eq()`
+- JSONB tests correctly remove 'ob' field
+- No-match tests use non-existent id=4
+
+**Blake3 Tests**: ⚠️ Partial match
+- Operator tests: ✅ Perfect match
+- Function tests: ✅ Perfect match
+- JSONB tests: ❌ Incorrectly remove 'ob' field (should NOT remove)
+- No-match tests: ✅ Correct approach
+
+### Loop Iteration Strategy
+
+**SQL**: Loops 1..3 times, testing multiple ids
+**Rust**: Single iteration per test
+
+**Coverage Documentation Notes** (line 59):
+> "Loop iterations: SQL tests run 1..3 iterations; Rust tests validate with single iterations (sufficient for unit testing)"
+
+**Assessment**: ✅ Acceptable trade-off
+- Single iteration verifies operator functionality
+- Multiple iterations would increase test time without adding value
+- Edge cases are covered by no-match tests
+- This is explicitly documented and intentional
+
+---
+
+## Security Considerations
+
+✅ No security concerns identified:
+- Tests don't expose sensitive data
+- SQL injection prevented by parameterized queries via format!
+- No hardcoded credentials
+- Test isolation ensures no data leakage between tests
+
+---
+
+## Performance Considerations
+
+✅ Test performance is excellent:
+- 27 tests complete in ~4 seconds
+- Parallel execution working correctly
+- Database reset per test via SQLx fixtures
+- No performance regressions expected
+
+---
+
+## Documentation Quality
+
+### CODE_REVIEW.md Standards Compliance
+
+✅ **Structure Validation**: All tests have clear comments
+✅ **Error Messages**: Helper function has comprehensive error context
+✅ **Test Coverage**: Coverage documentation is comprehensive
+✅ **Commit Messages**: All follow conventional format
+
+### Coverage Documentation
+
+The TEST_MIGRATION_COVERAGE.md file is exemplary:
+- Clear overview with metrics
+- Detailed mapping between SQL and Rust tests
+- Honest assessment of trade-offs (loop iterations)
+- Accurate completion status
+- Useful recommendations section
+
+---
+
+## Recommendations
+
+### MUST DO (Blocking)
+
+1. **Fix Blake3 JSONB tests** to match original SQL behavior
+   - Remove `- 'ob'` from 4 test functions
+   - Re-run tests to verify they still pass
+   - Commit fix with message: `fix(sqlx): correct Blake3 JSONB tests to match SQL behavior`
+
+### SHOULD DO (Non-blocking, but valuable)
+
+1. **Add a comment** explaining why HMAC removes 'ob' but Blake3 doesn't
+   - Helps future maintainers understand the distinction
+   - Documents the intentional difference in test setup
+
+2. **Consider adding a test** that explicitly verifies behavior with and without 'ob'
+   - Would make the distinction more explicit
+   - Could be done in Phase 3 (coverage improvements)
+
+### NICE TO HAVE
+
+1. **Property-based testing** for multiple iterations (mentioned in COVERAGE_IMPROVEMENTS.md)
+   - Future enhancement, not required for like-for-like migration
+   - Would provide more thorough coverage
+
+---
+
+## Sign-Off
+
+**Review Status**: ⚠️ **CHANGES REQUESTED**
+
+**Blockers**: 1
+- Blake3 JSONB tests must be corrected to remove 'ob' field removal
+
+**Non-blockers**: 0
+
+**When Fixed**:
+- Re-run full test suite: `mise run test:sqlx`
+- Verify all 27 tests still pass
+- Request re-review or proceed to merge
+
+**Overall Assessment**:
+
+This is **high-quality work** with excellent test coverage, documentation, and commit hygiene. The BLOCKING issue is minor (copy-paste error) and easily fixed. Once addressed, this batch is ready to merge.
+
+The test framework demonstrates solid engineering:
+- Consistent patterns
+- Comprehensive coverage
+- Clear documentation
+- Proper error handling
+
+**Confidence Level**: High (would merge with fix)
+
+---
+
+**Reviewed by**: Claude Code (code-reviewer agent)
+**Review Date**: 2025-10-24
+**Review Duration**: Comprehensive (full workflow followed)
+**Files Reviewed**:
+- tests/sqlx/tests/equality_tests.rs (294 lines)
+- tests/sqlx/TEST_MIGRATION_COVERAGE.md (177 lines)
+- docs/plans/2025-10-24-complete-sqlx-test-migration.md (reference)
+- src/operators/=_test.sql (reference)
+
+**Next Steps**:
+1. Author fixes Blake3 JSONB tests
+2. Author runs: `mise run test:sqlx`
+3. Author commits fix
+4. Ready for merge (or proceed to Batch 2)