use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use crate::model::EntityKind;
use crate::{Error, Result, Version};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum EntityPresence {
Required,
Optional,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct EntityExpectation {
pub entity: EntityKind,
pub presence: EntityPresence,
}
impl EntityExpectation {
pub fn new(entity: EntityKind, presence: EntityPresence) -> Self {
Self { entity, presence }
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct FieldExpectation {
pub entity: EntityKind,
pub path: String,
pub required: bool,
pub volatile: bool,
pub introduced_in: Version,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct FieldManifest {
pub backend: String,
pub for_version: Version,
pub entities: Vec<EntityExpectation>,
pub fields: Vec<FieldExpectation>,
}
impl FieldManifest {
pub fn new(backend: impl Into<String>, for_version: Version) -> Self {
Self {
backend: backend.into(),
for_version,
entities: Vec::new(),
fields: Vec::new(),
}
}
pub fn validate(&self) -> Result<()> {
if self.backend.trim().is_empty() {
return Err(Error::InvalidManifest(
"backend must be non-empty".to_string(),
));
}
let mut seen: BTreeMap<EntityKind, BTreeMap<&str, ()>> = BTreeMap::new();
for fe in &self.fields {
if fe.path.trim().is_empty() {
return Err(Error::InvalidManifest(format!(
"empty field path for entity {}",
super::entity_label(fe.entity)
)));
}
if seen
.entry(fe.entity)
.or_default()
.insert(fe.path.as_str(), ())
.is_some()
{
return Err(Error::InvalidManifest(format!(
"duplicate field expectation {} for entity {}",
fe.path,
super::entity_label(fe.entity)
)));
}
}
let mut entities = BTreeMap::new();
for ee in &self.entities {
if entities.insert(ee.entity, ee.presence).is_some() {
return Err(Error::InvalidManifest(format!(
"duplicate entity expectation for {}",
super::entity_label(ee.entity)
)));
}
}
if let Some(EntityPresence::Optional) = entities.get(&EntityKind::Realm) {
return Err(Error::InvalidManifest(
"Realm must always be present and cannot be declared optional".to_string(),
));
}
Ok(())
}
}
use std::fmt;
impl fmt::Display for FieldManifest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"FieldManifest({} @ {}, {} entities, {} fields)",
self.backend,
self.for_version,
self.entities.len(),
self.fields.len()
)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn manifest_for(backend: &str) -> FieldManifest {
FieldManifest::new(backend, Version::new(26, 0, 0))
}
#[test]
fn manifest_validate_rejects_duplicates() {
let mut manifest = manifest_for("stub");
let expectation = || FieldExpectation {
entity: EntityKind::Client,
path: "client_id".into(),
required: true,
volatile: false,
introduced_in: Version::new(1, 0, 0),
};
manifest.fields.push(expectation());
manifest.fields.push(expectation());
assert!(manifest.validate().is_err());
}
#[test]
fn manifest_validate_rejects_optional_realm() {
let mut manifest = manifest_for("stub");
manifest.entities.push(EntityExpectation::new(
EntityKind::Realm,
EntityPresence::Optional,
));
assert!(manifest.validate().is_err());
}
#[test]
fn manifest_validate_rejects_empty_path() {
let mut manifest = manifest_for("stub");
manifest.fields.push(FieldExpectation {
entity: EntityKind::Realm,
path: "".into(),
required: true,
volatile: false,
introduced_in: Version::new(1, 0, 0),
});
assert!(manifest.validate().is_err());
}
#[test]
fn manifest_without_entities_is_valid() {
let manifest = manifest_for("stub");
assert!(manifest.validate().is_ok());
}
}