use dever_core::source::SourceMap;
use dever_runtime::api::{Inputs, QueryValue};
use dever_runtime::bytes::Bytes;
use dever_runtime::config::RuntimeProfile;
use dever_runtime::http::{Header, Request};
use std::fs;
use std::process::Command;

#[path = "support/process.rs"]
#[allow(dead_code)]
mod process;
#[path = "support/temp.rs"]
mod temp;

fn source(files: &[(&str, &str)]) -> SourceMap {
    let mut sources = SourceMap::default();
    for (path, text) in files {
        sources.add(*path, *text);
    }
    sources
}

#[cfg(feature = "sqlite")]
#[test]
fn command_releases_short_transactions_before_waiting_and_preserves_committed_stages() {
    let sources = source(&[
        (
            "content/item/model.dever",
            "global type Item { name: Text unique }",
        ),
        (
            "content/item/app.dever",
            "transaction store(name: Text) (value: Text) { saved = model.create({ name = name })\nvalue = saved.name }\ncount() (total: Int) { total = model.count() }\nperform() (total: Int) { saved = store(\"first\")\ntask = run(count())\ntotal = wait(task) }\nfail_later() (value: Text) { committed = store(\"second\")\nvalue = store(committed) }",
        ),
        (
            "content/item/api.dever",
            "long cmd perform = app.perform\nlong cmd fail_later = app.fail_later\ncmd fail_atomic = app.fail_later\ncmd count = app.count",
        ),
    ]);
    let program = dever_core::check(&sources).unwrap_or_else(|errors| panic!("{errors:?}"));
    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    let native = dever_core::native::compile_project(
        &program,
        &sources,
        &rustc,
        RuntimeProfile {
            sqlite: true,
            postgres: false,
        },
    )
    .unwrap();
    let root = native.executable().parent().unwrap();
    fs::create_dir_all(root.join("config")).unwrap();
    fs::write(
        root.join("config/setting.json"),
        r#"{"database":{"default":{"type":"sqlite","path":"data/db/app.db","max_connections":1}}}"#,
    )
    .unwrap();
    let invoke = |operation: &str| {
        let mut child = Command::new(native.executable())
            .current_dir(root)
            .args([operation, "{}"])
            .stdout(std::process::Stdio::piped())
            .stderr(std::process::Stdio::piped())
            .spawn()
            .unwrap();
        process::wait(&mut child, std::time::Duration::from_secs(10)).unwrap();
        child.wait_with_output().unwrap()
    };
    let first = invoke("content.item.perform");
    assert!(
        first.status.success(),
        "{}",
        String::from_utf8_lossy(&first.stderr)
    );
    let first: serde_json::Value = serde_json::from_slice(&first.stdout).unwrap();
    assert_eq!(first["data"], 1);
    let atomic = invoke("content.item.fail_atomic");
    assert!(!atomic.status.success());
    assert!(String::from_utf8_lossy(&atomic.stderr).contains("UNIQUE"));
    let retained = invoke("content.item.count");
    assert!(retained.status.success());
    let retained: serde_json::Value = serde_json::from_slice(&retained.stdout).unwrap();
    assert_eq!(retained["data"], 1);
    let failed = invoke("content.item.fail_later");
    assert!(!failed.status.success());
    assert!(String::from_utf8_lossy(&failed.stderr).contains("UNIQUE"));
    let count = invoke("content.item.count");
    assert!(
        count.status.success(),
        "{}",
        String::from_utf8_lossy(&count.stderr)
    );
    let count: serde_json::Value = serde_json::from_slice(&count.stdout).unwrap();
    assert_eq!(count["data"], 2);
}

