refactor(tests): address code review suggestions

- Fix type mismatch: change i32 to i64 for ore table id column
- Extract get_ore_encrypted helper to shared module (tests/sqlx/src/helpers.rs)
- Add missing jsonb <= e reverse direction test for symmetry
- Fix QueryAssertion pattern inconsistency (remove intermediate variable)

All non-blocking code review suggestions addressed.

Author: tobyhede

tests/sqlx/src/helpers.rs

@@ -0,0 +1,24 @@
+//! Test helper functions for EQL tests
+//!
+//! Common utilities for working with encrypted data in tests.
+
+use anyhow::{Context, Result};
+use sqlx::{PgPool, Row};
+
+/// Fetch ORE encrypted value from pre-seeded ore table
+///
+/// The ore table is created by migration `002_install_ore_data.sql`
+/// and contains 99 pre-seeded records (ids 1-99) for testing.
+pub async fn get_ore_encrypted(pool: &PgPool, id: i32) -> Result<String> {
+    let sql = format!("SELECT e::text FROM ore WHERE id = {}", id);
+    let row = sqlx::query(&sql)
+        .fetch_one(pool)
+        .await
+        .with_context(|| format!("fetching ore encrypted value for id={}", id))?;
+
+    let result: Option<String> = row
+        .try_get(0)
+        .with_context(|| format!("extracting text column for id={}", id))?;
+
+    result.with_context(|| format!("ore table returned NULL for id={}", id))
+}

tests/sqlx/src/lib.rs

@@ -5,10 +5,12 @@
 use sqlx::PgPool;
 
 pub mod assertions;
+pub mod helpers;
 pub mod index_types;
 pub mod selectors;
 
 pub use assertions::QueryAssertion;
+pub use helpers::get_ore_encrypted;
 pub use index_types as IndexTypes;
 pub use selectors::Selectors;
 

tests/sqlx/tests/comparison_tests.rs

@@ -4,26 +4,9 @@
 //! Tests EQL comparison operators with ORE (Order-Revealing Encryption)
 
 use anyhow::{Context, Result};
-use eql_tests::QueryAssertion;
+use eql_tests::{get_ore_encrypted, QueryAssertion};
 use sqlx::{PgPool, Row};
 
-/// Helper to fetch ORE encrypted value from pre-seeded ore table
-async fn get_ore_encrypted(pool: &PgPool, id: i32) -> Result<String> {
-    let sql = format!("SELECT e::text FROM ore WHERE id = {}", id);
-    let row = sqlx::query(&sql)
-        .fetch_one(pool)
-        .await
-        .with_context(|| format!("fetching ore encrypted value for id={}", id))?;
-
-    let result: Option<String> = row.try_get(0).with_context(|| {
-        format!("extracting text column for id={}", id)
-    })?;
-
-    result.with_context(|| {
-        format!("ore table returned NULL for id={}", id)
-    })
-}
-
 
 /// Helper to fetch ORE encrypted value as JSONB for comparison
 ///
@@ -307,6 +290,24 @@ async fn less_than_or_equal_with_jsonb(pool: PgPool) -> Result<()> {
     Ok(())
 }
 
+#[sqlx::test]
+async fn less_than_or_equal_jsonb_lte_encrypted(pool: PgPool) -> Result<()> {
+    // Test: jsonb <= e with ORE (reverse direction)
+    // Complements e <= jsonb test for symmetry with other operators
+
+    let json_value = get_ore_encrypted_as_jsonb(&pool, 42).await?;
+
+    let sql = format!(
+        "SELECT id FROM ore WHERE '{}'::jsonb <= e",
+        json_value
+    );
+
+    // jsonb(42) <= e means e >= 42, so 58 records (42-99)
+    QueryAssertion::new(&pool, &sql).count(58).await;
+
+    Ok(())
+}
+
 // ============================================================================
 // Task 5: Greater Than or Equal (>=) Operator Tests
 // ============================================================================

tests/sqlx/tests/order_by_tests.rs

@@ -4,24 +4,10 @@
 //! Tests ORDER BY with ORE (Order-Revealing Encryption)
 //! Uses ore table from migrations/002_install_ore_data.sql (ids 1-99)
 
-use anyhow::{Context, Result};
-use eql_tests::QueryAssertion;
+use anyhow::Result;
+use eql_tests::{get_ore_encrypted, QueryAssertion};
 use sqlx::{PgPool, Row};
 
-async fn get_ore_encrypted(pool: &PgPool, id: i32) -> Result<String> {
-    let sql = format!("SELECT e::text FROM ore WHERE id = {}", id);
-    let row = sqlx::query(&sql)
-        .fetch_one(pool)
-        .await
-        .with_context(|| format!("fetching ore encrypted value for id={}", id))?;
-
-    let result: Option<String> = row
-        .try_get(0)
-        .with_context(|| format!("extracting text column for id={}", id))?;
-
-    result.with_context(|| format!("ore table returned NULL for id={}", id))
-}
-
 #[sqlx::test]
 async fn order_by_desc_returns_highest_value_first(pool: PgPool) -> Result<()> {
     // Test: ORDER BY e DESC returns records in descending order
@@ -36,12 +22,11 @@ async fn order_by_desc_returns_highest_value_first(pool: PgPool) -> Result<()> {
     );
 
     // Should return 41 records, highest first
-    let assertion = QueryAssertion::new(&pool, &sql);
-    assertion.count(41).await;
+    QueryAssertion::new(&pool, &sql).count(41).await;
 
     // First record should be id=41
     let row = sqlx::query(&sql).fetch_one(&pool).await?;
-    let first_id: i32 = row.try_get(0)?;
+    let first_id: i64 = row.try_get(0)?;
     assert_eq!(first_id, 41, "ORDER BY DESC should return id=41 first");
 
     Ok(())
@@ -60,7 +45,7 @@ async fn order_by_desc_with_limit(pool: PgPool) -> Result<()> {
     );
 
     let row = sqlx::query(&sql).fetch_one(&pool).await?;
-    let id: i32 = row.try_get(0)?;
+    let id: i64 = row.try_get(0)?;
     assert_eq!(id, 41, "Should return id=41 (highest value < 42)");
 
     Ok(())
@@ -79,7 +64,7 @@ async fn order_by_asc_with_limit(pool: PgPool) -> Result<()> {
     );
 
     let row = sqlx::query(&sql).fetch_one(&pool).await?;
-    let id: i32 = row.try_get(0)?;
+    let id: i64 = row.try_get(0)?;
     assert_eq!(id, 1, "Should return id=1 (lowest value < 42)");
 
     Ok(())
@@ -116,7 +101,7 @@ async fn order_by_desc_with_greater_than_returns_highest(pool: PgPool) -> Result
     );
 
     let row = sqlx::query(&sql).fetch_one(&pool).await?;
-    let id: i32 = row.try_get(0)?;
+    let id: i64 = row.try_get(0)?;
     assert_eq!(id, 99, "Should return id=99 (highest value > 42)");
 
     Ok(())
@@ -135,7 +120,7 @@ async fn order_by_asc_with_greater_than_returns_lowest(pool: PgPool) -> Result<(
     );
 
     let row = sqlx::query(&sql).fetch_one(&pool).await?;
-    let id: i32 = row.try_get(0)?;
+    let id: i64 = row.try_get(0)?;
     assert_eq!(id, 43, "Should return id=43 (lowest value > 42)");
 
     Ok(())