qualia_core_db/semantic_instruments/resolve/
registry.rs1use std::collections::BTreeMap;
9
10use super::dependency::DependencyLock;
11use crate::semantic_instruments::errors::InstrumentError;
12
13#[derive(Debug, Clone, PartialEq, Eq)]
15pub struct InstalledRelease {
16 pub release_id: String,
17 pub content_digest: String,
18 pub lock: DependencyLock,
19 pub closed: bool,
20}
21
22#[derive(Debug, Clone, Default)]
24pub struct LocalRegistry {
25 by_id: BTreeMap<String, InstalledRelease>,
26}
27
28impl LocalRegistry {
29 pub fn new() -> Self {
31 Self {
32 by_id: BTreeMap::new(),
33 }
34 }
35
36 pub fn install(&mut self, release: InstalledRelease) -> Result<(), InstrumentError> {
41 if release.release_id.is_empty() {
42 return Err(InstrumentError::MissingField("release_id"));
43 }
44 if release.content_digest.is_empty() {
45 return Err(InstrumentError::MissingField("content_digest"));
46 }
47 if let Some(existing) = self.by_id.get(&release.release_id) {
48 if existing.content_digest == release.content_digest {
49 return Ok(());
50 }
51 return Err(InstrumentError::Canonical("already installed".into()));
52 }
53 self.by_id.insert(release.release_id.clone(), release);
54 Ok(())
55 }
56
57 pub fn lookup(&self, release_id: &str) -> Option<&InstalledRelease> {
59 self.by_id.get(release_id)
60 }
61
62 pub fn uninstall(&mut self, release_id: &str) -> Option<InstalledRelease> {
64 self.by_id.remove(release_id)
65 }
66
67 pub fn activate(&self, release_id: &str) -> Result<&InstalledRelease, InstrumentError> {
69 let release = self
70 .by_id
71 .get(release_id)
72 .ok_or(InstrumentError::RequiredMissing)?;
73 if !release.closed {
74 return Err(InstrumentError::NotClosed);
75 }
76 Ok(release)
77 }
78}
79
80#[cfg(test)]
81mod tests {
82 use super::*;
83
84 const UNIT_CONVERT: &str = "https://ns.webizen.org/demo/unit-convert/releases/1.0.0";
85 const DIGEST: &str = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
86
87 fn empty_lock(release_id: &str) -> DependencyLock {
88 DependencyLock {
89 release_id: release_id.into(),
90 entries: Vec::new(),
91 }
92 }
93
94 fn closed_unit_convert() -> InstalledRelease {
95 InstalledRelease {
96 release_id: UNIT_CONVERT.into(),
97 content_digest: DIGEST.into(),
98 lock: empty_lock(UNIT_CONVERT),
99 closed: true,
100 }
101 }
102
103 #[test]
104 fn install_then_lookup() {
105 let mut reg = LocalRegistry::new();
106 reg.install(closed_unit_convert()).unwrap();
107 let found = reg.lookup(UNIT_CONVERT).expect("stored");
108 assert_eq!(found.release_id, UNIT_CONVERT);
109 assert_eq!(found.content_digest, DIGEST);
110 assert!(found.lock.is_empty());
111 assert!(found.closed);
112 }
113
114 #[test]
115 fn activate_closed_release_ok() {
116 let mut reg = LocalRegistry::new();
117 reg.install(closed_unit_convert()).unwrap();
119 let active = reg.activate(UNIT_CONVERT).unwrap();
120 assert_eq!(active.release_id, UNIT_CONVERT);
121 assert!(active.closed);
122 }
123
124 #[test]
125 fn activate_open_release_is_not_closed() {
126 let mut reg = LocalRegistry::new();
127 let mut open = closed_unit_convert();
128 open.closed = false;
129 reg.install(open).unwrap();
130 assert!(reg.lookup(UNIT_CONVERT).is_some());
131 assert_eq!(reg.activate(UNIT_CONVERT), Err(InstrumentError::NotClosed));
132 }
133
134 #[test]
135 fn activate_missing_is_required_missing() {
136 let reg = LocalRegistry::new();
137 assert_eq!(
138 reg.activate(UNIT_CONVERT),
139 Err(InstrumentError::RequiredMissing)
140 );
141 }
142
143 #[test]
144 fn empty_digest_is_missing_field() {
145 let mut reg = LocalRegistry::new();
146 let mut release = closed_unit_convert();
147 release.content_digest.clear();
148 assert_eq!(
149 reg.install(release),
150 Err(InstrumentError::MissingField("content_digest"))
151 );
152 assert!(reg.lookup(UNIT_CONVERT).is_none());
153 }
154
155 #[test]
156 fn uninstall_drops_lookup_not_history() {
157 let mut reg = LocalRegistry::new();
158 reg.install(closed_unit_convert()).unwrap();
159 assert!(reg.uninstall(UNIT_CONVERT).is_some());
160 assert!(reg.lookup(UNIT_CONVERT).is_none());
161 assert!(reg.uninstall(UNIT_CONVERT).is_none());
162 }
163
164 #[test]
165 fn duplicate_id_rejects_unless_digest_identical() {
166 let mut reg = LocalRegistry::new();
167 reg.install(closed_unit_convert()).unwrap();
168 reg.install(closed_unit_convert()).unwrap();
170 let mut other = closed_unit_convert();
171 other.content_digest =
172 "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb".into();
173 match reg.install(other) {
174 Err(InstrumentError::Canonical(msg)) => assert_eq!(msg, "already installed"),
175 other => panic!("expected Canonical already installed, got {other:?}"),
176 }
177 assert_eq!(reg.lookup(UNIT_CONVERT).unwrap().content_digest, DIGEST);
178 }
179}