#[test]
fn project_entry_collects_api_and_command_without_main() {
    let sources = source(&[
        (
            "user/account/app.dever",
            "greet(name: Text) (value: Text) { value = text.trim(name) }",
        ),
        (
            "user/account/api.dever",
            "get greeting = app.greet\ncmd greeting = app.greet",
        ),
    ]);
    let program = dever_core::check(&sources).unwrap();
    let code =
        dever_core::native::emit_project(&program, &sources, RuntimeProfile::default()).unwrap();
    assert!(code.contains("dever_runtime::api::serve(api_route).await"));
    assert!(code.contains("\"user.account.greeting\" => {"));
    assert!(code.contains("let service_start = args.is_empty()"));
    assert!(code.contains("cmd_dispatch(&args[0], &args[1]).await"));
    assert!(!code.contains("main.main"));
}

#[test]
fn project_entry_can_embed_verified_external_resources() {
    let sources = source(&[
        (
            "user/account/app.dever",
            "greet() (value: Text) { value = \"ok\" }",
        ),
        ("user/account/api.dever", "cmd greeting = app.greet"),
    ]);
    let program = dever_core::check(&sources).unwrap();
    let code = dever_core::native::emit_project_with_resources(
        &program,
        &sources,
        RuntimeProfile {
            sqlite: true,
            postgres: false,
        },
        &[dever_core::native::EmbeddedResource {
            path: "worker.bin".into(),
            bytes: b"worker".to_vec(),
            sha256: "87eba76e7f3164534045ba922e7770fb58bbd14ad732bbf5ba6f11cc56989e6e".into(),
            executable: true,
        }],
    )
    .unwrap();
    assert!(code.contains("dever_runtime::external::prepare"));
    assert!(code.contains("DEVER_EXTERNAL_RESOURCES"));
    assert!(code.contains("include_bytes!(\"external-resource-0.bin\")"));
}

#[test]
fn large_external_resources_do_not_expand_generated_source_and_reject_forged_digests() {
    use sha2::{Digest, Sha256};
    let sources = source(&[
        (
            "user/account/app.dever",
            "greet() (value: Text) { value = \"ok\" }",
        ),
        ("user/account/api.dever", "cmd greeting = app.greet"),
    ]);
    let program = dever_core::check(&sources).unwrap();
    let baseline =
        dever_core::native::emit_project(&program, &sources, RuntimeProfile::default()).unwrap();
    let bytes = vec![157; 1024 * 1024];
    let mut resource = dever_core::native::EmbeddedResource {
        path: "runtime.bin".into(),
        sha256: Sha256::digest(&bytes)
            .iter()
            .map(|byte| format!("{byte:02x}"))
            .collect(),
        bytes,
        executable: true,
    };
    let code = dever_core::native::emit_project_with_resources(
        &program,
        &sources,
        RuntimeProfile::default(),
        std::slice::from_ref(&resource),
    )
    .unwrap();
    assert!(
        code.len().saturating_sub(baseline.len()) < 8 * 1024,
        "resource bytes must not become Rust literals"
    );
    assert!(code.contains("include_bytes!(\"external-resource-0.bin\")"));
    let mut copy = resource.clone();
    copy.path = "runtime-copy.bin".into();
    copy.executable = false;
    let shared = dever_core::native::emit_project_with_resources(
        &program,
        &sources,
        RuntimeProfile::default(),
        &[resource.clone(), copy],
    )
    .unwrap();
    assert_eq!(shared.matches("include_bytes!(").count(), 1);
    assert!(!shared.contains("external-resource-1.bin"));
    assert!(shared.contains("runtime-copy.bin"));
    assert_eq!(shared.matches("bytes: DEVER_EXTERNAL_BYTES_0").count(), 2);
    resource.bytes[512 * 1024] ^= 1;
    assert!(
        dever_core::native::emit_project_with_resources(
            &program,
            &sources,
            RuntimeProfile::default(),
            &[resource],
        )
        .unwrap_err()
        .contains("invalid digest")
    );
}

