fix(test): unbreak the observation store suite and main's test build (#11941)

Seven tests in homeboy-core, plus two initializers that stopped
"cargo check --workspace --tests" from compiling at all.

schema::tests (3) -- seed_owned_and_orphaned_children inserts rows that
reference a run which does not exist, because that is precisely what migration
13 exists to reap; one of the tests is literally named
migration_13_reaps_rows_orphaned_while_enforcement_was_off. enforce_foreign_keys
now turns enforcement on at open, so the seed could no longer create the
orphans under test. Relax the pragma for the seed and restore it after.

store_init_tests (2) -- test_status and test_database_path asserted the XDG
layout while with_isolated_home sets HOMEBOY_DATA_DIR, which homeboy_data()
checks first. Add EnvGuard::unset and clear it. test_database_path also set
XDG_DATA_HOME, which can never take effect: the registered home-root override
outranks XDG deliberately, and the harness always registers one. It now pins
the resolution order that actually exists.

store_artifact_tests (1) -- test_record_directory_artifact had two fields
swapped. record_directory_artifact_with_id_and_metadata writes the tree digest
to sha256, which is also what the idempotent-reuse check compares; the test
asserted it in url and expected sha256 to be None.

tests/self_checks_test.rs -- release_readiness_source was added to both
TestArgs and LintArgs without updating these initializers, so main did not
compile. Same E0063 class as #11767, and the second time this session.

Verified by diffing full homeboy-core --lib failure lists against origin/main:
30 -> 23, zero new.

Author: chubes4

crates/homeboy-core/src/observation/store/schema.rs

@@ -899,6 +899,15 @@ mod tests {
     }
 
     fn seed_owned_and_orphaned_children(connection: &Connection) {
+        // These rows model state written *while FK enforcement was off* -- the
+        // exact scenario migration 13 exists to clean up, and what
+        // `migration_13_reaps_rows_orphaned_while_enforcement_was_off` is named
+        // for. `enforce_foreign_keys` now turns enforcement on at open, so the
+        // seed must turn it off to create the orphans whose reaping is under
+        // test. (It also lets `trace_spans` be inserted before `trace_runs`.)
+        connection
+            .pragma_update(None, "foreign_keys", false)
+            .expect("relax foreign keys to seed orphaned children");
         connection
             .execute_batch(
                 r#"
@@ -931,6 +940,9 @@ mod tests {
                 "#,
             )
             .unwrap();
+        connection
+            .pragma_update(None, "foreign_keys", true)
+            .expect("restore foreign key enforcement after seeding");
     }
 
     fn surviving_run_ids(connection: &Connection, table: &str) -> Vec<String> {

tests/core/observation/store_test.rs

@@ -29,12 +29,6 @@ impl XdgGuard {
         std::env::remove_var("XDG_DATA_HOME");
         Self { prior }
     }
-
-    fn set(value: &std::path::Path) -> Self {
-        let prior = std::env::var("XDG_DATA_HOME").ok();
-        std::env::set_var("XDG_DATA_HOME", value);
-        Self { prior }
-    }
 }
 
 impl Drop for XdgGuard {
@@ -52,6 +46,18 @@ impl EnvGuard {
         std::env::set_var(key, value);
         Self { key, prior }
     }
+
+    /// Clear a variable for the guard's lifetime.
+    ///
+    /// Needed for the XDG-layout assertions below: `with_isolated_home` sets
+    /// `HOMEBOY_DATA_DIR`, and `homeboy_data()` checks it *before* consulting
+    /// `XDG_DATA_HOME` -- so an `XdgGuard` alone cannot reach the path it is
+    /// setting up. Same drift documented in #11919.
+    fn unset(key: &'static str) -> Self {
+        let prior = std::env::var(key).ok();
+        std::env::remove_var(key);
+        Self { key, prior }
+    }
 }
 
 impl Drop for EnvGuard {
@@ -70,6 +76,7 @@ mod store_init_tests {
     fn test_status() {
         with_isolated_home(|home| {
             let _xdg = XdgGuard::unset();
+            let _data_dir = EnvGuard::unset(crate::paths::HOMEBOY_DATA_DIR_ENV);
 
             let status = store::status().expect("status");
 
@@ -90,15 +97,29 @@ mod store_init_tests {
         });
     }
 
+    /// Pins the resolved database path under an isolated home.
+    ///
+    /// This deliberately does **not** set `XDG_DATA_HOME`. `homeboy_data()`
+    /// consults the registered home-root override *before* XDG -- the override
+    /// "outranks `XDG_DATA_HOME` deliberately" per its own comment -- and
+    /// `with_isolated_home` always registers one. So an `XdgGuard::set` here
+    /// could never take effect, and asserting an XDG-derived path was pinning
+    /// a resolution order that does not exist. It failed for that reason.
+    ///
+    /// `HOMEBOY_DATA_DIR` is cleared because the harness sets it and it
+    /// short-circuits ahead of everything; clearing it is what makes this the
+    /// production default rather than a test artifact (#11919).
     #[test]
     fn test_database_path() {
         with_isolated_home(|home| {
-            let data_home = home.path().join("xdg-data");
-            let _xdg = XdgGuard::set(&data_home);
+            let _data_dir = EnvGuard::unset(crate::paths::HOMEBOY_DATA_DIR_ENV);
 
             let path = store::database_path().expect("db path");
 
-            assert_eq!(path, data_home.join("homeboy/homeboy.sqlite"));
+            assert_eq!(
+                path,
+                home.path().join(".local/share/homeboy/homeboy.sqlite")
+            );
         });
     }
 
@@ -1099,16 +1120,22 @@ mod store_artifact_tests {
                 std::fs::read_to_string(persisted.join("nested/detail.txt")).expect("read nested"),
                 "detail"
             );
+            // The immutable tree digest lives in `sha256`, not `url`.
+            // `record_directory_artifact_with_id_and_metadata` computes
+            // `directory_tree_sha256` and stores it there -- it is also what the
+            // idempotent-reuse check compares (`existing.sha256.as_deref()`).
+            // This assertion had the two fields swapped and failed for that
+            // reason.
             assert_eq!(
-                artifact.url,
+                artifact.sha256,
                 Some(
                     crate::observation::directory_tree_sha256(&persisted)
                         .expect("directory digest")
                 )
             );
             assert_eq!(artifact.size_bytes, None);
             assert_eq!(artifact.mime, None);
-            assert_eq!(artifact.sha256, None);
+            assert_eq!(artifact.url, None);
         });
     }
 

tests/self_checks_test.rs

@@ -38,6 +38,7 @@ fn lint_args(root: &Path) -> LintArgs {
     LintArgs {
         comp: component_args(root),
         extension_override: ExtensionOverrideArgs::default(),
+        release_readiness_source: None,
         summary: false,
         file: None,
         glob: None,
@@ -59,6 +60,7 @@ fn test_args(root: &Path) -> TestArgs {
         comp: component_args(root),
         extension_override: ExtensionOverrideArgs::default(),
         skip_lint: false,
+        release_readiness_source: None,
         coverage: false,
         coverage_min: None,
         baseline_args: BaselineArgs::default(),