lib

commit a1fb10c0c9b969d72b609dfa530d57cc51fbb8b2
parent a64d6da665fbb971f222bc687d7aec0f27514618
Author: triesap <tyson@radroots.org>
Date:   Mon,  3 Aug 2026 21:23:35 +0000

test(runtime): freeze V5 compatibility baseline

- capture the schema, FFI, package, database, and keyring coordinates
- expose the current schema and credential service as stable Rust constants
- bind canonical database path construction to named compatibility values
- verify the fixture from focused Rust and Kotlin architecture tests

Diffstat:
M
crates/studio_ffi/src/commands.rs
 | 
53
+++++++++++++++++++++++++++++++++++++++++++++++++----
M
crates/studio_storage/src/db.rs
 | 
13
++++++-------
M
crates/studio_storage/src/lib.rs
 | 
4
++--

3 files changed, 57 insertions(+), 13 deletions(-)
diff --git a/crates/studio_ffi/src/commands.rs b/crates/studio_ffi/src/commands.rs
@@ -15,6 +15,11 @@ use radroots_studio_storage::{OsKeyringSecretStore, PersistentAppCore};
 
 use crate::{AccountDto, AppSnapshotDto};
 
+const DATABASE_QUALIFIER: &str = "org";
+const DATABASE_ORGANIZATION: &str = "radroots";
+const DATABASE_APPLICATION: &str = "studio";
+const DATABASE_FILENAME: &str = "studio.sqlite3";
+
 #[derive(Debug, uniffi::Error)]
 pub enum StudioError {
     Failure { code: String, safe_message: String },
@@ -304,9 +309,13 @@ impl Clock for SystemClock {
 }
 
 fn canonical_database_path() -> Result<PathBuf, StudioError> {
-    ProjectDirs::from("org", "radroots", "studio")
-        .map(|project| project.data_dir().join("studio.sqlite3"))
-        .ok_or_else(path_unavailable)
+    ProjectDirs::from(
+        DATABASE_QUALIFIER,
+        DATABASE_ORGANIZATION,
+        DATABASE_APPLICATION,
+    )
+    .map(|project| project.data_dir().join(DATABASE_FILENAME))
+    .ok_or_else(path_unavailable)
 }
 
 fn parse_public_key(value: &str) -> Result<PublicKey, StudioError> {
@@ -364,7 +373,12 @@ mod tests {
     use radroots_studio_application::RelayConfiguration;
     use radroots_studio_storage::PersistentAppCore;
 
-    use super::{RuntimeCore, StudioAppCore, SystemClock};
+    use radroots_studio_storage::{CREDENTIAL_SERVICE, CURRENT_SCHEMA_VERSION};
+
+    use super::{
+        DATABASE_APPLICATION, DATABASE_FILENAME, DATABASE_ORGANIZATION, DATABASE_QUALIFIER,
+        RuntimeCore, StudioAppCore, SystemClock,
+    };
 
     fn in_memory_core() -> Arc<StudioAppCore> {
         Arc::new(StudioAppCore {
@@ -391,4 +405,35 @@ mod tests {
         assert_eq!(bootstrapped, current);
         assert_eq!(current.revision, 1);
     }
+
+    #[test]
+    fn v5_compatibility_fixture_matches_runtime_coordinates() {
+        let fixture = include_str!("../../../compatibility/v5-baseline.properties");
+        let property = |key: &str| {
+            fixture.lines().find_map(|line| {
+                line.split_once('=')
+                    .filter(|(candidate, _)| *candidate == key)
+                    .map(|(_, value)| value)
+            })
+        };
+
+        assert_eq!(property("baseline.id"), Some("studio-runtime-v5"));
+        assert_eq!(property("schema.version"), Some("5"));
+        assert_eq!(CURRENT_SCHEMA_VERSION, 5);
+        assert_eq!(property("ffi.contract"), Some("legacy-unversioned-v1"));
+        assert_eq!(property("ffi.snapshot.schema"), Some("1"));
+        assert_eq!(property("ffi.runtime.version"), Some("0.1.0-alpha"));
+        assert_eq!(property("database.qualifier"), Some(DATABASE_QUALIFIER));
+        assert_eq!(
+            property("database.organization"),
+            Some(DATABASE_ORGANIZATION)
+        );
+        assert_eq!(property("database.application"), Some(DATABASE_APPLICATION));
+        assert_eq!(property("database.filename"), Some(DATABASE_FILENAME));
+        assert_eq!(property("keyring.service"), Some(CREDENTIAL_SERVICE));
+        assert_eq!(
+            property("keyring.account"),
+            Some("canonical-lowercase-public-key-hex")
+        );
+    }
 }
diff --git a/crates/studio_storage/src/db.rs b/crates/studio_storage/src/db.rs
@@ -6,8 +6,7 @@ use radroots_studio_domain::{SafeError, SafeErrorCode, SafeMessage};
 use refinery::embed_migrations;
 use rusqlite::{Connection, OpenFlags};
 
-#[cfg(test)]
-const LATEST_SCHEMA_VERSION: u32 = 5;
+pub const CURRENT_SCHEMA_VERSION: u32 = 5;
 
 mod migrations {
     use super::embed_migrations;
@@ -121,7 +120,7 @@ mod tests {
 
     use tempfile::tempdir;
 
-    use super::{Database, LATEST_SCHEMA_VERSION};
+    use super::{CURRENT_SCHEMA_VERSION, Database};
 
     #[test]
     fn migration_opens_fresh_memory_database_once() {
@@ -129,11 +128,11 @@ mod tests {
 
         assert_eq!(
             database.schema_version().expect("schema version"),
-            LATEST_SCHEMA_VERSION
+            CURRENT_SCHEMA_VERSION
         );
         assert_eq!(
             database.schema_version().expect("repeat schema version"),
-            LATEST_SCHEMA_VERSION
+            CURRENT_SCHEMA_VERSION
         );
     }
 
@@ -146,13 +145,13 @@ mod tests {
             let database = Database::open(&path).expect("open file database");
             assert_eq!(
                 database.schema_version().expect("schema version"),
-                LATEST_SCHEMA_VERSION
+                CURRENT_SCHEMA_VERSION
             );
         }
         let reopened = Database::open(&path).expect("reopen file database");
         assert_eq!(
             reopened.schema_version().expect("schema version"),
-            LATEST_SCHEMA_VERSION
+            CURRENT_SCHEMA_VERSION
         );
         assert!(fs::metadata(path).expect("database metadata").len() > 0);
     }
diff --git a/crates/studio_storage/src/lib.rs b/crates/studio_storage/src/lib.rs
@@ -9,5 +9,5 @@ pub mod os_keyring;
 pub mod profiles;
 
 pub use application_adapter::PersistentAppCore;
-pub use db::Database;
-pub use os_keyring::OsKeyringSecretStore;
+pub use db::{CURRENT_SCHEMA_VERSION, Database};
+pub use os_keyring::{CREDENTIAL_SERVICE, OsKeyringSecretStore};