#[test]
fn api_and_command_inputs_share_strict_json_validation() {
    assert!(Inputs::from_json_object("{\"profile\":{\"name\":\"a\",\"name\":\"b\"}}").is_err());
    let mut inputs = Inputs::from_json_object("{}").unwrap();
    assert!(inputs.raw_json("required").is_err());
    assert_eq!(inputs.optional_raw_json("optional").unwrap(), None);
    assert!(inputs.json("required", QueryValue::Text).is_err());
    assert_eq!(
        inputs.optional_json("optional", QueryValue::Text).unwrap(),
        "null"
    );
    let request = Request {
        method: "PUT".into(),
        target: "/user/account/profile".into(),
        headers: vec![Header {
            name: "content-type".into(),
            value: Bytes::from_text("application/json"),
        }],
        body: Bytes::from_text("{\"count\":12}"),
    };
    let mut inputs = Inputs::from_request(&request).unwrap();
    assert_eq!(inputs.json("count", QueryValue::Int).unwrap(), "12");
    inputs.finish().unwrap();
}

#[test]
fn generated_write_entry_rejects_detached_concurrency() {
    let sources = source(&[
        (
            "content/article/model.dever",
            "type Article { title: Text(1, 32) }",
        ),
        (
            "content/article/app.dever",
            "write() () { article = model.create({ title = \"published\" }) }\npublish() (value: Text) { task = run(write())\nwait(task)\nvalue = \"done\" }",
        ),
        ("content/article/api.dever", "post publish = app.publish"),
    ]);
    let errors = dever_core::check(&sources).unwrap_err();
    let rendered = errors
        .iter()
        .map(|error| error.render(&sources))
        .collect::<String>();
    assert!(
        rendered.contains("automatic entry transactions cannot contain"),
        "{rendered}"
    );
}

#[test]
fn generated_long_entry_keeps_password_work_outside_its_write_transaction() {
    let sources = source(&[
        (
            "user/account/model.dever",
            "type Account { email: Text(1, 254)\nprivate password_hash: Text(255) }",
        ),
        (
            "user/account/app.dever",
            r#"register(password: Secret) (id: model.id) {
  hash = blocking(dever.crypto.password_hash(password))
  id = persist(hash)
}
transaction persist(hash: Text) (id: model.id) {
  stored = model.create({
    email = "reader@example.com"
    password_hash = hash
  })
  id = stored.id
}"#,
        ),
        (
            "user/account/api.dever",
            "long post register = app.register",
        ),
    ]);
    let program = dever_core::check(&sources).unwrap_or_else(|errors| {
        panic!(
            "{}",
            errors
                .iter()
                .map(|error| error.render(&sources))
                .collect::<String>()
        )
    });
    let code =
        dever_core::native::emit_project(&program, &sources, RuntimeProfile::default()).unwrap();
    assert!(
        code.contains("transaction_database.begin().await"),
        "{code}"
    );
    assert!(code.contains("task::blocking_typed"), "{code}");
}

#[test]
fn http_request_capabilities_are_not_available_to_commands() {
    let sources = source(&[
        (
            "user/account/app.dever",
            "current() (value: Text) { value = dever.api.request_id() }",
        ),
        ("user/account/api.dever", "cmd current = app.current"),
    ]);
    let errors = dever_core::check(&sources).unwrap_err();
    let rendered = errors
        .iter()
        .map(|error| error.render(&sources))
        .collect::<String>();
    assert!(
        rendered.contains("HTTP request capabilities are not available from CMD or Job"),
        "{rendered}"
    );
}

#[test]
fn http_request_capabilities_cannot_escape_into_detached_tasks() {
    let sources = source(&[
        (
            "user/account/app.dever",
            "read() (value: Text) { value = dever.api.request_id() }\ncurrent() (value: Text) { task = run(read())\nvalue = wait(task) }",
        ),
        ("user/account/api.dever", "get current = app.current"),
    ]);
    let errors = dever_core::check(&sources).unwrap_err();
    let rendered = errors
        .iter()
        .map(|error| error.render(&sources))
        .collect::<String>();
    assert!(rendered.contains("HTTP request, identity, and site capabilities cannot be used inside detached or parallel work"), "{rendered}");
}

