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 = "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>>;
#[cfg(feature = "postgres")]
impl crate::db::postgres::PostgresBootstrapSettings<::tier::Secret<String>> {
#[must_use]
pub fn into_runtime(self) -> crate::db::postgres::PostgresBootstrapSettings {
self.map_database_url(|secret| crate::secret::SecretString::new(secret.into_inner()))
}
}
#[cfg(feature = "postgres-admin")]
impl crate::db::postgres::admin::PostgresResetSettings<::tier::Secret<String>> {
#[must_use]
pub fn into_runtime(self) -> crate::db::postgres::admin::PostgresResetSettings {
self.map_database_url(|secret| crate::secret::SecretString::new(secret.into_inner()))
}
}
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",
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::<PostgresBootstrapInput>();
let metadata = PostgresBootstrapInput::metadata();
assert_eq!(metadata.secret_paths(), ["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!({
"database_url": "postgres://app:secret@localhost/app"
});
let loaded = ConfigLoader::<PostgresBootstrapInput>::from_value(defaults)
.derive_metadata()
.validator("postgres", |settings| {
settings.validate().map_err(Into::into)
})
.load()
.unwrap();
loaded.into_inner().into_runtime().build().unwrap();
}
#[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")]
#[test]
fn http_settings_expose_complete_tier_metadata() {
use crate::http::{
CorsMode, CorsSettings, ForwardedHeadersMode, ForwardedHeadersSettings,
HttpFoundationSettings, HttpIdempotencySettings, HttpRateLimitSettings,
HttpRequestPolicySettings, HttpRouteRuleSettings, IdempotencyRequestPolicySettings,
RateLimitKeySourceSettings, RateLimitRequestPolicySettings, RequestBodyLimitSettings,
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::<HttpFoundationSettings>();
assert_tier_metadata::<HttpIdempotencySettings>();
assert_tier_metadata::<HttpRateLimitSettings>();
assert_tier_metadata::<HttpRequestPolicySettings>();
assert_tier_metadata::<HttpRouteRuleSettings>();
assert_tier_metadata::<IdempotencyRequestPolicySettings>();
assert_tier_metadata::<RateLimitKeySourceSettings>();
assert_tier_metadata::<RateLimitRequestPolicySettings>();
assert_tier_metadata::<RequestBodyLimitSettings>();
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(),
))
.into_runtime()
.build()
.unwrap();
}
}