use serde::Serialize;
use std::collections::BTreeSet;
use thiserror::Error;
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ComparisonExtensionSelector {
pub name: String,
pub description: String,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ComparisonExtensionComparator {
pub declaration: String,
pub description: String,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ComparisonExtensionDescriptor {
pub id: String,
#[serde(rename = "displayName")]
pub display_name: String,
pub selectors: Vec<ComparisonExtensionSelector>,
pub comparators: Vec<ComparisonExtensionComparator>,
#[serde(rename = "metadataKeys")]
pub metadata_keys: Vec<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ComparisonExtensionMetadata {
#[serde(rename = "extensionId")]
pub extension_id: String,
pub key: String,
pub value: String,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct CohortEvidenceMetadata {
#[serde(rename = "segmentIndex")]
pub segment_index: usize,
pub rule: String,
#[serde(rename = "requiredCount")]
pub required_count: usize,
#[serde(rename = "activeCount")]
pub active_count: usize,
#[serde(rename = "isActive")]
pub is_active: bool,
#[serde(rename = "activeSources")]
pub active_sources: Vec<String>,
#[serde(rename = "rawValue")]
pub raw_value: String,
}
#[derive(Clone, Debug)]
pub struct ComparisonExtensionBuilder {
id: String,
display_name: String,
selectors: Vec<ComparisonExtensionSelector>,
comparators: Vec<ComparisonExtensionComparator>,
metadata_keys: Vec<String>,
}
#[derive(Clone, Debug, Eq, Error, PartialEq)]
pub enum ComparisonExtensionBuildError {
#[error("extension id and display name are required")]
MissingIdentity,
#[error("duplicate extension descriptor name '{0}'")]
DuplicateName(String),
}
impl ComparisonExtensionBuilder {
#[must_use]
pub fn new(id: impl Into<String>, display_name: impl Into<String>) -> Self {
Self {
id: id.into(),
display_name: display_name.into(),
selectors: Vec::new(),
comparators: Vec::new(),
metadata_keys: Vec::new(),
}
}
#[must_use]
pub fn add_selector(mut self, name: impl Into<String>, description: impl Into<String>) -> Self {
self.selectors.push(ComparisonExtensionSelector {
name: name.into(),
description: description.into(),
});
self
}
#[must_use]
pub fn add_comparator(
mut self,
declaration: impl Into<String>,
description: impl Into<String>,
) -> Self {
self.comparators.push(ComparisonExtensionComparator {
declaration: declaration.into(),
description: description.into(),
});
self
}
#[must_use]
pub fn add_metadata_key(mut self, key: impl Into<String>) -> Self {
self.metadata_keys.push(key.into());
self
}
pub fn build(self) -> Result<ComparisonExtensionDescriptor, ComparisonExtensionBuildError> {
if self.id.trim().is_empty() || self.display_name.trim().is_empty() {
return Err(ComparisonExtensionBuildError::MissingIdentity);
}
for names in [
self.selectors
.iter()
.map(|item| item.name.as_str())
.collect::<Vec<_>>(),
self.comparators
.iter()
.map(|item| item.declaration.as_str())
.collect::<Vec<_>>(),
self.metadata_keys
.iter()
.map(String::as_str)
.collect::<Vec<_>>(),
] {
let mut seen = BTreeSet::new();
for name in names {
if name.trim().is_empty() || !seen.insert(name) {
return Err(ComparisonExtensionBuildError::DuplicateName(
name.to_owned(),
));
}
}
}
Ok(ComparisonExtensionDescriptor {
id: self.id,
display_name: self.display_name,
selectors: self.selectors,
comparators: self.comparators,
metadata_keys: self.metadata_keys,
})
}
}
#[cfg(test)]
mod tests {
use super::{ComparisonExtensionBuildError, ComparisonExtensionBuilder};
#[test]
fn rejects_incomplete_or_ambiguous_descriptors() {
assert_eq!(
ComparisonExtensionBuilder::new(" ", "display").build(),
Err(ComparisonExtensionBuildError::MissingIdentity)
);
assert_eq!(
ComparisonExtensionBuilder::new("id", "display")
.add_selector("selector", "first")
.add_selector("selector", "duplicate")
.build(),
Err(ComparisonExtensionBuildError::DuplicateName(
"selector".to_owned()
))
);
}
#[test]
fn builds_a_valid_descriptor() {
let descriptor = ComparisonExtensionBuilder::new("fixture", "Fixture")
.add_selector("home", "Home side")
.add_comparator("position", "Position")
.add_metadata_key("provider")
.build()
.expect("valid descriptor");
assert_eq!(descriptor.id, "fixture");
assert_eq!(descriptor.selectors.len(), 1);
assert_eq!(descriptor.comparators.len(), 1);
assert_eq!(descriptor.metadata_keys, ["provider"]);
}
}