#[test]
fn generated_http_context_capabilities_compile_without_a_source_context_value() {
    let sources = source(&[
        (
            "user/account/app.dever",
            "current() (value: Text) { value = dever.api.request_id()\ndever.api.set_header(\"x-request-id\", value)\noptions = dever.api.secure_cookie_options()\ndever.api.set_cookie(\"theme\", \"dark\", options) }",
        ),
        ("user/account/api.dever", "get current = app.current"),
    ]);
    let program = dever_core::check(&sources).unwrap_or_else(|errors| {
        panic!(
            "{}",
            errors
                .iter()
                .map(|error| error.render(&sources))
                .collect::<String>()
        )
    });
    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    let native =
        dever_core::native::compile_project(&program, &sources, &rustc, RuntimeProfile::default())
            .unwrap();
    assert!(native.executable().is_file());
}

#[test]
fn generated_authenticated_route_compiles_with_safe_standard_error_mapping() {
    let directory = temp::TemporaryDirectory::new();
    fs::create_dir(directory.path().join("config")).unwrap();
    fs::write(
        directory.path().join("config/setting.json"),
        r#"{
          "auth": {
            "providers": {
              "session": {
                "verify": "user.account.verify",
                "jwtSecret": "0123456789abcdef0123456789abcdef"
              }
            }
          },
          "sites": {
            "admin": {"path": "admin", "auth": "session"}
          }
        }"#,
    )
    .unwrap();
    let settings = dever_runtime::config::Settings::load_project(directory.path()).unwrap();
    let sources = source(&[
        (
            "user/account/model.dever",
            "global type Account { email: Text(1, 254) }",
        ),
        (
            "platform/tenant/model.dever",
            "global type Tenant { name: Text(1, 64) }",
        ),
        (
            "user/account/app.dever",
            r#"type Identity {
  id: Text
  user_id: user.account.model.id?
  tenant_id: platform.tenant.model.id?
}
verify(claims: dever.auth.Claims) (identity: Identity) {
  identity = Identity {
    id = claims.subject
    user_id = null
    tenant_id = null
  }
}
profile() (response: Text) {
  fail(dever.api.Error.Forbidden)
}
permissions() (response: List<dever.auth.Permission>) {
  response = dever.auth.permissions()
}
manage_role() (ok: Bool) {
  dever.auth.save_role("reader", "Reader", false, ["user.account.admin.profile"])
  dever.auth.grant_role(1, "reader")
  dever.auth.revoke_role(1, "reader")
  dever.auth.disable_role("reader")
  ok = true
}
type Work { value: Text }
submit() (id: Id) {
  id = dever.job.enqueue(job.deliver, Work { value = "queued" }, "profile")
}
deliver(input: Work) () {
  news.article.deliver(input.value)
}"#,
        ),
        (
            "user/account/api/admin/profile.dever",
            "get profile = app.profile\nget permissions = app.permissions\npost manage_role = app.manage_role\npost submit = app.submit",
        ),
        (
            "user/account/job.dever",
            "database default\njob deliver(input: app.Work) () retry(2) timeout(1000) { app.deliver(input) }",
        ),
        (
            "news/article/model.dever",
            "type Article { title: Text(1, 128) }",
        ),
        (
            "news/article/app.dever",
            "deliver(title: Text) () { stored = model.create({ title = title }) }",
        ),
        (
            "gateway/session/app.dever",
            "login() (response: Text) { token = dever.auth.issue(\"account:1\", \"session:1\", null)\noptions = dever.api.secure_cookie_options()\ndever.api.set_secret_cookie(\"cms_session\", token, options)\nresponse = \"ok\" }",
        ),
        (
            "gateway/session/api/admin/login.dever",
            "public post login = app.login",
        ),
    ]);
    let program = dever_core::check_with_settings(&sources, &settings).unwrap_or_else(|errors| {
        panic!(
            "{}",
            errors
                .iter()
                .map(|error| error.render(&sources))
                .collect::<String>()
        )
    });
    let generated = dever_core::native::emit_project(
        &program,
        &sources,
        RuntimeProfile {
            sqlite: true,
            postgres: false,
        },
    )
    .unwrap();
    assert!(generated.contains("dever_runtime::api::standard_error(403)"));
    assert!(generated.contains("dever_runtime::auth::validate_job_source(&provider, &site)"));
    assert!(generated.contains(
        "dever_runtime::auth::validate_job_identity(&verified_claims, &verified_identity)"
    ));
    assert!(generated.contains("dever_runtime::auth::store::authorize"));
    assert!(generated.contains("AUTHORIZATION_PERMISSIONS.iter().any"));
    assert!(generated.contains("permission_key"));
    assert!(generated.contains("let auth_claims ="));
    assert!(generated.contains("job_dispatch_verified(claim).await"));
    let dispatch = generated.split_once("async fn job_dispatch(").unwrap().1;
    let verify = dispatch.find("let identity:").unwrap();
    let permission = dispatch
        .find("AUTHORIZATION_PERMISSIONS.iter().any")
        .unwrap();
    let components = permission
        + dispatch[permission..]
            .find("job_require_components(&claim).await")
            .unwrap();
    let role = components
        + dispatch[components..]
            .find("dever_runtime::auth::store::authorize")
            .unwrap();
    assert!(verify < permission && permission < components && components < role);
    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    let native = dever_core::native::compile_project(
        &program,
        &sources,
        &rustc,
        RuntimeProfile {
            sqlite: true,
            postgres: false,
        },
    )
    .unwrap();
    assert!(native.executable().is_file());
}

