// file: crates/ksp-worker-raw-transaction-ingest-lib/tests/public_api.rs
// version: 7

//! External public-surface proofs for the RAW transaction ingest Worker foundation.

#[test]
fn pre_003_kind_code_and_settings_are_consumable_from_crate_root() {
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE, "raw_transaction_ingest");
    let kind_result = ksp_worker_api::WorkerKindCode::new(ksp_worker_raw_transaction_ingest_lib::RAW_TRANSACTION_INGEST_WORKER_KIND_CODE);
    assert!(kind_result.is_ok());
    let kind = match kind_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(kind.as_str(), "raw_transaction_ingest");
    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let worker_id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let settings = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings::with_defaults(network, worker_id);
    assert_eq!(settings.network().as_str(), "mainnet");
    assert_eq!(settings.worker_id().as_str(), "raw-ingest-mainnet-001");
    assert_eq!(settings.admission_queue_capacity(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY);
    assert_eq!(settings.persistence_concurrency(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY);
    assert_eq!(settings.shutdown_drain_timeout(), ksp_worker_raw_transaction_ingest_lib::DEFAULT_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT);
    return;
}

#[test]
fn pre_003_invalid_network_and_worker_identity_remain_owned_by_lower_contracts() {
    let network = ksp_store_lib::RawNetworkId::new("");
    let worker_id = ksp_worker_api::WorkerId::new("invalid worker id");
    assert!(network.is_err());
    assert!(worker_id.is_err());
    let network_error = match network {
        std::result::Result::Ok(_) => return,
        std::result::Result::Err(value) => value,
    };
    assert_eq!(network_error.code(), ksp_store_lib::ERROR_CODE_RAW_MODEL_INVALID);
    let worker_error = match worker_id {
        std::result::Result::Ok(_) => return,
        std::result::Result::Err(value) => value,
    };
    assert_eq!(worker_error.code(), ksp_worker_api::ERROR_CODE_WORKER_ID_INVALID);
    return;
}

#[test]
fn pre_003_runtime_bound_errors_are_stable_and_do_not_echo_values() {
    let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let worker_id = match ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001") {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let result = ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings::new(network, worker_id, 0, 8, std::time::Duration::from_secs(5));
    assert!(result.is_err());
    let error = match result {
        std::result::Result::Ok(_) => return,
        std::result::Result::Err(value) => value,
    };
    assert_eq!(error.code(), ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_SETTINGS_INVALID);
    assert_eq!(error.message(), "invalid RAW transaction ingest Worker settings");
    assert_eq!(error.context().len(), 1);
    assert_eq!(error.context()[0].value(), "admission_queue_capacity");
    assert!(!std::format!("{error:?}").contains("raw-ingest-mainnet-001"));
    return;
}

#[test]
fn pre_004_start_handle_and_terminal_future_are_consumable_without_public_join_handle() {
    let _start: fn(
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSettings,
        std::sync::Arc<ksp_store_lib::Store>,
    ) -> ksp_core_lib::Result<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestWorker::start;
    let _request_stop: fn(&ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle) -> bool =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::request_stop;
    let _wait_terminal: for<'a> fn(
        &'a ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestTerminalFuture<'a> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::wait_terminal;
    let root = include_str!("../src/lib.rs");
    assert!(!root.contains("JoinHandle"));
    assert!(!root.contains("JoinSet"));
    return;
}

#[test]
fn pre_007_store_and_content_conflict_error_codes_are_public_and_stable() {
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_CONTENT_CONFLICT.domain(), "worker_raw_transaction_ingest");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_CONTENT_CONFLICT.code(), "content_conflict");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_STORE_FAILED.domain(), "worker_raw_transaction_ingest");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_STORE_FAILED.code(), "store_failed");
    return;
}

#[test]
fn pre_008_snapshot_surface_and_common_projection_are_public_and_stable() {
    let _snapshot_source: fn(
        &ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::snapshot_source;
    let _worker_snapshot_source: fn(
        &ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestHandle::worker_snapshot_source;
    let _current: fn(
        &ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshot =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource::current;
    let _wait: for<'a> fn(
        &'a ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource,
        ksp_worker_api::WorkerSnapshotSequence,
    ) -> ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotFuture<'a> =
        ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource::wait_for_change;
    fn require_worker_source<T: ksp_worker_api::WorkerSnapshotSource + std::marker::Send + std::marker::Sync>() {}
    require_worker_source::<ksp_worker_raw_transaction_ingest_lib::RawTransactionIngestSnapshotSource>();
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED.domain(), "worker_raw_transaction_ingest");
    assert_eq!(ksp_worker_raw_transaction_ingest_lib::ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED.code(), "counter_exhausted");
    return;
}