use crate::slot::classification::{classify, SlotClass};
use crate::slot::types::{ConfigSlot, SlotType, SuppliedBy};
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct RequiredSlot {
pub slot: SlotType,
pub class: SlotClass,
pub config_key: Option<String>,
}
#[must_use]
pub fn classify_slots(slots: &[ConfigSlot]) -> Vec<ClassifiedSlot> {
let mut all: Vec<ClassifiedSlot> = slots
.iter()
.map(|entry| ClassifiedSlot {
slot: entry.slot.clone(),
class: classify(&entry.slot),
config_key: entry.config_key.clone(),
supplied_by: entry.supplied_by,
})
.collect();
all.sort_by(|a, b| a.slot.key().cmp(&b.slot.key()));
all
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct ClassifiedSlot {
pub slot: SlotType,
pub class: SlotClass,
pub config_key: Option<String>,
pub supplied_by: SuppliedBy,
}
#[must_use]
pub fn required_slots(slots: &[ConfigSlot]) -> Vec<RequiredSlot> {
classify_slots(slots)
.into_iter()
.filter(|entry| entry.supplied_by.is_operator_supplied())
.map(|entry| RequiredSlot {
slot: entry.slot,
class: entry.class,
config_key: entry.config_key,
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::slot::deviation::detect_deviation;
use proptest::prelude::*;
fn secret() -> ConfigSlot {
ConfigSlot::new(SlotType::Secret {
name: "TFL_APP_KEY".to_string(),
})
.with_config_key("backend.auth.query_params.app_key")
}
fn endpoint() -> ConfigSlot {
ConfigSlot::new(SlotType::Endpoint {
name: "TFL_BASE_URL".to_string(),
tested_value: "https://api.tfl.gov.uk".to_string(),
})
.with_config_key("backend.base_url")
}
fn auth_mode() -> ConfigSlot {
ConfigSlot::new(SlotType::AuthMode {
name: "backend-auth-mode".to_string(),
tested_value: "api_key".to_string(),
})
.with_config_key("backend.auth.type")
}
#[test]
fn returns_both_identity_bearing_and_behavior_relevant_slots() {
let slots = vec![secret(), endpoint(), auth_mode()];
let required = required_slots(&slots);
assert_eq!(required.len(), 3);
let kinds: Vec<&str> = required.iter().map(|r| r.slot.key().0).collect();
assert_eq!(kinds, vec!["auth_mode", "endpoint", "secret"]);
}
#[test]
fn each_required_slot_carries_its_class_and_config_key() {
let slots = vec![secret(), endpoint(), auth_mode()];
let required = required_slots(&slots);
assert_eq!(required[0].class, SlotClass::BehaviorRelevant);
assert_eq!(required[0].config_key.as_deref(), Some("backend.auth.type"));
assert_eq!(required[1].class, SlotClass::BehaviorRelevant);
assert_eq!(required[1].config_key.as_deref(), Some("backend.base_url"));
assert_eq!(required[2].class, SlotClass::IdentityBearing);
assert_eq!(
required[2].config_key.as_deref(),
Some("backend.auth.query_params.app_key")
);
}
#[test]
fn empty_slot_set_returns_an_empty_inventory() {
assert_eq!(required_slots(&[]), vec![]);
}
#[test]
fn required_slots_enumerates_a_credential_that_detect_deviation_never_can() {
let a = SlotType::Secret {
name: "TFL_APP_KEY".to_string(),
};
let b = SlotType::Secret {
name: "TFL_APP_KEY_ROTATED".to_string(),
};
assert!(detect_deviation(&a, &b).is_none());
assert!(detect_deviation(&b, &a).is_none());
let required = required_slots(&[secret()]);
assert_eq!(required.len(), 1);
assert_eq!(required[0].slot.key(), ("secret", "TFL_APP_KEY"));
assert_eq!(required[0].class, SlotClass::IdentityBearing);
}
#[test]
fn duplicate_keys_are_preserved_rather_than_deduped() {
let slots = vec![secret(), secret()];
let required = required_slots(&slots);
assert_eq!(required.len(), 2);
assert_eq!(required[0].slot.key(), required[1].slot.key());
}
#[test]
fn classify_and_required_partition_every_slot_exactly_once() {
let slots = vec![
secret(),
endpoint().with_supplied_by(SuppliedBy::Platform),
ConfigSlot::new(SlotType::OauthClient {
name: "primary-oauth".to_string(),
})
.with_supplied_by(SuppliedBy::Runtime),
];
let all = classify_slots(&slots);
let required = required_slots(&slots);
let host_supplied: Vec<_> = all
.iter()
.filter(|e| !e.supplied_by.is_operator_supplied())
.collect();
assert_eq!(all.len(), slots.len());
assert_eq!(required.len() + host_supplied.len(), slots.len());
for entry in &required {
assert!(
!host_supplied
.iter()
.any(|h| h.slot.key() == entry.slot.key()),
"{:?} appears in BOTH groups",
entry.slot.key()
);
}
assert_eq!(required.len(), 1);
assert_eq!(required[0].slot.key(), ("secret", "TFL_APP_KEY"));
}
#[test]
fn the_projection_preserves_class_and_config_key() {
let slots = vec![secret(), endpoint()];
let all = classify_slots(&slots);
let required = required_slots(&slots);
assert_eq!(required.len(), all.len());
for (projected, full) in required.iter().zip(all.iter()) {
assert_eq!(projected.slot, full.slot);
assert_eq!(projected.class, full.class);
assert_eq!(projected.config_key, full.config_key);
}
}
#[test]
fn supplied_by_does_not_change_a_slots_class() {
let operator = classify_slots(&[endpoint()]);
let platform = classify_slots(&[endpoint().with_supplied_by(SuppliedBy::Platform)]);
assert_eq!(operator[0].class, platform[0].class);
assert_eq!(operator[0].slot.key(), platform[0].slot.key());
assert_ne!(operator[0].supplied_by, platform[0].supplied_by);
}
proptest! {
#[test]
fn ordering_is_stable_under_permutation(seed in proptest::collection::vec(0u32..1000, 8)) {
let slots: Vec<ConfigSlot> = vec![
ConfigSlot::new(SlotType::LlmProvider {
name: "primary-llm".to_string(),
tested_value: "anthropic".to_string(),
}),
secret(),
auth_mode(),
ConfigSlot::new(SlotType::HumanRole {
role: "approver".to_string(),
description: "Approves budget overrides".to_string(),
responsibilities: vec!["review".to_string()],
channel_hints: vec!["slack".to_string()],
}),
endpoint(),
ConfigSlot::new(SlotType::OauthClient {
name: "primary-oauth".to_string(),
}),
ConfigSlot::new(SlotType::BudgetOverride {
name: "monthly-cap".to_string(),
tested_value: "1000".to_string(),
}),
ConfigSlot::new(SlotType::ChannelBinding {
name: "notify-channel".to_string(),
}),
];
let mut indices: Vec<usize> = (0..8).collect();
indices.sort_by_key(|&i| seed[i]);
let permuted: Vec<ConfigSlot> = indices.iter().map(|&i| slots[i].clone()).collect();
let baseline = required_slots(&slots);
let shuffled = required_slots(&permuted);
prop_assert_eq!(baseline.len(), 8);
prop_assert_eq!(baseline, shuffled);
}
}
}