use super::SettingsValidationError;
#[cfg(feature = "secrets")]
impl crate::secret::ExposeSecret<str> for ::tier::Secret<String> {
fn expose_secret(&self) -> &str {
self.expose_ref()
}
}
#[cfg(feature = "secrets")]
impl From<::tier::Secret<String>> for crate::secret::SecretString {
fn from(secret: ::tier::Secret<String>) -> Self {
Self::new(secret.into_inner())
}
}
#[cfg(feature = "postgres")]
pub type PostgresConnectionInput =
crate::db::postgres::PostgresConnectionSettings<::tier::Secret<String>>;
#[cfg(feature = "postgres")]
pub type PostgresBootstrapInput =
crate::db::postgres::PostgresBootstrapSettings<::tier::Secret<String>>;
#[cfg(feature = "postgres-admin")]
pub type PostgresResetInput =
crate::db::postgres::admin::PostgresResetSettings<::tier::Secret<String>>;
impl From<&SettingsValidationError> for ::tier::ValidationErrors {
fn from(error: &SettingsValidationError) -> Self {
let mut errors = Self::new();
errors.extend(error.issues().iter().map(|issue| {
::tier::ValidationError::new(issue.path(), issue.message())
.with_rule("footing.settings")
}));
if error.is_truncated() {
errors.push(
::tier::ValidationError::new("settings", "additional issues omitted")
.with_rule("footing.settings.truncated"),
);
}
errors
}
}
impl From<SettingsValidationError> for ::tier::ValidationErrors {
fn from(error: SettingsValidationError) -> Self {
Self::from(&error)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::settings::SettingsIssues;
#[cfg(any(
feature = "http-stack",
feature = "postgres",
feature = "sqlite",
feature = "tls",
feature = "worker"
))]
fn assert_tier_metadata<T: ::tier::TierMetadata>() {}
#[test]
fn validation_conversion_preserves_paths_and_truncation() {
let mut issues = SettingsIssues::new();
for index in 0..=crate::settings::MAX_SETTINGS_ISSUES {
issues.push(format!("worker.{index}"), "is invalid");
}
let source = SettingsValidationError::new(issues);
let converted = ::tier::ValidationErrors::from(&source);
assert_eq!(converted.len(), crate::settings::MAX_SETTINGS_ISSUES + 1);
assert_eq!(converted.iter().next().unwrap().path, "worker.0");
assert_eq!(
converted.iter().last().unwrap().rule.as_deref(),
Some("footing.settings.truncated")
);
}
#[cfg(feature = "postgres")]
#[test]
fn postgres_settings_are_tier_loadable_without_serializing_runtime_secrets() {
use ::tier::{ConfigLoader, TierMetadata};
assert_tier_metadata::<crate::db::postgres::PostgresPoolSettings>();
assert_tier_metadata::<crate::db::postgres::PostgresStartupRetrySettings>();
assert_tier_metadata::<PostgresConnectionInput>();
assert_tier_metadata::<PostgresBootstrapInput>();
let metadata = PostgresBootstrapInput::metadata();
assert_eq!(metadata.secret_paths(), ["connection.database_url"]);
assert!(
metadata
.field("pool.max_connections")
.and_then(::tier::FieldMetadata::documentation)
.is_some()
);
let input = PostgresBootstrapInput::from_secret(::tier::Secret::new(
"postgres://app:secret@localhost/app".to_owned(),
));
let debug = format!("{input:?}");
assert!(!debug.contains("postgres://"));
let defaults = serde_json::json!({
"connection": {
"database_url": "postgres://app:secret@localhost/app",
"statement_timeout": "5s"
}
});
let loaded = ConfigLoader::<PostgresBootstrapInput>::from_value(defaults)
.derive_metadata()
.validator("postgres", |settings| {
settings.validate_at("").map_err(Into::into)
})
.load()
.unwrap();
let config = loaded.into_inner().build().unwrap();
assert_eq!(
config.connection_config().statement_timeout(),
Some(std::time::Duration::from_secs(5))
);
}
#[cfg(feature = "postgres")]
#[test]
fn postgres_connection_settings_are_independently_tier_loadable() {
use ::tier::{ConfigLoader, TierMetadata};
assert_eq!(PostgresConnectionInput::secret_paths(), ["database_url"]);
let metadata = PostgresConnectionInput::metadata();
for field in ["statement_timeout", "idle_in_transaction_session_timeout"] {
assert!(
metadata
.field(field)
.and_then(::tier::FieldMetadata::documentation)
.is_some()
);
}
let loaded = ConfigLoader::<PostgresConnectionInput>::from_value(serde_json::json!({
"database_url": "postgres://app:private-password@localhost/app",
"statement_timeout": "7s",
"idle_in_transaction_session_timeout": "11s"
}))
.derive_metadata()
.validator("postgres.connection", |settings| {
settings.validate_at("").map_err(Into::into)
})
.load()
.unwrap();
let settings = loaded.into_inner();
assert!(!format!("{settings:?}").contains("private-password"));
let config = settings.build().unwrap();
assert_eq!(
config.statement_timeout(),
Some(std::time::Duration::from_secs(7))
);
assert_eq!(
config.idle_in_transaction_session_timeout(),
Some(std::time::Duration::from_secs(11))
);
}
#[cfg(feature = "sqlite")]
#[test]
fn sqlite_settings_are_tier_loadable() {
use crate::db::sqlite::{
SqliteBootstrapSettings, SqliteConnectionSettings, SqlitePoolSettings,
};
use ::tier::{ConfigLoader, TierMetadata};
assert_tier_metadata::<SqlitePoolSettings>();
assert_tier_metadata::<SqliteConnectionSettings>();
assert_tier_metadata::<SqliteBootstrapSettings>();
assert!(SqliteBootstrapSettings::secret_paths().is_empty());
assert!(
SqliteBootstrapSettings::metadata()
.field("connection.database_url")
.is_some()
);
let loaded = ConfigLoader::new(SqliteBootstrapSettings::new("sqlite::memory:"))
.derive_metadata()
.validator("sqlite", |settings| settings.validate().map_err(Into::into))
.load()
.unwrap();
loaded.into_inner().build().unwrap();
}
#[cfg(feature = "http-stack")]
#[test]
fn http_settings_expose_complete_tier_metadata() {
use crate::http::{
CorsMode, CorsSettings, ForwardedHeadersMode, ForwardedHeadersSettings,
HttpIdempotencySettings, HttpMiddlewareSettings, HttpRateLimitSettings,
HttpRequestPolicySettings, HttpRouteRuleSettings, IdempotencyRequestPolicy,
RateLimitKeySourceSettings, RateLimitRequestPolicy, RequestBodyLimitSettings,
ResponseTimeout, RouteMatcherSettings, SecurityHeadersSettings,
StrictTransportSecuritySettings,
};
use ::tier::TierMetadata;
assert_tier_metadata::<CorsMode>();
assert_tier_metadata::<CorsSettings>();
assert_tier_metadata::<ForwardedHeadersMode>();
assert_tier_metadata::<ForwardedHeadersSettings>();
assert_tier_metadata::<HttpMiddlewareSettings>();
assert_tier_metadata::<HttpIdempotencySettings>();
assert_tier_metadata::<HttpRateLimitSettings>();
assert_tier_metadata::<HttpRequestPolicySettings>();
assert_tier_metadata::<HttpRouteRuleSettings>();
assert_tier_metadata::<IdempotencyRequestPolicy>();
assert_tier_metadata::<RateLimitKeySourceSettings>();
assert_tier_metadata::<RateLimitRequestPolicy>();
assert_tier_metadata::<RequestBodyLimitSettings>();
assert_tier_metadata::<ResponseTimeout>();
assert_tier_metadata::<RouteMatcherSettings>();
assert_tier_metadata::<SecurityHeadersSettings>();
assert_tier_metadata::<StrictTransportSecuritySettings>();
assert!(
HttpRateLimitSettings::secret_paths()
.iter()
.any(|path| path == "key_source")
);
}
#[cfg(feature = "worker")]
#[test]
fn worker_settings_expose_complete_tier_metadata() {
use crate::worker::{
BackoffSettings, OutboxWorkerSettings, WorkerLeaseSettings, WorkerSettings,
};
assert_tier_metadata::<BackoffSettings>();
assert_tier_metadata::<OutboxWorkerSettings>();
assert_tier_metadata::<WorkerLeaseSettings>();
assert_tier_metadata::<WorkerSettings>();
}
#[cfg(feature = "tls")]
#[test]
fn tls_settings_expose_tier_metadata() {
assert_tier_metadata::<crate::tls::TlsTrustSettings>();
}
#[cfg(feature = "postgres-admin")]
#[test]
fn postgres_reset_settings_are_tier_loadable() {
use ::tier::TierMetadata;
assert_tier_metadata::<PostgresResetInput>();
assert_eq!(PostgresResetInput::secret_paths(), ["database_url"]);
PostgresResetInput::from_secret(::tier::Secret::new(
"postgres://app:secret@localhost/app".to_owned(),
))
.build()
.unwrap();
}
}