#[test]
fn command_only_entry_requires_explicit_selection() {
    let sources = source(&[
        (
            "user/account/app.dever",
            "greet() (value: Text) { value = \"ok\" }",
        ),
        ("user/account/api.dever", "cmd greeting = app.greet"),
    ]);
    let program = dever_core::check(&sources).unwrap();
    let code =
        dever_core::native::emit_project(&program, &sources, RuntimeProfile::default()).unwrap();
    assert!(code.contains("application has no service entry; select a CMD and JSON input"));
    assert!(code.contains("\"user.account.greeting\" => Some(false)"));
    assert!(!code.contains("dever_runtime::api::serve(api_route)"));
}

#[test]
fn application_build_rejects_unreachable_app_and_private_forwarder() {
    let sources = source(&[
        (
            "user/account/domain.dever",
            "base(value: Text) (result: Text) pure { result = text.trim(value) }\nalias(value: Text) (result: Text) pure { result = base(value) }",
        ),
        (
            "user/account/app.dever",
            "greet(value: Text) (result: Text) { result = domain.alias(value) }\nunused() (result: Text) { result = \"unused\" }",
        ),
        ("user/account/api.dever", "get greeting = app.greet"),
    ]);
    let program = dever_core::check(&sources).unwrap();
    let errors = program.application_errors().unwrap();
    let rendered = errors
        .iter()
        .map(|error| error.render(&sources))
        .collect::<String>();
    assert!(
        rendered.contains("unreachable from API, CMD, or Job"),
        "{rendered}"
    );
    assert!(
        rendered.contains("only forwards unchanged inputs"),
        "{rendered}"
    );
}

