2001. 2001 "o1",
2002. 2002 ))
2003. 2003 .unwrap();
2004. 2004 lib.deactivate("dk1", LibraryScope::Workspace, "o1");
2005. 2005 assert!(lib.get("dk1", 1).is_some());
2006. 2006 }));
2007. 2007
2008. 2008 // 7o. Multiple activations for different semantic types
2009. 2009 scenarios.push(tc("multiple_activations_different_types", || {
2010. 2010 let mut lib = PresentationLibrary::default();
2011. 2011 lib.register(stored_simple(
2012. 2012 "ma1",
2013. 2013 1,
2014. 2014 &["detail", "comparison"],
2015. 2015 section_with_title(),
2016. 2016 "o1",
2017. 2017 ))
2018. 2018 .unwrap();
2019. 2019 lib.activate("ma1", 1, LibraryScope::Workspace, "o1")
2020. 2020 .unwrap();
2021. 2021 assert!(
2022. 2022 lib.select("detail", LibraryScope::Workspace, "o1")
2023. 2023 .is_some()
2024. 2024 );
2025. 2025 assert!(
2026. 2026 lib.select("comparison", LibraryScope::Workspace, "o1")
2027. 2027 .is_some()
2028. 2028 );
2029. 2029 }));
2030. 2030
2031. 2031 // 7p. Revocation does not remove unrelated specs
2032. 2032 scenarios.push(tc("revoke_does_not_remove_unrelated", || {
2033. 2033 let mut lib = PresentationLibrary::default();
2034. 2034 lib.register(stored_simple(
2035. 2035 "rel1",
2036. 2036 1,
2037. 2037 &["detail"],
2038. 2038 section_with_title(),
2039. 2039 "o1",
2040. 2040 ))
2041. 2041 .unwrap();
2042. 2042 lib.register(stored_plugin(
2043. 2043 "rel2",
2044. 2044 1,
2045. 2045 &["detail"],
2046. 2046 section_with_title(),
2047. 2047 "plugin.x",
2048. 2048 ))
2049. 2049 .unwrap();
2050. 2050 lib.revoke_plugin("plugin.x");
2051. 2051 assert!(lib.get("rel1", 1).is_some());
2052. 2052 assert!(lib.get("rel2", 1).is_none());
2053. 2053 }));
2054. 2054
2055. 2055 run("library_lifecycle", scenarios);
2056. 2056}
2057. 2057
2058. 2058// ════════════════════════════════════════════════════════════════════
2059. 2059// 8. REVISION LIFECYCLE
2060. 2060// ════════════════════════════════════════════════════════════════════
2061. 2061
2062. 2062#[test]
2063. 2063fn audit_revisions() {
2064. 2064 let mut scenarios: Vec<Scenario> = vec![];
2065. 2065
2066. 2066 scenarios.push(tc("valid_revision_ok", || {
2067. 2067 let base = make_spec("rev1", 1, &["detail"], text_binding_node());
2068. 2068 let mut proposed = base.clone();
2069. 2069 proposed.revision = 2;
2070. 2070 let req = PresentationRevisionRequest {
2071. 2071 base_id: "rev1".into(),
2072. 2072 base_revision: 1,
2073. 2073 feedback: "improve".into(),
2074. 2074 attempt: 1,
2075. 2075 };
2076. 2076 let result = propose_revision(req, proposed);
2077. 2077 assert!(result.is_ok());
2078. 2078 let rev = result.unwrap();
2079. 2079 assert_eq!(rev.proposed.revision, 2);
2080. 2080 assert_eq!(rev.digest, digest(&rev.proposed).unwrap());
2081. 2081 }));
2082. 2082
2083. 2083 scenarios.push(tc("empty_feedback_invalid", || {
2084. 2084 let base = make_spec("rev2", 1, &["detail"], text_binding_node());
2085. 2085 let req = PresentationRevisionRequest {
2086. 2086 base_id: "rev2".into(),
2087. 2087 base_revision: 1,
2088. 2088 feedback: "".into(),
2089. 2089 attempt: 1,
2090. 2090 };
2091. 2091 assert!(matches!(
2092. 2092 propose_revision(req, base),
2093. 2093 Err(PresentationError::InvalidSpec(_))
2094. 2094 ));
2095. 2095 }));
2096. 2096
2097. 2097 scenarios.push(tc("whitespace_feedback_invalid", || {
2098. 2098 let base = make_spec("rev3", 1, &["detail"], text_binding_node());
2099. 2099 let req = PresentationRevisionRequest {
2100. 2100 base_id: "rev3".into(),
2101. 2101 base_revision: 1,
2102. 2102 feedback: " \n\t ".into(),
2103. 2103 attempt: 1,
2104. 2104 };
2105. 2105 assert!(matches!(
2106. 2106 propose_revision(req, base),
2107. 2107 Err(PresentationError::InvalidSpec(_))
2108. 2108 ));
2109. 2109 }));
2110. 2110
2111. 2111 for attempt in [0u8, 3, 4, 255] {
2112. 2112 scenarios.push(tc(&format!("invalid_attempt_{attempt}"), move || {
2113. 2113 let base = make_spec("att", 1, &["detail"], text_binding_node());
2114. 2114 let req = PresentationRevisionRequest {
2115. 2115 base_id: "att".into(),
2116. 2116 base_revision: 1,
2117. 2117 feedback: "fix".into(),
2118. 2118 attempt,
2119. 2119 };
2120. 2120 assert!(matches!(
2121. 2121 propose_revision(req, base),
2122. 2122 Err(PresentationError::RevisionBudgetExceeded)
2123. 2123 ));
2124. 2124 }));
2125. 2125 }
2126. 2126
2127. 2127 scenarios.push(tc("identity_changed_error", || {
2128. 2128 let base = make_spec("ic1", 1, &["detail"], text_binding_node());
2129. 2129 let mut proposed = base.clone();
2130. 2130 proposed.id = "ic2".into();
2131. 2131 proposed.revision = 2;
2132. 2132 let req = PresentationRevisionRequest {
2133. 2133 base_id: "ic1".into(),
2134. 2134 base_revision: 1,
2135. 2135 feedback: "fix".into(),
2136. 2136 attempt: 1,
2137. 2137 };
2138. 2138 assert!(matches!(
2139. 2139 propose_revision(req, proposed),
2140. 2140 Err(PresentationError::RevisionIdentityChanged)
2141. 2141 ));
2142. 2142 }));
2143. 2143
2144. 2144 scenarios.push(tc("revision_overflow", || {
2145. 2145 let base = make_spec("ro1", u64::MAX, &["detail"], text_binding_node());
2146. 2146 let mut proposed = base.clone();
2147. 2147 proposed.revision = 1;
2148. 2148 let req = PresentationRevisionRequest {
2149. 2149 base_id: "ro1".into(),
2150. 2150 base_revision: u64::MAX,
2151. 2151 feedback: "fix".into(),
2152. 2152 attempt: 1,
2153. 2153 };
2154. 2154 assert!(matches!(
2155. 2155 propose_revision(req, proposed),
2156. 2156 Err(PresentationError::RevisionOverflow)
2157. 2157 ));
2158. 2158 }));
2159. 2159
2160. 2160 scenarios.push(tc("digest_matches_compiled", || {
2161. 2161 let base = make_spec("dg1", 1, &["detail"], text_binding_node());
2162. 2162 let mut proposed = base.clone();
2163. 2163 proposed.revision = 2;
2164. 2164 let req = PresentationRevisionRequest {
2165. 2165 base_id: "dg1".into(),
2166. 2166 base_revision: 1,
2167. 2167 feedback: "fix".into(),
2168. 2168 attempt: 1,
2169. 2169 };
2170. 2170 let rev = propose_revision(req, proposed).unwrap();
2171. 2171 assert_eq!(rev.digest, digest(&rev.proposed).unwrap());
2172. 2172 }));
2173. 2173
2174. 2174 scenarios.push(tc("revision_corrects_wrong_number", || {
2175. 2175 let base = make_spec("cor1", 1, &["detail"], text_binding_node());
2176. 2176 let mut proposed = base.clone();
2177. 2177 proposed.revision = 999;
2178. 2178 let req = PresentationRevisionRequest {
2179. 2179 base_id: "cor1".into(),
2180. 2180 base_revision: 1,
2181. 2181 feedback: "fix".into(),
2182. 2182 attempt: 1,
2183. 2183 };
2184. 2184 let rev = propose_revision(req, proposed).unwrap();
2185. 2185 assert_eq!(rev.proposed.revision, 2);
2186. 2186 }));
2187. 2187
2188. 2188 scenarios.push(tc("revision_2_valid", || {
2189. 2189 let base = make_spec("r2v", 1, &["detail"], text_binding_node());
2190. 2190 let mut proposed = base.clone();
2191. 2191 proposed.revision = 2;
2192. 2192 let req = PresentationRevisionRequest {
2193. 2193 base_id: "r2v".into(),
2194. 2194 base_revision: 1,
2195. 2195 feedback: "fix".into(),
2196. 2196 attempt: 2,
2197. 2197 };
2198. 2198 assert!(propose_revision(req, proposed).is_ok());
2199. 2199 }));
2200. 2200
2201. 2201 scenarios.push(tc("revision_rejects_invalid_spec", || {
2202. 2202 let base = make_spec("bad", 1, &["detail"], text_binding_node());
2203. 2203 let mut proposed = base.clone();
2204. 2204 proposed.accepts = vec![]; // Empty accepts is OK
2205. 2205 proposed.revision = 2;
2206. 2206 let req = PresentationRevisionRequest {
2207. 2207 base_id: "bad".into(),
2208. 2208 base_revision: 1,
2209. 2209 feedback: "fix".into(),
2210. 2210 attempt: 1,
2211. 2211 };
2212. 2212 assert!(propose_revision(req, proposed).is_ok());
2213. 2213 }));
2214. 2214
2215. 2215 scenarios.push(tc("revision_preserves_metadata", || {
2216. 2216 let base = make_spec("meta", 1, &["detail"], text_binding_node());
2217. 2217 let mut proposed = base.clone();
2218. 2218 proposed.revision = 2;
2219. 2219 proposed.metadata.insert("author".into(), "test".into());
2220. 2220 let req = PresentationRevisionRequest {
2221. 2221 base_id: "meta".into(),
2222. 2222 base_revision: 1,
2223. 2223 feedback: "fix".into(),
2224. 2224 attempt: 1,
2225. 2225 };
2226. 2226 let rev = propose_revision(req, proposed).unwrap();
2227. 2227 assert_eq!(
2228. 2228 rev.proposed.metadata.get("author"),
2229. 2229 Some(&"test".to_string())
2230. 2230 );
2231. 2231 }));
2232. 2232
2233. 2233 run("revisions", scenarios);
2234. 2234}
2235. 2235
2236. 2236// ════════════════════════════════════════════════════════════════════
2237. 2237// 9. SEED PACK
2238. 2238// ════════════════════════════════════════════════════════════════════
2239. 2239
2240. 2240#[test]
2241. 2241fn audit_seeds() {
2242. 2242 let mut scenarios: Vec<Scenario> = vec![];
2243. 2243
2244. 2244 scenarios.push(tc("seed_pack_has_75", || {
2245. 2245 assert_eq!(seeds::built_in_seed_pack().len(), 75);
2246. 2246 }));
2247. 2247
2248. 2248 scenarios.push(tc("seed_pack_all_disabled", || {
2249. 2249 assert!(seeds::built_in_seed_pack().iter().all(|r| !r.enabled));
2250. 2250 }));
2251. 2251
2252. 2252 scenarios.push(tc("seed_pack_all_nonempty_digest", || {
2253. 2253 assert!(
2254. 2254 seeds::built_in_seed_pack()
2255. 2255 .iter()
2256. 2256 .all(|r| !r.digest.is_empty())
2257. 2257 );
2258. 2258 }));
2259. 2259
2260. 2260 scenarios.push(tc(
2261. 2261 "seed_pack_revisions_match_immutable_definitions",
2262. 2262 || {
2263. 2263 assert!(seeds::built_in_seed_pack().iter().all(|r| r.spec.revision
2264. 2264 == if r.spec.id == "seed.travel-options" {
2265. 2265 7
2266. 2266 } else {
2267. 2267 6
2268. 2268 }));
2269. 2269 },
2270. 2270 ));
2271. 2271
2272. 2272 scenarios.push(tc("seed_pack_owner_is_builtin", || {
2273. 2273 assert!(
2274. 2274 seeds::built_in_seed_pack()
2275. 2275 .iter()
2276. 2276 .all(|r| r.origin.owner == "builtin")
2277. 2277 );
2278. 2278 }));
2279. 2279
2280. 2280 scenarios.push(tc("seed_pack_has_coding_types", || {
2281. 2281 let has = seeds::built_in_seed_pack()
2282. 2282 .iter()
2283. 2283 .any(|r| r.spec.accepts.iter().any(|t| t.starts_with("coding.")));
2284. 2284 assert!(has);
2285. 2285 }));
2286. 2286
2287. 2287 // Each seed validates
2288. 2288 for record in seeds::built_in_seed_pack() {
2289. 2289 let id = record.spec.id.clone();
2290. 2290 scenarios.push(tc(&format!("seed_validates_{id}"), move || {
2291. 2291 assert!(
2292. 2292 validate_spec(&record.spec).is_ok(),
2293. 2293 "seed {id} should validate"
2294. 2294 );
2295. 2295 }));
2296. 2296 }
2297. 2297
2298. 2298 // Emitter-shaped compilation for all 75 seeds lives in the server
2299. 2299 // projection conformance test. A single generic payload cannot satisfy
2300. 2300 // required rows, steps, sources, and other distinct result contracts.
2301. 2301
2302. 2302 // Seed can be activated and selected
2303. 2303 scenarios.push(tc("seed_activate_and_select", || {
2304. 2304 let mut lib = PresentationLibrary::default();
2305. 2305 let pack = seeds::built_in_seed_pack();
2306. 2306 let seed = pack
2307. 2307 .iter()
2308. 2308 .find(|r| r.spec.accepts[0] == "metric")
2309. 2309 .unwrap()
2310. 2310 .clone();
2311. 2311 let seed_id = seed.spec.id.clone();
2312. 2312 let seed_rev = seed.spec.revision;
2313. 2313 lib.register(seed).unwrap();
2314. 2314 lib.activate(&seed_id, seed_rev, LibraryScope::Workspace, "builtin")
2315. 2315 .unwrap();
2316. 2316 let selected = lib.select("metric", LibraryScope::Workspace, "builtin");
2317. 2317 assert!(selected.is_some());
2318. 2318 assert_eq!(selected.unwrap().spec.id, seed_id);
2319. 2319 }));
2320. 2320
2321. 2321 // Each seed has a unique id
2322. 2322 scenarios.push(tc("seed_ids_unique", || {
2323. 2323 let pack = seeds::built_in_seed_pack();
2324. 2324 let ids: std::collections::HashSet<_> = pack.iter().map(|r| &r.spec.id).collect();
2325. 2325 assert_eq!(ids.len(), pack.len());
2326. 2326 }));
2327. 2327
2328. 2328 // Each seed root has a valid primitive
2329. 2329 for record in seeds::built_in_seed_pack() {
2330. 2330 let id = record.spec.id.clone();
2331. 2331 let prim = record.spec.root.primitive;
2332. 2332 scenarios.push(tc(&format!("seed_root_primitive_{id}"), move || {
2333. 2333 assert_eq!(record.spec.root.primitive, prim);
2334. 2334 }));
2335. 2335 }
2336. 2336
2337. 2337 run("seeds", scenarios);
2338. 2338}
2339. 2339