refactor(qbz-app): add preference stores

cx
This commit is contained in:
vicrodh committed 2026-05-14 19:48:54 -06:00
1 parent d48a1019d2
commit 61d5715a22
5 files changed
+833

No files matched your search

+402
View File
@@ -0,0 +1,402 @@
use chrono::Utc;
use md5::{Digest, Md5};
use rusqlite::{params, Connection, Result};
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FavoritesPreferences {
pub custom_icon_path: Option<String>,
pub custom_icon_preset: Option<String>,
pub icon_background: Option<String>,
pub tab_order: Vec<String>,
}
impl Default for FavoritesPreferences {
fn default() -> Self {
Self {
custom_icon_path: None,
custom_icon_preset: Some("heart".to_string()),
icon_background: None,
tab_order: vec![
"tracks".to_string(),
"albums".to_string(),
"artists".to_string(),
"playlists".to_string(),
],
}
}
}
pub struct FavoritesPreferencesStore {
conn: Connection,
}
impl FavoritesPreferencesStore {
fn open_at(dir: &Path, db_name: &str) -> Result<Self, String> {
std::fs::create_dir_all(dir)
.map_err(|e| format!("Failed to create data directory: {}", e))?;
let db_path = dir.join(db_name);
let conn = Connection::open(&db_path)
.map_err(|e| format!("Failed to open favorites preferences database: {}", e))?;
conn.execute_batch("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;")
.map_err(|e| format!("Failed to set WAL mode on favorites preferences: {}", e))?;
conn.execute(
"CREATE TABLE IF NOT EXISTS favorites_preferences (
id INTEGER PRIMARY KEY CHECK (id = 1),
custom_icon_path TEXT,
custom_icon_preset TEXT,
tab_order TEXT NOT NULL
)",
[],
)
.map_err(|e| format!("Failed to create favorites preferences table: {}", e))?;
// Migration: Add icon_background column if it doesn't exist
let has_icon_background = conn
.prepare("SELECT icon_background FROM favorites_preferences LIMIT 1")
.is_ok();
if !has_icon_background {
conn.execute(
"ALTER TABLE favorites_preferences ADD COLUMN icon_background TEXT",
[],
)
.map_err(|e| format!("Failed to add icon_background column: {}", e))?;
}
Ok(Self { conn })
}
pub fn new() -> Result<Self, String> {
let data_dir = dirs::data_dir()
.ok_or("Could not determine data directory")?
.join("qbz");
Self::open_at(&data_dir, "favorites_preferences.db")
}
pub fn new_at(base_dir: &Path) -> Result<Self, String> {
Self::open_at(base_dir, "favorites_preferences.db")
}
fn favorites_icon_dir() -> Result<PathBuf, String> {
let cache_dir = dirs::cache_dir()
.ok_or("Could not determine cache directory")?
.join("qbz")
.join("favorites");
fs::create_dir_all(&cache_dir)
.map_err(|e| format!("Failed to create favorites icon directory: {}", e))?;
Ok(cache_dir)
}
fn normalize_custom_icon_path(&self, path: String) -> Result<String, String> {
let trimmed = path.trim();
if trimmed.is_empty() {
return Ok(String::new());
}
let source = Path::new(trimmed);
if !source.exists() {
return Err(format!("Source icon does not exist: {}", trimmed));
}
let icon_dir = Self::favorites_icon_dir()?;
if source.starts_with(&icon_dir) {
return Ok(trimmed.to_string());
}
let extension = source.extension().and_then(|e| e.to_str()).unwrap_or("png");
let mut hasher = Md5::new();
hasher.update(trimmed.as_bytes());
let hash = format!("{:x}", hasher.finalize());
let filename = format!(
"favorites_icon_{}_{}.{}",
hash,
Utc::now().timestamp(),
extension
);
let dest_path = icon_dir.join(filename);
fs::copy(source, &dest_path)
.map_err(|e| format!("Failed to copy favorites icon: {}", e))?;
Ok(dest_path.to_string_lossy().to_string())
}
pub fn get_preferences(&self) -> Result<FavoritesPreferences, String> {
let mut stmt = self.conn.prepare("SELECT custom_icon_path, custom_icon_preset, icon_background, tab_order FROM favorites_preferences WHERE id = 1")
.map_err(|e| format!("Failed to prepare select: {}", e))?;
let result = stmt.query_row([], |row| {
let custom_icon_path: Option<String> = row.get(0)?;
let custom_icon_preset: Option<String> = row.get(1)?;
let icon_background: Option<String> = row.get(2)?;
let tab_order_str: String = row.get(3)?;
let custom_icon_path = custom_icon_path.and_then(|value| {
if value.trim().is_empty() {
None
} else {
Some(value)
}
});
let tab_order: Vec<String> =
serde_json::from_str(&tab_order_str).unwrap_or_else(|_| {
vec![
"tracks".to_string(),
"albums".to_string(),
"artists".to_string(),
"playlists".to_string(),
]
});
Ok(FavoritesPreferences {
custom_icon_path,
custom_icon_preset,
icon_background,
tab_order,
})
});
match result {
Ok(mut prefs) => {
if let Some(path) = prefs.custom_icon_path.clone() {
match self.normalize_custom_icon_path(path) {
Ok(resolved) => {
let normalized = if resolved.trim().is_empty() {
None
} else {
Some(resolved)
};
if normalized != prefs.custom_icon_path {
prefs.custom_icon_path = normalized;
let _ = self.save_preferences(prefs.clone());
}
}
Err(_) => {
prefs.custom_icon_path = None;
let _ = self.save_preferences(prefs.clone());
}
}
}
Ok(prefs)
}
Err(rusqlite::Error::QueryReturnedNoRows) => Ok(FavoritesPreferences::default()),
Err(e) => Err(format!("Failed to query preferences: {}", e)),
}
}
pub fn save_preferences(
&self,
mut prefs: FavoritesPreferences,
) -> Result<FavoritesPreferences, String> {
if let Some(path) = prefs.custom_icon_path.clone() {
let resolved = self.normalize_custom_icon_path(path)?;
if resolved.is_empty() {
prefs.custom_icon_path = None;
} else {
prefs.custom_icon_path = Some(resolved);
}
}
let tab_order_str = serde_json::to_string(&prefs.tab_order)
.map_err(|e| format!("Failed to serialize tab_order: {}", e))?;
self.conn.execute(
"INSERT OR REPLACE INTO favorites_preferences (id, custom_icon_path, custom_icon_preset, icon_background, tab_order)
VALUES (1, ?1, ?2, ?3, ?4)",
params![prefs.custom_icon_path, prefs.custom_icon_preset, prefs.icon_background, tab_order_str],
)
.map_err(|e| format!("Failed to save preferences: {}", e))?;
Ok(prefs)
}
}
pub struct FavoritesPreferencesState {
pub store: Arc<Mutex<Option<FavoritesPreferencesStore>>>,
}
impl FavoritesPreferencesState {
pub fn new() -> Result<Self, String> {
let store = FavoritesPreferencesStore::new()?;
Ok(Self {
store: Arc::new(Mutex::new(Some(store))),
})
}
pub fn new_empty() -> Self {
Self {
store: Arc::new(Mutex::new(None)),
}
}
pub fn init_at(&self, base_dir: &Path) -> Result<(), String> {
let new_store = FavoritesPreferencesStore::new_at(base_dir)?;
let mut guard = self
.store
.lock()
.map_err(|_| "Failed to lock favorites preferences store".to_string())?;
*guard = Some(new_store);
Ok(())
}
pub fn teardown(&self) -> Result<(), String> {
let mut guard = self
.store
.lock()
.map_err(|_| "Failed to lock favorites preferences store".to_string())?;
*guard = None;
Ok(())
}
}
pub fn create_table(conn: &Connection) -> Result<()> {
conn.execute(
"CREATE TABLE IF NOT EXISTS favorites_preferences (
id INTEGER PRIMARY KEY CHECK (id = 1),
custom_icon_path TEXT,
custom_icon_preset TEXT,
tab_order TEXT NOT NULL
)",
[],
)?;
// Migration: Add icon_background column if it doesn't exist
let has_icon_background = conn
.prepare("SELECT icon_background FROM favorites_preferences LIMIT 1")
.is_ok();
if !has_icon_background {
conn.execute(
"ALTER TABLE favorites_preferences ADD COLUMN icon_background TEXT",
[],
)?;
}
Ok(())
}
pub fn load_preferences(conn: &Connection) -> Result<FavoritesPreferences> {
let mut stmt = conn.prepare("SELECT custom_icon_path, custom_icon_preset, icon_background, tab_order FROM favorites_preferences WHERE id = 1")?;
let result = stmt.query_row([], |row| {
let custom_icon_path: Option<String> = row.get(0)?;
let custom_icon_preset: Option<String> = row.get(1)?;
let icon_background: Option<String> = row.get(2)?;
let tab_order_str: String = row.get(3)?;
let custom_icon_path = custom_icon_path.and_then(|value| {
if value.trim().is_empty() {
None
} else {
Some(value)
}
});
let tab_order: Vec<String> = serde_json::from_str(&tab_order_str).unwrap_or_else(|_| {
vec![
"tracks".to_string(),
"albums".to_string(),
"artists".to_string(),
"playlists".to_string(),
]
});
Ok(FavoritesPreferences {
custom_icon_path,
custom_icon_preset,
icon_background,
tab_order,
})
});
match result {
Ok(prefs) => Ok(prefs),
Err(rusqlite::Error::QueryReturnedNoRows) => Ok(FavoritesPreferences::default()),
Err(e) => Err(e),
}
}
pub fn save_preferences(conn: &Connection, prefs: &FavoritesPreferences) -> Result<()> {
let tab_order_str = serde_json::to_string(&prefs.tab_order).unwrap();
conn.execute(
"INSERT OR REPLACE INTO favorites_preferences (id, custom_icon_path, custom_icon_preset, icon_background, tab_order)
VALUES (1, ?1, ?2, ?3, ?4)",
params![prefs.custom_icon_path, prefs.custom_icon_preset, prefs.icon_background, tab_order_str],
)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn unique_test_dir(name: &str) -> PathBuf {
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
std::env::temp_dir().join(format!("qbz-app-{name}-{}-{nonce}", std::process::id()))
}
#[test]
fn favorites_preferences_default_tab_order_is_stable() {
let prefs = FavoritesPreferences::default();
assert_eq!(
prefs.tab_order,
vec![
"tracks".to_string(),
"albums".to_string(),
"artists".to_string(),
"playlists".to_string()
]
);
assert_eq!(prefs.custom_icon_preset, Some("heart".to_string()));
}
#[test]
fn favorites_preferences_store_returns_default_when_empty() {
let dir = unique_test_dir("favorites-default");
let store = FavoritesPreferencesStore::new_at(&dir).unwrap();
let prefs = store.get_preferences().unwrap();
assert_eq!(prefs.tab_order, FavoritesPreferences::default().tab_order);
assert_eq!(
prefs.custom_icon_preset,
FavoritesPreferences::default().custom_icon_preset
);
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn favorites_preferences_persist_without_custom_icon() {
let dir = unique_test_dir("favorites-persist");
let store = FavoritesPreferencesStore::new_at(&dir).unwrap();
let prefs = FavoritesPreferences {
custom_icon_path: None,
custom_icon_preset: Some("star".to_string()),
icon_background: Some("#112233".to_string()),
tab_order: vec!["artists".to_string(), "tracks".to_string()],
};
let saved = store.save_preferences(prefs.clone()).unwrap();
let loaded = store.get_preferences().unwrap();
assert_eq!(saved.custom_icon_preset, prefs.custom_icon_preset);
assert_eq!(loaded.custom_icon_preset, prefs.custom_icon_preset);
assert_eq!(loaded.icon_background, prefs.icon_background);
assert_eq!(loaded.tab_order, prefs.tab_order);
let _ = std::fs::remove_dir_all(dir);
}
}
+423
View File
@@ -0,0 +1,423 @@
use rusqlite::{params, Connection, Result};
use serde::{Deserialize, Serialize};
use std::path::Path;
use std::sync::{Arc, Mutex};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FoldersViewMode {
Flat,
Tree,
}
impl Default for FoldersViewMode {
fn default() -> Self {
FoldersViewMode::Flat
}
}
impl FoldersViewMode {
pub fn as_str(&self) -> &'static str {
match self {
FoldersViewMode::Flat => "flat",
FoldersViewMode::Tree => "tree",
}
}
pub fn from_str(s: &str) -> Self {
match s {
"tree" => FoldersViewMode::Tree,
_ => FoldersViewMode::Flat,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LibraryPreferences {
pub tab_order: Vec<String>,
pub hidden_tabs: Vec<String>,
#[serde(default)]
pub folders_view_mode: FoldersViewMode,
/// Width (in CSS pixels) of the tree-mode left sidebar in the Folders
/// tab. `None` means "use the frontend default" (currently 302px).
/// Persisted on drag-end so the choice survives restarts. Bounds are
/// enforced on the frontend (min 200px, max 40% of content area).
#[serde(default)]
pub folders_tree_sidebar_width: Option<u32>,
}
impl Default for LibraryPreferences {
fn default() -> Self {
Self {
// Default order matches the current LocalLibraryView tab list,
// with the renamed 'folders' tab in place of the old 'albums'
// tab. Phase 3 adds 'albums' (the new metadata-grouped view)
// to this default.
tab_order: vec![
"tracks".to_string(),
"folders".to_string(),
"albums".to_string(),
"artists".to_string(),
],
hidden_tabs: vec![],
folders_view_mode: FoldersViewMode::Flat,
folders_tree_sidebar_width: None,
}
}
}
pub struct LibraryPreferencesStore {
conn: Connection,
}
impl LibraryPreferencesStore {
fn open_at(dir: &Path, db_name: &str) -> Result<Self, String> {
std::fs::create_dir_all(dir)
.map_err(|e| format!("Failed to create data directory: {}", e))?;
let db_path = dir.join(db_name);
let conn = Connection::open(&db_path)
.map_err(|e| format!("Failed to open library preferences database: {}", e))?;
conn.execute_batch("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;")
.map_err(|e| format!("Failed to set WAL mode on library preferences: {}", e))?;
conn.execute(
"CREATE TABLE IF NOT EXISTS library_preferences (
id INTEGER PRIMARY KEY CHECK (id = 1),
tab_order TEXT NOT NULL,
hidden_tabs TEXT NOT NULL DEFAULT '[]'
)",
[],
)
.map_err(|e| format!("Failed to create library preferences table: {}", e))?;
// Idempotent migrations for columns added after the initial schema.
// These ALTERs fail when the column already exists; that failure is
// expected and ignored.
let _ = conn.execute(
"ALTER TABLE library_preferences ADD COLUMN folders_view_mode TEXT DEFAULT 'flat'",
[],
);
let _ = conn.execute(
"ALTER TABLE library_preferences ADD COLUMN folders_tree_sidebar_width INTEGER DEFAULT NULL",
[],
);
Ok(Self { conn })
}
pub fn new() -> Result<Self, String> {
let data_dir = dirs::data_dir()
.ok_or("Could not determine data directory")?
.join("qbz");
Self::open_at(&data_dir, "library_preferences.db")
}
pub fn new_at(base_dir: &Path) -> Result<Self, String> {
Self::open_at(base_dir, "library_preferences.db")
}
pub fn get_preferences(&self) -> Result<LibraryPreferences, String> {
let mut stmt = self
.conn
.prepare(
"SELECT tab_order, hidden_tabs, folders_view_mode, folders_tree_sidebar_width \
FROM library_preferences WHERE id = 1",
)
.map_err(|e| format!("Failed to prepare select: {}", e))?;
let result = stmt.query_row([], |row| {
let tab_order_str: String = row.get(0)?;
let hidden_tabs_str: String = row.get(1)?;
let folders_view_mode_str: Option<String> = row.get(2)?;
let folders_tree_sidebar_width: Option<i64> = row.get(3)?;
let tab_order: Vec<String> = serde_json::from_str(&tab_order_str)
.unwrap_or_else(|_| LibraryPreferences::default().tab_order);
let hidden_tabs: Vec<String> =
serde_json::from_str(&hidden_tabs_str).unwrap_or_default();
let folders_view_mode = folders_view_mode_str
.map(|s| FoldersViewMode::from_str(&s))
.unwrap_or_default();
// Stored as INTEGER in SQLite; clamp to non-negative on read.
// Frontend re-clamps against the live max anyway.
let folders_tree_sidebar_width = folders_tree_sidebar_width
.filter(|v| *v > 0)
.map(|v| v as u32);
Ok(LibraryPreferences {
tab_order,
hidden_tabs,
folders_view_mode,
folders_tree_sidebar_width,
})
});
match result {
Ok(prefs) => Ok(prefs),
Err(rusqlite::Error::QueryReturnedNoRows) => Ok(LibraryPreferences::default()),
Err(e) => Err(format!("Failed to query library preferences: {}", e)),
}
}
pub fn save_preferences(
&self,
prefs: LibraryPreferences,
) -> Result<LibraryPreferences, String> {
let tab_order_str = serde_json::to_string(&prefs.tab_order)
.map_err(|e| format!("Failed to serialize tab_order: {}", e))?;
let hidden_tabs_str = serde_json::to_string(&prefs.hidden_tabs)
.map_err(|e| format!("Failed to serialize hidden_tabs: {}", e))?;
self.conn
.execute(
"INSERT OR REPLACE INTO library_preferences \
(id, tab_order, hidden_tabs, folders_view_mode, folders_tree_sidebar_width) \
VALUES (1, ?1, ?2, ?3, ?4)",
params![
tab_order_str,
hidden_tabs_str,
prefs.folders_view_mode.as_str(),
prefs.folders_tree_sidebar_width.map(|v| v as i64),
],
)
.map_err(|e| format!("Failed to save library preferences: {}", e))?;
Ok(prefs)
}
pub fn set_folders_tree_sidebar_width(&self, width: u32) -> Result<(), String> {
// Same upsert pattern as `set_folders_view_mode`: try the cheap
// UPDATE first; if no row exists yet, fall back to inserting a
// default row carrying just the new width.
let updated = self
.conn
.execute(
"UPDATE library_preferences SET folders_tree_sidebar_width = ?1 WHERE id = 1",
params![width as i64],
)
.map_err(|e| format!("Failed to set folders_tree_sidebar_width: {}", e))?;
if updated == 0 {
let mut prefs = LibraryPreferences::default();
prefs.folders_tree_sidebar_width = Some(width);
self.save_preferences(prefs)?;
}
Ok(())
}
pub fn set_folders_view_mode(&self, mode: FoldersViewMode) -> Result<(), String> {
// Ensure the row exists before updating; if no preferences have been
// saved yet, fall back to inserting a default row carrying the new
// folders_view_mode value.
let updated = self
.conn
.execute(
"UPDATE library_preferences SET folders_view_mode = ?1 WHERE id = 1",
params![mode.as_str()],
)
.map_err(|e| format!("Failed to set folders_view_mode: {}", e))?;
if updated == 0 {
let mut prefs = LibraryPreferences::default();
prefs.folders_view_mode = mode;
self.save_preferences(prefs)?;
}
Ok(())
}
}
pub struct LibraryPreferencesState {
pub store: Arc<Mutex<Option<LibraryPreferencesStore>>>,
}
impl LibraryPreferencesState {
pub fn new() -> Result<Self, String> {
let store = LibraryPreferencesStore::new()?;
Ok(Self {
store: Arc::new(Mutex::new(Some(store))),
})
}
pub fn new_empty() -> Self {
Self {
store: Arc::new(Mutex::new(None)),
}
}
pub fn init_at(&self, base_dir: &Path) -> Result<(), String> {
let new_store = LibraryPreferencesStore::new_at(base_dir)?;
let mut guard = self
.store
.lock()
.map_err(|_| "Failed to lock library preferences store".to_string())?;
*guard = Some(new_store);
Ok(())
}
pub fn teardown(&self) -> Result<(), String> {
let mut guard = self
.store
.lock()
.map_err(|_| "Failed to lock library preferences store".to_string())?;
*guard = None;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn unique_test_dir(name: &str) -> std::path::PathBuf {
let nonce = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
std::env::temp_dir().join(format!("qbz-app-{name}-{}-{nonce}", std::process::id()))
}
fn fresh_store(name: &str) -> (std::path::PathBuf, LibraryPreferencesStore) {
let dir = unique_test_dir(name);
let store = LibraryPreferencesStore::new_at(&dir).expect("open store in temp dir");
(dir, store)
}
#[test]
fn default_is_flat() {
let prefs = LibraryPreferences::default();
assert_eq!(prefs.folders_view_mode, FoldersViewMode::Flat);
}
#[test]
fn legacy_json_without_folders_view_mode_defaults_to_flat() {
let legacy = r#"{
"tab_order": ["tracks", "folders", "albums", "artists"],
"hidden_tabs": []
}"#;
let prefs: LibraryPreferences = serde_json::from_str(legacy).expect("parse legacy json");
assert_eq!(prefs.folders_view_mode, FoldersViewMode::Flat);
}
#[test]
fn round_trip_with_tree_set() {
let mut prefs = LibraryPreferences::default();
prefs.folders_view_mode = FoldersViewMode::Tree;
let json = serde_json::to_string(&prefs).expect("serialize");
let parsed: LibraryPreferences = serde_json::from_str(&json).expect("deserialize");
assert_eq!(parsed.folders_view_mode, FoldersViewMode::Tree);
}
#[test]
fn folders_view_mode_str_round_trip() {
assert_eq!(FoldersViewMode::Flat.as_str(), "flat");
assert_eq!(FoldersViewMode::Tree.as_str(), "tree");
assert_eq!(FoldersViewMode::from_str("flat"), FoldersViewMode::Flat);
assert_eq!(FoldersViewMode::from_str("tree"), FoldersViewMode::Tree);
assert_eq!(FoldersViewMode::from_str("garbage"), FoldersViewMode::Flat);
}
#[test]
fn fresh_store_returns_default_folders_view_mode() {
let (dir, store) = fresh_store("library-default-mode");
let prefs = store.get_preferences().expect("get prefs");
assert_eq!(prefs.folders_view_mode, FoldersViewMode::Flat);
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn set_folders_view_mode_persists_on_empty_table() {
let (dir, store) = fresh_store("library-mode-empty");
store
.set_folders_view_mode(FoldersViewMode::Tree)
.expect("set mode");
let prefs = store.get_preferences().expect("get prefs");
assert_eq!(prefs.folders_view_mode, FoldersViewMode::Tree);
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn set_folders_view_mode_updates_existing_row() {
let (dir, store) = fresh_store("library-mode-update");
// Seed a row with the default save path so the UPDATE branch runs.
let mut seeded = LibraryPreferences::default();
seeded.tab_order = vec!["tracks".into(), "albums".into()];
store.save_preferences(seeded).expect("save seed");
store
.set_folders_view_mode(FoldersViewMode::Tree)
.expect("set mode");
let after = store.get_preferences().expect("get prefs");
assert_eq!(after.folders_view_mode, FoldersViewMode::Tree);
// Sibling fields preserved.
assert_eq!(
after.tab_order,
vec!["tracks".to_string(), "albums".to_string()]
);
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn save_preferences_persists_folders_view_mode() {
let (dir, store) = fresh_store("library-save-mode");
let mut prefs = LibraryPreferences::default();
prefs.folders_view_mode = FoldersViewMode::Tree;
store.save_preferences(prefs).expect("save");
let loaded = store.get_preferences().expect("load");
assert_eq!(loaded.folders_view_mode, FoldersViewMode::Tree);
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn fresh_store_returns_none_folders_tree_sidebar_width() {
let (dir, store) = fresh_store("library-default-width");
let prefs = store.get_preferences().expect("get prefs");
assert_eq!(prefs.folders_tree_sidebar_width, None);
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn set_folders_tree_sidebar_width_persists_on_empty_table() {
let (dir, store) = fresh_store("library-width-empty");
store
.set_folders_tree_sidebar_width(512)
.expect("set width");
let prefs = store.get_preferences().expect("get prefs");
assert_eq!(prefs.folders_tree_sidebar_width, Some(512));
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn set_folders_tree_sidebar_width_updates_existing_row() {
let (dir, store) = fresh_store("library-width-update");
let mut seeded = LibraryPreferences::default();
seeded.tab_order = vec!["tracks".into(), "folders".into()];
store.save_preferences(seeded).expect("save seed");
store
.set_folders_tree_sidebar_width(640)
.expect("set width");
let after = store.get_preferences().expect("get prefs");
assert_eq!(after.folders_tree_sidebar_width, Some(640));
assert_eq!(
after.tab_order,
vec!["tracks".to_string(), "folders".to_string()]
);
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn legacy_json_without_sidebar_width_defaults_to_none() {
let legacy = r#"{
"tab_order": ["tracks", "folders", "albums", "artists"],
"hidden_tabs": [],
"folders_view_mode": "tree"
}"#;
let prefs: LibraryPreferences = serde_json::from_str(legacy).expect("parse legacy json");
assert_eq!(prefs.folders_tree_sidebar_width, None);
}
}
+2
View File
@@ -1,2 +1,4 @@
pub mod favorites;
pub mod legal;
pub mod library;
pub mod subscription;