keystate_core/verify/
manifest.rs1use std::collections::BTreeMap;
5
6use serde::{Deserialize, Serialize};
7
8use crate::model::EntityKind;
9use crate::{Error, Result, Version};
10
11#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
17#[serde(rename_all = "snake_case")]
18pub enum EntityPresence {
19 Required,
21 Optional,
23}
24
25#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
27pub struct EntityExpectation {
28 pub entity: EntityKind,
30 pub presence: EntityPresence,
32}
33
34impl EntityExpectation {
35 pub fn new(entity: EntityKind, presence: EntityPresence) -> Self {
37 Self { entity, presence }
38 }
39}
40
41#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
43pub struct FieldExpectation {
44 pub entity: EntityKind,
46 pub path: String,
50 pub required: bool,
53 pub volatile: bool,
57 pub introduced_in: Version,
60}
61
62#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
64pub struct FieldManifest {
65 pub backend: String,
67 pub for_version: Version,
69 pub entities: Vec<EntityExpectation>,
71 pub fields: Vec<FieldExpectation>,
73}
74
75impl FieldManifest {
76 pub fn new(backend: impl Into<String>, for_version: Version) -> Self {
78 Self {
79 backend: backend.into(),
80 for_version,
81 entities: Vec::new(),
82 fields: Vec::new(),
83 }
84 }
85
86 pub fn validate(&self) -> Result<()> {
93 if self.backend.trim().is_empty() {
94 return Err(Error::InvalidManifest(
95 "backend must be non-empty".to_string(),
96 ));
97 }
98 let mut seen: BTreeMap<EntityKind, BTreeMap<&str, ()>> = BTreeMap::new();
99 for fe in &self.fields {
100 if fe.path.trim().is_empty() {
101 return Err(Error::InvalidManifest(format!(
102 "empty field path for entity {}",
103 super::entity_label(fe.entity)
104 )));
105 }
106 if seen
107 .entry(fe.entity)
108 .or_default()
109 .insert(fe.path.as_str(), ())
110 .is_some()
111 {
112 return Err(Error::InvalidManifest(format!(
113 "duplicate field expectation {} for entity {}",
114 fe.path,
115 super::entity_label(fe.entity)
116 )));
117 }
118 }
119 let mut entities = BTreeMap::new();
120 for ee in &self.entities {
121 if entities.insert(ee.entity, ee.presence).is_some() {
122 return Err(Error::InvalidManifest(format!(
123 "duplicate entity expectation for {}",
124 super::entity_label(ee.entity)
125 )));
126 }
127 }
128 if let Some(EntityPresence::Optional) = entities.get(&EntityKind::Realm) {
129 return Err(Error::InvalidManifest(
130 "Realm must always be present and cannot be declared optional".to_string(),
131 ));
132 }
133 Ok(())
134 }
135}
136
137use std::fmt;
138
139impl fmt::Display for FieldManifest {
140 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
141 write!(
142 f,
143 "FieldManifest({} @ {}, {} entities, {} fields)",
144 self.backend,
145 self.for_version,
146 self.entities.len(),
147 self.fields.len()
148 )
149 }
150}
151
152#[cfg(test)]
153mod tests {
154 use super::*;
155
156 fn manifest_for(backend: &str) -> FieldManifest {
157 FieldManifest::new(backend, Version::new(26, 0, 0))
158 }
159
160 #[test]
161 fn manifest_validate_rejects_duplicates() {
162 let mut manifest = manifest_for("stub");
163 let expectation = || FieldExpectation {
164 entity: EntityKind::Client,
165 path: "client_id".into(),
166 required: true,
167 volatile: false,
168 introduced_in: Version::new(1, 0, 0),
169 };
170 manifest.fields.push(expectation());
171 manifest.fields.push(expectation());
172 assert!(manifest.validate().is_err());
173 }
174
175 #[test]
176 fn manifest_validate_rejects_optional_realm() {
177 let mut manifest = manifest_for("stub");
178 manifest.entities.push(EntityExpectation::new(
179 EntityKind::Realm,
180 EntityPresence::Optional,
181 ));
182 assert!(manifest.validate().is_err());
183 }
184
185 #[test]
186 fn manifest_validate_rejects_empty_path() {
187 let mut manifest = manifest_for("stub");
188 manifest.fields.push(FieldExpectation {
189 entity: EntityKind::Realm,
190 path: "".into(),
191 required: true,
192 volatile: false,
193 introduced_in: Version::new(1, 0, 0),
194 });
195 assert!(manifest.validate().is_err());
196 }
197
198 #[test]
199 fn manifest_without_entities_is_valid() {
200 let manifest = manifest_for("stub");
201 assert!(manifest.validate().is_ok());
202 }
203}