thoughts-tool 0.12.0

Flexible thought management using filesystem mounts for git repositories
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use super::manager::MountManager;
use super::types::*;
use crate::error::Result;
use async_trait::async_trait;
use std::collections::HashMap;
use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::Mutex;

/// Mock mount manager for testing
#[derive(Clone)]
pub struct MockMountManager {
    mounts: Arc<Mutex<HashMap<PathBuf, MountInfo>>>,
    should_fail: Arc<Mutex<bool>>,
}

impl Default for MockMountManager {
    fn default() -> Self {
        Self::new()
    }
}

impl MockMountManager {
    pub fn new() -> Self {
        Self {
            mounts: Arc::new(Mutex::new(HashMap::new())),
            should_fail: Arc::new(Mutex::new(false)),
        }
    }

    pub fn set_should_fail(&self, fail: bool) {
        *self.should_fail.lock().unwrap() = fail;
    }
}

#[async_trait]
impl MountManager for MockMountManager {
    async fn mount(
        &self,
        sources: &[PathBuf],
        target: &Path,
        _options: &MountOptions,
    ) -> Result<()> {
        if *self.should_fail.lock().unwrap() {
            return Err(crate::error::ThoughtsError::MountOperationFailed {
                message: "Mock mount failed".to_string(),
            });
        }

        let mount_info = MountInfo {
            target: target.to_path_buf(),
            sources: sources.to_vec(),
            status: MountStatus::Mounted,
            fs_type: "mock".to_string(),
            options: vec!["mock".to_string()],
            mounted_at: Some(std::time::SystemTime::now()),
            pid: Some(std::process::id()),
            metadata: MountMetadata::Unknown,
        };

        self.mounts
            .lock()
            .unwrap()
            .insert(target.to_path_buf(), mount_info);
        Ok(())
    }

    async fn unmount(&self, target: &Path, _force: bool) -> Result<()> {
        if *self.should_fail.lock().unwrap() {
            return Err(crate::error::ThoughtsError::MountOperationFailed {
                message: "Mock unmount failed".to_string(),
            });
        }

        self.mounts.lock().unwrap().remove(target);
        Ok(())
    }

    async fn is_mounted(&self, target: &Path) -> Result<bool> {
        Ok(self.mounts.lock().unwrap().contains_key(target))
    }

    async fn list_mounts(&self) -> Result<Vec<MountInfo>> {
        Ok(self.mounts.lock().unwrap().values().cloned().collect())
    }

    async fn get_mount_info(&self, target: &Path) -> Result<Option<MountInfo>> {
        Ok(self.mounts.lock().unwrap().get(target).cloned())
    }

    async fn check_health(&self) -> Result<()> {
        if *self.should_fail.lock().unwrap() {
            return Err(crate::error::ThoughtsError::MountOperationFailed {
                message: "Mock health check failed".to_string(),
            });
        }
        Ok(())
    }

    fn get_mount_command(
        &self,
        _sources: &[PathBuf],
        _target: &Path,
        _options: &MountOptions,
    ) -> String {
        "mock mount command".to_string()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_mock_mount_manager() {
        let manager = MockMountManager::new();
        let sources = vec![PathBuf::from("/tmp/a"), PathBuf::from("/tmp/b")];
        let target = Path::new("/tmp/merged");
        let options = MountOptions::default();

        // Should not be mounted initially
        assert!(!manager.is_mounted(target).await.unwrap());

        // Mount should succeed
        manager.mount(&sources, target, &options).await.unwrap();
        assert!(manager.is_mounted(target).await.unwrap());

        // Should appear in list
        let mounts = manager.list_mounts().await.unwrap();
        assert_eq!(mounts.len(), 1);
        assert_eq!(mounts[0].target, target);

        // Unmount should succeed
        manager.unmount(target, false).await.unwrap();
        assert!(!manager.is_mounted(target).await.unwrap());

        // Test failure mode
        manager.set_should_fail(true);
        assert!(manager.mount(&sources, target, &options).await.is_err());
    }
}