//! End-to-end integration: nomiscript form -> rpc::Session -> server::command::*

//! -> real Postgres.

//!

//! Gated on the `db` feature. Run via:

//!   DATABASE_URL=postgres://… cargo test -p tests-integration --features db

//!

//! Without `--features db`, the file compiles to nothing (the entire module

//! is `#![cfg(feature = "db")]`-gated), so default `cargo test --workspace`

//! doesn't try to connect to Postgres.

#![cfg(feature = "db")]

use chrono::Utc;

use rpc::{ScriptCtx, Session};

use server::db::DB_POOL;

use sqlx::PgPool;

use supp_macro::local_db_sqlx_test;

use uuid::Uuid;

        "INSERT INTO users (

            id, user_name, email, photo, verified, user_password,

            user_role, database_name, created_at

        ) VALUES (

            -- `verified = TRUE`: this fixture stands in for a usable account,

            -- and the SSH-key write commands refuse a disabled one.

            $1, 'rpc-test-user', 'rpc-test@example.com', 'default.png',

            TRUE, 'irrelevant', 'user', 'rpc-test', NOW()

        )",

        id

    )

#[local_db_sqlx_test]

async fn list_accounts_returns_empty_for_fresh_user(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    // Async Session: handle_form awaits on the test runtime directly. No

    // spawn_blocking, no nested-runtime panic — sqlx::test's single-thread

    // runtime drives both the test and the wasmtime async dispatch on the

    // same thread that has DB_POOL set.

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session.handle_form("(:id 1 :form (list-accounts))").await;

    assert!(

        response.contains(":id 1"),

        "expected response to carry id, got: {response}"

    );

    // P4 A5 wire shape: list-accounts returns `pair<account>`. The

    // empty list rides nomi-eval's anyref return slot as null; the

    // decoder surfaces null `PairRef(_)` as `nil`. No more

    // `:accounts ()` plist wrapper — the typed-entity shape is the

    // single source of truth.

    assert!(

        response.contains(":value nil)"),

        "expected empty accounts list, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_version_returns_baked_hash(pool: PgPool) -> anyhow::Result<()> {

    setup().await;

    let _ = pool;

    let user_id = Uuid::new_v4();

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session.handle_form("(:id 7 :form (get-version))").await;

    assert!(response.starts_with("(:id 7 :value \""), "got: {response}");

    assert!(response.ends_with("\")"), "got: {response}");

}

#[local_db_sqlx_test]

async fn list_commodities_returns_empty_for_fresh_user(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 3 :form (list-commodities))")

        .await;

    assert!(response.contains(":id 3"), "got: {response}");

    assert!(

        response.contains(":value nil)"),

        "expected empty commodities list, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn list_transactions_returns_empty_for_fresh_user(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 4 :form (list-transactions \"\"))")

        .await;

    assert!(response.contains(":id 4"), "got: {response}");

    // Pagination metadata (:has-more, cursor) moved out of the

    // list-X surface during the typed-entity migration. Plain pair

    // chain only — pagination natives land in a follow-up slice

    // once the rpc protocol carries cursor opt-args.

    assert!(

        response.contains(":value nil)"),

        "expected empty transactions list, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn list_ssh_keys_returns_empty_for_fresh_user(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session.handle_form("(:id 5 :form (list-ssh-keys))").await;

    assert!(response.contains(":id 5"), "got: {response}");

    assert!(

        response.contains(":value nil)"),

        "expected empty ssh-keys list, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_commodity_with_unknown_uuid_returns_error_envelope(

    pool: PgPool,

) -> anyhow::Result<()> {

    // A uuid arg is an id lookup; a uuid with no matching row surfaces a runtime

    // error envelope (GetCommodity uses fetch_one → RowNotFound). The symbol

    // fallback only applies to NON-uuid args, so uuid behavior is unchanged.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 6 :form (get-commodity \"00000000-0000-0000-0000-000000000000\"))")

        .await;

    assert!(response.contains(":id 6"), "got: {response}");

    assert!(

        response.contains(":error (:code runtime") && response.contains("get-commodity"),

        "expected runtime error envelope, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_commodity_resolves_by_symbol(pool: PgPool) -> anyhow::Result<()> {

    // get-commodity accepts a symbol (not just a uuid), mirroring get-account's

    // name fallback — so templates can write `(get-commodity "USD")`.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 1 :form (create-commodity \"USD\" \"US Dollar\"))")

        .await;

    let created = extract_id_field(&resp, "commodity-id").expect("created commodity uuid");

    // Look it up by symbol; the resolved entity's id must equal the created id.

    let response = session

        .handle_form("(:id 2 :form (commodity-id (get-commodity \"USD\")))")

        .await;

    assert!(response.contains(":id 2"), "got: {response}");

    assert!(

        response.contains(&created),

        "symbol lookup must resolve to the created uuid {created}, got: {response}"

    );

    // Case-insensitive.

    let response = session

        .handle_form("(:id 3 :form (commodity-id (get-commodity \"usd\")))")

        .await;

    assert!(

        response.contains(&created),

        "symbol lookup must be case-insensitive, got: {response}"

    );

    // An unknown symbol resolves to nil (not a trap, not a wrong match).

    let response = session

        .handle_form("(:id 4 :form (get-commodity \"NOPE\"))")

        .await;

    assert!(

        response.contains(":value nil"),

        "unknown symbol must be nil, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_commodity_ambiguous_symbol_errors(pool: PgPool) -> anyhow::Result<()> {

    // Symbols aren't unique in the schema. Two commodities sharing a symbol must

    // make a symbol lookup fail loudly rather than silently bind to one — a

    // wrong-currency draft is worse than an error.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    session

        .handle_form("(:id 1 :form (create-commodity \"DUP\" \"First\"))")

        .await;

    session

        .handle_form("(:id 2 :form (create-commodity \"DUP\" \"Second\"))")

        .await;

    let response = session

        .handle_form("(:id 3 :form (get-commodity \"DUP\"))")

        .await;

    assert!(

        response.contains(":error (:code runtime") && response.contains("ambiguous"),

        "ambiguous symbol must error, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_account_with_unknown_uuid_returns_empty_envelope(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 7 :form (get-account \"00000000-0000-0000-0000-000000000000\"))")

        .await;

    assert!(response.contains(":id 7"), "got: {response}");

    // GetAccount returns Option<TaggedEntity> → None for unknown uuid

    // → host fn returns `Option<Rooted<StructRef>>` as None →

    // decode_eval_result surfaces null `EntityRef(_)` as `nil`. Old

    // `:accounts ()` plist shape retired with A5.

    assert!(

        response.contains(":value nil"),

        "expected nil for unknown account, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_account_with_unknown_name_returns_empty_envelope(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 8 :form (get-account \"never-existed\"))")

        .await;

    assert!(response.contains(":id 8"), "got: {response}");

    assert!(

        response.contains(":value nil"),

        "expected nil for unknown account (uuid parse fell through to name lookup), got: {response}"

    );

}

#[local_db_sqlx_test]

async fn activity_report_for_fresh_user_returns_well_formed_envelope(

    pool: PgPool,

) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form(

            "(:id 30 :form (activity-report \"2026-01-01T00:00:00Z\" \"2026-12-31T23:59:59Z\"))",

        )

        .await;

    assert!(response.contains(":id 30"), "got: {response}");

    assert!(

        response.contains(":activity-report"),

        "expected :activity-report head, got: {response}"

    );

    assert!(

        response.contains(":date-from \\\"2026-01-01T00:00:00+00:00\\\""),

        "expected date-from echoed, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn category_breakdown_for_fresh_user_returns_well_formed_envelope(

    pool: PgPool,

) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form(

            "(:id 31 :form (category-breakdown \"2026-01-01T00:00:00Z\" \"2026-12-31T23:59:59Z\"))",

        )

        .await;

    assert!(response.contains(":id 31"), "got: {response}");

    assert!(

        response.contains(":category-breakdown"),

        "expected :category-breakdown head, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn update_transaction_for_unknown_id_returns_error(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form(

            "(:id 37 :form (update-transaction \"(:transaction-id \\\"00000000-0000-0000-0000-000000000000\\\" :note \\\"edited\\\")\"))",

        )

        .await;

    assert!(response.contains(":id 37"), "got: {response}");

    assert!(

        response.contains(":error (:code runtime") && response.contains("update-transaction"),

        "expected update-transaction error envelope, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn create_transaction_with_well_formed_payload_round_trips(

    pool: PgPool,

) -> anyhow::Result<()> {

    // Full end-to-end on the S-expr compound payload. We build the

    // pre-requisites (commodity + two accounts) via create-commodity /

    // create-account, then call create-transaction with two balancing

    // splits, then assert the transaction shows up in list-transactions

    // with the supplied note.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 32 :form (create-commodity \"BAR\" \"Bar Coin\"))")

        .await;

    let comm = extract_id_field(&resp, "commodity-id").expect("commodity-id");

    let resp = session

        .handle_form("(:id 33 :form (create-account \"From\" \"\"))")

        .await;

    let from = extract_id_field(&resp, "account-id").expect("from account-id");

    let resp = session

        .handle_form("(:id 34 :form (create-account \"To\" \"\"))")

        .await;

    let to = extract_id_field(&resp, "account-id").expect("to account-id");

    let form = format!(

        "(:id 35 :form (create-transaction \"(:post-date \\\"2026-01-15T00:00:00Z\\\" \

         :note \\\"rpc-test-tx\\\" \

         :splits ((:account-id \\\"{from}\\\" :commodity-id \\\"{comm}\\\" :value -100) \

                  (:account-id \\\"{to}\\\" :commodity-id \\\"{comm}\\\" :value 100)))\"))"

    );

    let create_resp = session.handle_form(&form).await;

    assert!(create_resp.contains(":id 35"), "got: {create_resp}");

    // Bare uuid string return — single-record write surfaces the

    // server-assigned id via :value "<uuid>".

    assert!(

        create_resp.contains(":value \""),

        "expected :value with transaction uuid, got: {create_resp}"

    );

    // Verify via the typed accessor surface rather than asserting on

    // a plist-style :note key — pair-rendered entity cars decode to

    // a placeholder; the note tag lives behind `transaction-note`.

    let note_resp = session

        .handle_form("(:id 36 :form (transaction-note (car (list-transactions \"\"))))")

        .await;

    assert!(note_resp.contains(":id 36"), "got: {note_resp}");

    assert!(

        note_resp.contains("\"rpc-test-tx\""),

        "expected new transaction note via accessor, got: {note_resp}"

    );

}

    // P4 A4 wire change: single-record writes (create-account,

    // create-commodity, create-transaction) return bare UUID

    // strings rather than `:foo-id "<uuid>"` plists. Pull the

    // quoted uuid out of `:value "<uuid>"`. `_key` stays in the

    // signature so call sites still document which entity they

    // expect — the extraction itself is uniform now.

#[local_db_sqlx_test]

async fn delete_transaction_unknown_uuid_returns_error(pool: PgPool) -> anyhow::Result<()> {

    // Not idempotent: server's DeleteTransaction surfaces an Args error

    // when the row isn't there. Native wraps as :error envelope.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 28 :form (delete-transaction \"00000000-0000-0000-0000-000000000000\"))")

        .await;

    assert!(response.contains(":id 28"), "got: {response}");

    assert!(

        response.contains(":error (:code runtime") && response.contains("delete-transaction"),

        "expected delete-transaction error envelope, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_account_for_manage_unknown_uuid_returns_empty_tree(

    pool: PgPool,

) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form(

            "(:id 27 :form (get-account-for-manage \"00000000-0000-0000-0000-000000000000\"))",

        )

        .await;

    assert!(response.contains(":id 27"), "got: {response}");

    assert!(

        response.contains(":value nil"),

        "expected nil on miss, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn list_accounts_for_manage_returns_empty_for_fresh_user(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 26 :form (list-accounts-for-manage))")

        .await;

    assert!(response.contains(":id 26"), "got: {response}");

    assert!(

        response.contains(":value nil)"),

        "expected empty accounts-tree (pair shape), got: {response}"

    );

}

#[local_db_sqlx_test]

async fn create_account_then_list_accounts_surfaces_new_row(pool: PgPool) -> anyhow::Result<()> {

    // Single-arg write returns the new entity's UUID as a bare

    // `StringRef`. Verify via the typed `(account-name (car ...))`

    // composition rather than the old `:accounts ((:name …))`

    // plist surface — accessor composition is the P4-A5 contract.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let create_resp = session

        .handle_form("(:id 23 :form (create-account \"rpc-test-account\" \"\"))")

        .await;

    assert!(create_resp.contains(":id 23"), "got: {create_resp}");

    // Bare UUID string return — single-record write surfaces the

    // server-assigned id as a quoted scalar.

    assert!(

        create_resp.contains(":value \""),

        "expected :value with uuid string, got: {create_resp}"

    );

    let name_resp = session

        .handle_form("(:id 24 :form (account-name (car (list-accounts))))")

        .await;

    assert!(name_resp.contains(":id 24"), "got: {name_resp}");

    assert!(

        name_resp.contains("\"rpc-test-account\""),

        "expected name accessor to surface tag value, got: {name_resp}"

    );

}

#[local_db_sqlx_test]

async fn set_account_tag_on_missing_account_returns_error(pool: PgPool) -> anyhow::Result<()> {

    // First 3-arg StringRef end-to-end test. Compiler emits three byte-

    // stream/finish pairs in declaration order (account-id, tag-name,

    // tag-value); host pops via FIFO take_arg in matching order. Server

    // rejects unknown account_id with CmdError::Args, which we surface

    // as the standard :error envelope.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form(

            "(:id 22 :form (set-account-tag \

                \"44444444-4444-4444-4444-444444444444\" \

                \"name\" \

                \"Renamed\"))",

        )

        .await;

    assert!(response.contains(":id 22"), "got: {response}");

    assert!(

        response.contains(":error (:code runtime") && response.contains("set-account-tag"),

        "expected set-account-tag runtime error envelope, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn create_commodity_then_list_commodities_surfaces_new_row(

    pool: PgPool,

) -> anyhow::Result<()> {

    // Two-arg write returning the new entity's UUID. After create, the

    // commodity must show up in list-commodities for the same user with

    // the symbol/name tags intact — exercises the write path's

    // tag-population side effect.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let create_resp = session

        .handle_form("(:id 20 :form (create-commodity \"FOO\" \"Foo Coin\"))")

        .await;

    assert!(create_resp.contains(":id 20"), "got: {create_resp}");

    assert!(

        create_resp.contains(":value \""),

        "expected uuid string return, got: {create_resp}"

    );

    // Verify the new row via the typed-entity accessor surface

    // — `(commodity-symbol (car (list-commodities)))` traverses

    // the pair head, downcasts to `EntityRef(Commodity)`, and

    // reads field 1 (symbol).

    let symbol_resp = session

        .handle_form("(:id 21 :form (commodity-symbol (car (list-commodities))))")

        .await;

    assert!(symbol_resp.contains(":id 21"), "got: {symbol_resp}");

    assert!(

        symbol_resp.contains("\"FOO\""),

        "expected FOO symbol, got: {symbol_resp}"

    );

    let name_resp = session

        .handle_form("(:id 22 :form (commodity-name (car (list-commodities))))")

        .await;

    assert!(

        name_resp.contains("\"Foo Coin\""),

        "expected commodity name, got: {name_resp}"

    );

}

#[local_db_sqlx_test]

async fn set_config_then_get_config_round_trips_value(pool: PgPool) -> anyhow::Result<()> {

    // First multi-arg StringRef end-to-end test: compiler emits two

    // byte-stream/finish pairs in declaration order, host pops via FIFO

    // take_arg. Round-trip through Postgres confirms the args queue

    // preserves order (name first, value second).

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let set_resp = session

        .handle_form("(:id 18 :form (set-config \"rpc-test-key\" \"hello-world\"))")

        .await;

    assert!(set_resp.contains(":id 18"), "got: {set_resp}");

    // P4 A4 bool returns surface as i32. set-config returns 1 on

    // success rather than the old plist `t` symbol.

    assert!(

        set_resp.contains(":value 1"),

        "expected set-config to return :value 1, got: {set_resp}"

    );

    let get_resp = session

        .handle_form("(:id 19 :form (get-config \"rpc-test-key\"))")

        .await;

    assert!(get_resp.contains(":id 19"), "got: {get_resp}");

    assert!(

        get_resp.contains("(:config-value \\\"hello-world\\\")"),

        "expected hello-world inside :config-value plist, got: {get_resp}"

    );

}

#[local_db_sqlx_test]

async fn config_field_is_case_insensitively_unique(pool: PgPool) -> anyhow::Result<()> {

    // The lower(field) unique index (migration 0006) must forbid case-variant

    // duplicates so reads (lower(field) = lower($1)) are unambiguous.

    sqlx::query(

        "INSERT INTO config (id, field, contents) VALUES (gen_random_uuid(), 'Theme', 'a')",

    )

    .execute(&pool)

    .await?;

    let dup = sqlx::query(

        "INSERT INTO config (id, field, contents) VALUES (gen_random_uuid(), 'theme', 'b')",

    )

    .execute(&pool)

    .await;

    assert!(

        dup.is_err(),

        "a case-variant duplicate config field must be rejected by the unique index"

    );

}

#[local_db_sqlx_test]

async fn remove_ssh_key_idempotent_for_unknown_fingerprint(pool: PgPool) -> anyhow::Result<()> {

    // First write op exercised end-to-end. RemoveSshKey is idempotent on

    // the wire: server returns Bool(true) whether or not the row existed.

    // Fresh user has no keys, so this surfaces as :value "t" — same shape

    // a successful deletion would take.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 17 :form (remove-ssh-key \"SHA256:never-registered\"))")

        .await;

    assert!(response.contains(":id 17"), "got: {response}");

    assert!(

        response.contains(":value 1"),

        "expected idempotent 1 return (i32 bool), got: {response}"

    );

}

#[local_db_sqlx_test]

async fn list_splits_for_account_without_splits_returns_empty(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 16 :form (list-splits \"33333333-3333-3333-3333-333333333333\"))")

        .await;

    assert!(response.contains(":id 16"), "got: {response}");

    assert!(

        response.contains(":value nil)"),

        "expected empty splits pair for account with no splits, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn lookup_user_by_ssh_key_for_unknown_fingerprint_returns_nil(

    pool: PgPool,

) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 15 :form (lookup-user-by-ssh-key \"SHA256:never-registered\"))")

        .await;

    assert!(response.contains(":id 15"), "got: {response}");

    assert!(

        response.contains(":value nil"),

        "expected nil for unknown fingerprint (Option<String> None), got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_config_for_missing_key_returns_nil(pool: PgPool) -> anyhow::Result<()> {

    // An absent key is "not set", returned as a successful `(:config-value nil)`

    // — NOT a hard error/trap. Absent (nil) stays distinct from a key holding

    // the empty string (""), and a missing key no longer traps the guest.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 13 :form (get-config \"never-set-this-key\"))")

        .await;

    assert!(response.contains(":id 13"), "got: {response}");

    assert!(

        response.contains(":value") && response.contains("(:config-value nil)"),

        "expected a (:config-value nil) value, got: {response}"

    );

    assert!(

        !response.contains(":error"),

        "an absent key must not surface as an error, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_config_returns_stored_value(pool: PgPool) -> anyhow::Result<()> {

    // The migration set no longer seeds config (seeding moved to

    // `bootstrap::seed`), so this test stores its own value and reads it back

    // through the script `get-config` native rather than relying on a baseline

    // seed row.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    server::user::User { id: user_id }

        .set_config("fixture_key", "YES".into())

        .await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 14 :form (get-config \"fixture_key\"))")

        .await;

    assert!(response.contains(":id 14"), "got: {response}");

    // get-config still wraps the value in a `(:config-value …)`

    // plist string for legacy emacs consumers; the StringRef return

    // carries that plist literally. Quotes inside the outer rpc

    // envelope show up backslash-escaped on the wire.

    assert!(

        response.contains("(:config-value \\\"YES\\\")"),

        "expected fixture_key=YES inside config-value plist, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_account_commodities_for_unknown_account_returns_empty(

    pool: PgPool,

) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form(

            "(:id 12 :form (get-account-commodities \"22222222-2222-2222-2222-222222222222\"))",

        )

        .await;

    assert!(response.contains(":id 12"), "got: {response}");

    assert!(

        response.contains(":value nil)"),

        "expected empty commodity-info list, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn account_balance_same_commodity_sum_composes(pool: PgPool) -> anyhow::Result<()> {

    // P3b/1c: same-commodity `+` over two account-balance results

    // composes through commodity_add and surfaces a Commodity value in

    // the envelope. Splits are -100 from A and +100 to B in FOO, so the

    // sum is 0/1 carrying FOO's id.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 40 :form (create-commodity \"FOO\" \"Foo Coin\"))")

        .await;

    let foo = extract_id_field(&resp, "commodity-id").expect("foo commodity");

    let resp = session

        .handle_form("(:id 41 :form (create-account \"A-foo\" \"\"))")

        .await;

    let acct_a = extract_id_field(&resp, "account-id").expect("A id");

    let resp = session

        .handle_form("(:id 42 :form (create-account \"B-foo\" \"\"))")

        .await;

    let acct_b = extract_id_field(&resp, "account-id").expect("B id");

    let tx = format!(

        "(:id 43 :form (create-transaction \"(:post-date \\\"2026-02-01T00:00:00Z\\\" \

         :note \\\"foo-tx\\\" \

         :splits ((:account-id \\\"{acct_a}\\\" :commodity-id \\\"{foo}\\\" :value -100) \

                  (:account-id \\\"{acct_b}\\\" :commodity-id \\\"{foo}\\\" :value 100)))\"))"

    );

    let _ = session.handle_form(&tx).await;

    let response = session

        .handle_form(&format!(

            "(:id 44 :form (+ (account-balance \"{acct_a}\") (account-balance \"{acct_b}\")))"

        ))

        .await;

    assert!(response.contains(":id 44"), "got: {response}");

    assert!(

        response.contains(":commodity"),

        "expected :commodity-shaped value, got: {response}"

    );

    assert!(

        response.contains(&foo),

        "expected FOO commodity id in result, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn account_balance_cross_commodity_sum_traps(pool: PgPool) -> anyhow::Result<()> {

    // Same form crosses currencies — commodity_add `throw`s a

    // `commodity-mismatch` `$nomi_error` inside the wasm guest; uncaught, the

    // boundary wrapper bridges it to `__nomi_raise` and the rpc envelope

    // surfaces `:code commodity-mismatch` (ADR-0014 + ADR-0026).

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 50 :form (create-commodity \"USD\" \"Dollar\"))")

        .await;

    let usd = extract_id_field(&resp, "commodity-id").expect("usd id");

    let resp = session

        .handle_form("(:id 51 :form (create-commodity \"JPY\" \"Yen\"))")

        .await;

    let jpy = extract_id_field(&resp, "commodity-id").expect("jpy id");

    let resp = session

        .handle_form("(:id 52 :form (create-account \"Wallet-USD\" \"\"))")

        .await;

    let usd_acct = extract_id_field(&resp, "account-id").expect("usd acct");

    let resp = session

        .handle_form("(:id 53 :form (create-account \"Shop-USD\" \"\"))")

        .await;

    let usd_other = extract_id_field(&resp, "account-id").expect("usd other");

    let resp = session

        .handle_form("(:id 54 :form (create-account \"Wallet-JPY\" \"\"))")

        .await;

    let jpy_acct = extract_id_field(&resp, "account-id").expect("jpy acct");

    let resp = session

        .handle_form("(:id 55 :form (create-account \"Shop-JPY\" \"\"))")

        .await;

    let jpy_other = extract_id_field(&resp, "account-id").expect("jpy other");

    let usd_tx = format!(

        "(:id 56 :form (create-transaction \"(:post-date \\\"2026-02-02T00:00:00Z\\\" \

         :note \\\"usd-tx\\\" \

         :splits ((:account-id \\\"{usd_acct}\\\" :commodity-id \\\"{usd}\\\" :value -50) \

                  (:account-id \\\"{usd_other}\\\" :commodity-id \\\"{usd}\\\" :value 50)))\"))"

    );

    let _ = session.handle_form(&usd_tx).await;

    let jpy_tx = format!(

        "(:id 57 :form (create-transaction \"(:post-date \\\"2026-02-02T00:00:00Z\\\" \

         :note \\\"jpy-tx\\\" \

         :splits ((:account-id \\\"{jpy_acct}\\\" :commodity-id \\\"{jpy}\\\" :value -1700) \

                  (:account-id \\\"{jpy_other}\\\" :commodity-id \\\"{jpy}\\\" :value 1700)))\"))"

    );

    let _ = session.handle_form(&jpy_tx).await;

    let response = session

        .handle_form(&format!(

            "(:id 58 :form (+ (account-balance \"{usd_acct}\") (account-balance \"{jpy_acct}\")))"

        ))

        .await;

    assert!(response.contains(":id 58"), "got: {response}");

    // Structured commodity-mismatch code (ADR-0014 + ADR-0026). The

    // commodity_add guest helper `throw`s a `$nomi_error` carrying a

    // `COMMODITY-MISMATCH` condition on id mismatch; the boundary wrapper

    // catches the uncaught throw and bridges it to `__nomi_raise`, so the

    // classifier yields `ScriptRaised{code:"COMMODITY-MISMATCH"}` and the

    // rpc envelope surfaces `:code COMMODITY-MISMATCH` rather than the

    // generic `:code runtime`. The code is the reader-folded (upper-cased)

    // symbol form, identical to a script `(error 'commodity-mismatch …)`.

    assert!(

        response.contains(":code COMMODITY-MISMATCH"),

        "expected structured COMMODITY-MISMATCH code, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn cross_commodity_mismatch_is_catchable_by_handler_case(pool: PgPool) -> anyhow::Result<()> {

    // The Tier 3.4 engine-error bridge: a commodity mismatch `throw`s

    // `$nomi_error` in-guest (ADR-0026), so an enclosing `(handler-case)`

    // catches it on the `commodity-mismatch` code (reader-folded to

    // `COMMODITY-MISMATCH`, matching the thrown condition) instead of

    // aborting the module. Proves engine errors travel the same catchable

    // exception channel as script `(error)` raises.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 60 :form (create-commodity \"USD\" \"Dollar\"))")

        .await;

    let usd = extract_id_field(&resp, "commodity-id").expect("usd id");

    let resp = session

        .handle_form("(:id 61 :form (create-commodity \"JPY\" \"Yen\"))")

        .await;

    let jpy = extract_id_field(&resp, "commodity-id").expect("jpy id");

    let resp = session

        .handle_form("(:id 62 :form (create-account \"W-USD\" \"\"))")

        .await;

    let usd_acct = extract_id_field(&resp, "account-id").expect("usd acct");

    let resp = session

        .handle_form("(:id 63 :form (create-account \"S-USD\" \"\"))")

        .await;

    let usd_other = extract_id_field(&resp, "account-id").expect("usd other");

    let resp = session

        .handle_form("(:id 64 :form (create-account \"W-JPY\" \"\"))")

        .await;

    let jpy_acct = extract_id_field(&resp, "account-id").expect("jpy acct");

    let resp = session

        .handle_form("(:id 65 :form (create-account \"S-JPY\" \"\"))")

        .await;

    let jpy_other = extract_id_field(&resp, "account-id").expect("jpy other");

    let usd_tx = format!(

        "(:id 66 :form (create-transaction \"(:post-date \\\"2026-02-02T00:00:00Z\\\" \

         :note \\\"usd-tx\\\" \

         :splits ((:account-id \\\"{usd_acct}\\\" :commodity-id \\\"{usd}\\\" :value -50) \

                  (:account-id \\\"{usd_other}\\\" :commodity-id \\\"{usd}\\\" :value 50)))\"))"

    );

    let _ = session.handle_form(&usd_tx).await;

    let jpy_tx = format!(

        "(:id 67 :form (create-transaction \"(:post-date \\\"2026-02-02T00:00:00Z\\\" \

         :note \\\"jpy-tx\\\" \

         :splits ((:account-id \\\"{jpy_acct}\\\" :commodity-id \\\"{jpy}\\\" :value -1700) \

                  (:account-id \\\"{jpy_other}\\\" :commodity-id \\\"{jpy}\\\" :value 1700)))\"))"

    );

    let _ = session.handle_form(&jpy_tx).await;

    // The cross-commodity sum mismatches; the handler-case catches it on its

    // code. Both arms must agree in type (handler-case unifies body + clause),

    // so the clause yields a commodity value too — a single-currency balance —

    // proving the catch fired by returning a value, not an error envelope.

    let response = session

        .handle_form(&format!(

            "(:id 68 :form (handler-case \

               (+ (account-balance \"{usd_acct}\") (account-balance \"{jpy_acct}\")) \

               (commodity-mismatch (e) (account-balance \"{usd_acct}\"))))"

        ))

        .await;

    assert!(response.contains(":id 68"), "got: {response}");

    assert!(

        !response.contains(":error"),

        "handler-case must catch the mismatch, not let it abort: {response}"

    );

}

#[local_db_sqlx_test]

async fn convert_commodity_uses_latest_price_row(pool: PgPool) -> anyhow::Result<()> {

    // P3b/1d: end-to-end on the new commodity-typed positional arg path

    // and the ConvertCommodity server command. Seeds: USD/JPY commodities,

    // a Price row USD→JPY at 150/1, an account holding 2 USD. The form

    // `(convert-commodity (account-balance "<usd>") "<jpy>")` walks the

    // capture-arg-commodity wire path on the way in, runs ConvertCommodity

    // server-side, and surfaces a Commodity carrying JPY's id.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 60 :form (create-commodity \"USD\" \"Dollar\"))")

        .await;

    let usd = extract_id_field(&resp, "commodity-id").expect("usd id");

    let resp = session

        .handle_form("(:id 61 :form (create-commodity \"JPY\" \"Yen\"))")

        .await;

    let jpy = extract_id_field(&resp, "commodity-id").expect("jpy id");

    let resp = session

        .handle_form("(:id 62 :form (create-account \"Wallet-USD\" \"\"))")

        .await;

    let wallet = extract_id_field(&resp, "account-id").expect("wallet");

    let resp = session

        .handle_form("(:id 63 :form (create-account \"Sink-USD\" \"\"))")

        .await;

    let sink = extract_id_field(&resp, "account-id").expect("sink");

    let tx = format!(

        "(:id 64 :form (create-transaction \"(:post-date \\\"2026-03-01T00:00:00Z\\\" \

         :note \\\"usd-conv-tx\\\" \

         :splits ((:account-id \\\"{wallet}\\\" :commodity-id \\\"{usd}\\\" :value 2) \

                  (:account-id \\\"{sink}\\\" :commodity-id \\\"{usd}\\\" :value -2)))\"))"

    );

    let _ = session.handle_form(&tx).await;

    // Direct insert: a fixed USD→JPY rate. No CreatePrice native exists

    // (see server::command::account tests for the same pattern), so the

    // test rides raw sqlx like the existing test suite does.

    let usd_uuid = Uuid::parse_str(&usd)?;

    let jpy_uuid = Uuid::parse_str(&jpy)?;

    let price_id = Uuid::new_v4();

    let price_date = Utc::now();

    sqlx::query!(

        "INSERT INTO prices (id, commodity_id, currency_id, commodity_split_id, \

         currency_split_id, price_date, value_num, value_denom) \

         VALUES ($1, $2, $3, NULL, NULL, $4, $5, $6)",

        price_id,

        usd_uuid,

        jpy_uuid,

        price_date,

        150_i64,

        1_i64,

    )

    .execute(&pool)

    .await?;

    let response = session

        .handle_form(&format!(

            "(:id 65 :form (convert-commodity (account-balance \"{wallet}\") \"{jpy}\"))"

        ))

        .await;

    assert!(response.contains(":id 65"), "got: {response}");

    assert!(

        response.contains(":commodity"),

        "expected Commodity-shaped value, got: {response}"

    );

    assert!(

        response.contains(&jpy),

        "expected JPY id in result, got: {response}"

    );

    // 2 USD × 150/1 = 300 in JPY.

    assert!(

        response.contains(":commodity 300"),

        "expected 300 JPY, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn convert_commodity_missing_price_row_traps(pool: PgPool) -> anyhow::Result<()> {

    // ConvertCommodity raises CmdError::Args when no Price row exists in

    // either direction. The rpc native maps it to wasmtime::Error, which

    // surfaces as :code runtime in the envelope.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 70 :form (create-commodity \"AAA\" \"Alpha\"))")

        .await;

    let aaa = extract_id_field(&resp, "commodity-id").expect("aaa");

    let resp = session

        .handle_form("(:id 71 :form (create-commodity \"BBB\" \"Beta\"))")

        .await;

    let bbb = extract_id_field(&resp, "commodity-id").expect("bbb");

    let resp = session

        .handle_form("(:id 72 :form (create-account \"A-wallet\" \"\"))")

        .await;

    let acct = extract_id_field(&resp, "account-id").expect("a wallet");

    let resp = session

        .handle_form("(:id 73 :form (create-account \"A-sink\" \"\"))")

        .await;

    let sink = extract_id_field(&resp, "account-id").expect("a sink");

    let tx = format!(

        "(:id 74 :form (create-transaction \"(:post-date \\\"2026-03-02T00:00:00Z\\\" \

         :note \\\"aaa-tx\\\" \

         :splits ((:account-id \\\"{acct}\\\" :commodity-id \\\"{aaa}\\\" :value 5) \

                  (:account-id \\\"{sink}\\\" :commodity-id \\\"{aaa}\\\" :value -5)))\"))"

    );

    let _ = session.handle_form(&tx).await;

    let response = session

        .handle_form(&format!(

            "(:id 75 :form (convert-commodity (account-balance \"{acct}\") \"{bbb}\"))"

        ))

        .await;

    assert!(response.contains(":id 75"), "got: {response}");

    // P3b structured no-conversion code (ADR-0014 follow-up).

    // ConvertCommodity's "no Price row" CmdError::Args surfaces

    // as `EngineError::NoConversion`, which maps to

    // `:code no-conversion`. Distinct from `commodity-mismatch`

    // because the remedy is different — add a price row, not

    // restructure arithmetic.

    assert!(

        response.contains(":code no-conversion"),

        "expected no-conversion structured code, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn account_balance_traps_when_no_commodity_yet(pool: PgPool) -> anyhow::Result<()> {

    // wraps_commodity migration (P3b/1b): account-balance now resolves

    // commodity via GetAccountCommodities before reading the rational. An

    // account with no splits has no associated commodity, so the native

    // traps rather than returning a phantom 0-of-no-currency value. Surfaces

    // through the envelope as :error.

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 30 :form (account-balance \"22222222-2222-2222-2222-222222222222\"))")

        .await;

    assert!(response.contains(":id 30"), "got: {response}");

    // 1b surfaces the trap as a generic runtime error envelope; structured

    // classification (commodity-mismatch / no-commodity codes) lands in 1c

    // together with the rest of commodity-aware trap dispatch.

    assert!(

        response.contains(":code runtime"),

        "expected :code runtime trap envelope, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_balance_for_account_with_no_splits_returns_zero(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    // Random uuid → no splits exist for it → GetBalance short-circuits to

    // CmdResult::Rational(0/1) → wire form bare ratio `:value 0` (native

    // Ratio, not a string-wrapped plist).

    let response = session

        .handle_form("(:id 11 :form (get-balance \"11111111-1111-1111-1111-111111111111\"))")

        .await;

    assert!(response.contains(":id 11"), "got: {response}");

    assert!(

        response.contains(":value 0"),

        "expected :value 0, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn user_has_ssh_key_returns_nil_for_fresh_user(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 10 :form (user-has-ssh-key))")

        .await;

    assert!(response.contains(":id 10"), "got: {response}");

    // P4 A4 bool returns surface as i32 — 0 for false (no key

    // registered yet). The old `:value "nil"` plist string retired

    // with the capture-protocol removal.

    assert!(

        response.contains(":value 0"),

        "expected :value 0 (i32 bool false), got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_transaction_with_unknown_uuid_returns_empty_envelope(

    pool: PgPool,

) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 9 :form (get-transaction \"00000000-0000-0000-0000-000000000000\"))")

        .await;

    assert!(response.contains(":id 9"), "got: {response}");

    // GetTransaction returns Ok(None) on miss → host fn returns

    // `Option<Rooted<StructRef>>` as None → decoder surfaces null

    // EntityRef as `nil`. The pagination metadata moved out with A5.

    assert!(

        response.contains(":value nil"),

        "expected nil for unknown transaction, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn create_cross_currency_transaction_with_price_persists(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 70 :form (create-commodity \"USD\" \"US Dollar\"))")

        .await;

    let usd = extract_id_field(&resp, "commodity-id").expect("usd id");

    let resp = session

        .handle_form("(:id 71 :form (create-commodity \"EUR\" \"Euro\"))")

        .await;

    let eur = extract_id_field(&resp, "commodity-id").expect("eur id");

    let resp = session

        .handle_form("(:id 72 :form (create-account \"Wallet USD\" \"\"))")

        .await;

    let from_acct = extract_id_field(&resp, "account-id").expect("from account");

    let resp = session

        .handle_form("(:id 73 :form (create-account \"Wallet EUR\" \"\"))")

        .await;

    let to_acct = extract_id_field(&resp, "account-id").expect("to account");

    let from_split_id = Uuid::new_v4().to_string();

    let to_split_id = Uuid::new_v4().to_string();

    // The EUR (commodity-side) split is listed first, so finance picks EUR as

    // the base commodity and the non-base USD split is reached through the

    // price's `currency_split` reference — the path the old single-sided

    // `else if` price index used to miss.

    let form = format!(

        "(:id 74 :form (create-transaction \

         \"(:post-date \\\"2026-03-15T00:00:00Z\\\" \

         :splits ((:id \\\"{to_split_id}\\\" \

                   :account-id \\\"{to_acct}\\\" \

                   :commodity-id \\\"{eur}\\\" \

                   :value 9200) \

                  (:id \\\"{from_split_id}\\\" \

                   :account-id \\\"{from_acct}\\\" \

                   :commodity-id \\\"{usd}\\\" \

                   :value -10000)) \

         :prices ((:commodity-id \\\"{eur}\\\" \

                   :currency-id \\\"{usd}\\\" \

                   :commodity-split \\\"{to_split_id}\\\" \

                   :currency-split \\\"{from_split_id}\\\" \

                   :value-num 10000 \

                   :value-denom 9200)))\"))"

    );

    let create_resp = session.handle_form(&form).await;

    assert!(create_resp.contains(":id 74"), "got: {create_resp}");

    assert!(

        create_resp.contains(":value \""),

        "expected transaction uuid in :value, got: {create_resp}"

    );

    let tx_resp = session

        .handle_form("(:id 75 :form (car (list-transactions \"\")))")

        .await;

    assert!(tx_resp.contains(":id 75"), "got: {tx_resp}");

    assert!(

        !tx_resp.contains(":value nil"),

        "expected a transaction entity, got: {tx_resp}"

    );

}

#[local_db_sqlx_test]

async fn get_balances_no_splits_returns_empty_list(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 10 :form (get-balances \"11111111-1111-1111-1111-111111111111\"))")

        .await;

    assert!(response.contains(":id 10"), "got: {response}");

    assert!(!response.contains(":error"), "got: {response}");

    assert!(

        response.contains(":value nil)"),

        "expected empty pair list, got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_balances_missing_arg_returns_error(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let response = session

        .handle_form("(:id 10 :form (get-balances \"\"))")

        .await;

    assert!(response.contains(":id 10"), "got: {response}");

    assert!(

        response.contains(":error") || response.contains(":code"),

        "got: {response}"

    );

}

#[local_db_sqlx_test]

async fn get_balances_single_currency_returns_one_element_list(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 10 :form (create-commodity \"USD\" \"US Dollar\"))")

        .await;

    let usd = extract_id_field(&resp, "commodity-id").expect("usd id");

    let resp = session

        .handle_form("(:id 11 :form (create-account \"Wallet\" \"\"))")

        .await;

    let wallet = extract_id_field(&resp, "account-id").expect("wallet");

    let resp = session

        .handle_form("(:id 12 :form (create-account \"Sink\" \"\"))")

        .await;

    let sink = extract_id_field(&resp, "account-id").expect("sink");

    let tx = format!(

        "(:id 13 :form (create-transaction \"(:post-date \\\"2026-01-01T00:00:00Z\\\" \

         :note \\\"test-tx\\\" \

         :splits ((:account-id \\\"{wallet}\\\" :commodity-id \\\"{usd}\\\" :value -50) \

                  (:account-id \\\"{sink}\\\" :commodity-id \\\"{usd}\\\" :value 50)))\"))"

    );

    session.handle_form(&tx).await;

    let response = session

        .handle_form(&format!("(:id 14 :form (get-balances \"{wallet}\"))"))

        .await;

    assert!(response.contains(":id 14"), "got: {response}");

    assert!(!response.contains(":error"), "got: {response}");

    assert!(response.contains(":value-num"), "got: {response}");

    assert!(response.contains("-50"), "got: {response}");

    assert!(response.contains("USD"), "got: {response}");

}

#[local_db_sqlx_test]

async fn get_balances_multi_currency_returns_n_elements(pool: PgPool) -> anyhow::Result<()> {

    let user_id = Uuid::new_v4();

    insert_test_user(&pool, user_id).await?;

    let mut session = Session::new(ScriptCtx::new(user_id)).expect("Session::new");

    let resp = session

        .handle_form("(:id 100 :form (create-commodity \"USD\" \"US Dollar\"))")

        .await;

    let usd = extract_id_field(&resp, "commodity-id").expect("usd");

    let resp = session

        .handle_form("(:id 101 :form (create-commodity \"JPY\" \"Yen\"))")

        .await;

    let jpy = extract_id_field(&resp, "commodity-id").expect("jpy");

    let resp = session

        .handle_form("(:id 102 :form (create-account \"Mixed\" \"\"))")

        .await;

    let mixed = extract_id_field(&resp, "account-id").expect("mixed");

    let resp = session

        .handle_form("(:id 103 :form (create-account \"SinkA\" \"\"))")

        .await;

    let sink_a = extract_id_field(&resp, "account-id").expect("sink_a");

    let resp = session

        .handle_form("(:id 104 :form (create-account \"SinkB\" \"\"))")

        .await;

    let sink_b = extract_id_field(&resp, "account-id").expect("sink_b");

    let tx1 = format!(

        "(:id 105 :form (create-transaction \"(:post-date \\\"2026-01-01T00:00:00Z\\\" \

         :note \\\"tx1\\\" \

         :splits ((:account-id \\\"{mixed}\\\" :commodity-id \\\"{usd}\\\" :value -100) \

                  (:account-id \\\"{sink_a}\\\" :commodity-id \\\"{usd}\\\" :value 100)))\"))"

    );

    session.handle_form(&tx1).await;

    let tx2 = format!(

        "(:id 106 :form (create-transaction \"(:post-date \\\"2026-01-02T00:00:00Z\\\" \

         :note \\\"tx2\\\" \

         :splits ((:account-id \\\"{mixed}\\\" :commodity-id \\\"{jpy}\\\" :value -5000) \

                  (:account-id \\\"{sink_b}\\\" :commodity-id \\\"{jpy}\\\" :value 5000)))\"))"

    );

    session.handle_form(&tx2).await;

    let response = session

        .handle_form(&format!("(:id 107 :form (get-balances \"{mixed}\"))"))

        .await;

    assert!(response.contains(":id 107"), "got: {response}");

    assert!(!response.contains(":error"), "got: {response}");

    assert!(

        response.contains("USD") || response.contains("JPY"),

        "expected commodity symbol in response, got: {response}"

    );

}