fix: fix some displays and features
This commit is contained in:
@ -26,12 +26,13 @@ use domain::markdown::MarkdownDoc;
|
||||
use domain::ports::{
|
||||
AgentContextStore, AgentRuntime, ContextInjectionPlan, DirEntry, EventBus, EventStream,
|
||||
ExitStatus, FileSystem, FsError, IdGenerator, OutputStream, PreparedContext, ProfileStore,
|
||||
PtyError, PtyHandle, PtyPort, RemotePath, RuntimeError, SpawnSpec, StoreError,
|
||||
PtyError, PtyHandle, PtyPort, RemotePath, RuntimeError, SkillStore, SpawnSpec, StoreError,
|
||||
};
|
||||
use domain::profile::{AgentProfile, ContextInjection};
|
||||
use domain::project::{Project, ProjectPath};
|
||||
use domain::remote::RemoteRef;
|
||||
use domain::{PtySize, SessionId};
|
||||
use domain::skill::{Skill, SkillScope};
|
||||
use domain::{PtySize, SessionId, SkillId, SkillRef};
|
||||
use uuid::Uuid;
|
||||
|
||||
use application::{
|
||||
@ -177,6 +178,49 @@ impl ProfileStore for FakeProfiles {
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// FakeSkills (SkillStore) — an in-memory store seeded with a few skills
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
struct FakeSkills(Arc<Vec<Skill>>);
|
||||
|
||||
impl FakeSkills {
|
||||
fn with(skills: Vec<Skill>) -> Self {
|
||||
Self(Arc::new(skills))
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl SkillStore for FakeSkills {
|
||||
async fn list(&self, scope: SkillScope, _root: &ProjectPath) -> Result<Vec<Skill>, StoreError> {
|
||||
Ok(self.0.iter().filter(|s| s.scope == scope).cloned().collect())
|
||||
}
|
||||
async fn get(
|
||||
&self,
|
||||
scope: SkillScope,
|
||||
_root: &ProjectPath,
|
||||
id: SkillId,
|
||||
) -> Result<Skill, StoreError> {
|
||||
self.0
|
||||
.iter()
|
||||
.find(|s| s.scope == scope && s.id == id)
|
||||
.cloned()
|
||||
.ok_or(StoreError::NotFound)
|
||||
}
|
||||
async fn save(&self, _skill: &Skill, _root: &ProjectPath) -> Result<(), StoreError> {
|
||||
Ok(())
|
||||
}
|
||||
async fn delete(
|
||||
&self,
|
||||
_scope: SkillScope,
|
||||
_root: &ProjectPath,
|
||||
_id: SkillId,
|
||||
) -> Result<(), StoreError> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// FakeRuntime (AgentRuntime) — records prepare + returns a configured plan
|
||||
// ---------------------------------------------------------------------------
|
||||
@ -577,6 +621,7 @@ fn launch_fixture(injection: ContextInjection, plan: Option<ContextInjectionPlan
|
||||
Arc::new(runtime),
|
||||
Arc::new(fs.clone()),
|
||||
Arc::new(pty.clone()),
|
||||
Arc::new(FakeSkills::default()),
|
||||
Arc::clone(&sessions),
|
||||
Arc::new(bus.clone()),
|
||||
);
|
||||
@ -695,6 +740,7 @@ async fn two_agents_same_root_get_distinct_run_dirs_no_collision() {
|
||||
Arc::new(FakeRuntime::new(Arc::clone(&tr), plan)),
|
||||
Arc::new(fs.clone()),
|
||||
Arc::new(pty.clone()),
|
||||
Arc::new(FakeSkills::default()),
|
||||
Arc::clone(&sessions),
|
||||
Arc::new(SpyBus::default()),
|
||||
);
|
||||
@ -730,6 +776,98 @@ async fn two_agents_same_root_get_distinct_run_dirs_no_collision() {
|
||||
assert!(String::from_utf8(writes[1].1.clone()).unwrap().contains("# bravo"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn launch_conventionfile_injects_assigned_skills_in_order() {
|
||||
// An agent with two assigned global skills; the generated convention file must
|
||||
// carry both skill bodies, after the persona, in assignment order (§14.2).
|
||||
let skill_id = |n: u128| SkillId::from_uuid(Uuid::from_u128(n));
|
||||
let skill = |n: u128, name: &str, body: &str| {
|
||||
Skill::new(skill_id(n), name, MarkdownDoc::new(body), SkillScope::Global).unwrap()
|
||||
};
|
||||
|
||||
let mut agent = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
|
||||
agent.assign_skill(SkillRef::new(skill_id(1), SkillScope::Global));
|
||||
agent.assign_skill(SkillRef::new(skill_id(2), SkillScope::Global));
|
||||
|
||||
let contexts = FakeContexts::with_agent(&agent, "# persona");
|
||||
let profiles = FakeProfiles::new(vec![profile(
|
||||
pid(9),
|
||||
ContextInjection::convention_file("CLAUDE.md").unwrap(),
|
||||
)]);
|
||||
let tr = trace();
|
||||
let fs = FakeFs::new(Arc::clone(&tr));
|
||||
let pty = FakePty::new(Arc::clone(&tr), sid(777));
|
||||
let skills = FakeSkills::with(vec![
|
||||
skill(1, "refactor", "REFAC_BODY"),
|
||||
skill(2, "review", "REVIEW_BODY"),
|
||||
]);
|
||||
let launch = LaunchAgent::new(
|
||||
Arc::new(contexts),
|
||||
Arc::new(profiles),
|
||||
Arc::new(FakeRuntime::new(
|
||||
Arc::clone(&tr),
|
||||
Some(ContextInjectionPlan::File {
|
||||
target: "CLAUDE.md".to_owned(),
|
||||
}),
|
||||
)),
|
||||
Arc::new(fs.clone()),
|
||||
Arc::new(pty.clone()),
|
||||
Arc::new(skills),
|
||||
Arc::new(TerminalSessions::new()),
|
||||
Arc::new(SpyBus::default()),
|
||||
);
|
||||
|
||||
launch.execute(launch_input(agent.id)).await.unwrap();
|
||||
|
||||
let writes = fs.writes();
|
||||
assert_eq!(writes.len(), 1);
|
||||
let doc = String::from_utf8(writes[0].1.clone()).unwrap();
|
||||
assert!(doc.contains("# persona"), "persona present: {doc}");
|
||||
assert!(doc.contains("REFAC_BODY"), "first skill body present");
|
||||
assert!(doc.contains("REVIEW_BODY"), "second skill body present");
|
||||
// Deterministic order: persona before skills, skill 1 before skill 2.
|
||||
let persona_at = doc.find("# persona").unwrap();
|
||||
let refac_at = doc.find("REFAC_BODY").unwrap();
|
||||
let review_at = doc.find("REVIEW_BODY").unwrap();
|
||||
assert!(persona_at < refac_at && refac_at < review_at, "ordering: {doc}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn launch_skips_dangling_skill_ref_without_failing() {
|
||||
// The agent references a skill that no longer exists in the store: launch must
|
||||
// still succeed and simply omit it (no Skills section for a sole dangling ref).
|
||||
let mut agent = scratch_agent(aid(1), "Backend", "agents/backend.md", pid(9));
|
||||
agent.assign_skill(SkillRef::new(SkillId::from_uuid(Uuid::from_u128(99)), SkillScope::Global));
|
||||
|
||||
let contexts = FakeContexts::with_agent(&agent, "# persona");
|
||||
let profiles = FakeProfiles::new(vec![profile(
|
||||
pid(9),
|
||||
ContextInjection::convention_file("CLAUDE.md").unwrap(),
|
||||
)]);
|
||||
let tr = trace();
|
||||
let fs = FakeFs::new(Arc::clone(&tr));
|
||||
let pty = FakePty::new(Arc::clone(&tr), sid(777));
|
||||
let launch = LaunchAgent::new(
|
||||
Arc::new(contexts),
|
||||
Arc::new(profiles),
|
||||
Arc::new(FakeRuntime::new(
|
||||
Arc::clone(&tr),
|
||||
Some(ContextInjectionPlan::File {
|
||||
target: "CLAUDE.md".to_owned(),
|
||||
}),
|
||||
)),
|
||||
Arc::new(fs.clone()),
|
||||
Arc::new(pty.clone()),
|
||||
Arc::new(FakeSkills::default()), // empty store ⇒ the ref is dangling
|
||||
Arc::new(TerminalSessions::new()),
|
||||
Arc::new(SpyBus::default()),
|
||||
);
|
||||
|
||||
launch.execute(launch_input(agent.id)).await.expect("launch must succeed");
|
||||
let doc = String::from_utf8(fs.writes()[0].1.clone()).unwrap();
|
||||
assert!(!doc.contains("# Skills"), "no Skills section for a dangling ref: {doc}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn launch_stdin_strategy_pipes_context_after_spawn() {
|
||||
let (launch, agent, fs, pty, _bus, _sessions, tr) =
|
||||
@ -771,6 +909,7 @@ async fn launch_unknown_profile_is_not_found() {
|
||||
Arc::new(FakeRuntime::new(Arc::clone(&tr), Some(ContextInjectionPlan::Stdin))),
|
||||
Arc::new(FakeFs::new(Arc::clone(&tr))),
|
||||
Arc::new(pty.clone()),
|
||||
Arc::new(FakeSkills::default()),
|
||||
Arc::new(TerminalSessions::new()),
|
||||
Arc::new(SpyBus::default()),
|
||||
);
|
||||
|
||||
395
crates/application/tests/skill_usecases.rs
Normal file
395
crates/application/tests/skill_usecases.rs
Normal file
@ -0,0 +1,395 @@
|
||||
//! L12 tests for the skill use cases with in-memory port fakes (no real
|
||||
//! store/FS): CRUD across scopes (`CreateSkill`, `UpdateSkill`, `DeleteSkill`,
|
||||
//! `ListSkills`) and the manifest-mutating assignment
|
||||
//! (`AssignSkillToAgent` / `UnassignSkillFromAgent`), asserting the
|
||||
//! `SkillAssigned` event and idempotence.
|
||||
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use async_trait::async_trait;
|
||||
use domain::events::DomainEvent;
|
||||
use domain::ids::{AgentId, ProfileId, ProjectId, SkillId};
|
||||
use domain::markdown::MarkdownDoc;
|
||||
use domain::ports::{
|
||||
AgentContextStore, EventBus, EventStream, IdGenerator, SkillStore, StoreError,
|
||||
};
|
||||
use domain::skill::{Skill, SkillScope};
|
||||
use domain::{AgentManifest, ManifestEntry, Project, ProjectPath, RemoteRef, SkillRef};
|
||||
use uuid::Uuid;
|
||||
|
||||
use application::{
|
||||
AssignSkillToAgent, AssignSkillToAgentInput, CreateSkill, CreateSkillInput, DeleteSkill,
|
||||
DeleteSkillInput, ListSkills, ListSkillsInput, UnassignSkillFromAgent,
|
||||
UnassignSkillFromAgentInput, UpdateSkill, UpdateSkillInput,
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fakes
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// In-memory skill store keyed by `(scope, id)`, honouring scope isolation.
|
||||
#[derive(Clone, Default)]
|
||||
struct FakeSkills(Arc<Mutex<Vec<Skill>>>);
|
||||
#[async_trait]
|
||||
impl SkillStore for FakeSkills {
|
||||
async fn list(&self, scope: SkillScope, _root: &ProjectPath) -> Result<Vec<Skill>, StoreError> {
|
||||
Ok(self
|
||||
.0
|
||||
.lock()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.filter(|s| s.scope == scope)
|
||||
.cloned()
|
||||
.collect())
|
||||
}
|
||||
async fn get(
|
||||
&self,
|
||||
scope: SkillScope,
|
||||
_root: &ProjectPath,
|
||||
id: SkillId,
|
||||
) -> Result<Skill, StoreError> {
|
||||
self.0
|
||||
.lock()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|s| s.scope == scope && s.id == id)
|
||||
.cloned()
|
||||
.ok_or(StoreError::NotFound)
|
||||
}
|
||||
async fn save(&self, skill: &Skill, _root: &ProjectPath) -> Result<(), StoreError> {
|
||||
let mut v = self.0.lock().unwrap();
|
||||
if let Some(slot) = v.iter_mut().find(|s| s.scope == skill.scope && s.id == skill.id) {
|
||||
*slot = skill.clone();
|
||||
} else {
|
||||
v.push(skill.clone());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
async fn delete(
|
||||
&self,
|
||||
scope: SkillScope,
|
||||
_root: &ProjectPath,
|
||||
id: SkillId,
|
||||
) -> Result<(), StoreError> {
|
||||
let mut v = self.0.lock().unwrap();
|
||||
let before = v.len();
|
||||
v.retain(|s| !(s.scope == scope && s.id == id));
|
||||
if v.len() == before {
|
||||
return Err(StoreError::NotFound);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct FakeContexts(Arc<Mutex<AgentManifest>>);
|
||||
impl FakeContexts {
|
||||
fn new(entries: Vec<ManifestEntry>) -> Self {
|
||||
Self(Arc::new(Mutex::new(AgentManifest { version: 1, entries })))
|
||||
}
|
||||
fn manifest(&self) -> AgentManifest {
|
||||
self.0.lock().unwrap().clone()
|
||||
}
|
||||
}
|
||||
#[async_trait]
|
||||
impl AgentContextStore for FakeContexts {
|
||||
async fn read_context(
|
||||
&self,
|
||||
_p: &Project,
|
||||
_agent: &AgentId,
|
||||
) -> Result<MarkdownDoc, StoreError> {
|
||||
Err(StoreError::NotFound)
|
||||
}
|
||||
async fn write_context(
|
||||
&self,
|
||||
_p: &Project,
|
||||
_agent: &AgentId,
|
||||
_md: &MarkdownDoc,
|
||||
) -> Result<(), StoreError> {
|
||||
Ok(())
|
||||
}
|
||||
async fn load_manifest(&self, _p: &Project) -> Result<AgentManifest, StoreError> {
|
||||
Ok(self.manifest())
|
||||
}
|
||||
async fn save_manifest(&self, _p: &Project, m: &AgentManifest) -> Result<(), StoreError> {
|
||||
*self.0.lock().unwrap() = m.clone();
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default, Clone)]
|
||||
struct SpyBus(Arc<Mutex<Vec<DomainEvent>>>);
|
||||
impl SpyBus {
|
||||
fn events(&self) -> Vec<DomainEvent> {
|
||||
self.0.lock().unwrap().clone()
|
||||
}
|
||||
}
|
||||
impl EventBus for SpyBus {
|
||||
fn publish(&self, event: DomainEvent) {
|
||||
self.0.lock().unwrap().push(event);
|
||||
}
|
||||
fn subscribe(&self) -> EventStream {
|
||||
Box::new(std::iter::empty())
|
||||
}
|
||||
}
|
||||
|
||||
struct SeqIds(Mutex<u128>);
|
||||
impl SeqIds {
|
||||
fn new() -> Self {
|
||||
Self(Mutex::new(1))
|
||||
}
|
||||
}
|
||||
impl IdGenerator for SeqIds {
|
||||
fn new_uuid(&self) -> Uuid {
|
||||
let mut n = self.0.lock().unwrap();
|
||||
let id = Uuid::from_u128(*n);
|
||||
*n += 1;
|
||||
id
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Builders
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn pid(n: u128) -> ProfileId {
|
||||
ProfileId::from_uuid(Uuid::from_u128(n))
|
||||
}
|
||||
fn aid(n: u128) -> AgentId {
|
||||
AgentId::from_uuid(Uuid::from_u128(n))
|
||||
}
|
||||
fn sid(n: u128) -> SkillId {
|
||||
SkillId::from_uuid(Uuid::from_u128(n))
|
||||
}
|
||||
fn root() -> ProjectPath {
|
||||
ProjectPath::new("/home/me/demo").unwrap()
|
||||
}
|
||||
fn project() -> Project {
|
||||
Project::new(
|
||||
ProjectId::from_uuid(Uuid::from_u128(1000)),
|
||||
"demo",
|
||||
root(),
|
||||
RemoteRef::local(),
|
||||
1_700_000_000_000,
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
fn scratch_entry(agent: AgentId) -> ManifestEntry {
|
||||
ManifestEntry::new(agent, "A", "agents/a.md", pid(1), None, false, None).unwrap()
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// CRUD
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[tokio::test]
|
||||
async fn create_skill_persists_in_its_scope() {
|
||||
let store = FakeSkills::default();
|
||||
let out = CreateSkill::new(Arc::new(store.clone()), Arc::new(SeqIds::new()))
|
||||
.execute(CreateSkillInput {
|
||||
name: "refactor".to_owned(),
|
||||
content: "# body".to_owned(),
|
||||
scope: SkillScope::Project,
|
||||
project_root: root(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(out.skill.scope, SkillScope::Project);
|
||||
assert_eq!(
|
||||
store.list(SkillScope::Project, &root()).await.unwrap().len(),
|
||||
1
|
||||
);
|
||||
assert!(store
|
||||
.list(SkillScope::Global, &root())
|
||||
.await
|
||||
.unwrap()
|
||||
.is_empty());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn create_skill_rejects_empty_content() {
|
||||
let store = FakeSkills::default();
|
||||
let err = CreateSkill::new(Arc::new(store), Arc::new(SeqIds::new()))
|
||||
.execute(CreateSkillInput {
|
||||
name: "k".to_owned(),
|
||||
content: String::new(),
|
||||
scope: SkillScope::Global,
|
||||
project_root: root(),
|
||||
})
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "INVALID");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn update_skill_replaces_content() {
|
||||
let store = FakeSkills::default();
|
||||
store
|
||||
.save(
|
||||
&Skill::new(sid(1), "k", MarkdownDoc::new("v1"), SkillScope::Global).unwrap(),
|
||||
&root(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let out = UpdateSkill::new(Arc::new(store.clone()))
|
||||
.execute(UpdateSkillInput {
|
||||
scope: SkillScope::Global,
|
||||
skill_id: sid(1),
|
||||
content: "v2".to_owned(),
|
||||
project_root: root(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(out.skill.content_md.as_str(), "v2");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn update_unknown_skill_is_not_found() {
|
||||
let store = FakeSkills::default();
|
||||
let err = UpdateSkill::new(Arc::new(store))
|
||||
.execute(UpdateSkillInput {
|
||||
scope: SkillScope::Global,
|
||||
skill_id: sid(404),
|
||||
content: "x".to_owned(),
|
||||
project_root: root(),
|
||||
})
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "NOT_FOUND");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn list_is_scope_filtered() {
|
||||
let store = FakeSkills::default();
|
||||
store
|
||||
.save(
|
||||
&Skill::new(sid(1), "g", MarkdownDoc::new("x"), SkillScope::Global).unwrap(),
|
||||
&root(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
store
|
||||
.save(
|
||||
&Skill::new(sid(2), "p", MarkdownDoc::new("x"), SkillScope::Project).unwrap(),
|
||||
&root(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let listed = ListSkills::new(Arc::new(store))
|
||||
.execute(ListSkillsInput {
|
||||
scope: SkillScope::Global,
|
||||
project_root: root(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(listed.skills.len(), 1);
|
||||
assert_eq!(listed.skills[0].id, sid(1));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn delete_then_delete_is_not_found() {
|
||||
let store = FakeSkills::default();
|
||||
store
|
||||
.save(
|
||||
&Skill::new(sid(1), "k", MarkdownDoc::new("x"), SkillScope::Project).unwrap(),
|
||||
&root(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let uc = DeleteSkill::new(Arc::new(store));
|
||||
uc.execute(DeleteSkillInput {
|
||||
scope: SkillScope::Project,
|
||||
skill_id: sid(1),
|
||||
project_root: root(),
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let err = uc
|
||||
.execute(DeleteSkillInput {
|
||||
scope: SkillScope::Project,
|
||||
skill_id: sid(1),
|
||||
project_root: root(),
|
||||
})
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "NOT_FOUND");
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Assignment
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn assigned_event(events: &[DomainEvent]) -> Vec<(SkillId, bool)> {
|
||||
events
|
||||
.iter()
|
||||
.filter_map(|e| match e {
|
||||
DomainEvent::SkillAssigned {
|
||||
skill_id, assigned, ..
|
||||
} => Some((*skill_id, *assigned)),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn assign_mutates_manifest_emits_event_and_is_idempotent() {
|
||||
let contexts = FakeContexts::new(vec![scratch_entry(aid(1))]);
|
||||
let bus = SpyBus::default();
|
||||
let uc = AssignSkillToAgent::new(Arc::new(contexts.clone()), Arc::new(bus.clone()));
|
||||
let input = AssignSkillToAgentInput {
|
||||
project: project(),
|
||||
agent_id: aid(1),
|
||||
skill: SkillRef::new(sid(9), SkillScope::Global),
|
||||
};
|
||||
|
||||
uc.execute(input.clone()).await.unwrap();
|
||||
// Re-assigning the same skill is a no-op (dedup).
|
||||
uc.execute(input).await.unwrap();
|
||||
|
||||
let entry = &contexts.manifest().entries[0];
|
||||
assert_eq!(entry.skills.len(), 1, "no duplicate assignment");
|
||||
assert_eq!(entry.skills[0].skill_id, sid(9));
|
||||
assert_eq!(
|
||||
assigned_event(&bus.events()),
|
||||
vec![(sid(9), true)],
|
||||
"exactly one assign event despite double execute"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unassign_removes_and_emits_false_then_is_noop() {
|
||||
let mut entry = scratch_entry(aid(1));
|
||||
entry.skills.push(SkillRef::new(sid(9), SkillScope::Global));
|
||||
let contexts = FakeContexts::new(vec![entry]);
|
||||
let bus = SpyBus::default();
|
||||
let uc = UnassignSkillFromAgent::new(Arc::new(contexts.clone()), Arc::new(bus.clone()));
|
||||
let input = UnassignSkillFromAgentInput {
|
||||
project: project(),
|
||||
agent_id: aid(1),
|
||||
skill_id: sid(9),
|
||||
};
|
||||
|
||||
uc.execute(input.clone()).await.unwrap();
|
||||
uc.execute(input).await.unwrap(); // already gone → no-op
|
||||
|
||||
assert!(contexts.manifest().entries[0].skills.is_empty());
|
||||
assert_eq!(assigned_event(&bus.events()), vec![(sid(9), false)]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn assign_to_unknown_agent_is_not_found() {
|
||||
let contexts = FakeContexts::new(vec![]);
|
||||
let bus = SpyBus::default();
|
||||
let err = AssignSkillToAgent::new(Arc::new(contexts), Arc::new(bus))
|
||||
.execute(AssignSkillToAgentInput {
|
||||
project: project(),
|
||||
agent_id: aid(404),
|
||||
skill: SkillRef::new(sid(9), SkillScope::Global),
|
||||
})
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(err.code(), "NOT_FOUND");
|
||||
}
|
||||
Reference in New Issue
Block a user