use core::fmt;
#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[non_exhaustive]
pub enum CanaryKind {
Password,
ApiKey,
Token,
Jwt,
DbUrl,
PrivateKey,
Custom(String),
}
impl CanaryKind {
pub const BUILT_IN: &'static [CanaryKind] = &[
Self::Password,
Self::ApiKey,
Self::Token,
Self::Jwt,
Self::DbUrl,
Self::PrivateKey,
];
#[must_use]
pub fn custom(name: impl Into<String>) -> Self {
Self::Custom(name.into())
}
#[must_use]
pub fn as_builtin_str(&self) -> Option<&'static str> {
match self {
Self::Password => Some("password"),
Self::ApiKey => Some("api-key"),
Self::Token => Some("token"),
Self::Jwt => Some("jwt"),
Self::DbUrl => Some("db-url"),
Self::PrivateKey => Some("private-key"),
Self::Custom(_) => None,
}
}
#[must_use]
pub fn is_builtin(&self) -> bool {
self.as_builtin_str().is_some()
}
#[must_use]
pub fn is_custom(&self) -> bool {
matches!(self, Self::Custom(_))
}
}
impl fmt::Display for CanaryKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Password => f.write_str("password"),
Self::ApiKey => f.write_str("api-key"),
Self::Token => f.write_str("token"),
Self::Jwt => f.write_str("jwt"),
Self::DbUrl => f.write_str("db-url"),
Self::PrivateKey => f.write_str("private-key"),
Self::Custom(name) => write!(f, "custom:{name}"),
}
}
}
impl core::str::FromStr for CanaryKind {
type Err = ParseCanaryKindError;
fn from_str(input: &str) -> Result<Self, Self::Err> {
const CUSTOM_PREFIX: &str = "custom:";
let input = input.trim();
if input.is_empty() {
return Err(ParseCanaryKindError::new());
}
let has_custom_prefix = input
.get(..CUSTOM_PREFIX.len())
.is_some_and(|prefix| prefix.eq_ignore_ascii_case(CUSTOM_PREFIX));
if has_custom_prefix {
let name = input[CUSTOM_PREFIX.len()..].trim();
if name.is_empty() {
return Err(ParseCanaryKindError::new());
}
return Ok(Self::Custom(name.to_owned()));
}
if input.eq_ignore_ascii_case("password")
|| input.eq_ignore_ascii_case("pass")
|| input.eq_ignore_ascii_case("pwd")
{
return Ok(Self::Password);
}
if input.eq_ignore_ascii_case("api-key")
|| input.eq_ignore_ascii_case("apikey")
|| input.eq_ignore_ascii_case("api_key")
{
return Ok(Self::ApiKey);
}
if input.eq_ignore_ascii_case("token") || input.eq_ignore_ascii_case("access-token") {
return Ok(Self::Token);
}
if input.eq_ignore_ascii_case("jwt") || input.eq_ignore_ascii_case("json-web-token") {
return Ok(Self::Jwt);
}
if input.eq_ignore_ascii_case("db-url")
|| input.eq_ignore_ascii_case("db")
|| input.eq_ignore_ascii_case("database-url")
|| input.eq_ignore_ascii_case("database_url")
{
return Ok(Self::DbUrl);
}
if input.eq_ignore_ascii_case("private-key")
|| input.eq_ignore_ascii_case("privatekey")
|| input.eq_ignore_ascii_case("private_key")
{
return Ok(Self::PrivateKey);
}
Err(ParseCanaryKindError::new())
}
}
impl From<CanaryKind> for String {
fn from(kind: CanaryKind) -> Self {
kind.to_string()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ParseCanaryKindError {
_private: (),
}
impl ParseCanaryKindError {
const fn new() -> Self {
Self { _private: () }
}
}
impl fmt::Display for ParseCanaryKindError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("invalid canary kind")
}
}
impl core::error::Error for ParseCanaryKindError {}
#[cfg(test)]
mod tests {
use super::CanaryKind;
use super::ParseCanaryKindError;
use core::str::FromStr;
#[test]
fn display_uses_canonical_builtin_values() {
assert_eq!(CanaryKind::Password.to_string(), "password");
assert_eq!(CanaryKind::ApiKey.to_string(), "api-key");
assert_eq!(CanaryKind::Token.to_string(), "token");
assert_eq!(CanaryKind::Jwt.to_string(), "jwt");
assert_eq!(CanaryKind::DbUrl.to_string(), "db-url");
assert_eq!(CanaryKind::PrivateKey.to_string(), "private-key");
}
#[test]
fn display_uses_custom_prefix() {
assert_eq!(CanaryKind::custom("ldap").to_string(), "custom:ldap");
assert_eq!(
CanaryKind::Custom("service-account".to_owned()).to_string(),
"custom:service-account"
);
}
#[test]
fn as_builtin_str_returns_canonical_values_for_builtin_kinds() {
assert_eq!(CanaryKind::Password.as_builtin_str(), Some("password"));
assert_eq!(CanaryKind::ApiKey.as_builtin_str(), Some("api-key"));
assert_eq!(CanaryKind::Token.as_builtin_str(), Some("token"));
assert_eq!(CanaryKind::Jwt.as_builtin_str(), Some("jwt"));
assert_eq!(CanaryKind::DbUrl.as_builtin_str(), Some("db-url"));
assert_eq!(CanaryKind::PrivateKey.as_builtin_str(), Some("private-key"));
}
#[test]
fn as_builtin_str_returns_none_for_custom() {
assert_eq!(CanaryKind::custom("ldap").as_builtin_str(), None);
}
#[test]
fn is_builtin_and_is_custom_are_complementary() {
for kind in CanaryKind::BUILT_IN {
assert!(kind.is_builtin());
assert!(!kind.is_custom());
}
let custom = CanaryKind::custom("ldap");
assert!(custom.is_custom());
assert!(!custom.is_builtin());
}
#[test]
fn built_in_contains_only_builtin_kinds() {
assert_eq!(CanaryKind::BUILT_IN.len(), 6);
assert!(CanaryKind::BUILT_IN.iter().all(CanaryKind::is_builtin));
}
#[test]
fn from_str_accepts_canonical_builtin_values() {
for kind in CanaryKind::BUILT_IN {
let canonical = kind
.as_builtin_str()
.expect("built-in kind must have canonical string");
assert_eq!(CanaryKind::from_str(canonical), Ok(kind.clone()));
}
}
#[test]
fn from_str_accepts_common_aliases() {
assert_eq!(CanaryKind::from_str("pass"), Ok(CanaryKind::Password));
assert_eq!(CanaryKind::from_str("pwd"), Ok(CanaryKind::Password));
assert_eq!(CanaryKind::from_str("apikey"), Ok(CanaryKind::ApiKey));
assert_eq!(CanaryKind::from_str("api_key"), Ok(CanaryKind::ApiKey));
assert_eq!(CanaryKind::from_str("access-token"), Ok(CanaryKind::Token));
assert_eq!(CanaryKind::from_str("json-web-token"), Ok(CanaryKind::Jwt));
assert_eq!(CanaryKind::from_str("db"), Ok(CanaryKind::DbUrl));
assert_eq!(CanaryKind::from_str("database-url"), Ok(CanaryKind::DbUrl));
assert_eq!(CanaryKind::from_str("database_url"), Ok(CanaryKind::DbUrl));
assert_eq!(
CanaryKind::from_str("privatekey"),
Ok(CanaryKind::PrivateKey)
);
assert_eq!(
CanaryKind::from_str("private_key"),
Ok(CanaryKind::PrivateKey)
);
}
#[test]
fn from_str_trims_whitespace_and_ignores_ascii_case() {
assert_eq!(
CanaryKind::from_str(" PASSWORD "),
Ok(CanaryKind::Password)
);
assert_eq!(CanaryKind::from_str("Api-Key"), Ok(CanaryKind::ApiKey));
assert_eq!(CanaryKind::from_str("jwt"), Ok(CanaryKind::Jwt));
assert_eq!(CanaryKind::from_str("DB-URL"), Ok(CanaryKind::DbUrl));
assert_eq!(
CanaryKind::from_str("Private-Key"),
Ok(CanaryKind::PrivateKey)
);
}
#[test]
fn from_str_accepts_custom_kinds_with_prefix() {
assert_eq!(
CanaryKind::from_str("custom:ldap"),
Ok(CanaryKind::Custom("ldap".to_owned()))
);
assert_eq!(
CanaryKind::from_str("CUSTOM:ldap"),
Ok(CanaryKind::Custom("ldap".to_owned()))
);
assert_eq!(
CanaryKind::from_str(" custom: service-account "),
Ok(CanaryKind::Custom("service-account".to_owned()))
);
}
#[test]
fn custom_kind_roundtrips_through_display_and_from_str() {
let kind = CanaryKind::custom("ldap");
let serialized = kind.to_string();
assert_eq!(serialized, "custom:ldap");
assert_eq!(CanaryKind::from_str(&serialized), Ok(kind));
}
#[test]
fn from_str_rejects_empty_custom_name() {
assert_eq!(
CanaryKind::from_str("custom:"),
Err(ParseCanaryKindError::new())
);
assert_eq!(
CanaryKind::from_str("custom: "),
Err(ParseCanaryKindError::new())
);
}
#[test]
fn from_str_rejects_unknown_values_without_custom_prefix() {
assert_eq!(CanaryKind::from_str(""), Err(ParseCanaryKindError::new()));
assert_eq!(
CanaryKind::from_str(" "),
Err(ParseCanaryKindError::new())
);
assert_eq!(
CanaryKind::from_str("ldap"),
Err(ParseCanaryKindError::new())
);
assert_eq!(
CanaryKind::from_str("kubernetes"),
Err(ParseCanaryKindError::new())
);
assert_eq!(
CanaryKind::from_str("password-like"),
Err(ParseCanaryKindError::new())
);
}
#[test]
fn error_display_is_stable() {
assert_eq!(
ParseCanaryKindError::new().to_string(),
"invalid canary kind"
);
}
#[test]
fn string_conversion_matches_display() {
let kind = CanaryKind::DbUrl;
let owned: String = kind.clone().into();
assert_eq!(owned, kind.to_string());
}
}