pharos_native/runtime/

payment_provider.rs

//! App-neutral payment-provider contracts.
//!
//! This module is deliberately independent of any proving app. Apps supply
//! owner and route mappings through their manifest; adapters supply provider
//! protocol behavior; the lifecycle service joins those contracts.

#[cfg(test)]
use std::collections::BTreeMap;
use std::env;
#[cfg(test)]
use std::fs;
use std::path::Path;
use std::time::{SystemTime, UNIX_EPOCH};
#[cfg(test)]
use std::{cell::RefCell, collections::VecDeque};

use serde_json::{Map, Value};

struct RuntimePaymentProviderConfigSource<'a> {
    app_root: &'a Path,
    runtime_conf_path: Option<&'a Path>,
}

impl pharos_runtime_payment::PaymentProviderConfigSource
    for RuntimePaymentProviderConfigSource<'_>
{
    fn config_value(&self, key: &str) -> Option<String> {
        super::json_commands::dynamic_config_value(self.app_root, self.runtime_conf_path, key)
    }
}

impl pharos_runtime_payment::PaymentProviderProtocolConfig
    for RuntimePaymentProviderConfigSource<'_>
{
    fn secret_env_value(&self, key: &str) -> Option<String> {
        payment_provider_secret_env_value(self.app_root, self.runtime_conf_path, key)
    }
}

impl pharos_runtime_payment::PaymentProviderSecretKeyResolver
    for RuntimePaymentProviderConfigSource<'_>
{
    fn active_secret_key_version(&self) -> Option<String> {
        payment_provider_active_secret_key_version(self.app_root, self.runtime_conf_path)
    }

    fn encryption_key_for_version(&self, key_version: &str) -> Option<[u8; 32]> {
        payment_provider_encryption_key_for_version(
            self.app_root,
            self.runtime_conf_path,
            key_version,
        )
    }
}

impl pharos_runtime_payment::PaymentProviderBookingAdapter
    for RuntimePaymentProviderConfigSource<'_>
{
    fn business_open_for_slot(
        &self,
        root: &Value,
        business_id: i64,
        date_value: &str,
        time_value: &str,
        duration_minutes: i64,
    ) -> bool {
        super::business::dynamic_business_open_for_slot(
            root,
            business_id,
            date_value,
            time_value,
            duration_minutes,
        )
    }

    fn assign_technician_for_slot(
        &self,
        root: &Value,
        business_id: i64,
        service_id: i64,
        date_value: &str,
        time_value: &str,
    ) -> i64 {
        super::business::dynamic_assign_technician_for_slot(
            root,
            business_id,
            service_id,
            date_value,
            time_value,
        )
    }
}

impl pharos_runtime_payment::PaymentProviderHttpClient for RuntimePaymentProviderConfigSource<'_> {
    fn request_json(
        &self,
        method: &str,
        url: &str,
        content_type: Option<&str>,
        payload: &str,
        extra_headers: &[(&str, String)],
        allow_plaintext_local: bool,
    ) -> Result<(u16, Value), i32> {
        stripe_request_json(
            method,
            url,
            content_type,
            payload,
            extra_headers,
            allow_plaintext_local,
        )
    }
}

fn payment_provider_config_source<'a>(
    app_root: &'a Path,
    runtime_conf_path: Option<&'a Path>,
) -> RuntimePaymentProviderConfigSource<'a> {
    RuntimePaymentProviderConfigSource {
        app_root,
        runtime_conf_path,
    }
}

/// Verifies provider input before passing its scoped mutation to the database interface.
pub fn database_checkout_webhook_complete(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    store: &super::database::LogicalAppStore,
    provider: &str,
    headers: &str,
    body: &[u8],
) -> Result<(), i32> {
    let environment = payment_provider_config_source(app_root, runtime_conf_path);
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_err(|_| 503)?
        .as_secs();
    let Some((kind, references)) =
        pharos_runtime_payment::verified_checkout_event(&environment, headers, body, now)?
    else {
        return Ok(());
    };
    let checkout = pharos_runtime_payment::checkout_manifest_config(app_root).ok_or(404)?;
    let checkout_kind =
        pharos_runtime_payment::checkout_manifest_string(&checkout, "kind", "commerce_cart");
    pharos_runtime_payment::database::apply_checkout_event(
        store.adapter.as_ref(),
        &store.config,
        &store.schema,
        pharos_runtime_payment::database::CheckoutEvent {
            kind,
            checkout_kind: &checkout_kind,
            provider,
            references: &references,
        },
    )
    .map_err(|error| match error {
        pharos_runtime_database::operations::DatabaseError::InvalidInput => 422,
        pharos_runtime_database::operations::DatabaseError::MissingRecord => 404,
        pharos_runtime_database::operations::DatabaseError::Conflict => 409,
        _ => 503,
    })
}

/// Runs provider checkout through the configured operation interface.
pub fn database_checkout(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    store: &super::database::LogicalAppStore,
    completion_adapter: &dyn pharos_runtime_database::operations::DatabaseOperations,
    provider: &str,
    request: PaymentProviderCheckoutRequest,
) -> Result<PaymentProviderCheckoutStart, i32> {
    let checkout = pharos_runtime_payment::checkout_manifest_config(app_root).ok_or(404)?;
    let kind = pharos_runtime_payment::checkout_manifest_string(&checkout, "kind", "commerce_cart");
    let environment = payment_provider_config_source(app_root, runtime_conf_path);
    let database = pharos_runtime_payment::database::CheckoutDatabase {
        adapter: store.adapter.as_ref(),
        completion_adapter,
        config: &store.config,
        schema: &store.schema,
    };
    match kind.as_str() {
        "commerce_cart" => pharos_runtime_payment::database::runtime_commerce_checkout(
            database,
            app_root,
            &environment,
            provider,
            request,
        ),
        "appointment_booking" => pharos_runtime_payment::database::runtime_appointment_checkout(
            database,
            app_root,
            &environment,
            provider,
            request,
        ),
        _ => Err(422),
    }
}

pub type ConnectionState = pharos_runtime_payment::PaymentProviderConnectionState;

pub type PaymentProviderOperation = pharos_runtime_payment::PaymentProviderOperation;
pub type PaymentProviderCheckoutOutcome = pharos_runtime_payment::PaymentProviderCheckoutOutcome;
pub type PaymentProviderCheckoutStart = pharos_runtime_payment::PaymentProviderCheckoutStart;
pub type PaymentProviderCheckoutRequest = pharos_runtime_payment::PaymentProviderCheckoutRequest;
pub type PaymentProviderRouteBinding = pharos_runtime_payment::PaymentProviderRouteBinding;
pub type PaymentProviderCredentialField = pharos_runtime_payment::PaymentProviderCredentialField;
pub type PaymentProviderResolvedCredentials =
    pharos_runtime_payment::PaymentProviderResolvedCredentials;
pub type PaymentProviderCredentialSubmission =
    pharos_runtime_payment::PaymentProviderCredentialSubmission;
pub use pharos_runtime_payment::{
    ManifestOwnerResolver, PaymentProviderAccountMutation, PaymentProviderAccountStore,
    PaymentProviderAccountUpdate, PaymentProviderAdapter, PaymentProviderAdapterRegistry,
    PaymentProviderAuditEvent, PaymentProviderCallbackNonce, PaymentProviderLifecycleService,
    PaymentProviderOwner, PaymentProviderOwnerResolver, actor_owns_declared_payment_provider_route,
    payment_provider_account_row, payment_provider_account_row_mut,
    payment_provider_default_owner_route_value, payment_provider_owner_from_route,
    payment_provider_owner_payload, payment_provider_owner_route_value, payment_provider_row_str,
    resolve_manifest_owner,
};

pub fn declared_operation(
    management: &Value,
    action_id: &str,
) -> Option<(String, PaymentProviderOperation)> {
    pharos_runtime_payment::declared_operation(management, action_id)
}

pub fn declared_route_binding(
    management: &Value,
    action_id: &str,
) -> Option<PaymentProviderRouteBinding> {
    pharos_runtime_payment::declared_route_binding(management, action_id)
}

#[cfg(test)]
type PaymentProviderConnectionState = ConnectionState;
#[cfg(test)]
fn payment_provider_manifest_config(app_root: &Path) -> Option<Value> {
    pharos_runtime_payment::payment_provider_manifest_config(app_root)
}

pub fn payment_provider_copy_value(app_root: &Path, key: &str) -> Option<String> {
    pharos_runtime_payment::payment_provider_copy_value(app_root, key)
}

pub fn payment_provider_copy_entries(app_root: &Path) -> Option<Map<String, Value>> {
    pharos_runtime_payment::payment_provider_copy_entries(app_root)
}

pub fn payment_provider_template_params(
    root: &Value,
    app_root: &Path,
    owner_route_value: &str,
    provider: &str,
) -> serde_json::Map<String, Value> {
    pharos_runtime_payment::payment_provider_template_params(
        root,
        app_root,
        owner_route_value,
        provider,
    )
}

pub fn payment_provider_render_params(
    root: &Value,
    app_root: &Path,
    request_path: &str,
) -> serde_json::Map<String, Value> {
    pharos_runtime_payment::payment_provider_render_params(root, app_root, request_path)
}

pub fn payment_provider_declared_credential_fields(
    app_root: &Path,
    provider: &str,
) -> Vec<PaymentProviderCredentialField> {
    pharos_runtime_payment::payment_provider_declared_credential_fields(app_root, provider)
}

pub fn payment_provider_return_path(app_root: &Path, owner_route_value: &str) -> Option<String> {
    pharos_runtime_payment::payment_provider_return_path(app_root, owner_route_value)
}

pub fn payment_provider_setup_path(
    app_root: &Path,
    owner_route_value: &str,
    provider: &str,
) -> Option<String> {
    pharos_runtime_payment::payment_provider_setup_path(app_root, owner_route_value, provider)
}

pub type PaymentProviderLifecycleAction = pharos_runtime_payment::PaymentProviderLifecycleAction;
pub type PaymentProviderConnectRequest<'a> =
    pharos_runtime_payment::PaymentProviderConnectRequest<'a>;

pub fn payment_provider_callback_action_declared(app_root: &Path, action_id: &str) -> bool {
    pharos_runtime_payment::payment_provider_callback_action_declared(app_root, action_id)
}

pub fn payment_provider_lifecycle_action_declared(
    app_root: &Path,
    action_id: &str,
) -> Option<(String, PaymentProviderLifecycleAction)> {
    pharos_runtime_payment::payment_provider_lifecycle_action_declared(app_root, action_id)
}

pub fn payment_provider_checkout_action_declared(
    app_root: &Path,
    action_id: &str,
) -> Option<String> {
    pharos_runtime_payment::payment_provider_checkout_action_declared(app_root, action_id)
}

pub fn payment_provider_checkout_webhook_action_declared(
    app_root: &Path,
    action_id: &str,
) -> Option<String> {
    pharos_runtime_payment::payment_provider_checkout_webhook_action_declared(app_root, action_id)
}

pub fn persist_payment_provider_state_or_500(root: &Value, state_path: &Path) -> Result<(), i32> {
    pharos_runtime_payment::persist_payment_provider_state_or_500(root, state_path)
}

fn payment_provider_config_value(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    key: &str,
) -> Option<String> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_config_value(&source, key)
}