#[test]
fn generated_api_and_command_binary_compiles() {
    let sources = source(&[
        (
            "user/account/app.dever",
            "greet(name: Text) (value: Text) { value = text.trim(name) }",
        ),
        (
            "user/account/api.dever",
            "get greeting = app.greet\npost greeting = app.greet\ncmd greeting = app.greet",
        ),
    ]);
    let program = dever_core::check(&sources).unwrap();
    assert!(program.application_errors().unwrap().is_empty());
    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    let binary =
        dever_core::native::compile_project(&program, &sources, &rustc, RuntimeProfile::default())
            .unwrap();
    assert!(binary.executable().is_file());
    let directory = temp::TemporaryDirectory::new();
    fs::create_dir(directory.path().join("config")).unwrap();
    fs::write(directory.path().join("config/setting.json"), "{}\n").unwrap();
    let executable = directory.path().join("app");
    binary.save(&executable).unwrap();
    let run = Command::new(&executable)
        .args(["user.account.greeting", r#"{"name":" Ada "}"#])
        .output()
        .unwrap();
    assert!(
        run.status.success(),
        "{}",
        String::from_utf8_lossy(&run.stderr)
    );
    assert_eq!(
        String::from_utf8(run.stdout).unwrap().trim(),
        r#"{"code":0,"message":"ok","data":"Ada"}"#
    );
}

#[test]
fn generated_job_entry_wraps_model_writes_in_transaction() {
    let sources = source(&[
        (
            "content/article/model.dever",
            "type Article { title: Text(1, 32) }",
        ),
        (
            "content/article/app.dever",
            "apply() () { article = model.create({ title = \"published\" }) }",
        ),
        (
            "content/article/job.dever",
            "database default\njob publish() () retry(2) timeout(1000) { app.apply() }",
        ),
    ]);
    let program = dever_core::check(&sources).unwrap();
    assert!(program.application_errors().unwrap().is_empty());
    let code = dever_core::native::emit_project(
        &program,
        &sources,
        RuntimeProfile {
            sqlite: true,
            postgres: false,
        },
    )
    .unwrap();
    assert!(code.contains("job_serve().await"));
    assert!(code.contains("Some(&transaction)"));
    assert!(code.contains("transaction.commit().await"));
    assert!(code.contains("transaction.rollback().await"));
    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    let binary = dever_core::native::compile_project(
        &program,
        &sources,
        &rustc,
        RuntimeProfile {
            sqlite: true,
            postgres: false,
        },
    )
    .unwrap();
    assert!(binary.executable().is_file());
}

#[test]
fn postgres_profile_compiles_without_connecting() {
    let sources = source(&[
        (
            "content/article/model.dever",
            "global type Article { title: Text(1, 32) }",
        ),
        (
            "content/article/app.dever",
            "count() (total: Int) { total = model.count() }",
        ),
        ("content/article/api.dever", "cmd count = app.count"),
    ]);
    let program = dever_core::check(&sources).unwrap();
    assert!(program.application_errors().unwrap().is_empty());
    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    let binary = dever_core::native::compile_project(
        &program,
        &sources,
        &rustc,
        RuntimeProfile {
            sqlite: false,
            postgres: true,
        },
    )
    .unwrap();
    assert!(binary.executable().is_file());
}

#[cfg(feature = "sqlite")]
#[test]
fn generated_tenant_migration_is_explicit_idempotent_and_never_falls_back() {
    use dever_runtime::orm::Value;
    use dever_runtime::sqlite::Database;

    let directory = temp::TemporaryDirectory::new();
    fs::create_dir(directory.path().join("config")).unwrap();
    fs::write(
        directory.path().join("config/setting.json"),
        r#"{
          "tenant": {
            "database": "default",
            "max_pools": 4,
            "idle_timeout_ms": 60000
          },
          "database": {
            "default": {
              "type": "sqlite",
              "path": "data/platform.db",
              "tenant_directory": "data/tenants",
              "max_connections": 2
            }
          }
        }"#,
    )
    .unwrap();
    let settings = dever_runtime::config::Settings::load_project(directory.path()).unwrap();
    let sources = source(&[
        (
            "content/article/model.dever",
            "type Article { title: Text(1, 160) }",
        ),
        (
            "content/article/app.dever",
            "count() (total: Int) { total = model.count() }",
        ),
        ("content/article/api.dever", "cmd count = app.count"),
    ]);
    let program = dever_core::check_with_settings(&sources, &settings).unwrap_or_else(|errors| {
        panic!(
            "{}",
            errors
                .iter()
                .map(|error| error.render(&sources))
                .collect::<String>()
        )
    });
    assert!(program.application_errors().unwrap().is_empty());
    let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    let binary = dever_core::native::compile_project(
        &program,
        &sources,
        &rustc,
        RuntimeProfile {
            sqlite: true,
            postgres: false,
        },
    )
    .unwrap();
    let executable = directory.path().join("app");
    binary.save(&executable).unwrap();
    let tenant_database = directory.path().join("data/tenants/tenant_7.db");

    let unscoped = Command::new(&executable)
        .args(["content.article.count", "{}"])
        .output()
        .unwrap();
    assert!(!unscoped.status.success());
    assert!(
        String::from_utf8_lossy(&unscoped.stderr).contains("requires an explicit tenant"),
        "{}",
        String::from_utf8_lossy(&unscoped.stderr),
    );
    assert!(!tenant_database.exists());

    for _ in 0..2 {
        let migrated = Command::new(&executable)
            .args(["--dever-tenant-migrate", "7"])
            .output()
            .unwrap();
        assert!(
            migrated.status.success(),
            "{}",
            String::from_utf8_lossy(&migrated.stderr),
        );
    }
    assert!(tenant_database.is_file());

    let scoped = Command::new(&executable)
        .args(["--dever-tenant-cmd", "7", "content.article.count", "{}"])
        .output()
        .unwrap();
    assert!(
        scoped.status.success(),
        "{}",
        String::from_utf8_lossy(&scoped.stderr)
    );
    assert_eq!(
        String::from_utf8(scoped.stdout).unwrap().trim(),
        r#"{"code":0,"message":"ok","data":0}"#,
    );

    let disabled = Command::new(&executable)
        .args(["--dever-tenant-component", "7", "disable", "content"])
        .output()
        .unwrap();
    assert!(
        disabled.status.success(),
        "{}",
        String::from_utf8_lossy(&disabled.stderr)
    );
    let blocked = Command::new(&executable)
        .args(["--dever-tenant-cmd", "7", "content.article.count", "{}"])
        .output()
        .unwrap();
    assert!(!blocked.status.success());
    assert!(
        String::from_utf8_lossy(&blocked.stderr).contains("tenant component 'content' is disabled"),
        "{}",
        String::from_utf8_lossy(&blocked.stderr),
    );
    let enabled = Command::new(&executable)
        .args(["--dever-tenant-component", "7", "enable", "content"])
        .output()
        .unwrap();
    assert!(
        enabled.status.success(),
        "{}",
        String::from_utf8_lossy(&enabled.stderr)
    );
    let restored = Command::new(&executable)
        .args(["--dever-tenant-cmd", "7", "content.article.count", "{}"])
        .output()
        .unwrap();
    assert!(
        restored.status.success(),
        "{}",
        String::from_utf8_lossy(&restored.stderr)
    );

    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .unwrap();
    runtime.block_on(async {
        let tenant = Database::open(&tenant_database, 1, 100).unwrap();
        let marker = tenant
            .query(
                "SELECT tenant_id FROM _dever_tenant_ready WHERE marker = 1",
                Vec::new(),
            )
            .await
            .unwrap();
        assert_eq!(marker[0].get(0).unwrap(), &Value::Int(7));
        tenant
            .query(
                "SELECT id, title, created_at FROM article LIMIT 1",
                Vec::new(),
            )
            .await
            .unwrap();

        let platform = Database::open(directory.path().join("data/platform.db"), 1, 100).unwrap();
        assert!(
            platform
                .query(
                    "SELECT id, title, created_at FROM article LIMIT 1",
                    Vec::new()
                )
                .await
                .is_err()
        );
    });
}

#[test]
fn generated_command_rolls_back_when_output_encoding_fails() {
    let sources = source(&[
        (
            "content/article/model.dever",
            "type Article { title: Text(1, 32) }",
        ),
        (
            "content/article/app.dever",
            "create() (article: model.Article) { article = model.create({ title = \"published\" }) }",
        ),
        ("content/article/api.dever", "cmd create = app.create"),
    ]);
    let program = dever_core::check(&sources).unwrap();
    let code = dever_core::native::emit_project(
        &program,
        &sources,
        RuntimeProfile {
            sqlite: true,
            postgres: false,
        },
    )
    .unwrap();
    assert!(code.contains("let encoded = match cmd_output_0_encode(&value)"));
    assert!(code.contains("Err(error) => { let rollback = transaction.rollback().await;"));
}