fix(tests): embed Tier A fixture corpus at compile time so CI shards find it

The fixture-oracle property tests loaded their corpus at runtime via
std::fs::read_to_string keyed off CARGO_MANIFEST_DIR/fixtures/eql_v2_<T>.sql.
In CI's archive->shard split the test shards do a fresh checkout where those
gitignored fixtures are absent, so int2/text (and every Tier A oracle test)
failed with "No such file or directory". Only 3 surfaced because nextest
fail-fast cancelled the shard after 93/518.

Embed the fixture SQL into the test binary via include_str! at compile time,
exactly like sqlx::test's scripts(...) does, so the corpus travels inside the
prebuilt nextest archive. The embed lives in the fixture_oracle test target
(not the eql_tests lib) so generate_all_fixtures still compiles before the
fixtures exist. ensure_fixture_loaded now takes the script as a parameter.

No CI or catalog changes.

Author: tobyhede

tests/sqlx/src/property.rs

@@ -23,33 +23,36 @@ static FIXTURE_LOADED: OnceLock<Mutex<HashSet<&'static str>>> = OnceLock::new();
 
 /// Materialise the live-encrypted fixture corpus for `T` into the connected DB.
 ///
-/// The fixture `.sql` files (`tests/sqlx/fixtures/eql_v2_<T>.sql`, regenerated
-/// each `test:sqlx:prep`) are normally loaded only into `#[sqlx::test]`'s
-/// ephemeral per-test databases. The property tiers connect to the shared test
-/// DB directly (they cannot use `#[sqlx::test]`'s injected pool from a sync
-/// `proptest!` body), so the corpus is not present there. This loads it on
-/// demand: the script is self-contained and idempotent
-/// (`CREATE SCHEMA IF NOT EXISTS` / `DROP TABLE IF EXISTS` / `CREATE` /
-/// `INSERT`), and a process-wide async mutex guarantees exactly-once execution
-/// per type across the parallel test threads (each driving its own runtime).
-/// `CARGO_MANIFEST_DIR` resolves the path independent of the test's CWD.
-pub async fn ensure_fixture_loaded<T: ScalarType>(pool: &PgPool) -> Result<()> {
+/// The fixture `.sql` files (`tests/sqlx/fixtures/eql_v2_<T>.sql`) are normally
+/// loaded only into `#[sqlx::test]`'s ephemeral per-test databases. The property
+/// tiers connect to the shared test DB directly (they cannot use
+/// `#[sqlx::test]`'s injected pool from a sync `proptest!` body), so the corpus
+/// is not present there. This loads it on demand: the script is self-contained
+/// and idempotent (`CREATE SCHEMA IF NOT EXISTS` / `DROP TABLE IF EXISTS` /
+/// `CREATE` / `INSERT`), and a process-wide async mutex guarantees exactly-once
+/// execution per type across the parallel test threads (each driving its own
+/// runtime).
+///
+/// `script` is the fixture SQL, passed in by the caller. It is `include_str!`-
+/// embedded into the test binary at compile time (see `fixture_oracle.rs`) so it
+/// travels inside the prebuilt nextest archive that CI shards run from — those
+/// shards do a fresh checkout where the gitignored `.sql` files are absent, so a
+/// runtime `std::fs` read would fail there.
+pub async fn ensure_fixture_loaded<T: ScalarType>(pool: &PgPool, script: &str) -> Result<()> {
     let guard = FIXTURE_LOADED.get_or_init(|| Mutex::new(HashSet::new()));
     let mut loaded = guard.lock().await;
     if loaded.contains(T::PG_TYPE) {
         return Ok(());
     }
-    let path = format!(
-        "{}/fixtures/eql_v2_{}.sql",
-        env!("CARGO_MANIFEST_DIR"),
-        T::PG_TYPE
-    );
-    let script = std::fs::read_to_string(&path)
-        .with_context(|| format!("reading fixture script {path} (run test:sqlx:prep first)"))?;
-    sqlx::raw_sql(&script)
+    sqlx::raw_sql(script)
         .execute(pool)
         .await
-        .with_context(|| format!("loading fixture corpus into shared DB from {path}"))?;
+        .with_context(|| {
+            format!(
+                "loading fixture corpus for {} into shared DB",
+                T::PG_TYPE
+            )
+        })?;
     loaded.insert(T::PG_TYPE);
     Ok(())
 }

tests/sqlx/tests/encrypted_domain/property/fixture_oracle.rs

@@ -17,11 +17,35 @@ use proptest::prelude::*;
 use proptest::test_runner::{Config, TestCaseError, TestRunner};
 use sqlx::PgPool;
 
+/// The fixture corpus SQL for `T`, `include_str!`-embedded into this test binary
+/// at compile time (one arm per catalog token). Embedding rather than reading
+/// from disk at runtime is what lets the prebuilt nextest archive carry the
+/// corpus into CI shards, which do a fresh checkout where the gitignored
+/// `tests/sqlx/fixtures/eql_v2_<T>.sql` files are absent. The path resolves
+/// against the `eql_tests` crate root (`tests/sqlx`). Mirrors the loud catch-all
+/// of the `generate_for_token` fixture dispatch.
+fn embedded_fixture_sql<T: ScalarType>() -> &'static str {
+    match T::PG_TYPE {
+        "int4" => include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/eql_v2_int4.sql")),
+        "int2" => include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/eql_v2_int2.sql")),
+        "int8" => include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/eql_v2_int8.sql")),
+        "date" => include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/eql_v2_date.sql")),
+        "text" => include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/eql_v2_text.sql")),
+        "timestamptz" => {
+            include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/fixtures/eql_v2_timestamptz.sql"))
+        }
+        other => panic!(
+            "no embedded fixture for catalog token '{other}'; \
+             add an include_str! arm in fixture_oracle.rs"
+        ),
+    }
+}
+
 /// Read every `(plaintext, payload::text)` fixture row for `T`, in id order.
 /// Ensures the corpus is present in the shared DB first (it lives in
 /// `#[sqlx::test]`'s ephemeral DBs by default, not the pool we connect to).
 async fn load_fixture_rows<T: ScalarType>(pool: &PgPool) -> Result<Vec<Row<T>>> {
-    ensure_fixture_loaded::<T>(pool).await?;
+    ensure_fixture_loaded::<T>(pool, embedded_fixture_sql::<T>()).await?;
     let sql = format!(
         "SELECT plaintext, payload::text FROM {} ORDER BY id",
         T::fixture_table_name()