use crate::{CallbackSink, CanaryEvent, CanaryKind, CanaryToken, Error, Result, Sink};
use core::fmt;
pub struct CanaryTokenBuilder {
name: String,
kind: Option<CanaryKind>,
value: Option<String>,
generate: bool,
sinks: Vec<Box<dyn Sink>>,
}
impl CanaryTokenBuilder {
#[must_use]
pub fn new(name: impl Into<String>) -> Self {
Self {
name: name.into(),
kind: None,
value: None,
generate: false,
sinks: Vec::new(),
}
}
#[must_use]
pub fn kind(mut self, kind: CanaryKind) -> Self {
self.kind = Some(kind);
self
}
#[must_use]
pub fn value(mut self, value: impl Into<String>) -> Self {
self.value = Some(value.into());
self.generate = false;
self
}
#[cfg(feature = "generators")]
#[must_use]
pub fn generate_value(mut self) -> Self {
self.value = None;
self.generate = true;
self
}
#[must_use]
pub fn on_trigger(mut self, callback: impl Fn(&CanaryEvent) + Send + Sync + 'static) -> Self {
self.sinks.push(Box::new(CallbackSink::new(callback)));
self
}
#[must_use]
pub fn with_sink(mut self, sink: impl Sink + 'static) -> Self {
self.sinks.push(Box::new(sink));
self
}
pub fn build(self) -> Result<CanaryToken> {
let Self {
name,
kind,
value,
generate,
sinks,
} = self;
let kind = kind.ok_or(Error::MissingKind)?;
let value = Self::resolve_value(&kind, value, generate)?;
Ok(CanaryToken::from_parts(name, kind, value, sinks))
}
fn resolve_value(kind: &CanaryKind, value: Option<String>, generate: bool) -> Result<String> {
if generate {
#[cfg(feature = "generators")]
{
return crate::generator::generate(kind);
}
#[cfg(not(feature = "generators"))]
{
let _ = kind;
return Err(Error::MissingValue);
}
}
value.ok_or(Error::MissingValue)
}
}
impl fmt::Debug for CanaryTokenBuilder {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CanaryTokenBuilder")
.field("name", &self.name)
.field("kind", &self.kind)
.field("value", &self.value.as_ref().map(|_| "[REDACTED]"))
.field("generate", &self.generate)
.field("sinks", &self.sinks.len())
.finish()
}
}
#[cfg(test)]
mod tests {
use super::CanaryTokenBuilder;
use crate::{CanaryEvent, CanaryKind, CanaryToken, Error, Sink};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
#[derive(Debug, Clone, Default)]
struct RecordingSink {
events: Arc<Mutex<Vec<CanaryEvent>>>,
}
impl Sink for RecordingSink {
fn emit(&self, event: &CanaryEvent) {
self.events
.lock()
.expect("recording sink mutex poisoned")
.push(event.clone());
}
}
fn sample_builder() -> CanaryTokenBuilder {
CanaryToken::builder("prod.db.password")
.kind(CanaryKind::Password)
.value("canary-fake-password")
}
#[test]
fn build_creates_token_with_manual_value() {
let token = sample_builder().build().expect("build should succeed");
assert_eq!(token.name(), "prod.db.password");
assert_eq!(token.kind(), &CanaryKind::Password);
assert_eq!(token.reveal(), "canary-fake-password");
}
#[test]
fn build_requires_kind() {
let result = CanaryToken::builder("prod.db.password")
.value("canary-fake-password")
.build();
assert_eq!(result.err(), Some(Error::MissingKind));
}
#[test]
fn build_requires_value_when_generation_is_not_requested() {
let result = CanaryToken::builder("prod.db.password")
.kind(CanaryKind::Password)
.build();
assert_eq!(result.err(), Some(Error::MissingValue));
}
#[test]
fn on_trigger_receives_events() {
let count = Arc::new(AtomicUsize::new(0));
let counter = count.clone();
let token = sample_builder()
.on_trigger(move |_event| {
counter.fetch_add(1, Ordering::SeqCst);
})
.build()
.expect("build should succeed");
drop(token.reveal());
token.with_value(|_| {});
assert_eq!(count.load(Ordering::SeqCst), 2);
}
#[test]
fn with_sink_receives_events() {
let sink = RecordingSink::default();
let events = sink.events.clone();
let token = sample_builder()
.with_sink(sink)
.build()
.expect("build should succeed");
drop(token.reveal());
let events = events.lock().expect("events mutex poisoned");
assert_eq!(events.len(), 1);
}
#[test]
fn debug_redacts_value() {
let builder = sample_builder();
let debug = format!("{builder:?}");
assert!(debug.contains("CanaryTokenBuilder"));
assert!(debug.contains("prod.db.password"));
assert!(debug.contains("[REDACTED]"));
assert!(!debug.contains("canary-fake-password"));
}
#[test]
fn value_after_generate_value_disables_generation() {
let token = CanaryToken::builder("prod.db.password")
.kind(CanaryKind::Password)
.generate_value()
.value("manual-value")
.build()
.expect("build should succeed");
assert_eq!(token.reveal(), "manual-value");
}
#[cfg(feature = "generators")]
#[test]
fn generate_value_creates_non_empty_value() {
let token = CanaryToken::builder("prod.db.password")
.kind(CanaryKind::Password)
.generate_value()
.build()
.expect("build should succeed");
let value = token.reveal();
assert!(!value.is_empty());
assert_ne!(value, "manual-value");
}
#[cfg(feature = "generators")]
#[test]
fn generate_value_requires_kind() {
let result = CanaryToken::builder("prod.db.password")
.generate_value()
.build();
assert_eq!(result.err(), Some(Error::MissingKind));
}
#[cfg(feature = "generators")]
#[test]
fn generate_value_after_manual_value_overrides_manual_value() {
let token = CanaryToken::builder("prod.db.password")
.kind(CanaryKind::Password)
.value("manual-value")
.generate_value()
.build()
.expect("build should succeed");
let value = token.reveal();
assert!(!value.is_empty());
assert_ne!(value, "manual-value");
}
#[test]
fn builder_is_send_and_sync() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<CanaryTokenBuilder>();
}
}