Test spec for preferences API.

src/helpers/account.rs

@@ -313,7 +313,9 @@ pub async fn new_account(
         .text("NEW ACCOUNT".into())
         .text(format!("{}", account_name).into())
         .text(
-            "Creating a new account will perform the following actions:".into())
+            "Creating a new account will perform the following actions:"
+                .into(),
+        )
         .text(message.into())
         .render();
     println!("{}", banner);

src/helpers/secret.rs

@@ -74,9 +74,7 @@ pub fn print_secret(
         .text(secret_meta.label().into());
 
     let mut banner = match secret_data {
-        Secret::Note { text, .. } => {
-            banner.text(text.expose_secret().into())
-        }
+        Secret::Note { text, .. } => banner.text(text.expose_secret().into()),
         Secret::Account {
             account,
             url,
@@ -125,9 +123,7 @@ pub fn print_secret(
         Secret::Password { password, .. } => {
             banner.text(password.expose_secret().into())
         }
-        Secret::Link { url, .. } => {
-            banner.text(url.expose_secret().into())
-        }
+        Secret::Link { url, .. } => banner.text(url.expose_secret().into()),
         Secret::Signer { .. } | Secret::Age { .. } => {
             banner.text("[REDACTED PRIVATE SIGNING KEY]".into())
         }
@@ -248,7 +244,9 @@ fn multiline_banner(kind: &str, label: &str) {
         .text(format!("[{}] {}", kind, label).into())
         .text(
             r#"To abort enter Ctrl+C
-To save enter Ctrl+D on a newline"#.into())
+To save enter Ctrl+D on a newline"#
+                .into(),
+        )
         .render();
     println!("{}", banner);
 }

tests/local_account/main.rs

@@ -9,6 +9,7 @@ mod identity_login;
 mod migrate_export;
 mod migrate_import;
 mod move_secret;
+mod preferences;
 mod search;
 mod secret_lifecycle;
 mod security_report;

tests/local_account/preferences.rs

@@ -0,0 +1,109 @@
+use crate::test_utils::{setup, teardown};
+use anyhow::Result;
+use sos_net::sdk::prelude::*;
+
+/// Tests the account preferences.
+#[tokio::test]
+async fn local_preferences() -> Result<()> {
+    const TEST_ID: &str = "preferences";
+    //crate::test_utils::init_tracing();
+
+    let mut dirs = setup(TEST_ID, 1).await?;
+    let data_dir = dirs.clients.remove(0);
+
+    let account_name = TEST_ID.to_string();
+    let (password, _) = generate_passphrase()?;
+
+    let mut account = LocalAccount::new_account(
+        account_name.clone(),
+        password.clone(),
+        Some(data_dir.clone()),
+    )
+    .await?;
+
+    let key: AccessKey = password.into();
+    account.sign_in(&key).await?;
+
+    let identity = account.public_identity().await?.clone();
+    let identities = vec![identity];
+
+    CachedPreferences::initialize(&identities, Some(data_dir.clone()))
+        .await?;
+
+    // Create preferences
+    CachedPreferences::set(
+        account.address(),
+        "mock.bool".to_owned(),
+        true.into(),
+    )
+    .await?;
+
+    CachedPreferences::set(
+        account.address(),
+        "mock.int".to_owned(),
+        (-15 as i64).into(),
+    )
+    .await?;
+
+    CachedPreferences::set(
+        account.address(),
+        "mock.double".to_owned(),
+        (3.14 as f64).into(),
+    )
+    .await?;
+    CachedPreferences::set(
+        account.address(),
+        "mock.string".to_owned(),
+        "message".to_owned().into(),
+    )
+    .await?;
+    let list = vec!["item-1".to_owned(), "item-2".to_owned()];
+    CachedPreferences::set(
+        account.address(),
+        "mock.string-list".to_owned(),
+        list.into(),
+    )
+    .await?;
+
+    // Retrieve preferences
+    let missing =
+        CachedPreferences::get(account.address(), "mock.non-existent")
+            .await?;
+    assert!(matches!(missing, None));
+
+    let boolean =
+        CachedPreferences::get(account.address(), "mock.bool").await?;
+    assert!(matches!(boolean, Some(Preference::Bool(_))));
+
+    let int = CachedPreferences::get(account.address(), "mock.int").await?;
+    assert!(matches!(int, Some(Preference::Int(_))));
+
+    let double =
+        CachedPreferences::get(account.address(), "mock.double").await?;
+    assert!(matches!(double, Some(Preference::Double(_))));
+
+    let string =
+        CachedPreferences::get(account.address(), "mock.string").await?;
+    assert!(matches!(string, Some(Preference::String(_))));
+
+    let string_list =
+        CachedPreferences::get(account.address(), "mock.string-list").await?;
+    assert!(matches!(string_list, Some(Preference::StringList(_))));
+
+    // Remove preferences
+    let removed =
+        CachedPreferences::remove(account.address(), "mock.bool").await?;
+    assert!(matches!(removed, Some(Preference::Bool(true))));
+
+    // Clear preferences
+    CachedPreferences::clear(account.address()).await?;
+    let prefs = CachedPreferences::load(account.address()).await;
+    let items = prefs.iter().collect::<Vec<_>>();
+    assert!(items.is_empty());
+
+    account.sign_out().await?;
+
+    teardown(TEST_ID).await;
+
+    Ok(())
+}

workspace/sdk/src/account/preferences.rs

@@ -25,11 +25,18 @@ impl CachedPreferences {
     ///
     /// If a preferences file exists for an account it is loaded
     /// into memory otherwise empty preferences are used.
-    pub async fn initialize(accounts: &[PublicIdentity]) -> Result<()> {
+    pub async fn initialize(
+        accounts: &[PublicIdentity],
+        data_dir: Option<PathBuf>,
+    ) -> Result<()> {
+        let data_dir = if let Some(data_dir) = data_dir {
+            data_dir
+        } else {
+            Paths::data_dir()?
+        };
         let mut cache = CACHE.lock().await;
         for account in accounts {
-            let paths =
-                Paths::new(Paths::data_dir()?, account.address().to_string());
+            let paths = Paths::new(&data_dir, account.address().to_string());
             let file = paths.preferences();
             let prefs = if file.exists() {
                 let mut prefs = Preferences::new(&paths);
@@ -44,7 +51,7 @@ impl CachedPreferences {
     }
 
     /// Load the preferences for an account.
-    pub async fn load_preferences(address: &Address) -> Preferences {
+    pub async fn load(address: &Address) -> Preferences {
         let cache = CACHE.lock().await;
         if let Some(prefs) = cache.get(address) {
             prefs.clone()
@@ -54,7 +61,7 @@ impl CachedPreferences {
     }
 
     /// Get a preference for an account.
-    pub async fn get_preference(
+    pub async fn get(
         address: &Address,
         key: impl AsRef<str>,
     ) -> Result<Option<Preference>> {
@@ -71,7 +78,7 @@ impl CachedPreferences {
     }
 
     /// Set a preference for an account.
-    pub async fn set_preference(
+    pub async fn set(
         address: &Address,
         key: String,
         value: Preference,
@@ -83,18 +90,17 @@ impl CachedPreferences {
     }
 
     /// Remove a preference for an account.
-    pub async fn remove_preference(
+    pub async fn remove(
         address: &Address,
         key: impl AsRef<str>,
-    ) -> Result<()> {
+    ) -> Result<Option<Preference>> {
         let mut cache = CACHE.lock().await;
         let prefs = cache.entry(*address).or_default();
-        prefs.remove(key).await?;
-        Ok(())
+        prefs.remove(key).await
     }
 
     /// Clear all preferences for an account.
-    pub async fn clear_preferences(address: &Address) -> Result<()> {
+    pub async fn clear(address: &Address) -> Result<()> {
         let mut cache = CACHE.lock().await;
         if let Some(mut prefs) = cache.remove(address) {
             prefs.clear().await?;
@@ -104,7 +110,7 @@ impl CachedPreferences {
 }
 
 /// Preference value.
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum Preference {
     /// Boolean value.
@@ -119,6 +125,36 @@ pub enum Preference {
     StringList(Vec<String>),
 }
 
+impl From<bool> for Preference {
+    fn from(value: bool) -> Self {
+        Self::Bool(value)
+    }
+}
+
+impl From<f64> for Preference {
+    fn from(value: f64) -> Self {
+        Self::Double(value)
+    }
+}
+
+impl From<i64> for Preference {
+    fn from(value: i64) -> Self {
+        Self::Int(value)
+    }
+}
+
+impl From<String> for Preference {
+    fn from(value: String) -> Self {
+        Self::String(value)
+    }
+}
+
+impl From<Vec<String>> for Preference {
+    fn from(value: Vec<String>) -> Self {
+        Self::StringList(value)
+    }
+}
+
 /// Preferences for an account.
 #[derive(Default, Clone, Serialize, Deserialize)]
 pub struct Preferences {
@@ -179,9 +215,13 @@ impl Preferences {
     /// Remove a preference.
     ///
     /// Changes are written to disc.
-    pub async fn remove(&mut self, key: impl AsRef<str>) -> Result<()> {
-        self.values.remove(key.as_ref());
-        self.save().await
+    pub async fn remove(
+        &mut self,
+        key: impl AsRef<str>,
+    ) -> Result<Option<Preference>> {
+        let pref = self.values.remove(key.as_ref());
+        self.save().await?;
+        Ok(pref)
     }
 
     /// Clear all preferences.

workspace/sdk/src/audit/mod.rs

@@ -7,8 +7,8 @@ use serde::{Deserialize, Serialize};
 use crate::{
     events::{Event, EventKind, LogEvent, ReadEvent, WriteEvent},
     signer::ecdsa::Address,
-    UtcDateTime,
     vault::{secret::SecretId, VaultId},
+    UtcDateTime,
 };
 
 use crate::events::AccountEvent;

workspace/sdk/src/date_time.rs

@@ -1,7 +1,7 @@
 //! UTC date and time that can be encoded to and from binary.
 //!
 //! Encoded as an i64 of the seconds since the UNIX epoch and
-//! a u32 nanosecond offset from the second so the total size 
+//! a u32 nanosecond offset from the second so the total size
 //! when encoded is 12 bytes.
 
 use serde::{Deserialize, Serialize};

workspace/sdk/src/events/log/file.rs

@@ -24,9 +24,8 @@ use crate::{
         EventLogRecord, FileIdentity, FileItem, FormatStream,
         FormatStreamIterator,
     },
-    UtcDateTime,
     vfs::{self, File, OpenOptions},
-    Error, Result,
+    Error, Result, UtcDateTime,
 };
 
 use crate::events::AccountEvent;

workspace/sdk/src/events/log/mod.rs

@@ -1,7 +1,6 @@
 //! Event log types and traits.
 use crate::{
-    commit::CommitHash, decode, formats::EventLogRecord,
-    UtcDateTime, Result,
+    commit::CommitHash, decode, formats::EventLogRecord, Result, UtcDateTime,
 };
 use binary_stream::futures::Decodable;
 

workspace/sdk/src/events/log/reducer.rs

@@ -323,9 +323,7 @@ mod files {
         /// Reduce file events to a canonical collection
         /// of external files.
         #[cfg(not(feature = "sync"))]
-        pub async fn reduce(
-            self,
-        ) -> Result<IndexSet<ExternalFile>> {
+        pub async fn reduce(self) -> Result<IndexSet<ExternalFile>> {
             let mut files: IndexSet<ExternalFile> = IndexSet::new();
 
             let stream = self.log.stream(false).await;

workspace/sdk/src/prelude.rs

@@ -1,6 +1,8 @@
 //! Prelude re-exports common types.
 #[cfg(all(feature = "account", feature = "archive"))]
 pub use crate::account::archive::*;
+#[cfg(all(feature = "account", feature = "preferences"))]
+pub use crate::account::preferences::*;
 #[cfg(all(feature = "account", feature = "security-report"))]
 pub use crate::account::security_report::*;
 #[cfg(feature = "account")]