khadhroony-solana-project/crates/ksp-store-api/tests/public_api.rs

// file: crates/ksp-store-api/tests/public_api.rs
// version: 3

//! Integration canaries for the public `ksp-store-api` surface.

fn consume_result(value: ksp_store_api::Result<ksp_store_api::Pubkey>) -> ksp_store_api::Result<ksp_store_api::Pubkey> {
    return value;
}

fn code(value: &str) -> std::option::Option<ksp_store_api::RawProvenanceCode> {
    return match ksp_store_api::RawProvenanceCode::new(value.to_owned()) {
        std::result::Result::Ok(value) => std::option::Option::Some(value),
        std::result::Result::Err(_) => std::option::Option::None,
    };
}

#[test]
fn public_pre_002_core_facade_remains_available_from_crate_root() {
    let pubkey = ksp_store_api::Pubkey::new_from_array([0x31_u8; 32]);
    let forwarded = consume_result(std::result::Result::Ok(pubkey));
    assert!(forwarded.is_ok());
    let error_code_type: std::option::Option<ksp_store_api::ErrorCode> = std::option::Option::None;
    let error_context_type: std::option::Option<ksp_store_api::ErrorContext> = std::option::Option::None;
    let error_type: std::option::Option<ksp_store_api::Error> = std::option::Option::None;
    assert!(error_code_type.is_none());
    assert!(error_context_type.is_none());
    assert!(error_type.is_none());
    return;
}

#[test]
fn public_pre_003_raw_transaction_and_observation_are_constructible_from_crate_root() {
    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let reference = ksp_store_api::RawTransactionReference::new(network, ksp_store_api::RawTransactionSignature::new([1_u8; 64]));
    let format = match ksp_store_api::RawFormatId::new("ksp.solana.raw_transaction".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let payload = match ksp_store_api::RawPayload::try_new(format, 1, vec![1_u8, 2_u8, 3_u8].into_boxed_slice(), ksp_store_api::RawContentHash::new([2_u8; 32]))
    {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let transaction = ksp_store_api::RawTransaction::new(reference.clone(), 123, std::option::Option::None, payload);
    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(1_000) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let provider = match code("provider") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let protocol = match code("solana_http") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let method = match code("getTransaction") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Backfill, received_at);
    let observation = ksp_store_api::RawTransactionObservation::new(ksp_store_api::RawObservationKey::new([3_u8; 32]), reference, provenance);
    assert_eq!(transaction.slot(), 123);
    assert_eq!(transaction.payload().bytes(), &[1_u8, 2_u8, 3_u8]);
    assert_eq!(observation.transaction().network().as_str(), "mainnet-beta");
    assert_eq!(observation.provenance().acquisition_method().as_str(), "getTransaction");
    assert_eq!(ksp_store_api::ERROR_CODE_RAW_PAYLOAD_INVALID.domain(), "store_api");
    return;
}

#[test]
fn public_pre_003_surface_keeps_backend_and_structural_types_out() {
    let source = include_str!("../src/lib.rs");
    assert!(!source.contains("pub mod "));
    for forbidden in ["Postgres", "Sql", "Migration", "StructuralTransaction", "RawLog", "ProgramInstruction"] {
        assert!(!source.contains(forbidden), "forbidden pre.003 Store API public concept detected: {forbidden}");
    }
    return;
}

#[test]
fn public_pre_004_raw_account_state_and_observation_are_constructible_from_crate_root() {
    let network = match ksp_store_api::RawNetworkId::new("mainnet-beta".to_owned()) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let reference = ksp_store_api::RawAccountStateReference::new(
        network,
        ksp_store_api::Pubkey::new_from_array([21_u8; 32]),
        55,
        ksp_store_api::RawContentHash::new([22_u8; 32]),
    );
    let state = ksp_store_api::RawAccountState::try_new(
        reference.clone(),
        123,
        ksp_store_api::Pubkey::new_from_array([23_u8; 32]),
        false,
        9,
        vec![1_u8, 2_u8].into_boxed_slice(),
    );
    assert!(state.is_ok());
    let received_at = match ksp_store_api::RawTimestamp::from_unix_millis(2_000) {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let provider = match code("provider") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let protocol = match code("solana_http") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let method = match code("getAccountInfo") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let provenance = ksp_store_api::RawAcquisitionProvenance::new(provider, protocol, method, ksp_store_api::RawAcquisitionOrigin::Backfill, received_at);
    let observation = ksp_store_api::RawAccountObservation::new(ksp_store_api::RawObservationKey::new([24_u8; 32]), reference, provenance);
    assert_eq!(observation.account().slot(), 55);
    assert!(observation.write_version().is_none());
    assert_eq!(ksp_store_api::MAX_RAW_ACCOUNT_DATA_BYTES, 16 * 1024 * 1024);
    return;
}