fn payment_provider_secret_env_value(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    config_key: &str,
) -> Option<String> {
    let env_key = payment_provider_config_value(app_root, runtime_conf_path, config_key)?;
    env::var(env_key).ok().filter(|value| !value.is_empty())
}

fn payment_provider_active_secret_key_version(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
) -> Option<String> {
    let version = payment_provider_config_value(
        app_root,
        runtime_conf_path,
        "payment_provider_secret_key_version",
    )
    .unwrap_or_else(|| "v1".to_owned());
    (version.len() <= 32
        && version
            .bytes()
            .all(|byte| byte.is_ascii_alphanumeric() || byte == b'_'))
    .then_some(version)
}

fn payment_provider_encryption_key_for_version(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    key_version: &str,
) -> Option<[u8; 32]> {
    let active_version = payment_provider_active_secret_key_version(app_root, runtime_conf_path)?;
    let config_key = if key_version == active_version {
        "payment_provider_secret_key_env"
    } else if payment_provider_config_value(
        app_root,
        runtime_conf_path,
        "payment_provider_secret_previous_key_version",
    )
    .as_deref()
        == Some(key_version)
    {
        "payment_provider_secret_previous_key_env"
    } else {
        return None;
    };
    let env_key = payment_provider_config_value(app_root, runtime_conf_path, config_key)?;
    #[cfg(test)]
    if env_key == "__pharos_test_payment_provider_secret_key__" {
        return Some([
            0x9f, 0x5b, 0xe7, 0xf6, 0x65, 0xc2, 0xb5, 0xe3, 0x41, 0xdf, 0xf8, 0xf2, 0x99, 0xb3,
            0xd2, 0xf1, 0xf3, 0x44, 0x9a, 0x90, 0xe4, 0x06, 0x66, 0x35, 0x0e, 0x72, 0x7b, 0x90,
            0x54, 0x15, 0x8a, 0x62,
        ]);
    }
    #[cfg(test)]
    if env_key == "__pharos_test_payment_provider_secret_key_v2__" {
        return Some([
            0x76, 0x1c, 0xbf, 0x2d, 0x93, 0xa8, 0x45, 0xf1, 0x57, 0x0e, 0xc4, 0x2b, 0xd9, 0x68,
            0x31, 0x6a, 0x04, 0xbe, 0x87, 0xf5, 0x25, 0x73, 0xca, 0x18, 0xed, 0x52, 0x9b, 0x3a,
            0x7c, 0xe1, 0x60, 0x94,
        ]);
    }
    pharos_runtime_payment::hex_decode_fixed::<32>(&env::var(env_key).ok()?)
}

pub fn upsert_payment_provider_secret(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    app_id: &str,
    tenant_id: i64,
    owner_resource_type: &str,
    owner_resource_id: i64,
    provider: &str,
    secret_kind: &str,
    plaintext: &str,
) -> Result<i64, i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::upsert_payment_provider_secret(
        root,
        &source,
        app_id,
        tenant_id,
        owner_resource_type,
        owner_resource_id,
        provider,
        secret_kind,
        plaintext,
    )
}

pub fn read_payment_provider_secret(
    root: &Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    app_id: &str,
    tenant_id: i64,
    owner_resource_type: &str,
    owner_resource_id: i64,
    provider: &str,
    secret_kind: &str,
) -> Result<String, i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::read_payment_provider_secret(
        root,
        &source,
        app_id,
        tenant_id,
        owner_resource_type,
        owner_resource_id,
        provider,
        secret_kind,
    )
}

pub fn rotate_payment_provider_secret(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    app_id: &str,
    tenant_id: i64,
    owner_resource_type: &str,
    owner_resource_id: i64,
    provider: &str,
    secret_kind: &str,
) -> Result<i64, i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::rotate_payment_provider_secret(
        root,
        &source,
        app_id,
        tenant_id,
        owner_resource_type,
        owner_resource_id,
        provider,
        secret_kind,
    )
}

pub fn revoke_payment_provider_secret(
    root: &mut Value,
    app_id: &str,
    tenant_id: i64,
    owner_resource_type: &str,
    owner_resource_id: i64,
    provider: &str,
    secret_kind: &str,
) -> Result<(), i32> {
    pharos_runtime_payment::revoke_payment_provider_secret(
        root,
        app_id,
        tenant_id,
        owner_resource_type,
        owner_resource_id,
        provider,
        secret_kind,
    )
}

fn stripe_request_json(
    method: &str,
    url: &str,
    content_type: Option<&str>,
    payload: &str,
    extra_headers: &[(&str, String)],
    allow_plaintext_local: bool,
) -> Result<(u16, Value), i32> {
    #[cfg(test)]
    if let Some(response) = stripe_test_take_response() {
        return response;
    }
    pharos_runtime_payment::stripe_request_json(
        method,
        url,
        content_type,
        payload,
        extra_headers,
        allow_plaintext_local,
    )
}

#[cfg(test)]
thread_local! {
    static STRIPE_TEST_RESPONSES: RefCell<VecDeque<Result<(u16, Value), i32>>> = const { RefCell::new(VecDeque::new()) };
}

#[cfg(test)]
fn stripe_test_take_response() -> Option<Result<(u16, Value), i32>> {
    STRIPE_TEST_RESPONSES.with(|responses| responses.borrow_mut().pop_front())
}

#[cfg(test)]
fn stripe_test_set_responses(responses: Vec<Result<(u16, Value), i32>>) {
    STRIPE_TEST_RESPONSES.with(|queue| {
        *queue.borrow_mut() = responses.into();
    });
}

#[cfg(test)]
fn stripe_endpoint_url(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    config_key: &str,
    default_url: &str,
) -> Result<(String, bool), (String, String, i32)> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::stripe_endpoint_url(&source, config_key, default_url)
}

#[cfg(test)]
fn stripe_account_status(
    account: &Value,
) -> (
    &'static str,
    &'static str,
    bool,
    bool,
    bool,
    Option<String>,
    Option<String>,
) {
    let status = pharos_runtime_payment::stripe_account_status(account);
    (
        status.connection_state,
        status.onboarding_state,
        status.charges_enabled,
        status.payouts_enabled,
        status.details_submitted,
        status.reason_code,
        status.reason_detail,
    )
}

#[cfg(test)]
fn payment_provider_state_token(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    app_id: &str,
    tenant_id: i64,
    owner_resource_id: i64,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
    revision: i64,
    nonce: &str,
    expires_at: &str,
) -> Option<String> {
    let secret = payment_provider_secret_env_value(
        app_root,
        runtime_conf_path,
        "payment_provider_state_key_env",
    )?;
    pharos_runtime_payment::payment_provider_state_token(
        &secret,
        app_id,
        tenant_id,
        owner_resource_id,
        owner_route_value,
        provider,
        actor_user_id,
        revision,
        nonce,
        expires_at,
    )
}

#[cfg(test)]
fn verify_payment_provider_state_token(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    presented_state: &str,
) -> Option<pharos_runtime_payment::VerifiedPaymentProviderStateToken> {
    let secret = payment_provider_secret_env_value(
        app_root,
        runtime_conf_path,
        "payment_provider_state_key_env",
    )?;
    pharos_runtime_payment::verify_payment_provider_state_token(
        &secret,
        presented_state,
        &pharos_runtime_core::time::current_timestamp_utc(),
    )
}

pub fn payment_provider_connect_start(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
) -> Result<String, i32> {
    payment_provider_connect_start_with_request(
        root,
        app_root,
        runtime_conf_path,
        owner_route_value,
        provider,
        actor_user_id,
        PaymentProviderConnectRequest::default(),
    )
}

/// Starts provider onboarding from a generic app-submitted connection request.
pub fn payment_provider_connect_start_with_request(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
    request: PaymentProviderConnectRequest<'_>,
) -> Result<String, i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_runtime_connect_start_with_request(
        root,
        app_root,
        &source,
        owner_route_value,
        provider,
        actor_user_id,
        request,
    )
}

pub fn payment_provider_callback_complete(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    owner_route_value: &str,
    provider: &str,
    presented_state: &str,
    authorization_code: &str,
    current_actor_user_id: i64,
) -> Result<(), i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_runtime_callback_complete(
        root,
        app_root,
        &source,
        owner_route_value,
        provider,
        presented_state,
        authorization_code,
        current_actor_user_id,
    )
}

pub fn payment_provider_refresh(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
) -> Result<(), i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_runtime_refresh(
        root,
        app_root,
        &source,
        owner_route_value,
        provider,
        actor_user_id,
    )
}

pub fn payment_provider_disconnect(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
) -> Result<(), i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_runtime_disconnect(
        root,
        app_root,
        &source,
        owner_route_value,
        provider,
        actor_user_id,
    )
}

pub fn payment_provider_configure_credentials(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
    submission: PaymentProviderCredentialSubmission,
) -> Result<(), i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_runtime_configure_credentials(
        root,
        app_root,
        &source,
        owner_route_value,
        provider,
        actor_user_id,
        submission,
    )
}
/// Tests the currently resolved provider credentials without starting hosted onboarding.
pub fn payment_provider_test_connection(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
    request: PaymentProviderConnectRequest<'_>,
) -> Result<(), (String, String, i32)> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_runtime_test_connection(
        root,
        app_root,
        &source,
        owner_route_value,
        provider,
        actor_user_id,
        request,
    )
}
pub fn payment_provider_revoke_credentials(
    root: &mut Value,
    app_root: &Path,
    _runtime_conf_path: Option<&Path>,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
) -> Result<(), i32> {
    pharos_runtime_payment::payment_provider_revoke_credentials(
        root,
        app_root,
        owner_route_value,
        provider,
        actor_user_id,
    )
}
pub fn payment_provider_set_checkout_mode(
    root: &mut Value,
    app_root: &Path,
    owner_route_value: &str,
    provider: &str,
    actor_user_id: i64,
    checkout_mode: &str,
) -> Result<(), i32> {
    pharos_runtime_payment::payment_provider_set_checkout_mode(
        root,
        app_root,
        owner_route_value,
        provider,
        actor_user_id,
        checkout_mode,
    )
}
pub fn payment_provider_checkout_start(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    provider: &str,
    request: PaymentProviderCheckoutRequest,
) -> Result<PaymentProviderCheckoutStart, i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_runtime_checkout_start(
        root, app_root, &source, provider, request,
    )
}

#[cfg(test)]
fn payment_provider_app_scoped_url(
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    path: &str,
) -> Option<String> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    pharos_runtime_payment::payment_provider_app_scoped_url(app_root, &source, path)
}

