Files
crank/crates/crank-registry/tests/integration/migrations/import_plan.rs
T
bsodfather 90e5357a08
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
feat(epic4): продолжение ожидающей Task после ввода (Story 4.5)
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-индекс.
2026-10-30 16:24:12 +00:00

460 lines
16 KiB
Rust

use sqlx::Row;
use super::*;
fn count_sql(table: &str) -> sqlx::AssertSqlSafe<String> {
sqlx::AssertSqlSafe(format!("select count(*) from {table}"))
}
async fn count_rows(pool: &sqlx::PgPool, sql: sqlx::AssertSqlSafe<String>) -> i64 {
let value: i64 = sqlx::query_scalar::<_, i64>(sql)
.fetch_one(pool)
.await
.unwrap();
value
}
async fn seed_import_plan_fixture(pool: &sqlx::PgPool) {
let now = time::OffsetDateTime::now_utc();
sqlx::query(
"insert into workspaces (id, slug, display_name, status, settings_json, created_at, updated_at)
values ('ws_import_plan', 'import-plan', 'Import Plan', 'active', '{}'::jsonb, $1, $1)",
)
.bind(now)
.bind(now)
.execute(pool)
.await
.unwrap();
sqlx::query(
"insert into import_jobs (
id, workspace_id, kind, source_format, status, preview_payload, created_at, expires_at
) values (
'job_v14', 'ws_import_plan', 'openapi', 'openapi', 'ready', '{}'::jsonb, $1, $1 + interval '1 hour'
)",
)
.bind(now)
.bind(now)
.execute(pool)
.await
.unwrap();
let digest = "ab".repeat(32);
sqlx::query(
"insert into import_plans (
workspace_id, id, job_id, digest, payload, created_at, expires_at
) values (
'ws_import_plan', 'plan_v14', 'job_v14', $1, '{}'::jsonb, $2, $2 + interval '1 hour'
)",
)
.bind(&digest)
.bind(now)
.execute(pool)
.await
.unwrap();
sqlx::query(
"insert into import_plan_applications (
workspace_id, idempotency_key, plan_id, plan_digest, report, created_at
) values (
'ws_import_plan', 'idem_v14', 'plan_v14', $1, '{}'::jsonb, $2
)",
)
.bind(&digest)
.bind(now)
.execute(pool)
.await
.unwrap();
}
#[tokio::test]
async fn fresh_install_exposes_import_plan_objects_with_cascading_job_fk() {
let database_url = crank_test_support::postgres_schema_url("test_v14_fresh").await;
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
MigrationAuthority::apply(&pool).await.unwrap();
assert_eq!(
MigrationAuthority::preflight(&pool).await.unwrap(),
MigrationPreflight::Current { version: 30 }
);
let tables = 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(&pool)
.await
.unwrap();
let names = tables
.iter()
.map(|row| row.get::<String, _>("table_name"))
.collect::<Vec<_>>();
assert_eq!(names, vec!["import_plan_applications", "import_plans"]);
// The plan FK to the job is immediate with ON DELETE CASCADE: a plan never
// outlives its job. The applications table keeps only its workspace FK —
// replay evidence must survive plan and job cleanup.
let foreign_keys = sqlx::query(
"select c.conname, c.condeferrable, c.condeferred, c.confdeltype::text as delete_rule
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 c.contype = 'f'
and c.conname in (
'import_plans_job_fk',
'import_plans_workspace_id_fkey',
'import_plan_applications_workspace_id_fkey'
)
order by c.conname",
)
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(
foreign_keys.len(),
3,
"workspace-scoped FKs must all exist and the applications plan FK must be absent"
);
for row in &foreign_keys {
assert!(
!row.get::<bool, _>("condeferrable"),
"v14 plan FKs must be immediate, not deferrable"
);
assert!(
!row.get::<bool, _>("condeferred"),
"v14 plan FKs must start immediate"
);
assert_eq!(
row.get::<String, _>("delete_rule"),
"c",
"only workspace-cascading FKs may remain"
);
}
let plan_fk_absent: bool = sqlx::query_scalar(
"select not exists (
select 1 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 c.conname = 'import_plan_applications_plan_fk'
)",
)
.fetch_one(&pool)
.await
.unwrap();
assert!(
plan_fk_absent,
"replay evidence must not be pinned to the plan row"
);
let unique: bool = sqlx::query_scalar(
"select exists (
select 1 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 = 'import_jobs'
and c.conname = 'import_jobs_workspace_id_unique'
and c.contype = 'u'
)",
)
.fetch_one(&pool)
.await
.unwrap();
assert!(
unique,
"workspace-scoped import job identity must be unique"
);
}
#[tokio::test]
async fn healthy_v13_upgrades_to_v14_without_changing_prior_ledger() {
let database_url = crank_test_support::postgres_schema_url("test_v13_to_v14_import_plan").await;
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
MigrationAuthority::apply(&pool).await.unwrap();
let now = time::OffsetDateTime::now_utc();
sqlx::query(
"insert into workspaces
(id, slug, display_name, status, settings_json, created_at, updated_at)
values ('ws_v13_data', 'v13-data', 'V13 Data', 'active', '{}'::jsonb, $1, $1)",
)
.bind(now)
.bind(now)
.execute(&pool)
.await
.unwrap();
sqlx::query(
"insert into import_jobs (
id, workspace_id, kind, source_format, status, preview_payload, created_at, expires_at
) values (
'job_v13_data', 'ws_v13_data', 'openapi', 'openapi', 'ready',
'{\"marker\":\"preserved\"}'::jsonb, $1, $1 + interval '1 hour'
)",
)
.bind(now)
.bind(now)
.execute(&pool)
.await
.unwrap();
remove_v14_schema(&pool).await;
let job_before: String = sqlx::query_scalar(
"select preview_payload::text || status from import_jobs where id = 'job_v13_data'",
)
.fetch_one(&pool)
.await
.unwrap();
let prior = sqlx::query(
"select version, name, checksum, phase, compatibility, applied_at
from __crank_migrations where version <= 13 order by version",
)
.fetch_all(&pool)
.await
.unwrap()
.into_iter()
.map(|row| {
(
row.get::<i64, _>("version"),
row.get::<String, _>("name"),
row.get::<String, _>("checksum"),
row.get::<String, _>("phase"),
row.get::<String, _>("compatibility"),
row.get::<time::OffsetDateTime, _>("applied_at"),
)
})
.collect::<Vec<_>>();
assert_eq!(prior.len(), 13, "the prior ledger must cover v1..v13");
assert_eq!(
MigrationAuthority::preflight(&pool).await.unwrap(),
MigrationPreflight::MigrationRequired {
current: 13,
target: 30,
}
);
MigrationAuthority::apply(&pool).await.unwrap();
let after = sqlx::query(
"select version, name, checksum, phase, compatibility, applied_at
from __crank_migrations where version <= 13 order by version",
)
.fetch_all(&pool)
.await
.unwrap()
.into_iter()
.map(|row| {
(
row.get::<i64, _>("version"),
row.get::<String, _>("name"),
row.get::<String, _>("checksum"),
row.get::<String, _>("phase"),
row.get::<String, _>("compatibility"),
row.get::<time::OffsetDateTime, _>("applied_at"),
)
})
.collect::<Vec<_>>();
assert_eq!(
after, prior,
"prior ledger must survive the v13 -> v14 upgrade"
);
let job_after: String = sqlx::query_scalar(
"select preview_payload::text || status from import_jobs where id = 'job_v13_data'",
)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(
job_after, job_before,
"existing import jobs must be untouched by the upgrade"
);
let objects: i64 = count_rows(
&pool,
sqlx::AssertSqlSafe(String::from(
"select count(*) from information_schema.tables
where table_schema = current_schema()
and table_name in ('import_plans', 'import_plan_applications')",
)),
)
.await;
assert_eq!(objects, 2, "both v14 objects must exist after the upgrade");
}
#[tokio::test]
async fn wrong_workspace_foreign_key_is_rejected_immediately() {
let database_url = crank_test_support::postgres_schema_url("test_v14_wrong_workspace").await;
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
MigrationAuthority::apply(&pool).await.unwrap();
let now = time::OffsetDateTime::now_utc();
let mut transaction = pool.begin().await.unwrap();
for (workspace, label) in [("ws_job_owner", "job-owner"), ("ws_intruder", "intruder")] {
sqlx::query(
"insert into workspaces
(id, slug, display_name, status, settings_json, created_at, updated_at)
values ($1, $2, $2, 'active', '{}'::jsonb, $3, $3)",
)
.bind(workspace)
.bind(label)
.bind(now)
.execute(&mut *transaction)
.await
.unwrap();
}
sqlx::query(
"insert into import_jobs (
id, workspace_id, kind, source_format, status, preview_payload, created_at, expires_at
) values (
'job_owned', 'ws_job_owner', 'openapi', 'openapi', 'ready',
'{}'::jsonb, $1, $1 + interval '1 hour'
)",
)
.bind(now)
.bind(now)
.execute(&mut *transaction)
.await
.unwrap();
let digest = "ab".repeat(32);
let error = sqlx::query(
"insert into import_plans (
workspace_id, id, job_id, digest, payload, created_at, expires_at
) values (
'ws_intruder', 'plan_cross_workspace', 'job_owned', $1, '{}'::jsonb, $2,
$2 + interval '1 hour'
)",
)
.bind(&digest)
.bind(now)
.execute(&mut *transaction)
.await
.expect_err("a plan may not bind a job from another workspace");
assert!(
error
.to_string()
.contains("violates foreign key constraint"),
"wrong-workspace reference must fail the job FK: {}",
error
);
transaction.rollback().await.unwrap();
}
#[tokio::test]
async fn update_guards_reject_plan_and_application_mutations() {
let database_url = crank_test_support::postgres_schema_url("test_v14_immutable").await;
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
MigrationAuthority::apply(&pool).await.unwrap();
seed_import_plan_fixture(&pool).await;
for statement in [
"update import_plans set expires_at = expires_at + interval '1 hour' where id = 'plan_v14'",
"update import_plan_applications
set report = report || jsonb_build_object('tampered', true)
where idempotency_key = 'idem_v14'",
] {
let error = sqlx::query(statement)
.execute(&pool)
.await
.expect_err("import plan rows must be immutable");
assert!(
error.to_string().contains("import plan rows are immutable"),
"statement '{}' must hit the immutability guard: {}",
statement,
error
);
}
}
#[tokio::test]
async fn deletion_cascades_to_plans_but_preserves_application_anchor() {
let database_url = crank_test_support::postgres_schema_url("test_v14_deletion_retention").await;
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
MigrationAuthority::apply(&pool).await.unwrap();
seed_import_plan_fixture(&pool).await;
// Deleting the plan succeeds: application rows are replay evidence, not
// dependents. The anchor must keep its full replay data.
let mut transaction = pool.begin().await.unwrap();
sqlx::query("delete from import_plans where id = 'plan_v14'")
.execute(&mut *transaction)
.await
.unwrap();
transaction
.commit()
.await
.expect("plan deletion must not be blocked by the application row");
let application_count = count_rows(&pool, count_sql("import_plan_applications")).await;
assert_eq!(
application_count, 1,
"application must remain as replay evidence after plan deletion"
);
// Re-create the plan anchored to its job, then delete the expired job:
// the cascade must take the plan with it while the anchor survives.
let now = time::OffsetDateTime::now_utc();
let digest = "ab".repeat(32);
sqlx::query(
"insert into import_plans (
workspace_id, id, job_id, digest, payload, created_at, expires_at
) values (
'ws_import_plan', 'plan_v14', 'job_v14', $1, '{}'::jsonb, $2, $2 + interval '1 hour'
)",
)
.bind(&digest)
.bind(now)
.execute(&pool)
.await
.unwrap();
let mut transaction = pool.begin().await.unwrap();
sqlx::query("delete from import_jobs where id = 'job_v14'")
.execute(&mut *transaction)
.await
.unwrap();
transaction
.commit()
.await
.expect("job deletion must cascade to its plan, not be blocked by it");
assert_eq!(
count_rows(&pool, count_sql("import_jobs")).await,
0,
"the expired job must be gone"
);
assert_eq!(
count_rows(&pool, count_sql("import_plans")).await,
0,
"the plan must cascade with its job"
);
// The anchor row survives both deletions and is still replayable data.
let anchor = sqlx::query(
"select idempotency_key, plan_id, plan_digest, report
from import_plan_applications where workspace_id = 'ws_import_plan'",
)
.fetch_one(&pool)
.await
.expect("the application anchor must survive job and plan deletion");
assert_eq!(
anchor.try_get::<String, _>("idempotency_key").unwrap(),
"idem_v14",
"the idempotency identity must survive for replay"
);
assert_eq!(
anchor.try_get::<String, _>("plan_id").unwrap(),
"plan_v14",
"the stored plan_id stays a history string, not an FK"
);
assert_eq!(anchor.try_get::<String, _>("plan_digest").unwrap(), digest);
let report = anchor.try_get::<serde_json::Value, _>("report").unwrap();
assert!(report.is_object(), "the report must stay valid jsonb");
}
#[tokio::test]
async fn workspace_deletion_cascades_to_jobs_plans_and_applications() {
let database_url = crank_test_support::postgres_schema_url("test_v14_workspace_cascade").await;
let pool = sqlx::PgPool::connect(&database_url).await.unwrap();
MigrationAuthority::apply(&pool).await.unwrap();
seed_import_plan_fixture(&pool).await;
let mut transaction = pool.begin().await.unwrap();
sqlx::query("delete from workspaces where id = 'ws_import_plan'")
.execute(&mut *transaction)
.await
.unwrap();
transaction
.commit()
.await
.expect("workspace deletion must succeed after the cascades");
for table in ["import_jobs", "import_plans", "import_plan_applications"] {
let count = count_rows(&pool, count_sql(table)).await;
assert_eq!(count, 0, "{table} rows must cascade with the workspace");
}
}