create-feltdb 0.9.0 → 0.10.0

package/dist/server-source/crates/feltdb-server/tests/principal_tenant_migration.rs

@@ -0,0 +1,247 @@
+use feltdb::{AtomicMutation, AtomicPrecondition, FeltDb};
+use feltdb_server::canonical_principals::{
+    application_ownership_key, CanonicalApplicationOwnership,
+};
+use serde_json::json;
+use std::{
+    fs,
+    io::{BufRead, BufReader},
+    path::{Path, PathBuf},
+    process::{Child, Command, Stdio},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+const PRODUCTION_SHAPED_APPLICATION: &str = "app_pKEN4gJ0lvQV4D2ZWa";
+
+fn fixture_dir() -> PathBuf {
+    std::env::temp_dir().join(format!(
+        "feltdb-principal-tenant-migration-{}-{}",
+        std::process::id(),
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos()
+    ))
+}
+
+fn start(data: &Path) -> Child {
+    Command::new(env!("CARGO_BIN_EXE_feltdb-server"))
+        .args([
+            "--host",
+            "127.0.0.1",
+            "--port",
+            "0",
+            "--namespace",
+            "principal-tenant-migration",
+            "--data",
+            data.to_str().unwrap(),
+            "--keys",
+            data.with_extension("keys.json").to_str().unwrap(),
+            "--audit",
+            data.with_extension("audit.log").to_str().unwrap(),
+        ])
+        .env(
+            "FELTDB_MASTER_KEY",
+            "principal-tenant-migration-development-key",
+        )
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap()
+}
+
+fn await_readiness(child: &mut Child) {
+    let stdout = child.stdout.take().unwrap();
+    for line in BufReader::new(stdout).lines() {
+        let line = line.unwrap();
+        if line.contains("ready at http://127.0.0.1:") {
+            return;
+        }
+    }
+    let stderr = child
+        .stderr
+        .take()
+        .map(|value| std::io::read_to_string(value).unwrap_or_default())
+        .unwrap_or_default();
+    panic!("server failed before readiness: {stderr}");
+}
+
+fn await_failure(child: Child) -> String {
+    let output = child.wait_with_output().unwrap();
+    assert!(!output.status.success());
+    format!(
+        "{}{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    )
+}
+
+#[test]
+fn principal_startup_production_shaped_fixture_and_authority_loss() {
+    let directory = fixture_dir();
+    fs::create_dir_all(&directory).unwrap();
+    let data = directory.join("feltdb.log");
+    fs::write(
+        data.with_extension("platform.json"),
+        serde_json::to_vec_pretty(&json!({
+            "users": [],
+            "tenants": [{
+                "id": "tenant_production",
+                "name": "Sanitized production tenant",
+                "slug": "sanitized-production-tenant",
+                "created_by": "principal_owner",
+                "created_at": 1,
+                "updated_at": 1
+            }],
+            "applications": [],
+            "tenant_memberships": [],
+            "application_memberships": [],
+            "application_service_principals": [],
+            "invitations": [],
+            "audit": []
+        }))
+        .unwrap(),
+    )
+    .unwrap();
+    let legacy = data.with_extension("principals.json");
+    fs::write(
+        &legacy,
+        serde_json::to_vec_pretty(&json!({
+            "principals": [{
+                "id": "agent_stable",
+                "application_id": PRODUCTION_SHAPED_APPLICATION,
+                "kind": "agent",
+                "name": "Sanitized Agent",
+                "version": 3,
+                "status": "active",
+                "created_by": "principal_delegator",
+                "created_at": 100,
+                "capabilities": ["state:read"],
+                "parent_id": null,
+                "worker_id": null,
+                "started_at": null,
+                "completed_at": null
+            }],
+            "audit": []
+        }))
+        .unwrap(),
+    )
+    .unwrap();
+
+    let pre_backfill = start(&data);
+    let output = await_failure(pre_backfill);
+    assert!(output
+        .contains("PRINCIPAL_TENANT_MIGRATION_CONFLICT:MISSING_OWNERSHIP:app_pKEN4gJ0lvQV4D2ZWa"));
+
+    let db = FeltDb::open(&data).unwrap();
+    let ownership = CanonicalApplicationOwnership {
+        application_id: PRODUCTION_SHAPED_APPLICATION.into(),
+        tenant_id: "tenant_production".into(),
+        source_authority: "sanitized_authoritative_registration_export".into(),
+        source_record_id: "registration_record_1".into(),
+        source_digest: format!("sha256:{}", "a".repeat(64)),
+        authorization_reference: "approval://release/0.10D-R2/test".into(),
+        authorized_by: "release_test_authority".into(),
+        authorized_at: "2026-09-09T00:00:00Z".into(),
+        migration_version: "application-ownership-backfill/v1".into(),
+        reason: "sanitized production incident regression".into(),
+    };
+    let transaction_id = "application-ownership-backfill-test-v1";
+    let commit = || {
+        db.apply_atomic_transaction(
+            transaction_id,
+            None,
+            &[AtomicPrecondition {
+                capability: "system_application_ownership".into(),
+                key: application_ownership_key(PRODUCTION_SHAPED_APPLICATION),
+                expected_version: None,
+            }],
+            &[AtomicMutation {
+                capability: "system_application_ownership".into(),
+                key: application_ownership_key(PRODUCTION_SHAPED_APPLICATION),
+                value: Some(serde_json::to_value(&ownership).unwrap()),
+            }],
+            Some(json!({
+                "kind": "application_ownership_backfill",
+                "tenant": "tenant_production",
+                "application": PRODUCTION_SHAPED_APPLICATION,
+                "authorization_reference": ownership.authorization_reference,
+                "source_digest": ownership.source_digest,
+                "operation_id": transaction_id
+            })),
+        )
+    };
+    let first_commit = commit().unwrap();
+    assert!(!first_commit.duplicate);
+    let repeated = commit().unwrap();
+    assert!(repeated.duplicate);
+    assert_eq!(repeated.commit_revision, first_commit.commit_revision);
+    let attribution = db
+        .transaction_attribution(transaction_id)
+        .unwrap()
+        .expect("durable ownership transaction attribution");
+    assert_eq!(attribution.transaction_id, transaction_id);
+    assert!(!attribution.operation_ids.is_empty());
+    drop(db);
+
+    let mut first = start(&data);
+    await_readiness(&mut first);
+    first.kill().unwrap();
+    first.wait().unwrap();
+
+    let reopened = FeltDb::open(&data).unwrap();
+    assert_eq!(
+        reopened
+            .get_value(&application_ownership_key(PRODUCTION_SHAPED_APPLICATION))
+            .unwrap()
+            .unwrap()["tenant_id"],
+        "tenant_production"
+    );
+    assert!(reopened
+        .transaction_attribution(transaction_id)
+        .unwrap()
+        .is_some());
+    drop(reopened);
+
+    fs::remove_file(&legacy).unwrap();
+    let mut restarted = start(&data);
+    await_readiness(&mut restarted);
+    restarted.kill().unwrap();
+    restarted.wait().unwrap();
+    fs::remove_dir_all(directory).unwrap();
+    assert_missing_canonical_ownership_fails_closed();
+}
+
+fn assert_missing_canonical_ownership_fails_closed() {
+    let directory = fixture_dir();
+    fs::create_dir_all(&directory).unwrap();
+    let data = directory.join("feltdb.log");
+    fs::write(
+        data.with_extension("principals.json"),
+        serde_json::to_vec(&json!({
+            "principals": [{
+                "id": "agent_unresolved",
+                "application_id": PRODUCTION_SHAPED_APPLICATION,
+                "kind": "agent",
+                "name": "Unresolved Agent",
+                "version": 1,
+                "status": "active",
+                "created_by": "principal_delegator",
+                "created_at": 100,
+                "capabilities": [],
+                "parent_id": null,
+                "worker_id": null,
+                "started_at": null,
+                "completed_at": null
+            }],
+            "audit": []
+        }))
+        .unwrap(),
+    )
+    .unwrap();
+    let child = start(&data);
+    let output = await_failure(child);
+    assert!(output
+        .contains("PRINCIPAL_TENANT_MIGRATION_CONFLICT:MISSING_OWNERSHIP:app_pKEN4gJ0lvQV4D2ZWa"));
+    fs::remove_dir_all(directory).unwrap();
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "create-feltdb",
   "private": false,
   "description": "Create a new FeltDB application with one command",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "license": "MIT",
   "bin": {
     "create-feltdb": "bin/create-feltdb.js"