pub fn payment_provider_checkout_webhook_complete(
    root: &mut Value,
    app_root: &Path,
    runtime_conf_path: Option<&Path>,
    provider: &str,
    headers: &str,
    body: &[u8],
) -> Result<(), i32> {
    let source = payment_provider_config_source(app_root, runtime_conf_path);
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|value| value.as_secs())
        .unwrap_or_default();
    pharos_runtime_payment::payment_provider_runtime_checkout_webhook_complete(
        root, app_root, &source, provider, headers, body, now,
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::runtime::json_commands;
    use std::path::PathBuf;
    use std::time::{SystemTime, UNIX_EPOCH};

    fn temp_app_root(name: &str) -> PathBuf {
        let nanos = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_nanos();
        let dir = std::env::temp_dir().join(format!("pharos-{name}-{nanos}"));
        fs::create_dir_all(&dir).expect("create temp app root");
        dir
    }

    fn write_payment_provider_fixture_app(app_root: &Path) -> PathBuf {
        fs::write(
            app_root.join("pharos.app.yml"),
            r#"app_id: commerce_test
runtime:
  base_path: /commerce-test
payments:
  provider_management:
    owner_resource_type: merchant
    owner_state_section: merchants
    owner_route_field: slug
    owner_id_field: id
    owner_user_id_field: owner_id
    tenant_state_section: tenants
    tenant_owner_id_field: source_merchant_id
    tenant_id_field: id
    tenant_owner_user_id_field: owner_user_id
    membership_state_section: memberships
    membership_user_id_field: user_id
    membership_tenant_id_field: tenant_id
    membership_status_field: membership_status
    owner_path_prefix: /merchants/
    owner_route_param: merchant_slug
    settings_return_path: /merchants/:merchant_slug/
    supported_providers:
      - provider: stripe
        connect_action_id: payment_provider_connect_stripe
        callback_action_id: payment_provider_callback_stripe
        test_action_id: payment_provider_test_stripe
        refresh_action_id: payment_provider_refresh_stripe
        disconnect_action_id: payment_provider_disconnect_stripe
        credentials_action_id: payment_provider_credentials_stripe
        credentials_delete_action_id: payment_provider_credentials_delete_stripe
        checkout_mode_action_id: payment_provider_mode_stripe
        credential_fields:
          - name: stripe_client_id
            secret_kind: client_id
            required: true
          - name: stripe_client_secret
            secret_kind: client_secret
            required: true
  provider_checkout:
    action_id: complete_purchase
    provider: stripe
    reference_prefix: ORDER
    owner_route_value: acme-audio
    success_path: /checkout/success/
    cancel_path: /checkout/cancel/
    webhook_action_id: payment_provider_webhook_stripe
"#,
        )
        .expect("write manifest");
        fs::create_dir_all(app_root.join("data/contracts"))
            .expect("create route contract directory");
        fs::write(
            app_root.join("data/contracts/routes.yml"),
            r#"routes:
  - action_id: payment_provider_callback_stripe
    path: /merchants/:merchant_slug/payment-providers/stripe/callback/
"#,
        )
        .expect("write route contract");
        let conf_path = app_root.join("app.conf");
        fs::write(
            &conf_path,
            "base_url=http://127.0.0.1:8084/commerce-test\npayment_providers=stripe\nstripe_client_id=ca_test_123\nstripe_client_secret_env=PATH\nstripe_webhook_secret_env=PATH\npayment_provider_state_key_env=PATH\npayment_provider_secret_key_env=__pharos_test_payment_provider_secret_key__\n",
        )
        .expect("write config");
        conf_path
    }

    fn write_payment_provider_appointment_fixture_app(app_root: &Path) -> PathBuf {
        fs::write(
            app_root.join("pharos.app.yml"),
            r#"app_id: ucal_test
runtime:
  base_path: /ucal
payments:
  provider_management:
    owner_resource_type: business
    owner_state_section: businesses
    owner_route_field: slug
    owner_id_field: id
    owner_user_id_field: owner_id
    tenant_state_section: tenants
    tenant_owner_id_field: source_business_id
    tenant_id_field: id
    tenant_owner_user_id_field: owner_user_id
    owner_path_prefix: /businesses/
    owner_route_param: business_slug
    settings_return_path: /businesses/:business_slug/
    supported_providers:
      - provider: stripe
        connect_action_id: payment_provider_connect_stripe
        callback_action_id: payment_provider_callback_stripe
        refresh_action_id: payment_provider_refresh_stripe
        disconnect_action_id: payment_provider_disconnect_stripe
        credentials_action_id: payment_provider_credentials_stripe
        credentials_delete_action_id: payment_provider_credentials_delete_stripe
        checkout_mode_action_id: payment_provider_mode_stripe
        credential_fields:
          - name: stripe_client_id
            secret_kind: client_id
            required: true
          - name: stripe_client_secret
            secret_kind: client_secret
            required: true
  provider_checkout:
    kind: appointment_booking
    action_id: create_appointment
    provider: stripe
    reference_prefix: APPT
    success_path: /appointments/
    cancel_path: /explore/
    webhook_action_id: payment_provider_checkout_webhook_stripe
"#,
        )
        .expect("write appointment manifest");
        fs::create_dir_all(app_root.join("data/contracts"))
            .expect("create route contract directory");
        fs::write(
            app_root.join("data/contracts/routes.yml"),
            r#"routes:
  - action_id: payment_provider_callback_stripe
    path: /businesses/:business_slug/payment-providers/stripe/callback/
"#,
        )
        .expect("write appointment routes");
        let conf_path = app_root.join("app.conf");
        fs::write(
            &conf_path,
            "base_url=http://127.0.0.1:8084/ucal\npayment_providers=stripe\nstripe_client_id=ca_test_123\nstripe_client_secret_env=PATH\nstripe_webhook_secret_env=PATH\npayment_provider_state_key_env=PATH\npayment_provider_secret_key_env=__pharos_test_payment_provider_secret_key__\n",
        )
        .expect("write appointment config");
        conf_path
    }

    #[test]
    fn payment_provider_copy_value_loads_manifest_declared_provider_file() {
        let app_root = temp_app_root("payment-provider-file");
        fs::create_dir_all(app_root.join("data")).expect("create data dir");
        fs::write(
            app_root.join("pharos.app.yml"),
            r#"app_id: commerce_test
payments:
  provider_src: data/payment_provider.yml
"#,
        )
        .expect("write manifest");
        fs::write(
            app_root.join("data/payment_provider.yml"),
            r#"owner_resource_type: merchant
supported_providers:
  - provider: stripe
copy:
  owner_payment_provider_setup_headline: Provider file headline
"#,
        )
        .expect("write provider file");

        let headline =
            payment_provider_copy_value(&app_root, "owner_payment_provider_setup_headline")
                .expect("load provider copy file value");
        assert_eq!(headline, "Provider file headline");
        fs::remove_dir_all(app_root).ok();
    }

    #[test]
    fn payment_provider_config_loads_manifest_declared_provider_file() {
        let app_root = temp_app_root("payment-provider-config-file");
        fs::create_dir_all(app_root.join("data")).expect("create data dir");
        fs::write(
            app_root.join("pharos.app.yml"),
            r#"app_id: commerce_test
payments:
  provider_src: data/payment_provider.yml
"#,
        )
        .expect("write manifest");
        fs::write(
            app_root.join("data/payment_provider.yml"),
            r#"owner_resource_type: merchant
supported_providers:
  - provider: stripe
copy:
  owner_payment_provider_setup_headline: Provider file headline
"#,
        )
        .expect("write provider file");

        let config = payment_provider_manifest_config(&app_root).expect("load provider config");
        assert_eq!(
            config.get("owner_resource_type").and_then(Value::as_str),
            Some("merchant")
        );
        assert!(config.get("supported_providers").is_some());
        fs::remove_dir_all(app_root).ok();
    }

    #[test]
    fn payment_provider_app_scoped_url_does_not_duplicate_base_path() {
        let app_root = temp_app_root("payment-provider-scoped-url");
        let conf_path = write_payment_provider_appointment_fixture_app(&app_root);

        assert_eq!(
            payment_provider_app_scoped_url(&app_root, Some(&conf_path), "/appointments/"),
            Some("http://127.0.0.1:8084/ucal/appointments/".to_owned())
        );
        assert_eq!(
            payment_provider_app_scoped_url(&app_root, Some(&conf_path), "/ucal/appointments/"),
            Some("http://127.0.0.1:8084/ucal/appointments/".to_owned())
        );

        fs::remove_dir_all(app_root).ok();
    }

    #[test]
    fn payment_provider_live_checkout_params_remove_demo_copy_and_decline_action() {
        let app_root = temp_app_root("payment-provider-live-checkout-copy");
        write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        seed_connected_payment_provider_account(&mut root);
        if let Some(row) =
            payment_provider_account_row_mut(&mut root, "commerce_test", "merchant", 7, "stripe")
            && let Some(object) = row.as_object_mut()
        {
            object.insert("checkout_mode".to_owned(), Value::String("live".to_owned()));
        }
        root.as_object_mut().expect("state object").insert(
            "payment_provider_secrets".to_owned(),
            serde_json::json!([
                {
                    "app_id": "commerce_test",
                    "tenant_id": 91,
                    "owner_resource_type": "merchant",
                    "owner_resource_id": 7,
                    "provider_id": "stripe",
                    "secret_kind": "client_id",
                    "ciphertext": "encrypted-client-id",
                    "revoked_at": ""
                },
                {
                    "app_id": "commerce_test",
                    "tenant_id": 91,
                    "owner_resource_type": "merchant",
                    "owner_resource_id": 7,
                    "provider_id": "stripe",
                    "secret_kind": "client_secret",
                    "ciphertext": "encrypted-client-secret",
                    "revoked_at": ""
                }
            ]),
        );

        let params = payment_provider_template_params(&root, &app_root, "acme-audio", "stripe");

        assert_eq!(
            params
                .get("payment_checkout_mode_value")
                .and_then(Value::as_str),
            Some("live")
        );
        assert_eq!(
            params
                .get("payment_checkout_notice_class")
                .and_then(Value::as_str),
            Some("checkout-notice-hidden")
        );
        assert_eq!(
            params
                .get("payment_checkout_decline_class")
                .and_then(Value::as_str),
            Some("checkout-action-hidden")
        );
        assert_eq!(
            params
                .get("checkout_primary_action")
                .and_then(Value::as_str),
            Some("Purchase")
        );
        assert_eq!(
            params.get("checkout_notice_title").and_then(Value::as_str),
            Some("")
        );
        assert_eq!(
            params.get("checkout_notice_body").and_then(Value::as_str),
            Some("")
        );
        fs::remove_dir_all(app_root).expect("remove payment provider live checkout copy root");
    }

    #[test]
    fn payment_provider_live_checkout_params_require_saved_credentials() {
        let app_root = temp_app_root("payment-provider-live-checkout-requires-credentials");
        write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        seed_connected_payment_provider_account(&mut root);
        if let Some(row) =
            payment_provider_account_row_mut(&mut root, "commerce_test", "merchant", 7, "stripe")
            && let Some(object) = row.as_object_mut()
        {
            object.insert("checkout_mode".to_owned(), Value::String("live".to_owned()));
        }

        let params = payment_provider_template_params(&root, &app_root, "acme-audio", "stripe");

        assert_eq!(
            params
                .get("payment_checkout_mode_value")
                .and_then(Value::as_str),
            Some("demo")
        );
        assert_eq!(
            params
                .get("payment_checkout_notice_class")
                .and_then(Value::as_str),
            Some("demo-notice")
        );
        assert_eq!(
            params
                .get("payment_checkout_decline_class")
                .and_then(Value::as_str),
            Some("")
        );
        assert_eq!(
            params
                .get("payment_provider_credentials_state")
                .and_then(Value::as_str),
            Some("not_saved")
        );
        fs::remove_dir_all(app_root)
            .expect("remove payment provider live checkout requires credentials root");
    }

    #[test]
    fn payment_provider_declares_generic_test_credentials_operation() {
        let manifest = serde_json::json!({
            "supported_providers": [
                {
                    "provider": "stripe",
                    "connect_action_id": "payment_provider_connect_stripe",
                    "test_action_id": "payment_provider_test_stripe"
                }
            ]
        });

        assert_eq!(
            declared_operation(&manifest, "payment_provider_test_stripe"),
            Some((
                "stripe".to_owned(),
                PaymentProviderOperation::TestCredentials
            ))
        );
        assert_eq!(
            declared_operation(&manifest, "payment_provider_connect_stripe"),
            Some(("stripe".to_owned(), PaymentProviderOperation::Connect))
        );
    }

    #[test]
    fn payment_provider_copy_value_loads_compiled_json_provider_file_for_yaml_manifest_reference() {
        let app_root = temp_app_root("payment-provider-json-fallback");
        fs::create_dir_all(app_root.join("data")).expect("create data dir");
        fs::write(
            app_root.join("pharos.app.json"),
            r#"{"app_id":"commerce_test","payments":{"provider_src":"data/payment_provider.yml"}}"#,
        )
        .expect("write manifest");
        fs::write(
            app_root.join("data/payment_provider.json"),
            r#"{"owner_resource_type":"merchant","supported_providers":[{"provider":"stripe"}],"copy":{"owner_payment_provider_setup_headline":"Compiled provider file headline"}}"#,
        )
        .expect("write provider file");

        let headline =
            payment_provider_copy_value(&app_root, "owner_payment_provider_setup_headline")
                .expect("load compiled provider copy file value");
        assert_eq!(headline, "Compiled provider file headline");
        fs::remove_dir_all(app_root).ok();
    }

    fn seed_payment_provider_root() -> Value {
        serde_json::json!({
                "merchants": [
                    {"id": 7, "slug": "acme-audio", "owner_id": 11, "name": "Acme Audio"}
                ],
                "tenants": [
                    {"id": 91, "source_merchant_id": 7, "owner_user_id": 11}
                ],
                "memberships": [
                    {"user_id": 12, "tenant_id": 91, "membership_status": "active"}
                ],
            "payment_provider_accounts": [],
            "payment_provider_secrets": [],
            "payment_provider_audit_events": [],
            "payment_provider_callback_nonces": []
        })
    }

    fn seed_payment_provider_checkout_cart(root: &mut Value) {
        root.as_object_mut().expect("state object").insert(
            "shopping_carts".to_owned(),
            serde_json::json!([
                {"id": 31, "user_id": 12, "currency": "USD"}
            ]),
        );
        root.as_object_mut().expect("state object").insert(
            "shopping_cart_items".to_owned(),
            serde_json::json!([
                {
                    "id": 41,
                    "cart_id": 31,
                    "user_id": 12,
                    "product_id": 3,
                    "product_slug": "tape-drum-loops",
                    "product_title": "Tape Drum Loops",
                    "price_minor": 2900,
                    "price_display": "$29",
                    "currency": "USD",
                    "download_asset_key": "tape-drum-loops.zip"
                }
            ]),
        );
        root.as_object_mut()
            .expect("state object")
            .insert("commerce_orders".to_owned(), Value::Array(Vec::new()));
        root.as_object_mut()
            .expect("state object")
            .insert("commerce_order_items".to_owned(), Value::Array(Vec::new()));
        root.as_object_mut()
            .expect("state object")
            .insert("download_entitlements".to_owned(), Value::Array(Vec::new()));
        root.as_object_mut().expect("state object").insert(
            "inventory_reservations".to_owned(),
            serde_json::json!([
                {
                    "id": 51,
                    "cart_id": 31,
                    "user_id": 12,
                    "product_id": 3,
                    "reservation_status": "reserved",
                    "reserved_at": "2026-09-10T00:00:00Z",
                    "confirmed_at": null,
                    "released_at": null,
                    "release_reason": ""
                }
            ]),
        );
    }

    fn stripe_test_signature_header(payload: &str) -> String {
        let secret = std::env::var("PATH").expect("PATH is available as test secret");
        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs()
            .to_string();
        let message = format!("{timestamp}.{payload}");
        let digest = crate::runtime::dynamic::hex_digest(&crate::runtime::dynamic::hmac_sha256(
            secret.as_bytes(),
            message.as_bytes(),
        ));
        format!("Stripe-Signature: t={timestamp},v1={digest}")
    }

    #[test]
    fn provider_checkout_redirects_to_stripe_and_unlocks_only_after_signed_webhook() {
        let app_root = temp_app_root("payment-provider-checkout");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        seed_payment_provider_checkout_cart(&mut root);
        payment_provider_configure_credentials(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
            PaymentProviderCredentialSubmission {
                fields: vec![
                    ("stripe_client_id".to_owned(), "acct_owner_123".to_owned()),
                    (
                        "stripe_client_secret".to_owned(),
                        "sk_test_owner_secret".to_owned(),
                    ),
                ],
            },
        )
        .expect("configure checkout credentials");
        stripe_test_set_responses(vec![Ok((
            200,
            serde_json::json!({
                "id": "approved",
                "url": "https://checkout.stripe.test/session/approved"
            }),
        ))]);
        let checkout = payment_provider_checkout_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            PaymentProviderCheckoutRequest {
                actor_user_id: 12,
                idempotency_key: "checkout-idempotency-001".to_owned(),
                request_target: "/checkout".to_owned(),
                form_fields: BTreeMap::new(),
            },
        )
        .expect("start live checkout");
        assert_eq!(checkout.outcome, PaymentProviderCheckoutOutcome::Redirect);
        assert_eq!(
            checkout.redirect_location.as_deref(),
            Some("https://checkout.stripe.test/session/approved")
        );
        assert_eq!(root["commerce_orders"][0]["payment_mode"], "live");
        assert_eq!(root["commerce_orders"][0]["provider_id"], "stripe");
        assert_eq!(
            root["commerce_orders"][0]["provider_order_reference"],
            "approved"
        );
        assert!(
            root["commerce_orders"][0]["provider_client_reference"]
                .as_str()
                .is_some_and(|value| value.starts_with("ORDER-") && value.ends_with("-1"))
        );
        assert_eq!(root["commerce_orders"][0]["status"], "payment_pending");
        assert_eq!(
            root["download_entitlements"]
                .as_array()
                .expect("entitlements array")
                .len(),
            0
        );

        let payload = r#"{"type":"checkout.session.completed","data":{"object":{"id":"approved","status":"complete","payment_status":"paid"}}}"#;
        let headers = stripe_test_signature_header(payload);
        payment_provider_checkout_webhook_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            &headers,
            payload.as_bytes(),
        )
        .expect("complete checkout webhook");
        assert_eq!(root["commerce_orders"][0]["status"], "paid");
        assert_eq!(root["download_entitlements"][0]["user_id"], 12);
        assert_eq!(
            root["inventory_reservations"][0]["reservation_status"],
            "confirmed"
        );
        assert_eq!(
            root["shopping_cart_items"]
                .as_array()
                .expect("cart items")
                .len(),
            0
        );
        fs::remove_dir_all(app_root).ok();
    }

    #[test]
    fn provider_checkout_terminal_webhooks_keep_or_revoke_access_correctly() {
        let app_root = temp_app_root("payment-provider-checkout-terminal-webhooks");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        seed_payment_provider_checkout_cart(&mut root);
        payment_provider_configure_credentials(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
            PaymentProviderCredentialSubmission {
                fields: vec![
                    ("stripe_client_id".to_owned(), "acct_owner_123".to_owned()),
                    (
                        "stripe_client_secret".to_owned(),
                        "sk_test_owner_secret".to_owned(),
                    ),
                ],
            },
        )
        .expect("configure checkout credentials");
        stripe_test_set_responses(vec![Ok((
            200,
            serde_json::json!({
                "id": "cs_expired_session",
                "url": "https://checkout.stripe.test/session/cs_expired_session"
            }),
        ))]);
        payment_provider_checkout_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            PaymentProviderCheckoutRequest {
                actor_user_id: 12,
                idempotency_key: "checkout-idempotency-expired".to_owned(),
                request_target: "/checkout".to_owned(),
                form_fields: BTreeMap::new(),
            },
        )
        .expect("start expired checkout");
        let expired_payload = r#"{"type":"checkout.session.expired","data":{"object":{"id":"cs_expired_session","status":"expired","payment_status":"unpaid"}}}"#;
        let expired_headers = stripe_test_signature_header(expired_payload);
        payment_provider_checkout_webhook_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            &expired_headers,
            expired_payload.as_bytes(),
        )
        .expect("expire checkout");
        assert_eq!(root["commerce_orders"][0]["status"], "payment_expired");
        assert_eq!(
            root["download_entitlements"]
                .as_array()
                .expect("entitlements")
                .len(),
            0
        );

        let mut paid_root = seed_payment_provider_root();
        seed_payment_provider_checkout_cart(&mut paid_root);
        payment_provider_configure_credentials(
            &mut paid_root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
            PaymentProviderCredentialSubmission {
                fields: vec![
                    ("stripe_client_id".to_owned(), "acct_owner_123".to_owned()),
                    (
                        "stripe_client_secret".to_owned(),
                        "sk_test_owner_secret".to_owned(),
                    ),
                ],
            },
        )
        .expect("configure refund checkout credentials");
        stripe_test_set_responses(vec![Ok((
            200,
            serde_json::json!({
                "id": "cs_refunded_session",
                "url": "https://checkout.stripe.test/session/cs_refunded_session"
            }),
        ))]);
        payment_provider_checkout_start(
            &mut paid_root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            PaymentProviderCheckoutRequest {
                actor_user_id: 12,
                idempotency_key: "checkout-idempotency-refund".to_owned(),
                request_target: "/checkout".to_owned(),
                form_fields: BTreeMap::new(),
            },
        )
        .expect("start refundable checkout");
        let paid_payload = r#"{"type":"checkout.session.completed","data":{"object":{"id":"cs_refunded_session","status":"complete","payment_status":"paid"}}}"#;
        let paid_headers = stripe_test_signature_header(paid_payload);
        payment_provider_checkout_webhook_complete(
            &mut paid_root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            &paid_headers,
            paid_payload.as_bytes(),
        )
        .expect("pay checkout");
        assert_eq!(paid_root["commerce_orders"][0]["status"], "paid");
        assert_eq!(
            paid_root["download_entitlements"]
                .as_array()
                .expect("entitlements")
                .len(),
            1
        );
        let refund_payload = r#"{"type":"charge.refunded","data":{"object":{"id":"ch_123","metadata":{"checkout_session_id":"cs_refunded_session"}}}}"#;
        let refund_headers = stripe_test_signature_header(refund_payload);
        payment_provider_checkout_webhook_complete(
            &mut paid_root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            &refund_headers,
            refund_payload.as_bytes(),
        )
        .expect("refund checkout");
        assert_eq!(paid_root["commerce_orders"][0]["status"], "refunded");
        assert_eq!(
            paid_root["download_entitlements"]
                .as_array()
                .expect("entitlements")
                .len(),
            0
        );
        fs::remove_dir_all(app_root).ok();
    }

    #[test]
    fn provider_checkout_falls_back_to_demo_when_credentials_are_not_saved() {
        let app_root = temp_app_root("payment-provider-checkout-demo-fallback");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        seed_payment_provider_checkout_cart(&mut root);
        let checkout = payment_provider_checkout_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            PaymentProviderCheckoutRequest {
                actor_user_id: 12,
                idempotency_key: "checkout-idempotency-002".to_owned(),
                request_target: "/checkout".to_owned(),
                form_fields: BTreeMap::new(),
            },
        )
        .expect("demo fallback checkout");
        assert_eq!(
            checkout.outcome,
            PaymentProviderCheckoutOutcome::DemoFallback
        );
        assert!(
            root["commerce_orders"]
                .as_array()
                .expect("orders")
                .is_empty()
        );
        fs::remove_dir_all(app_root).ok();
    }

    #[test]
    fn provider_checkout_supports_prepaid_appointment_confirmation() {
        let app_root = temp_app_root("payment-provider-appointment-checkout");
        let conf_path = write_payment_provider_appointment_fixture_app(&app_root);
        let mut root = serde_json::json!({
            "businesses": [
                {"id": 1, "slug": "lotus-studio", "owner_id": 11, "name": "Lotus Studio"}
            ],
            "tenants": [
                {"id": 91, "source_business_id": 1, "owner_user_id": 11}
            ],
            "services": [
                {
                    "id": 4,
                    "business_id": 1,
                    "name": "Studio session",
                    "duration_minutes": 60,
                    "cost": "75",
                    "is_active": true,
                    "technician_ids": [21]
                }
            ],
            "technicians": [
                {"id": 21, "business_id": 1, "name": "Ari", "is_active": true}
            ],
            "business_availability": [
                {"id": 31, "business_id": 1, "day_of_week": "Tue", "start_time": "09:00", "end_time": "17:00", "is_active": true}
            ],
            "technician_availability": [
                {"id": 41, "technician_id": 21, "day_of_week": "Tue", "start_time": "09:00", "end_time": "17:00", "is_active": true}
            ],
            "appointments": [],
            "payment_provider_accounts": [],
            "payment_provider_secrets": [],
            "payment_provider_audit_events": [],
            "payment_provider_callback_nonces": []
        });
        payment_provider_configure_credentials(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "lotus-studio",
            "stripe",
            11,
            PaymentProviderCredentialSubmission {
                fields: vec![
                    ("stripe_client_id".to_owned(), "ca_owner_123".to_owned()),
                    (
                        "stripe_client_secret".to_owned(),
                        "sk_test_owner_secret".to_owned(),
                    ),
                ],
            },
        )
        .expect("configure appointment credentials");
        stripe_test_set_responses(vec![Ok((
            200,
            serde_json::json!({
                "id": "approved",
                "url": "https://checkout.stripe.test/session/appointment-approved"
            }),
        ))]);
        let checkout = payment_provider_checkout_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            PaymentProviderCheckoutRequest {
                actor_user_id: 12,
                idempotency_key: "appointment-idempotency-001".to_owned(),
                request_target: "/business/lotus-studio/book/4/".to_owned(),
                form_fields: BTreeMap::from_iter([
                    ("date".to_owned(), "2026-09-15".to_owned()),
                    ("time_hour".to_owned(), "2".to_owned()),
                    ("time_minute".to_owned(), "30".to_owned()),
                    ("time_period".to_owned(), "PM".to_owned()),
                    ("notes".to_owned(), "Prepaid test".to_owned()),
                ]),
            },
        )
        .expect("start appointment checkout");
        assert_eq!(checkout.outcome, PaymentProviderCheckoutOutcome::Redirect);
        assert_eq!(
            checkout.redirect_location.as_deref(),
            Some("https://checkout.stripe.test/session/appointment-approved")
        );
        assert_eq!(root["appointments"][0]["status"], "payment_pending");
        assert_eq!(root["appointments"][0]["payment_status"], "pending");
        assert_eq!(root["appointments"][0]["payment_mode"], "live");
        assert_eq!(root["appointments"][0]["provider_id"], "stripe");
        assert_eq!(
            root["appointments"][0]["provider_order_reference"],
            "approved"
        );
        assert!(
            root["appointments"][0]["provider_client_reference"]
                .as_str()
                .is_some_and(|value| value.starts_with("APPT-") && value.ends_with("-1"))
        );

        let payload = r#"{"type":"checkout.session.completed","data":{"object":{"id":"approved","status":"complete","payment_status":"paid"}}}"#;
        let headers = stripe_test_signature_header(payload);
        payment_provider_checkout_webhook_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            &headers,
            payload.as_bytes(),
        )
        .expect("complete appointment webhook");
        assert_eq!(root["appointments"][0]["status"], "confirmed");
        assert_eq!(root["appointments"][0]["payment_status"], "paid");
        fs::remove_dir_all(app_root).ok();
    }

    #[test]
    fn provider_checkout_terminal_webhooks_update_prepaid_appointments() {
        let app_root = temp_app_root("payment-provider-appointment-terminal-webhooks");
        let conf_path = write_payment_provider_appointment_fixture_app(&app_root);
        let mut root = serde_json::json!({
            "businesses": [
                {"id": 1, "slug": "lotus-studio", "owner_id": 11, "name": "Lotus Studio"}
            ],
            "tenants": [
                {"id": 91, "source_business_id": 1, "owner_user_id": 11}
            ],
            "services": [
                {
                    "id": 4,
                    "business_id": 1,
                    "name": "Studio session",
                    "duration_minutes": 60,
                    "cost": "75",
                    "is_active": true,
                    "technician_ids": [21]
                }
            ],
            "technicians": [
                {"id": 21, "business_id": 1, "name": "Ari", "is_active": true}
            ],
            "business_availability": [
                {"id": 31, "business_id": 1, "day_of_week": "Tue", "start_time": "09:00", "end_time": "17:00", "is_active": true}
            ],
            "technician_availability": [
                {"id": 41, "technician_id": 21, "day_of_week": "Tue", "start_time": "09:00", "end_time": "17:00", "is_active": true}
            ],
            "appointments": [],
            "payment_provider_accounts": [],
            "payment_provider_secrets": [],
            "payment_provider_audit_events": [],
            "payment_provider_callback_nonces": []
        });
        payment_provider_configure_credentials(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "lotus-studio",
            "stripe",
            11,
            PaymentProviderCredentialSubmission {
                fields: vec![
                    ("stripe_client_id".to_owned(), "ca_owner_123".to_owned()),
                    (
                        "stripe_client_secret".to_owned(),
                        "sk_test_owner_secret".to_owned(),
                    ),
                ],
            },
        )
        .expect("configure appointment credentials");
        stripe_test_set_responses(vec![Ok((
            200,
            serde_json::json!({
                "id": "cs_failed_appointment_session",
                "url": "https://checkout.stripe.test/session/cs_failed_appointment_session"
            }),
        ))]);
        payment_provider_checkout_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            PaymentProviderCheckoutRequest {
                actor_user_id: 12,
                idempotency_key: "appointment-idempotency-failed".to_owned(),
                request_target: "/business/lotus-studio/book/4/".to_owned(),
                form_fields: BTreeMap::from_iter([
                    ("date".to_owned(), "2026-09-15".to_owned()),
                    ("time_hour".to_owned(), "2".to_owned()),
                    ("time_minute".to_owned(), "30".to_owned()),
                    ("time_period".to_owned(), "PM".to_owned()),
                ]),
            },
        )
        .expect("start failed appointment checkout");
        let failed_payload = r#"{"type":"payment_intent.payment_failed","data":{"object":{"id":"pi_123","metadata":{"checkout_session_id":"cs_failed_appointment_session"}}}}"#;
        let failed_headers = stripe_test_signature_header(failed_payload);
        payment_provider_checkout_webhook_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            &failed_headers,
            failed_payload.as_bytes(),
        )
        .expect("fail appointment checkout");
        assert_eq!(root["appointments"][0]["status"], "payment_failed");
        assert_eq!(root["appointments"][0]["payment_status"], "failed");

        let dispute_payload = r#"{"type":"charge.dispute.created","data":{"object":{"id":"dp_123","metadata":{"checkout_session_id":"cs_failed_appointment_session"}}}}"#;
        let dispute_headers = stripe_test_signature_header(dispute_payload);
        payment_provider_checkout_webhook_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "stripe",
            &dispute_headers,
            dispute_payload.as_bytes(),
        )
        .expect("dispute appointment checkout");
        assert_eq!(root["appointments"][0]["status"], "payment_disputed");
        assert_eq!(root["appointments"][0]["payment_status"], "disputed");
        fs::remove_dir_all(app_root).ok();
    }

    #[test]
    fn payment_provider_owner_resolver_supports_non_business_owner_without_runtime_branch() {
        let manifest = serde_json::json!({
            "owner_resource_type": "organization",
            "owner_state_section": "organizations",
            "owner_route_field": "handle",
            "owner_id_field": "org_id",
            "owner_user_id_field": "admin_user_id",
            "tenant_state_section": "accounts",
            "tenant_owner_id_field": "source_org_id",
            "tenant_id_field": "account_id",
            "tenant_owner_user_id_field": "primary_user_id",
            "membership_state_section": "account_memberships",
            "membership_user_id_field": "user_id",
            "membership_tenant_id_field": "account_id",
            "membership_status_field": "status",
        });
        let root = serde_json::json!({
            "organizations": [
                {"org_id": 42, "handle": "northstar-labs", "admin_user_id": 501}
            ],
            "accounts": [
                {"account_id": 7001, "source_org_id": 42, "primary_user_id": 501}
            ],
            "account_memberships": [
                {"account_id": 7001, "user_id": 502, "status": "active"},
                {"account_id": 7001, "user_id": 503, "status": "suspended"}
            ]
        });
        let owner = resolve_manifest_owner(&manifest, &root, "northstar-labs")
            .expect("resolve non-business owner");
        assert_eq!(
            owner,
            PaymentProviderOwner {
                owner_type: "organization".to_owned(),
                owner_id: 42,
                tenant_id: 7001,
                route_value: "northstar-labs".to_owned(),
            }
        );
        let resolver = ManifestOwnerResolver::from_manifest(&manifest).expect("owner resolver");
        assert!(resolver.actor_owns(&root, &owner, 501));
        assert!(resolver.actor_owns(&root, &owner, 502));
        assert!(!resolver.actor_owns(&root, &owner, 503));
        assert!(!resolver.actor_owns(&root, &owner, 999));
    }

    #[test]
    fn payment_provider_owner_route_value_accepts_mounted_runtime_path() {
        let app_root = temp_app_root("payment-provider-mounted-path");
        write_payment_provider_fixture_app(&app_root);
        assert_eq!(
            payment_provider_owner_route_value(
                &app_root,
                "/commerce-test/merchants/acme-audio/payment-providers/stripe/connect/"
            )
            .as_deref(),
            Some("acme-audio")
        );
        assert_eq!(
            payment_provider_owner_route_value(
                &app_root,
                "/merchants/acme-audio/payment-providers/stripe/connect/"
            )
            .as_deref(),
            Some("acme-audio")
        );
        fs::remove_dir_all(app_root).expect("remove payment provider mounted-path root");
    }

    #[test]
    fn payment_provider_actor_ownership_uses_manifest_declared_fields() {
        let app_root = temp_app_root("payment-provider-actor-ownership");
        write_payment_provider_fixture_app(&app_root);
        let root = seed_payment_provider_root();
        assert_eq!(
            actor_owns_declared_payment_provider_route(
                &root,
                &app_root,
                "/commerce-test/merchants/acme-audio/payment-providers/stripe/connect/",
                11,
            ),
            Ok(true)
        );
        assert_eq!(
            actor_owns_declared_payment_provider_route(
                &root,
                &app_root,
                "/commerce-test/merchants/acme-audio/payment-providers/stripe/connect/",
                12,
            ),
            Ok(true)
        );
        assert_eq!(
            actor_owns_declared_payment_provider_route(
                &root,
                &app_root,
                "/commerce-test/merchants/acme-audio/payment-providers/stripe/connect/",
                99,
            ),
            Ok(false)
        );
        fs::remove_dir_all(app_root).expect("remove payment provider actor-ownership root");
    }

    #[test]
    fn payment_provider_stripe_endpoint_overrides_require_https_or_explicit_loopback_http() {
        let app_root = temp_app_root("payment-provider-endpoint-policy");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        fs::write(
            &conf_path,
            "base_url=http://127.0.0.1:8084/commerce-test\npayment_providers=stripe\nstripe_client_id=ca_test_123\nstripe_client_secret_env=PATH\npayment_provider_state_key_env=PATH\npayment_provider_secret_key_env=__pharos_test_payment_provider_secret_key__\nstripe_oauth_token_url=http://192.0.2.10/oauth/token\n",
        )
        .expect("write unsafe endpoint config");
        assert_eq!(
            stripe_endpoint_url(
                &app_root,
                Some(conf_path.as_path()),
                "stripe_oauth_token_url",
                "https://connect.stripe.com/oauth/token",
            )
            .expect_err("reject non-loopback http")
            .2,
            503
        );
        fs::write(
            &conf_path,
            "base_url=http://127.0.0.1:8084/commerce-test\npayment_providers=stripe\nstripe_client_id=ca_test_123\nstripe_client_secret_env=PATH\npayment_provider_state_key_env=PATH\npayment_provider_secret_key_env=__pharos_test_payment_provider_secret_key__\npayment_provider_allow_plaintext_local=true\nstripe_oauth_token_url=http://127.0.0.1:19999/oauth/token\n",
        )
        .expect("write loopback endpoint config");
        assert_eq!(
            stripe_endpoint_url(
                &app_root,
                Some(conf_path.as_path()),
                "stripe_oauth_token_url",
                "https://connect.stripe.com/oauth/token",
            )
            .expect("accept explicit loopback http"),
            ("http://127.0.0.1:19999/oauth/token".to_owned(), true)
        );
        fs::remove_dir_all(app_root).expect("remove payment provider endpoint-policy root");
    }

    #[test]
    fn payment_provider_secret_storage_encrypts_and_binds_owner_metadata() {
        let app_root = temp_app_root("payment-provider-secret");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        let secret_id = upsert_payment_provider_secret(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "commerce_test",
            91,
            "merchant",
            7,
            "stripe",
            "refresh_token",
            "rt_sensitive_value",
        )
        .expect("encrypt secret");
        let row = root["payment_provider_secrets"]
            .as_array()
            .and_then(|rows| rows.first())
            .expect("secret row");
        assert_eq!(row["id"].as_i64(), Some(secret_id));
        let ciphertext = row["ciphertext"].as_str().expect("ciphertext");
        assert!(!ciphertext.contains("rt_sensitive_value"));
        let aad = pharos_runtime_payment::payment_provider_secret_aad(
            "commerce_test",
            91,
            "merchant",
            7,
            "stripe",
            "refresh_token",
        )
        .expect("aad");
        let key =
            payment_provider_encryption_key_for_version(&app_root, Some(conf_path.as_path()), "v1")
                .expect("secret key");
        assert_eq!(
            pharos_runtime_payment::decrypt_payment_provider_secret_with_key(
                &key, &aad, ciphertext,
            )
            .as_deref(),
            Some("rt_sensitive_value")
        );
        let wrong_owner_aad = pharos_runtime_payment::payment_provider_secret_aad(
            "commerce_test",
            91,
            "merchant",
            8,
            "stripe",
            "refresh_token",
        )
        .expect("wrong owner aad");
        assert!(
            pharos_runtime_payment::decrypt_payment_provider_secret_with_key(
                &key,
                &wrong_owner_aad,
                ciphertext,
            )
            .is_none()
        );
        fs::remove_dir_all(app_root).expect("remove payment provider secret root");
    }

    #[test]
    fn payment_provider_secret_rotation_and_revocation_are_fail_closed() {
        let app_root = temp_app_root("payment-provider-secret-rotation");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        let secret_id = upsert_payment_provider_secret(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "commerce_test",
            91,
            "merchant",
            7,
            "stripe",
            "refresh_token",
            "rt_rotate_me",
        )
        .expect("write v1 secret");
        fs::write(
            &conf_path,
            "base_url=http://127.0.0.1:8084/commerce-test\npayment_providers=stripe\nstripe_client_id=ca_test_123\nstripe_client_secret_env=PATH\npayment_provider_state_key_env=PATH\npayment_provider_secret_key_version=v2\npayment_provider_secret_key_env=__pharos_test_payment_provider_secret_key_v2__\npayment_provider_secret_previous_key_version=v1\npayment_provider_secret_previous_key_env=__pharos_test_payment_provider_secret_key__\n",
        )
        .expect("write rotated config");
        assert_eq!(
            read_payment_provider_secret(
                &root,
                &app_root,
                Some(conf_path.as_path()),
                "commerce_test",
                91,
                "merchant",
                7,
                "stripe",
                "refresh_token",
            )
            .as_deref(),
            Ok("rt_rotate_me")
        );
        assert_eq!(
            rotate_payment_provider_secret(
                &mut root,
                &app_root,
                Some(conf_path.as_path()),
                "commerce_test",
                91,
                "merchant",
                7,
                "stripe",
                "refresh_token",
            ),
            Ok(secret_id)
        );
        assert_eq!(root["payment_provider_secrets"][0]["key_version"], "v2");
        revoke_payment_provider_secret(
            &mut root,
            "commerce_test",
            91,
            "merchant",
            7,
            "stripe",
            "refresh_token",
        )
        .expect("revoke secret");
        assert_eq!(root["payment_provider_secrets"][0]["ciphertext"], "");
        assert_eq!(
            read_payment_provider_secret(
                &root,
                &app_root,
                Some(conf_path.as_path()),
                "commerce_test",
                91,
                "merchant",
                7,
                "stripe",
                "refresh_token",
            ),
            Err(409)
        );
        fs::remove_dir_all(app_root).expect("remove payment provider secret rotation root");
    }

    #[test]
    fn payment_provider_credentials_action_encrypts_declared_owner_fields() {
        let app_root = temp_app_root("payment-provider-credentials");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();

        payment_provider_configure_credentials(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
            PaymentProviderCredentialSubmission {
                fields: vec![
                    ("stripe_client_id".to_owned(), "acct_owner_123".to_owned()),
                    (
                        "stripe_client_secret".to_owned(),
                        "sk_test_owner_secret".to_owned(),
                    ),
                ],
            },
        )
        .expect("configure credentials");

        let secrets = root["payment_provider_secrets"]
            .as_array()
            .expect("secret rows");
        assert_eq!(secrets.len(), 2);
        assert!(secrets.iter().all(|row| {
            row.get("ciphertext")
                .and_then(Value::as_str)
                .is_some_and(|ciphertext| {
                    !ciphertext.contains("acct_owner_123")
                        && !ciphertext.contains("sk_test_owner_secret")
                })
        }));
        assert_eq!(
            read_payment_provider_secret(
                &root,
                &app_root,
                Some(conf_path.as_path()),
                "commerce_test",
                91,
                "merchant",
                7,
                "stripe",
                "client_id",
            )
            .as_deref(),
            Ok("acct_owner_123")
        );
        assert_eq!(
            read_payment_provider_secret(
                &root,
                &app_root,
                Some(conf_path.as_path()),
                "commerce_test",
                91,
                "merchant",
                7,
                "stripe",
                "client_secret",
            )
            .as_deref(),
            Ok("sk_test_owner_secret")
        );
        let audit_json =
            serde_json::to_string(&root["payment_provider_audit_events"]).expect("audit json");
        assert!(audit_json.contains("provider_credentials_configured"));
        assert!(!audit_json.contains("sk_test_owner_secret"));
        assert_eq!(
            root["payment_provider_accounts"][0]["connection_mode"],
            "direct_credentials"
        );
        assert_eq!(
            root["payment_provider_accounts"][0]["checkout_mode"],
            "live"
        );

        payment_provider_set_checkout_mode(
            &mut root,
            &app_root,
            "acme-audio",
            "stripe",
            11,
            "demo",
        )
        .expect("set checkout demo mode");
        assert_eq!(
            root["payment_provider_accounts"][0]["checkout_mode"],
            "demo"
        );
        payment_provider_set_checkout_mode(
            &mut root,
            &app_root,
            "acme-audio",
            "stripe",
            11,
            "live",
        )
        .expect("set checkout live mode with saved credentials");
        assert_eq!(
            root["payment_provider_accounts"][0]["checkout_mode"],
            "live"
        );

        payment_provider_revoke_credentials(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        )
        .expect("revoke credentials");
        assert_eq!(
            root["payment_provider_accounts"][0]["checkout_mode"],
            "demo"
        );
        assert_eq!(
            root["payment_provider_accounts"][0]["connection_mode"],
            "hosted_onboarding"
        );
        assert!(
            root["payment_provider_secrets"]
                .as_array()
                .expect("secret rows")
                .iter()
                .all(|row| row.get("revoked_at").and_then(Value::as_str).is_some())
        );
        assert_eq!(
            payment_provider_set_checkout_mode(
                &mut root,
                &app_root,
                "acme-audio",
                "stripe",
                11,
                "live",
            ),
            Err(409)
        );

        fs::remove_dir_all(app_root).expect("remove payment provider credentials root");
    }

    #[test]
    fn payment_provider_test_requires_saved_direct_credentials() {
        let app_root = temp_app_root("payment-provider-test-requires-credentials");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();

        let result = payment_provider_test_connection(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
            PaymentProviderConnectRequest::default(),
        );

        assert_eq!(
            result,
            Err((
                "provider_credentials_required".to_owned(),
                "Save provider credentials before testing the connection.".to_owned(),
                409
            ))
        );
        fs::remove_dir_all(app_root).expect("remove payment provider test root");
    }

    #[test]
    fn payment_provider_connect_uses_owner_scoped_client_id_when_saved() {
        let app_root = temp_app_root("payment-provider-owner-client-id");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();

        payment_provider_configure_credentials(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
            PaymentProviderCredentialSubmission {
                fields: vec![
                    ("stripe_client_id".to_owned(), "ca_owner_456".to_owned()),
                    (
                        "stripe_client_secret".to_owned(),
                        "sk_test_owner_secret".to_owned(),
                    ),
                ],
            },
        )
        .expect("configure credentials");
        let url = payment_provider_connect_start_with_request(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
            PaymentProviderConnectRequest {
                provider_account_label: Some("Owner Stripe"),
            },
        )
        .expect("connect start");

        assert!(url.contains("client_id=ca_owner_456"));
        assert!(!url.contains("ca_test_123"));

        fs::remove_dir_all(app_root).expect("remove payment provider owner-client-id root");
    }

    fn seed_connected_payment_provider_account(root: &mut Value) {
        for (status, onboarding_state, charges_enabled, payouts_enabled, details_submitted) in [
            (
                PaymentProviderConnectionState::ConnectRequested.as_str(),
                "connect_requested",
                false,
                false,
                false,
            ),
            (
                PaymentProviderConnectionState::RedirectPending.as_str(),
                "oauth_redirect",
                false,
                false,
                false,
            ),
            (
                PaymentProviderConnectionState::CallbackReceived.as_str(),
                "callback_received",
                false,
                false,
                false,
            ),
            (
                PaymentProviderConnectionState::Connected.as_str(),
                "ready",
                true,
                true,
                true,
            ),
        ] {
            root.upsert_account_state(PaymentProviderAccountUpdate {
                app_id: "commerce_test",
                tenant_id: 91,
                owner_resource_type: "merchant",
                owner_resource_id: 7,
                provider_id: "stripe",
                actor_user_id: 11,
                status,
                onboarding_state,
                provider_account_id: Some("acct_123456789"),
                provider_account_label: Some("Acme Audio Stripe"),
                last_error_code: None,
                last_error_message: None,
                charges_enabled,
                payouts_enabled,
                details_submitted,
            })
            .expect("seed connected account");
        }
    }

    fn connect_state_from_redirect(location: &str) -> String {
        let needle = "state=";
        let start = location.find(needle).expect("state query") + needle.len();
        let tail = &location[start..];
        let encoded = tail.split('&').next().unwrap_or_default();
        let mut out = String::with_capacity(encoded.len());
        let mut chars = encoded.as_bytes().iter().copied();
        while let Some(byte) = chars.next() {
            if byte == b'%' {
                let hi = chars.next().expect("percent hi") as char;
                let lo = chars.next().expect("percent lo") as char;
                let value = u8::from_str_radix(&format!("{hi}{lo}"), 16).expect("hex decode");
                out.push(char::from(value));
            } else {
                out.push(char::from(byte));
            }
        }
        out
    }

    #[test]
    fn payment_provider_state_token_binds_app_tenant_owner_and_revision() {
        let app_root = temp_app_root("payment-provider-token");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let token = payment_provider_state_token(
            &app_root,
            Some(conf_path.as_path()),
            "commerce_test",
            91,
            7,
            "acme-audio",
            "stripe",
            11,
            3,
            "nonce-123",
            "2099-01-01T00:00:00Z",
        )
        .expect("token");
        let decoded =
            verify_payment_provider_state_token(&app_root, Some(conf_path.as_path()), &token)
                .expect("verified");
        assert_eq!(decoded.app_id, "commerce_test");
        assert_eq!(decoded.tenant_id, 91);
        assert_eq!(decoded.owner_resource_id, 7);
        assert_eq!(decoded.owner_route_value, "acme-audio");
        assert_eq!(decoded.provider, "stripe");
        assert_eq!(decoded.actor_user_id, 11);
        assert_eq!(decoded.revision, 3);
    }

    #[test]
    fn payment_provider_callback_rejects_replayed_nonce() {
        let app_root = temp_app_root("payment-provider-replay");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let state_path = app_root.join("runtime-state.json");
        let mut root = seed_payment_provider_root();
        stripe_test_set_responses(vec![
            Ok((
                200,
                serde_json::json!({
                    "stripe_user_id": "acct_123456789",
                }),
            )),
            Ok((
                200,
                serde_json::json!({
                    "id": "acct_123456789",
                    "charges_enabled": true,
                    "payouts_enabled": true,
                    "details_submitted": true,
                    "email": "billing@example.test",
                    "requirements": { "disabled_reason": null }
                }),
            )),
        ]);
        let redirect = payment_provider_connect_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        )
        .expect("connect start");
        let state = connect_state_from_redirect(&redirect);
        persist_payment_provider_state_or_500(&root, &state_path).expect("persist connect state");
        let mut root =
            json_commands::json_doc_load_file(&state_path).expect("reload connect state");
        payment_provider_callback_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            &state,
            "auth_code_123",
            11,
        )
        .expect("first callback");
        persist_payment_provider_state_or_500(&root, &state_path).expect("persist callback state");
        let mut root =
            json_commands::json_doc_load_file(&state_path).expect("reload callback state");
        let account = &root["payment_provider_accounts"][0];
        assert_eq!(account["connection_state"], "connected");
        assert_eq!(account["capability_state"], "fully_enabled");
        assert!(
            root["payment_provider_callback_nonces"][0]["claimed_at"]
                .as_str()
                .is_some_and(|value| !value.is_empty())
        );
        assert_eq!(
            root["payment_provider_audit_events"]
                .as_array()
                .map(Vec::len),
            Some(4)
        );
        assert_eq!(
            root["payment_provider_audit_events"][0]["event_state_before"],
            "never_started"
        );
        assert_eq!(
            root["payment_provider_audit_events"][3]["event_state_after"],
            "connected"
        );
        let replay = payment_provider_callback_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            &state,
            "auth_code_123",
            11,
        );
        assert_eq!(replay, Err(409));
        fs::remove_dir_all(app_root).expect("remove payment provider replay root");
    }

    #[test]
    fn payment_provider_transition_graph_rejects_out_of_order_states() {
        use PaymentProviderConnectionState as State;

        assert!(State::NeverStarted.can_transition_to(State::ConnectRequested));
        assert!(State::ConnectRequested.can_transition_to(State::RedirectPending));
        assert!(State::RedirectPending.can_transition_to(State::CallbackReceived));
        assert!(State::CallbackReceived.can_transition_to(State::Connected));
        assert!(State::Connected.can_transition_to(State::DisconnectRequested));
        assert!(State::DisconnectRequested.can_transition_to(State::Disconnected));
        assert!(State::Connected.can_transition_to(State::Connected));
        assert!(!State::NeverStarted.can_transition_to(State::Connected));
        assert!(!State::Disconnected.can_transition_to(State::CallbackReceived));
        assert!(!State::DisconnectRequested.can_transition_to(State::Connected));
    }

    #[test]
    fn payment_provider_account_mutation_fails_closed_on_invalid_transition() {
        let mut root = seed_payment_provider_root();
        let result = root.upsert_account_state(PaymentProviderAccountUpdate {
            app_id: "commerce_test",
            tenant_id: 91,
            owner_resource_type: "merchant",
            owner_resource_id: 7,
            provider_id: "stripe",
            actor_user_id: 11,
            status: PaymentProviderConnectionState::Connected.as_str(),
            onboarding_state: "ready",
            provider_account_id: Some("acct_invalid_transition"),
            provider_account_label: Some("Invalid transition"),
            last_error_code: None,
            last_error_message: None,
            charges_enabled: true,
            payouts_enabled: true,
            details_submitted: true,
        });
        assert_eq!(result, Err(409));
        assert!(
            root["payment_provider_accounts"]
                .as_array()
                .is_some_and(Vec::is_empty)
        );
    }

    #[test]
    fn payment_provider_adapter_dispatches_supported_provider_only() {
        assert_eq!(
            pharos_runtime_payment::BuiltInPaymentProviderAdapterRegistry
                .adapter("stripe")
                .ok()
                .map(PaymentProviderAdapter::provider_id),
            Some("stripe")
        );
        assert!(
            pharos_runtime_payment::BuiltInPaymentProviderAdapterRegistry
                .adapter("paypal")
                .is_err()
        );
    }

    #[test]
    fn payment_provider_callback_failure_persists_redacted_detail() {
        let app_root = temp_app_root("payment-provider-redaction");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        stripe_test_set_responses(vec![Ok((
            400,
            serde_json::json!({
                "error": {
                    "code": "invalid_request_error",
                    "message": "Stripe rejected secret sk_test_should_not_persist"
                }
            }),
        ))]);
        let redirect = payment_provider_connect_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        )
        .expect("connect start");
        let state = connect_state_from_redirect(&redirect);
        let callback = payment_provider_callback_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            &state,
            "auth_code_123",
            11,
        );
        assert_eq!(callback, Err(400));
        let account = &root["payment_provider_accounts"][0];
        assert_eq!(account["connection_state"], "failed");
        assert_eq!(account["status_reason_code"], "invalid_request_error");
        assert_eq!(
            account["status_reason_detail"],
            "Stripe rejected secret [redacted]"
        );
        assert!(
            !account["status_reason_detail"]
                .as_str()
                .unwrap_or_default()
                .contains("sk_test_should_not_persist")
        );
        fs::remove_dir_all(app_root).expect("remove payment provider redaction root");
    }

    #[test]
    fn payment_provider_callback_rejects_expired_state() {
        let app_root = temp_app_root("payment-provider-expired-state");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        let state = payment_provider_state_token(
            &app_root,
            Some(conf_path.as_path()),
            "commerce_test",
            91,
            7,
            "acme-audio",
            "stripe",
            11,
            1,
            "expired-nonce",
            "2000-01-01T00:00:00Z",
        )
        .expect("expired token");
        let callback = payment_provider_callback_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            &state,
            "auth_code_123",
            11,
        );
        assert_eq!(callback, Err(422));
        assert!(
            root["payment_provider_audit_events"]
                .as_array()
                .is_some_and(Vec::is_empty)
        );
        fs::remove_dir_all(app_root).expect("remove payment provider expired root");
    }

    #[test]
    fn payment_provider_connect_config_failure_does_not_persist_partial_state() {
        let app_root = temp_app_root("payment-provider-connect-config");
        write_payment_provider_fixture_app(&app_root);
        let conf_path = app_root.join("app.conf");
        fs::write(
            &conf_path,
            "base_url=http://127.0.0.1:8084/commerce-test\npayment_providers=stripe\npayment_provider_state_key_env=PATH\n",
        )
        .expect("write config");
        let mut root = seed_payment_provider_root();
        let result = payment_provider_connect_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        );
        assert_eq!(result, Err(503));
        assert!(
            root["payment_provider_accounts"]
                .as_array()
                .is_some_and(Vec::is_empty)
        );
        fs::remove_dir_all(app_root).expect("remove payment provider connect-config root");
    }

    #[test]
    fn payment_provider_callback_rejects_actor_and_owner_mismatch() {
        let app_root = temp_app_root("payment-provider-mismatch");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        let redirect = payment_provider_connect_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        )
        .expect("connect start");
        let state = connect_state_from_redirect(&redirect);
        let actor_mismatch = payment_provider_callback_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            &state,
            "auth_code_123",
            12,
        );
        assert_eq!(actor_mismatch, Err(403));
        assert_eq!(
            root["payment_provider_callback_nonces"][0]["claimed_at"],
            ""
        );

        let owner_mismatch = payment_provider_callback_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "wrong-merchant",
            "stripe",
            &state,
            "auth_code_123",
            0,
        );
        assert_eq!(owner_mismatch, Err(422));
        assert_eq!(
            root["payment_provider_callback_nonces"][0]["claimed_at"],
            ""
        );
        fs::remove_dir_all(app_root).expect("remove payment provider mismatch root");
    }

    #[test]
    fn payment_provider_callback_missing_code_persists_stable_reason() {
        let app_root = temp_app_root("payment-provider-missing-code");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        let redirect = payment_provider_connect_start(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        )
        .expect("connect start");
        let state = connect_state_from_redirect(&redirect);
        let callback = payment_provider_callback_complete(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            &state,
            "",
            11,
        );
        assert_eq!(callback, Err(422));
        let account = &root["payment_provider_accounts"][0];
        assert_eq!(account["connection_state"], "failed");
        assert_eq!(
            account["status_reason_code"],
            "provider_callback_missing_code"
        );
        assert_eq!(
            root["payment_provider_audit_events"][3]["reason_code"],
            "provider_callback_missing_code"
        );
        fs::remove_dir_all(app_root).expect("remove payment provider missing-code root");
    }

    #[test]
    fn payment_provider_refresh_marks_provider_revocation() {
        let app_root = temp_app_root("payment-provider-refresh-revoked");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        seed_connected_payment_provider_account(&mut root);
        stripe_test_set_responses(vec![Ok((
            404,
            serde_json::json!({
                "error": {
                    "code": "account_invalid",
                    "message": "No such connected account sk_test_should_not_persist"
                }
            }),
        ))]);
        let refresh = payment_provider_refresh(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        );
        assert_eq!(refresh, Err(404));
        let account = &root["payment_provider_accounts"][0];
        assert_eq!(account["connection_state"], "revoked_externally");
        assert_eq!(account["onboarding_state"], "revoked_externally");
        assert_eq!(account["status_reason_code"], "account_invalid");
        assert_eq!(
            account["status_reason_detail"],
            "No such connected account [redacted]"
        );
        assert_eq!(
            root["payment_provider_audit_events"][0]["reason_code"],
            "account_invalid"
        );
        fs::remove_dir_all(app_root).expect("remove payment provider refresh revoked root");
    }

    #[test]
    fn payment_provider_refresh_verifies_saved_direct_credentials_without_provider_account() {
        let app_root = temp_app_root("payment-provider-refresh-direct-credentials");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();

        payment_provider_configure_credentials(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
            PaymentProviderCredentialSubmission {
                fields: vec![
                    ("stripe_client_id".to_owned(), "acct_owner_123".to_owned()),
                    (
                        "stripe_client_secret".to_owned(),
                        "sk_test_owner_secret".to_owned(),
                    ),
                ],
            },
        )
        .expect("configure direct credentials");
        assert_eq!(
            root["payment_provider_accounts"][0]["connection_mode"],
            "direct_credentials"
        );
        assert!(
            root["payment_provider_accounts"][0]["provider_account_id"]
                .as_str()
                .unwrap_or_default()
                .is_empty()
        );

        stripe_test_set_responses(vec![Ok((
            200,
            serde_json::json!({
                "id": "acct_owner_123",
                "charges_enabled": true,
                "payouts_enabled": true,
                "details_submitted": true,
                "business_profile": {"name": "Owner direct credentials"},
                "requirements": {"currently_due": [], "disabled_reason": null}
            }),
        ))]);
        payment_provider_refresh(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        )
        .expect("refresh direct credentials");

        let account = &root["payment_provider_accounts"][0];
        assert_eq!(account["connection_mode"], "direct_credentials");
        assert_eq!(account["checkout_mode"], "live");
        assert_eq!(account["connection_state"], "connected");
        assert_eq!(account["onboarding_state"], "ready");
        assert!(
            account["provider_account_id"]
                .as_str()
                .unwrap_or_default()
                .is_empty()
        );
        assert_eq!(
            account["provider_account_label"],
            "Owner direct credentials"
        );
        assert_eq!(account["status_reason_code"], Value::Null);
        assert_eq!(
            account["status_reason_detail"],
            "Stripe account linked and charges are enabled."
        );
        let audit_json =
            serde_json::to_string(&root["payment_provider_audit_events"]).expect("audit json");
        assert!(audit_json.contains("provider_credentials_verified"));
        assert!(!audit_json.contains("acct_owner_123"));
        assert!(!audit_json.contains("sk_test_owner_secret"));

        fs::remove_dir_all(app_root)
            .expect("remove payment provider refresh direct credentials root");
    }

    #[test]
    fn payment_provider_test_verifies_replaced_direct_credentials_after_previous_lifecycle() {
        for previous_state in [
            "disconnected",
            "redirect_pending",
            "connect_requested",
            "callback_received",
            "connected",
            "restricted",
        ] {
            let app_root = temp_app_root("payment-provider-replaced-direct-credentials");
            let conf_path = write_payment_provider_fixture_app(&app_root);
            let mut root = seed_payment_provider_root();
            root.upsert_account_state(PaymentProviderAccountUpdate {
                app_id: "commerce_test",
                tenant_id: 91,
                owner_resource_type: "merchant",
                owner_resource_id: 7,
                provider_id: "stripe",
                actor_user_id: 11,
                status: PaymentProviderConnectionState::NeverStarted.as_str(),
                onboarding_state: "credentials_deleted",
                provider_account_id: None,
                provider_account_label: Some("Stripe credentials deleted"),
                last_error_code: None,
                last_error_message: None,
                charges_enabled: false,
                payouts_enabled: false,
                details_submitted: false,
            })
            .expect("seed never started account");
            if let Some(row) = payment_provider_account_row_mut(
                &mut root,
                "commerce_test",
                "merchant",
                7,
                "stripe",
            ) && let Some(object) = row.as_object_mut()
            {
                object.insert(
                    "connection_state".to_owned(),
                    Value::String(previous_state.to_owned()),
                );
                object.insert(
                    "connection_mode".to_owned(),
                    Value::String("hosted_onboarding".to_owned()),
                );
                object.insert("checkout_mode".to_owned(), Value::String("demo".to_owned()));
            }

            let previous_revision = root["payment_provider_accounts"][0]["revision"]
                .as_i64()
                .unwrap();
            payment_provider_configure_credentials(
                &mut root,
                &app_root,
                Some(conf_path.as_path()),
                "acme-audio",
                "stripe",
                11,
                PaymentProviderCredentialSubmission {
                    fields: vec![
                        ("stripe_client_id".to_owned(), "acct_owner_456".to_owned()),
                        (
                            "stripe_client_secret".to_owned(),
                            "sk_test_owner_secret_456".to_owned(),
                        ),
                    ],
                },
            )
            .expect("replace direct credentials");
            assert_eq!(
                root["payment_provider_accounts"][0]["connection_state"],
                "verification_pending"
            );
            assert_eq!(
                root["payment_provider_accounts"][0]["connection_mode"],
                "direct_credentials"
            );

            assert_eq!(
                root["payment_provider_accounts"][0]["revision"],
                previous_revision + 1
            );
            assert_eq!(
                root["payment_provider_accounts"][0]["charges_enabled"],
                false
            );
            let stale_state = payment_provider_state_token(
                &app_root,
                Some(conf_path.as_path()),
                "commerce_test",
                91,
                7,
                "acme-audio",
                "stripe",
                11,
                previous_revision,
                "old-credential-nonce",
                "2099-01-01T00:00:00Z",
            )
            .expect("old revision token");
            assert_eq!(
                payment_provider_callback_complete(
                    &mut root,
                    &app_root,
                    Some(conf_path.as_path()),
                    "acme-audio",
                    "stripe",
                    &stale_state,
                    "old_authorization",
                    11,
                ),
                Err(409)
            );

            stripe_test_set_responses(vec![Ok((
                200,
                serde_json::json!({
                    "id": "acct_owner_456",
                    "charges_enabled": true,
                    "payouts_enabled": true,
                    "details_submitted": true,
                    "business_profile": {"name": "Replaced direct credentials"},
                    "requirements": {"currently_due": [], "disabled_reason": null}
                }),
            ))]);
            payment_provider_test_connection(
                &mut root,
                &app_root,
                Some(conf_path.as_path()),
                "acme-audio",
                "stripe",
                11,
                PaymentProviderConnectRequest::default(),
            )
            .expect("test replaced direct credentials after disconnect");

            let account = &root["payment_provider_accounts"][0];
            assert_eq!(account["connection_mode"], "direct_credentials");
            assert_eq!(account["connection_state"], "connected");
            assert_eq!(account["checkout_mode"], "live");
            assert_eq!(
                account["provider_account_label"],
                "Replaced direct credentials"
            );
            fs::remove_dir_all(app_root).expect("remove replaced direct credentials root");
        }
    }

    #[test]
    fn payment_provider_disconnect_failure_persists_redacted_reason() {
        let app_root = temp_app_root("payment-provider-disconnect-failure");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        seed_connected_payment_provider_account(&mut root);
        stripe_test_set_responses(vec![Ok((
            500,
            serde_json::json!({
                "error": {
                    "code": "api_error",
                    "message": "Stripe failed while handling sk_test_should_not_persist"
                }
            }),
        ))]);
        let disconnect = payment_provider_disconnect(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        );
        assert_eq!(disconnect, Err(500));
        let account = &root["payment_provider_accounts"][0];
        assert_eq!(account["connection_state"], "failed");
        assert_eq!(account["onboarding_state"], "disconnect_failed");
        assert_eq!(account["status_reason_code"], "api_error");
        assert_eq!(
            account["status_reason_detail"],
            "Stripe failed while handling [redacted]"
        );
        assert_eq!(
            root["payment_provider_audit_events"]
                .as_array()
                .map(Vec::len),
            Some(2)
        );
        assert_eq!(
            root["payment_provider_audit_events"][1]["event_type"],
            "disconnect_failed"
        );
        fs::remove_dir_all(app_root).expect("remove payment provider disconnect failure root");
    }

    #[test]
    fn payment_provider_disconnect_is_idempotent_after_disconnect() {
        let app_root = temp_app_root("payment-provider-disconnect-idempotent");
        let conf_path = write_payment_provider_fixture_app(&app_root);
        let mut root = seed_payment_provider_root();
        seed_connected_payment_provider_account(&mut root);
        stripe_test_set_responses(vec![Ok((
            200,
            serde_json::json!({"stripe_user_id": "acct_123456789"}),
        ))]);
        payment_provider_disconnect(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        )
        .expect("first disconnect");
        let revision = root["payment_provider_accounts"][0]["revision"]
            .as_i64()
            .expect("revision");
        let audit_count = root["payment_provider_audit_events"]
            .as_array()
            .map(Vec::len)
            .unwrap_or_default();
        payment_provider_disconnect(
            &mut root,
            &app_root,
            Some(conf_path.as_path()),
            "acme-audio",
            "stripe",
            11,
        )
        .expect("second disconnect");
        assert_eq!(
            root["payment_provider_accounts"][0]["connection_state"],
            "disconnected"
        );
        assert_eq!(root["payment_provider_accounts"][0]["revision"], revision);
        assert_eq!(
            root["payment_provider_audit_events"]
                .as_array()
                .map(Vec::len),
            Some(audit_count)
        );
        fs::remove_dir_all(app_root).expect("remove payment provider disconnect idempotent root");
    }

    #[test]
    fn stripe_account_status_maps_restricted_accounts() {
        let (
            status,
            onboarding_state,
            charges_enabled,
            payouts_enabled,
            details_submitted,
            reason_code,
            reason_detail,
        ) = stripe_account_status(&serde_json::json!({
            "charges_enabled": false,
            "payouts_enabled": false,
            "details_submitted": true,
            "requirements": {
                "disabled_reason": "requirements.past_due"
            }
        }));
        assert_eq!(status, "restricted");
        assert_eq!(onboarding_state, "restricted");
        assert!(!charges_enabled);
        assert!(!payouts_enabled);
        assert!(details_submitted);
        assert_eq!(reason_code.as_deref(), Some("requirements.past_due"));
        assert!(
            reason_detail
                .as_deref()
                .is_some_and(|value| value.contains("requirements.past_due"))
        );
    }
}