kimun-notes 0.24.3

// tui/tests/common/mod.rs
//
// Helpers shared by the integration tests. Every test binary compiles this
// module separately and uses a different subset of it, hence the blanket
// dead-code allow.
#![allow(dead_code)]

use std::path::{Path, PathBuf};

use kimun_core::{IndexFile, NoteVault, SystemPath, VaultConfig};
use kimun_notes::components::events::{AppEvent, InputEvent};
use ratatui::Terminal;
use ratatui::backend::TestBackend;
use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers};

/// The workspace name test vaults index under, instead of the default
/// `<workspace>/kimun.sqlite`.
///
/// Both about not colliding with the code under test: `kimun.sqlite` is the
/// name the vault-local index has always had, so a test vault using it would
/// share a file with any code path that reaches for the default. The leading
/// dot also keeps the file out of the vault walk.
pub const TEST_INDEX_NAME: &str = ".test-index";

/// A [`SystemPath`] for a path a test has already made absolute (a `TempDir`,
/// a host literal). Panics rather than returning a `Result`: a test handing
/// over a relative path is a broken test, not a failure case.
pub fn sys<P: AsRef<Path>>(path: P) -> SystemPath {
    SystemPath::try_absolute(&path).unwrap_or_else(|e| panic!("test path must be absolute: {e}"))
}

/// [`VaultConfig`] for a test vault rooted at `dir`, indexed under
/// [`TEST_INDEX_NAME`].
pub fn test_vault_config(dir: &Path) -> VaultConfig {
    let root = sys(dir);
    let index = IndexFile::in_dir(&root, TEST_INDEX_NAME);
    VaultConfig::new(root).with_index(index)
}

/// Opens a test vault at `dir` with its database initialised.
///
/// Close it (`vault.close().await`) before the [`TempDir`] drops. The pool
/// holds the index file open — plus its `-wal`/`-shm` sidecars — and dropping
/// a pool only *schedules* the close; Windows then cannot `remove_dir_all` the
/// directory, an error `tempfile` swallows, so the leaked temp directory is
/// silent.
///
/// [`TempDir`]: tempfile::TempDir
pub async fn open_test_vault(dir: &Path) -> NoteVault {
    let vault = NoteVault::new(test_vault_config(dir))
        .await
        .expect("failed to create vault");
    vault
        .validate_and_init()
        .await
        .expect("failed to init vault");
    vault
}

/// Builds a genuinely absolute path for the host from `/`-separated
/// components.
///
/// A literal like `"/nonexistent/path"` is absolute on Unix but merely
/// *rooted* on Windows, where [`Path::is_absolute`] also wants a prefix
/// (`C:\`). Settings treat a rooted-but-prefixless path as relative and rebase
/// it onto the config directory, so a test written with the literal stops
/// testing what its name says.
///
/// [`Path::is_absolute`]: std::path::Path::is_absolute
pub fn absolute(unix_style: &str) -> PathBuf {
    let trimmed = unix_style.trim_start_matches('/');
    if cfg!(windows) {
        PathBuf::from(format!("C:\\{}", trimmed.replace('/', "\\")))
    } else {
        PathBuf::from(format!("/{trimmed}"))
    }
}

/// [`absolute`] as the contents of a TOML string literal — Windows separators
/// have to survive TOML's own escaping.
pub fn absolute_toml(unix_style: &str) -> String {
    absolute(unix_style).to_string_lossy().replace('\\', "\\\\")
}

/// A key press as crossterm reports it.
pub fn press(code: KeyCode, modifiers: KeyModifiers) -> KeyEvent {
    KeyEvent {
        code,
        modifiers,
        kind: KeyEventKind::Press,
        state: KeyEventState::NONE,
    }
}

/// The same press as the loop's input event.
pub fn input(key: KeyEvent) -> AppEvent {
    AppEvent::Input(InputEvent::Key(key))
}

/// A config at the current version with a single workspace.
///
/// `cache_dir`/`history_dir` are left at their defaults, which resolve against
/// the config file's own directory — so a test writing this into a temp dir
/// keeps its index and history there rather than in the real installation.
pub fn write_config(config_path: &Path, workspace: &Path) {
    let toml = format!(
        r#"config_version = 6

[global]
current_workspace = "default"

[workspaces.default]
path = {:?}
created = "2024-01-15T10:30:00Z"
"#,
        workspace.to_string_lossy().as_ref()
    );
    std::fs::write(config_path, toml).expect("failed to write config file");
}

/// Every cell of the last drawn frame, row-major, as one string — enough to
/// ask "does the frame show this text" without caring where.
pub fn buffer_text(terminal: &Terminal<TestBackend>) -> String {
    terminal
        .backend()
        .buffer()
        .content()
        .iter()
        .map(|cell| cell.symbol())
        .collect()
}