102 lines
3.8 KiB
Rust
102 lines
3.8 KiB
Rust
use std::process::Command;
|
|
|
|
use crank_registry::{
|
|
MASTER_KEY_CIPHER_CONTRACT, MasterKeyIdentityCandidate, MigrationAuthority, PostgresRegistry,
|
|
};
|
|
use crank_runtime::SecretCrypto;
|
|
use time::{OffsetDateTime, format_description::well_known::Rfc3339};
|
|
|
|
const TEST_MASTER_KEY: &str = "test-master-key-00000000000000000000000000000000";
|
|
const REGISTERED_MASTER_KEY: &str = "registered-master-key-CANARY_SECRET_VALUE-00000000";
|
|
const WRONG_MASTER_KEY: &str = "wrong-master-key-CANARY_SECRET_VALUE-0000000000000";
|
|
|
|
fn run_with(entries: &[(&str, &str)]) -> String {
|
|
let mut command = Command::new(env!("CARGO_BIN_EXE_mcp-server"));
|
|
for field in crank_config::field_registry() {
|
|
command.env_remove(field.env_name);
|
|
}
|
|
command.env("CRANK_MASTER_KEY", TEST_MASTER_KEY);
|
|
for (name, value) in entries {
|
|
command.env(name, value);
|
|
}
|
|
let output = command.output().expect("MCP binary executes");
|
|
assert!(!output.status.success());
|
|
let stderr = String::from_utf8(output.stderr).expect("stderr is UTF-8");
|
|
assert!(!stderr.contains("CANARY_SECRET_VALUE"));
|
|
assert!(!stderr.contains("connection refused"));
|
|
assert!(stderr.len() <= 65_536);
|
|
stderr
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_config_fails_before_database_or_listener_side_effects() {
|
|
for (entries, code) in [
|
|
(
|
|
vec![("CRANK_CONFIG_CANARY_UNKNOWN", "CANARY_SECRET_VALUE")],
|
|
"config.unknown_field",
|
|
),
|
|
(vec![("CRANK_MCP_REFRESH_MS", "bad")], "config.invalid_type"),
|
|
(
|
|
vec![
|
|
("CRANK_DATABASE_URL", "postgres://db/crank"),
|
|
("POSTGRES_HOST", "other"),
|
|
],
|
|
"config.conflict",
|
|
),
|
|
(vec![("CRANK_LOG_LEVEL", "[")], "config.invalid_type"),
|
|
] {
|
|
let stderr = run_with(&entries);
|
|
assert!(stderr.contains(code), "{stderr}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn database_driver_failures_are_normalized_and_redacted() {
|
|
let stderr = run_with(&[(
|
|
"CRANK_DATABASE_URL",
|
|
"postgres://CANARY_SECRET_VALUE:CANARY_SECRET_VALUE@127.0.0.1:1/crank",
|
|
)]);
|
|
assert!(stderr.contains("startup_failed"), "{stderr}");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn fresh_database_startup_is_read_only() {
|
|
let database_url = crank_test_support::postgres_schema_url("mcp_startup_read_only").await;
|
|
let stderr = run_with(&[("CRANK_DATABASE_URL", &database_url)]);
|
|
assert!(stderr.contains("schema_missing"), "{stderr}");
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
let present: bool = sqlx::query_scalar(
|
|
"select to_regclass(format('%I.%I', current_schema(), '__crank_core_migrations')) is not null",
|
|
)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert!(!present);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn master_key_mismatch_blocks_startup_with_safe_diagnostic() {
|
|
let database_url = crank_test_support::postgres_schema_url("mcp_master_key_mismatch").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
let registry = PostgresRegistry::connect(&database_url).await.unwrap();
|
|
let crypto = SecretCrypto::new(REGISTERED_MASTER_KEY).unwrap();
|
|
registry
|
|
.verify_or_register_master_key_identity(MasterKeyIdentityCandidate {
|
|
epoch: 1,
|
|
fingerprint: crypto.master_key_fingerprint(),
|
|
cipher_contract: MASTER_KEY_CIPHER_CONTRACT,
|
|
observed_at: &OffsetDateTime::parse("2026-08-21T00:00:00Z", &Rfc3339).unwrap(),
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let stderr = run_with(&[
|
|
("CRANK_DATABASE_URL", &database_url),
|
|
("CRANK_MASTER_KEY", WRONG_MASTER_KEY),
|
|
]);
|
|
assert!(stderr.contains("master_key_identity_mismatch"), "{stderr}");
|
|
assert!(!stderr.contains("registered-master-key"));
|
|
assert!(!stderr.contains("wrong-master-key"));
|
|
}
|