feat(chat): persistance bornee du brouillon custom chat par projet/layout (#182)

crates/application/tests/chat_drafts.rs

@@ -0,0 +1,230 @@
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+use async_trait::async_trait;
+use domain::ports::{ChatDraftStore, Clock, ProjectStore, StoreError};
+use domain::{
+    ChatDraft, ChatDraftKey, LayoutId, NodeId, Project, ProjectId, ProjectPath, RemoteRef,
+};
+use uuid::Uuid;
+
+use application::{
+    ChatDraftScopeInput, ClearChatDraft, ReadChatDraft, SaveChatDraft, SaveChatDraftInput,
+};
+
+#[derive(Default)]
+struct FakeProjects {
+    projects: Mutex<HashMap<ProjectId, Project>>,
+}
+
+#[async_trait]
+impl ProjectStore for FakeProjects {
+    async fn list_projects(&self) -> Result<Vec<Project>, StoreError> {
+        Ok(self.projects.lock().unwrap().values().cloned().collect())
+    }
+
+    async fn load_project(&self, id: ProjectId) -> Result<Project, StoreError> {
+        self.projects
+            .lock()
+            .unwrap()
+            .get(&id)
+            .cloned()
+            .ok_or(StoreError::NotFound)
+    }
+
+    async fn save_project(&self, project: &Project) -> Result<(), StoreError> {
+        self.projects
+            .lock()
+            .unwrap()
+            .insert(project.id, project.clone());
+        Ok(())
+    }
+
+    async fn save_workspace(
+        &self,
+        _workspace: &domain::layout::Workspace,
+    ) -> Result<(), StoreError> {
+        Ok(())
+    }
+
+    async fn load_workspace(&self) -> Result<domain::layout::Workspace, StoreError> {
+        Err(StoreError::NotFound)
+    }
+}
+
+#[derive(Default)]
+struct FakeDrafts {
+    drafts: Mutex<HashMap<ChatDraftKey, ChatDraft>>,
+    saves: Mutex<Vec<ChatDraft>>,
+    clears: Mutex<Vec<ChatDraftKey>>,
+}
+
+#[async_trait]
+impl ChatDraftStore for FakeDrafts {
+    async fn read(
+        &self,
+        _root: &ProjectPath,
+        key: ChatDraftKey,
+    ) -> Result<Option<ChatDraft>, StoreError> {
+        Ok(self.drafts.lock().unwrap().get(&key).cloned())
+    }
+
+    async fn save(&self, _root: &ProjectPath, draft: ChatDraft) -> Result<(), StoreError> {
+        self.saves.lock().unwrap().push(draft.clone());
+        self.drafts.lock().unwrap().insert(draft.key, draft);
+        Ok(())
+    }
+
+    async fn clear(&self, _root: &ProjectPath, key: ChatDraftKey) -> Result<(), StoreError> {
+        self.clears.lock().unwrap().push(key);
+        self.drafts.lock().unwrap().remove(&key);
+        Ok(())
+    }
+}
+
+struct FixedClock;
+
+impl Clock for FixedClock {
+    fn now_millis(&self) -> i64 {
+        1234
+    }
+}
+
+fn pid() -> ProjectId {
+    ProjectId::from_uuid(Uuid::from_u128(1))
+}
+
+fn lid(n: u128) -> LayoutId {
+    LayoutId::from_uuid(Uuid::from_u128(n))
+}
+
+fn nid(n: u128) -> NodeId {
+    NodeId::from_uuid(Uuid::from_u128(n))
+}
+
+fn project() -> Project {
+    Project::new(
+        pid(),
+        "P",
+        ProjectPath::new("/tmp/idea-chat-drafts-test").unwrap(),
+        RemoteRef::Local,
+        0,
+    )
+    .unwrap()
+}
+
+fn scope(layout_id: LayoutId, node_id: NodeId) -> ChatDraftScopeInput {
+    ChatDraftScopeInput {
+        project_id: pid(),
+        layout_id,
+        node_id,
+    }
+}
+
+#[tokio::test]
+async fn save_and_read_chat_draft_round_trip_text_only() {
+    let projects = Arc::new(FakeProjects::default());
+    projects.save_project(&project()).await.unwrap();
+    let drafts = Arc::new(FakeDrafts::default());
+    let save = SaveChatDraft::new(
+        Arc::clone(&projects) as Arc<dyn ProjectStore>,
+        Arc::clone(&drafts) as Arc<dyn ChatDraftStore>,
+        Arc::new(FixedClock),
+    );
+    let read = ReadChatDraft::new(
+        Arc::clone(&projects) as Arc<dyn ProjectStore>,
+        Arc::clone(&drafts) as Arc<dyn ChatDraftStore>,
+    );
+
+    save.execute(SaveChatDraftInput {
+        scope: scope(lid(2), nid(3)),
+        text: "hello draft".to_owned(),
+    })
+    .await
+    .unwrap();
+
+    let output = read.execute(scope(lid(2), nid(3))).await.unwrap();
+    assert_eq!(output.text.as_deref(), Some("hello draft"));
+    assert_eq!(output.updated_at_ms, Some(1234));
+    assert_eq!(drafts.saves.lock().unwrap()[0].text, "hello draft");
+}
+
+#[tokio::test]
+async fn save_empty_text_clears_draft() {
+    let projects = Arc::new(FakeProjects::default());
+    projects.save_project(&project()).await.unwrap();
+    let drafts = Arc::new(FakeDrafts::default());
+    let key = ChatDraftKey::new(pid(), lid(2), nid(3));
+    drafts
+        .drafts
+        .lock()
+        .unwrap()
+        .insert(key, ChatDraft::new(key, "old", 1).unwrap());
+    let save = SaveChatDraft::new(
+        Arc::clone(&projects) as Arc<dyn ProjectStore>,
+        Arc::clone(&drafts) as Arc<dyn ChatDraftStore>,
+        Arc::new(FixedClock),
+    );
+
+    save.execute(SaveChatDraftInput {
+        scope: scope(lid(2), nid(3)),
+        text: String::new(),
+    })
+    .await
+    .unwrap();
+
+    assert!(drafts.drafts.lock().unwrap().is_empty());
+    assert_eq!(drafts.clears.lock().unwrap().as_slice(), &[key]);
+}
+
+#[tokio::test]
+async fn clear_chat_draft_is_scoped_by_layout_and_node() {
+    let projects = Arc::new(FakeProjects::default());
+    projects.save_project(&project()).await.unwrap();
+    let drafts = Arc::new(FakeDrafts::default());
+    let keep = ChatDraftKey::new(pid(), lid(2), nid(4));
+    let clear = ChatDraftKey::new(pid(), lid(2), nid(3));
+    drafts
+        .drafts
+        .lock()
+        .unwrap()
+        .insert(keep, ChatDraft::new(keep, "keep", 1).unwrap());
+    drafts
+        .drafts
+        .lock()
+        .unwrap()
+        .insert(clear, ChatDraft::new(clear, "clear", 1).unwrap());
+    let usecase = ClearChatDraft::new(
+        Arc::clone(&projects) as Arc<dyn ProjectStore>,
+        Arc::clone(&drafts) as Arc<dyn ChatDraftStore>,
+    );
+
+    usecase.execute(scope(lid(2), nid(3))).await.unwrap();
+
+    let drafts = drafts.drafts.lock().unwrap();
+    assert!(drafts.contains_key(&keep));
+    assert!(!drafts.contains_key(&clear));
+}
+
+#[tokio::test]
+async fn oversized_chat_draft_is_rejected_before_store_call() {
+    let projects = Arc::new(FakeProjects::default());
+    projects.save_project(&project()).await.unwrap();
+    let drafts = Arc::new(FakeDrafts::default());
+    let save = SaveChatDraft::new(
+        Arc::clone(&projects) as Arc<dyn ProjectStore>,
+        Arc::clone(&drafts) as Arc<dyn ChatDraftStore>,
+        Arc::new(FixedClock),
+    );
+
+    let err = save
+        .execute(SaveChatDraftInput {
+            scope: scope(lid(2), nid(3)),
+            text: "x".repeat(domain::CHAT_DRAFT_MAX_BYTES + 1),
+        })
+        .await
+        .unwrap_err();
+
+    assert_eq!(err.code(), "INVALID");
+    assert!(drafts.saves.lock().unwrap().is_empty());
+}