CI / UI Checks (pull_request) Successful in 8s
CI / Rust Checks (pull_request) Successful in 21m42s
CI / Rust Feature Validation (pull_request) Skipped
CI / Frontend E2E (pull_request) Skipped
CI / Community Image Smoke (pull_request) Skipped
CI / Required Checks (pull_request) Successful in 1s
CI / Deploy (pull_request) Skipped
Durable worker приостанавливает Task как input_required до dispatch, если закреплённая схема требует отсутствующее поле; authorized schema-validated update атомарно и с аудитом возобновляет тот же Task ровно один раз. Replay/conflict/TTL безопасны, ожидание удерживает admission permit. Additive schema v30: task_input_requests, fingerprint/version, TTL-индекс.
844 lines
33 KiB
Rust
844 lines
33 KiB
Rust
use crank_registry::{MigrationAuthority, MigrationPreflight, PostgresRegistry};
|
|
use sqlx::Row;
|
|
|
|
mod artifact_metadata;
|
|
mod durable_tasks_guard;
|
|
mod import_plan;
|
|
mod legacy_adoption;
|
|
mod preflight;
|
|
mod resource_security_revocations;
|
|
mod rollback;
|
|
|
|
mod schema_removal;
|
|
|
|
pub(crate) use schema_removal::*;
|
|
|
|
static EVENT_TRIGGER_TEST_LOCK: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
|
|
|
|
fn legacy_preservation_row_expr(table: &str) -> &'static str {
|
|
match table {
|
|
"invocation_logs" => {
|
|
"to_jsonb(t) - array['trace_id','operation_version','execution_stage','execution_error_code','retryability','outcome_certainty','platform_api_key_id']"
|
|
}
|
|
"operation_versions" => {
|
|
"to_jsonb(t) - array['name','display_name','category','protocol','security_level','snapshot_provenance','snapshot_observed_at','published_at','published_by']"
|
|
}
|
|
"approval_requests" => "to_jsonb(t) - array['request_id','trace_id']",
|
|
"agents" => "to_jsonb(t) - array['catalog_revision']",
|
|
_ => "to_jsonb(t)",
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn controlled_authority_is_versioned_and_safe_under_concurrent_apply() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_core_migration").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
let (first, second) = tokio::join!(
|
|
MigrationAuthority::apply(&pool),
|
|
MigrationAuthority::apply(&pool),
|
|
);
|
|
first.expect("first controlled runner must apply the sequence");
|
|
second.expect("second controlled runner must observe the applied sequence");
|
|
let first = PostgresRegistry::connect(&database_url)
|
|
.await
|
|
.expect("service startup must verify the migrated schema");
|
|
let rows =
|
|
sqlx::query("select version, name, checksum from __crank_migrations order by version")
|
|
.fetch_all(first.pool())
|
|
.await
|
|
.expect("migration ledger must be readable");
|
|
let expected = [
|
|
(1, "community-baseline-v1"),
|
|
(2, "legacy-consolidation-v2"),
|
|
(3, "request-trace-identity-v3"),
|
|
(4, "operation-lifecycle-v4"),
|
|
(5, "execution-outcome-v5"),
|
|
(6, "platform-key-name-reuse-v6"),
|
|
(7, "master-key-identity-v7"),
|
|
(8, "admin-auth-lifecycle-v8"),
|
|
(9, "agent-catalog-lifecycle-v9"),
|
|
(10, "approval-side-effects-v10"),
|
|
(11, "onboarding-product-events-v11"),
|
|
(12, "artifact-metadata-v12"),
|
|
(13, "artifact-cleanup-indexes-v13"),
|
|
(14, "import-plan-v14"),
|
|
(15, "onboarding-import-selection-v15"),
|
|
(16, "resource-drafts-v16"),
|
|
(17, "resource-publications-v17"),
|
|
(18, "agent-resource-bindings-v18"),
|
|
(19, "resource-security-revocations-v19"),
|
|
(20, "resource-template-sources-v20"),
|
|
(21, "prompts-v21"),
|
|
(22, "prompt-publications-v22"),
|
|
(23, "prompt-dependencies-v23"),
|
|
(24, "execution-admission-v24"),
|
|
(25, "durable-tasks-v25"),
|
|
(26, "durable-tasks-v26"),
|
|
(27, "durable-tasks-v27"),
|
|
(28, "durable-tasks-v28"),
|
|
(29, "durable-tasks-v29"),
|
|
(30, "durable-task-input-v30"),
|
|
];
|
|
assert_eq!(rows.len(), expected.len());
|
|
for (row, (version, name)) in rows.iter().zip(expected) {
|
|
assert_eq!(row.get::<i64, _>("version"), version);
|
|
assert_eq!(row.get::<String, _>("name"), name);
|
|
let checksum = row.get::<String, _>("checksum");
|
|
assert!(checksum == "crank-community-baseline-v1" || checksum.len() == 64);
|
|
}
|
|
let approval_columns = sqlx::query(
|
|
"select column_name
|
|
from information_schema.columns
|
|
where table_schema = current_schema()
|
|
and table_name = 'approval_requests'
|
|
and column_name in ('execution_started_at', 'execution_attempts', 'request_fingerprint')",
|
|
)
|
|
.fetch_all(first.pool())
|
|
.await
|
|
.expect("approval schema must be readable");
|
|
assert_eq!(approval_columns.len(), 3);
|
|
let onboarding_relations = sqlx::query(
|
|
"select table_name
|
|
from information_schema.tables
|
|
where table_schema = current_schema()
|
|
and table_name in ('product_events', 'product_event_daily_rollups', 'onboarding_selections')
|
|
order by table_name",
|
|
)
|
|
.fetch_all(first.pool())
|
|
.await
|
|
.expect("V11 onboarding relations must be readable");
|
|
assert_eq!(onboarding_relations.len(), 3);
|
|
let key_scope_column: bool = sqlx::query_scalar(
|
|
"select exists (
|
|
select 1 from information_schema.columns
|
|
where table_schema = current_schema()
|
|
and table_name = 'invocation_logs'
|
|
and column_name = 'platform_api_key_id'
|
|
)",
|
|
)
|
|
.fetch_one(first.pool())
|
|
.await
|
|
.expect("V11 key provenance column must be readable");
|
|
assert!(key_scope_column);
|
|
let artifact_relations = sqlx::query(
|
|
"select table_name
|
|
from information_schema.tables
|
|
where table_schema = current_schema()
|
|
and table_name in ('artifact_blobs', 'artifact_sources')
|
|
order by table_name",
|
|
)
|
|
.fetch_all(first.pool())
|
|
.await
|
|
.expect("V12 artifact metadata relations must be readable");
|
|
assert_eq!(artifact_relations.len(), 2);
|
|
let import_plan_relations = sqlx::query(
|
|
"select table_name
|
|
from information_schema.tables
|
|
where table_schema = current_schema()
|
|
and table_name in ('import_plans', 'import_plan_applications')
|
|
order by table_name",
|
|
)
|
|
.fetch_all(first.pool())
|
|
.await
|
|
.expect("V14 import plan relations must be readable");
|
|
assert_eq!(import_plan_relations.len(), 2);
|
|
let publication_relations = sqlx::query(
|
|
"select table_name
|
|
from information_schema.tables
|
|
where table_schema = current_schema()
|
|
and table_name in ('resource_publications', 'resource_versions')
|
|
order by table_name",
|
|
)
|
|
.fetch_all(first.pool())
|
|
.await
|
|
.expect("V17 publication relation must be readable");
|
|
assert_eq!(
|
|
publication_relations.len(),
|
|
2,
|
|
"V17 must add resource_publications beside resource_versions"
|
|
);
|
|
let binding_relations = sqlx::query(
|
|
"select table_name
|
|
from information_schema.tables
|
|
where table_schema = current_schema()
|
|
and table_name = 'agent_resource_bindings'",
|
|
)
|
|
.fetch_all(first.pool())
|
|
.await
|
|
.expect("V18 binding relation must be readable");
|
|
assert_eq!(
|
|
binding_relations.len(),
|
|
1,
|
|
"V18 must add the typed agent_resource_bindings table"
|
|
);
|
|
let binding_fks: i64 = sqlx::query_scalar(
|
|
"select count(*)::bigint
|
|
from pg_catalog.pg_constraint c
|
|
join pg_catalog.pg_class t on t.oid = c.conrelid
|
|
join pg_catalog.pg_namespace n on n.oid = t.relnamespace
|
|
where n.nspname = current_schema()
|
|
and t.relname = 'agent_resource_bindings' and c.contype = 'f'",
|
|
)
|
|
.fetch_one(first.pool())
|
|
.await
|
|
.expect("V18 binding constraints must be readable");
|
|
assert_eq!(
|
|
binding_fks, 3,
|
|
"V18 must keep workspace equality on both ends plus the exact Agent version"
|
|
);
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(first.pool()).await.unwrap(),
|
|
MigrationPreflight::Current { version: 30 }
|
|
);
|
|
}
|
|
#[tokio::test]
|
|
async fn v18_guard_rejects_missing_agent_resource_binding_trigger() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_v18_guard_drift").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
sqlx::query("drop trigger agent_resource_bindings_immutable_guard on agent_resource_bindings")
|
|
.execute(&pool)
|
|
.await
|
|
.expect("the V18 trigger must be droppable for the drift fixture");
|
|
let error = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
|
assert_eq!(error.code(), "partial_sequence");
|
|
assert_eq!(
|
|
error.version(),
|
|
Some(18),
|
|
"a missing V18 immutability trigger must be attributed to V18: {error}"
|
|
);
|
|
assert_eq!(error.stage(), "v18.immutable_trigger");
|
|
sqlx::raw_sql(
|
|
"create trigger agent_resource_bindings_immutable_guard
|
|
before insert or update or delete on agent_resource_bindings
|
|
for each row
|
|
execute function crank_reject_published_agent_binding_mutation();",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.expect("the canonical trigger must be restorable");
|
|
let function_drift = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
|
assert_eq!(
|
|
function_drift.code(),
|
|
"partial_sequence",
|
|
"V18 guard must pin the V18-local OLD+NEW function, not the V9 function"
|
|
);
|
|
assert_eq!(function_drift.stage(), "v18.immutable_trigger");
|
|
sqlx::raw_sql(
|
|
"drop trigger agent_resource_bindings_immutable_guard on agent_resource_bindings;
|
|
create trigger agent_resource_bindings_immutable_guard
|
|
before insert or update or delete on agent_resource_bindings
|
|
for each row
|
|
execute function crank_reject_published_agent_resource_binding_mutation();",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.expect("the V18-local guard must be restorable");
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool).await.unwrap(),
|
|
MigrationPreflight::Current { version: 30 },
|
|
"restoring the exact V18 contract must return the current verdict"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn service_connect_is_read_only_on_fresh_database() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_read_only_startup").await;
|
|
let error = PostgresRegistry::connect(&database_url)
|
|
.await
|
|
.expect_err("fresh schema must require the controlled migration command");
|
|
assert!(error.to_string().contains("schema_missing"));
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
let ledger = sqlx::query("select to_regclass('__crank_migrations')::text as name")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap()
|
|
.try_get::<Option<String>, _>("name")
|
|
.unwrap();
|
|
assert_eq!(
|
|
ledger, None,
|
|
"startup compatibility check must not create DDL"
|
|
);
|
|
}
|
|
#[tokio::test]
|
|
async fn changed_checksum_fails_closed_without_repair() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_changed_checksum").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
sqlx::query("update __crank_migrations set checksum = 'changed' where version = 1")
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
let error = MigrationAuthority::apply(&pool)
|
|
.await
|
|
.expect_err("published checksum mismatch must fail closed");
|
|
assert_eq!(error.code(), "checksum_mismatch");
|
|
let checksum = sqlx::query("select checksum from __crank_migrations where version = 1")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap()
|
|
.get::<String, _>("checksum");
|
|
assert_eq!(
|
|
checksum, "changed",
|
|
"authority must not rewrite corrupt history"
|
|
);
|
|
}
|
|
#[tokio::test]
|
|
async fn ledgerless_legacy_baseline_is_consolidated_without_data_loss() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_legacy_core").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
remove_v4_schema(&pool).await;
|
|
sqlx::query(
|
|
"insert into workspaces (id, slug, display_name, status, settings_json, created_at, updated_at)
|
|
values ('ws_preserved', 'preserved', 'Preserved', 'active', '{}'::jsonb, now(), now())",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
sqlx::raw_sql(
|
|
"insert into operations
|
|
(id, workspace_id, name, display_name, protocol, status, created_at, updated_at)
|
|
values ('op_preserved', 'ws_default', 'preserved', 'Preserved', 'rest', 'draft', now(), now());
|
|
insert into operation_versions
|
|
(operation_id, version, status, target_json, input_schema_json, output_schema_json,
|
|
input_mapping_json, output_mapping_json, execution_config_json,
|
|
tool_description_json, created_at)
|
|
values ('op_preserved', 1, 'draft', '{}'::jsonb, '{}'::jsonb, '{}'::jsonb,
|
|
'{}'::jsonb, '{}'::jsonb, '{}'::jsonb, '{}'::jsonb, now());
|
|
insert into agents
|
|
(id, workspace_id, slug, display_name, description, status, created_at, updated_at)
|
|
values ('agent_preserved', 'ws_default', 'preserved', 'Preserved', '', 'draft', now(), now());
|
|
insert into agent_versions
|
|
(agent_id, version, status, instructions_json, tool_selection_policy_json, created_at)
|
|
values ('agent_preserved', 1, 'draft', '{}'::jsonb, '{}'::jsonb, now());
|
|
insert into platform_api_keys
|
|
(id, workspace_id, agent_id, name, prefix, secret_hash, scopes_json, status, created_at)
|
|
values ('key_preserved', 'ws_default', 'agent_preserved', 'Preserved', 'cp_', 'hash', '[]'::jsonb, 'active', now());
|
|
insert into approval_requests
|
|
(id, workspace_id, agent_id, operation_id, operation_version, status, risk_level,
|
|
request_payload_json, created_at, expires_at)
|
|
values ('approval_preserved', 'ws_default', 'agent_preserved', 'op_preserved', 1,
|
|
'pending', 'high', '{}'::jsonb, now(), now() + interval '1 hour');
|
|
insert into invocation_logs
|
|
(id, workspace_id, agent_id, operation_id, source, level, status, tool_name,
|
|
message, duration_ms, request_preview_json, response_preview_json, created_at)
|
|
values ('log_preserved', 'ws_default', 'agent_preserved', 'op_preserved', 'mcp',
|
|
'info', 'success', 'preserved', 'safe', 1, '{}'::jsonb, '{}'::jsonb, now());",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
remove_v3_schema(&pool).await;
|
|
let tables = [
|
|
"operations",
|
|
"operation_versions",
|
|
"agents",
|
|
"agent_versions",
|
|
"platform_api_keys",
|
|
"approval_requests",
|
|
"invocation_logs",
|
|
];
|
|
let mut before = Vec::new();
|
|
for table in tables {
|
|
let row = legacy_preservation_row_expr(table);
|
|
let sql = format!("select jsonb_agg({row} order by {row}::text)::text from {table} t");
|
|
before.push(
|
|
sqlx::query_scalar::<_, Option<String>>(sqlx::AssertSqlSafe(sql))
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap(),
|
|
);
|
|
}
|
|
sqlx::query(
|
|
"drop table __crank_migrations, __crank_migration_legacy_audit,
|
|
__crank_mcp_migrations, mcp_transport_sessions, __crank_ext_migrations,
|
|
__crank_core_migrations",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool).await.unwrap(),
|
|
MigrationPreflight::MigrationRequired {
|
|
current: 0,
|
|
target: 30,
|
|
}
|
|
);
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
let display_name = sqlx::query("select display_name from workspaces where id = 'ws_preserved'")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap()
|
|
.get::<String, _>("display_name");
|
|
assert_eq!(display_name, "Preserved");
|
|
let mut after = Vec::new();
|
|
for table in tables {
|
|
let row = legacy_preservation_row_expr(table);
|
|
let sql = format!("select jsonb_agg({row} order by {row}::text)::text from {table} t");
|
|
after.push(
|
|
sqlx::query_scalar::<_, Option<String>>(sqlx::AssertSqlSafe(sql))
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap(),
|
|
);
|
|
}
|
|
assert_eq!(before, after, "brownfield rows must remain byte-equivalent");
|
|
}
|
|
#[tokio::test]
|
|
async fn legacy_mcp_sessions_survive_consolidation() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_legacy_mcp").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
sqlx::query(
|
|
"insert into mcp_transport_sessions (
|
|
id, protocol_version, initialized, supports_elicitation,
|
|
workspace_slug, agent_slug, created_at, updated_at, expires_at
|
|
) values ('session_preserved', '2025-11-25', true, false,
|
|
'default', 'agent', now(), now(), null)",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
remove_v4_schema(&pool).await;
|
|
remove_v3_schema(&pool).await;
|
|
sqlx::query("drop table __crank_migrations, __crank_migration_legacy_audit")
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
let count = sqlx::query("select count(*)::bigint as count from mcp_transport_sessions where id = 'session_preserved'")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap()
|
|
.get::<i64, _>("count");
|
|
assert_eq!(count, 1);
|
|
}
|
|
#[tokio::test]
|
|
async fn repeated_apply_does_not_rewrite_audit_timestamps() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_repeat_apply").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
let before = sqlx::query("select applied_at from __crank_migrations order by version")
|
|
.fetch_all(&pool)
|
|
.await
|
|
.unwrap()
|
|
.into_iter()
|
|
.map(|row| row.get::<time::OffsetDateTime, _>("applied_at"))
|
|
.collect::<Vec<_>>();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
let after = sqlx::query("select applied_at from __crank_migrations order by version")
|
|
.fetch_all(&pool)
|
|
.await
|
|
.unwrap()
|
|
.into_iter()
|
|
.map(|row| row.get::<time::OffsetDateTime, _>("applied_at"))
|
|
.collect::<Vec<_>>();
|
|
assert_eq!(before, after);
|
|
}
|
|
#[tokio::test]
|
|
async fn future_sequence_fails_closed() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_future_sequence").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
let current: i64 = sqlx::query_scalar("select max(version) from __crank_migrations")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
sqlx::query("update __crank_migrations set version = $1 where version = $2")
|
|
.bind(current + 1)
|
|
.bind(current)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool)
|
|
.await
|
|
.unwrap_err()
|
|
.code(),
|
|
"future_version"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn healthy_v2_is_reported_as_migration_required_and_upgrades_to_v3() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_v2_to_v3_identity").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
remove_v4_schema(&pool).await;
|
|
sqlx::query("delete from __crank_migrations where version = 3")
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
remove_v3_schema(&pool).await;
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool).await.unwrap(),
|
|
MigrationPreflight::MigrationRequired {
|
|
current: 2,
|
|
target: 30,
|
|
}
|
|
);
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool).await.unwrap(),
|
|
MigrationPreflight::Current { version: 30 }
|
|
);
|
|
let trace_column: bool = sqlx::query_scalar(
|
|
"select exists (
|
|
select 1 from information_schema.columns
|
|
where table_schema = current_schema()
|
|
and table_name = 'invocation_logs'
|
|
and column_name = 'trace_id'
|
|
)",
|
|
)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert!(trace_column);
|
|
}
|
|
#[tokio::test]
|
|
async fn healthy_v3_upgrades_to_v4_with_honest_legacy_snapshot_provenance() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_v3_to_v4_lifecycle").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
remove_v4_schema(&pool).await;
|
|
sqlx::raw_sql(
|
|
"insert into operations
|
|
(id, workspace_id, name, display_name, category, protocol, security_level, status,
|
|
current_draft_version, latest_published_version, created_at, updated_at, published_at)
|
|
values ('op_v3_cutover', 'ws_default', 'v3_cutover', 'V3 Cutover', 'general', 'rest',
|
|
'standard', 'published', 1, 1, now(), now(), now());
|
|
insert into operation_versions
|
|
(operation_id, version, status, target_json, input_schema_json, output_schema_json,
|
|
input_mapping_json, output_mapping_json, execution_config_json,
|
|
tool_description_json, created_at)
|
|
values ('op_v3_cutover', 1, 'published', '{}'::jsonb, '{}'::jsonb, '{}'::jsonb,
|
|
'{}'::jsonb, '{}'::jsonb, '{}'::jsonb, '{}'::jsonb, now());
|
|
insert into published_operations(operation_id, version, published_at, published_by)
|
|
values ('op_v3_cutover', 1, now(), 'legacy-owner');",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool).await.unwrap(),
|
|
MigrationPreflight::MigrationRequired {
|
|
current: 3,
|
|
target: 30,
|
|
}
|
|
);
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
let row = sqlx::query(
|
|
"select name, display_name, snapshot_provenance, snapshot_observed_at,
|
|
published_at, published_by
|
|
from operation_versions where operation_id = 'op_v3_cutover' and version = 1",
|
|
)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(row.get::<String, _>("name"), "v3_cutover");
|
|
assert_eq!(row.get::<String, _>("display_name"), "V3 Cutover");
|
|
assert_eq!(
|
|
row.get::<String, _>("snapshot_provenance"),
|
|
"legacy_observed"
|
|
);
|
|
assert!(
|
|
row.try_get::<time::OffsetDateTime, _>("snapshot_observed_at")
|
|
.is_ok()
|
|
);
|
|
assert!(
|
|
row.try_get::<time::OffsetDateTime, _>("published_at")
|
|
.is_ok()
|
|
);
|
|
assert_eq!(
|
|
row.try_get::<Option<String>, _>("published_by").unwrap(),
|
|
Some("legacy-owner".to_owned())
|
|
);
|
|
}
|
|
#[tokio::test]
|
|
async fn healthy_v4_upgrades_to_v5_without_fabricating_legacy_outcomes() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_v4_to_v5_outcome").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
remove_v5_schema(&pool).await;
|
|
sqlx::query(
|
|
"insert into operations
|
|
(id, workspace_id, name, display_name, protocol, status, created_at, updated_at)
|
|
values ('op_v4_history', 'ws_default', 'v4_history', 'V4 History', 'rest',
|
|
'draft', now(), now())",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
sqlx::query(
|
|
"insert into invocation_logs
|
|
(id, workspace_id, operation_id, source, level, status, tool_name, message,
|
|
duration_ms, request_preview_json, response_preview_json, created_at)
|
|
values ('legacy_v4_log', 'ws_default', 'op_v4_history', 'admin', 'info',
|
|
'success', 'legacy', 'safe', 1, '{}'::jsonb, '{}'::jsonb, now())",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool).await.unwrap(),
|
|
MigrationPreflight::MigrationRequired {
|
|
current: 4,
|
|
target: 30,
|
|
}
|
|
);
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
let row = sqlx::query(
|
|
"select operation_version, execution_stage, execution_error_code,
|
|
retryability, outcome_certainty
|
|
from invocation_logs where id = 'legacy_v4_log'",
|
|
)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
for column in [
|
|
"operation_version",
|
|
"execution_stage",
|
|
"execution_error_code",
|
|
"retryability",
|
|
"outcome_certainty",
|
|
] {
|
|
assert!(
|
|
row.try_get::<Option<String>, _>(column)
|
|
.is_ok_and(|value| value.is_none())
|
|
|| row
|
|
.try_get::<Option<i32>, _>(column)
|
|
.is_ok_and(|value| value.is_none())
|
|
);
|
|
}
|
|
}
|
|
#[tokio::test]
|
|
async fn failed_operation_lifecycle_migration_rolls_back_schema_and_ledger() {
|
|
let _event_trigger_guard = EVENT_TRIGGER_TEST_LOCK.lock().await;
|
|
let database_url =
|
|
crank_test_support::postgres_schema_url("test_operation_lifecycle_rollback").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
remove_v4_schema(&pool).await;
|
|
let schema: String = sqlx::query_scalar("select current_schema()")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
let failure_trigger = format!(
|
|
"create function reject_story17_v4() returns event_trigger language plpgsql as $$
|
|
begin
|
|
if current_schema() = '{schema}' and current_query() like '%operation_versions_immutable_guard%' then
|
|
raise exception 'injected v4 ddl failure';
|
|
end if;
|
|
end $$;
|
|
create event trigger reject_story17_v4 on ddl_command_start
|
|
execute function reject_story17_v4();"
|
|
);
|
|
sqlx::raw_sql(sqlx::AssertSqlSafe(failure_trigger))
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
let error = MigrationAuthority::apply(&pool).await.unwrap_err();
|
|
sqlx::raw_sql(
|
|
"drop event trigger reject_story17_v4;
|
|
drop function reject_story17_v4();",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(error.code(), "apply_failed");
|
|
assert_eq!(error.version(), Some(4));
|
|
let lifecycle_column: bool = sqlx::query_scalar(
|
|
"select exists (
|
|
select 1 from information_schema.columns
|
|
where table_schema = current_schema()
|
|
and table_name = 'operation_versions'
|
|
and column_name = 'snapshot_provenance'
|
|
)",
|
|
)
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert!(!lifecycle_column);
|
|
let ledger_v4: i64 =
|
|
sqlx::query_scalar("select count(*) from __crank_migrations where version = 4")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(ledger_v4, 0);
|
|
}
|
|
#[tokio::test]
|
|
async fn v2_with_partial_v3_objects_fails_before_apply() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_v2_partial_v3").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
remove_v4_schema(&pool).await;
|
|
sqlx::query("delete from __crank_migrations where version = 3")
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
sqlx::raw_sql(
|
|
"drop index invocation_logs_workspace_request_id_idx;
|
|
drop index invocation_logs_workspace_trace_id_idx;
|
|
alter table invocation_logs drop constraint invocation_logs_trace_id_format_check;",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
let error = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
|
assert_eq!(error.code(), "partial_sequence");
|
|
assert_eq!(error.stage(), "preflight.schema");
|
|
}
|
|
#[tokio::test]
|
|
async fn v3_rejects_same_named_constraint_or_index_with_wrong_definition() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_v3_named_drift").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
sqlx::raw_sql(
|
|
"alter table invocation_logs drop constraint invocation_logs_trace_id_format_check;
|
|
alter table invocation_logs add constraint invocation_logs_trace_id_format_check
|
|
check (true) not valid;",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool)
|
|
.await
|
|
.unwrap_err()
|
|
.code(),
|
|
"partial_sequence"
|
|
);
|
|
sqlx::raw_sql(
|
|
"alter table invocation_logs drop constraint invocation_logs_trace_id_format_check;
|
|
alter table invocation_logs add constraint invocation_logs_trace_id_format_check
|
|
check (
|
|
trace_id is null or (
|
|
trace_id ~ '^[0-9a-f]{32}$'
|
|
and trace_id <> '00000000000000000000000000000000'
|
|
)
|
|
) not valid;
|
|
drop index invocation_logs_workspace_trace_id_idx;
|
|
create index invocation_logs_workspace_trace_id_idx on invocation_logs(trace_id);",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool)
|
|
.await
|
|
.unwrap_err()
|
|
.code(),
|
|
"partial_sequence"
|
|
);
|
|
}
|
|
#[tokio::test]
|
|
async fn v5_rejects_same_named_execution_code_constraint_with_wrong_definition() {
|
|
let database_url =
|
|
crank_test_support::postgres_schema_url("test_v5_execution_code_named_drift").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
sqlx::raw_sql(
|
|
"alter table invocation_logs
|
|
drop constraint invocation_logs_execution_error_code_check;
|
|
alter table invocation_logs
|
|
add constraint invocation_logs_execution_error_code_check check (true) not valid;",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
let error = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
|
assert_eq!(error.code(), "partial_sequence");
|
|
assert_eq!(error.stage(), "preflight.schema");
|
|
}
|
|
#[tokio::test]
|
|
async fn v11_rejects_same_named_product_event_contract_drift() {
|
|
let database_url =
|
|
crank_test_support::postgres_schema_url("test_v11_product_event_named_drift").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
|
|
sqlx::raw_sql(
|
|
"alter table product_events drop constraint product_events_name_check;
|
|
alter table product_events add constraint product_events_name_check check (true) not valid;",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
let constraint_error = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
|
assert_eq!(constraint_error.code(), "partial_sequence");
|
|
assert_eq!(constraint_error.stage(), "preflight.schema");
|
|
|
|
sqlx::raw_sql(
|
|
"alter table product_events drop constraint product_events_name_check;
|
|
alter table product_events add constraint product_events_name_check check (event_name in (
|
|
'onboarding_eligible', 'onboarding_started', 'onboarding_resumed',
|
|
'onboarding_dismissed', 'onboarding_abandoned', 'onboarding_completed'
|
|
));
|
|
drop index product_events_workspace_occurred_idx;
|
|
create index product_events_workspace_occurred_idx
|
|
on product_events(occurred_at, workspace_id, id);",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
let index_error = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
|
assert_eq!(index_error.code(), "partial_sequence");
|
|
assert_eq!(index_error.stage(), "preflight.schema");
|
|
|
|
sqlx::raw_sql(
|
|
"drop index product_events_workspace_occurred_idx;
|
|
create index product_events_workspace_occurred_idx
|
|
on product_events(workspace_id, occurred_at, id);
|
|
create or replace function crank_reject_product_event_mutation()
|
|
returns trigger language plpgsql as $$
|
|
begin
|
|
raise exception 'ProductEvent is append-only' using errcode = '23514';
|
|
end;
|
|
$$;",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
let function_error = MigrationAuthority::preflight(&pool).await.unwrap_err();
|
|
assert_eq!(function_error.code(), "partial_sequence");
|
|
assert_eq!(function_error.stage(), "preflight.schema");
|
|
}
|
|
#[tokio::test]
|
|
async fn v3_upgrade_ignores_oversized_legacy_request_ids_in_partial_index() {
|
|
let database_url = crank_test_support::postgres_schema_url("test_v3_legacy_request_id").await;
|
|
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
sqlx::raw_sql(
|
|
"insert into operations
|
|
(id, workspace_id, name, display_name, protocol, status, created_at, updated_at)
|
|
values ('op_legacy_request', 'ws_default', 'legacy-request', 'Legacy Request',
|
|
'rest', 'draft', now(), now());",
|
|
)
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
sqlx::query(
|
|
"insert into invocation_logs
|
|
(id, workspace_id, operation_id, source, level, status, tool_name, message,
|
|
request_id, duration_ms, request_preview_json, response_preview_json, created_at)
|
|
values ('legacy_request_log', 'ws_default', 'op_legacy_request', 'admin', 'info',
|
|
'success', 'legacy_request', 'safe', $1, 1, '{}'::jsonb, '{}'::jsonb, now())",
|
|
)
|
|
.bind("x".repeat(10_000))
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
remove_v4_schema(&pool).await;
|
|
sqlx::query("delete from __crank_migrations where version = 3")
|
|
.execute(&pool)
|
|
.await
|
|
.unwrap();
|
|
remove_v3_schema(&pool).await;
|
|
MigrationAuthority::apply(&pool).await.unwrap();
|
|
assert_eq!(
|
|
MigrationAuthority::preflight(&pool).await.unwrap(),
|
|
MigrationPreflight::Current { version: 30 }
|
|
);
|
|
}
|