v0.2.4-pre.003

crates/ksp-onchain-transport-lib/unit_tests/rpc_blocks.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/unit_tests/rpc_blocks.rs
-// version: 1
+// version: 2
 
 #[test]
 fn transaction_details_and_get_block_config_preserve_all_modern_options() {
@@ -148,3 +148,166 @@ fn block_reward_rejects_invalid_pubkey_without_echoing_value() {
     assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RESPONSE);
     assert!(!error.to_string().contains("not-a-pubkey"));
 }
+
+fn pool_for_url(url: &str) -> crate::HttpTransportPool {
+    let role = crate::HttpEndpointRoleSettings::new(
+        crate::HttpRoleName::new("default"),
+        true,
+        std::vec![crate::HttpRequestKind::wildcard()],
+        10,
+        crate::HttpRoleLimits::new(std::option::Option::None, std::option::Option::None, std::option::Option::None, std::option::Option::None),
+    );
+    let endpoint = crate::HttpEndpointSettings::new(
+        "fixture",
+        true,
+        crate::HttpProviderName::new("fixture"),
+        crate::HttpClusterName::new("local"),
+        crate::HttpEndpointUrl::parse(url).expect("fixture URL must parse"),
+        std::time::Duration::from_secs(1),
+        std::time::Duration::from_secs(1),
+        std::option::Option::Some(1),
+        std::vec![role],
+    );
+    let settings = crate::HttpTransportSettings::new(
+        std::vec![endpoint],
+        crate::HttpRetrySettings::new(0, std::time::Duration::from_millis(1), std::time::Duration::from_millis(1)),
+    );
+    return crate::HttpTransportPool::new(settings).expect("fixture pool must build");
+}
+
+fn serve_once(body: &'static str) -> (std::string::String, std::thread::JoinHandle<std::string::String>) {
+    let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("fixture listener must bind");
+    let address = listener.local_addr().expect("fixture listener address must resolve");
+    let handle = std::thread::spawn(move || {
+        let (mut stream, _) = listener.accept().expect("fixture server must accept one request");
+        let request = read_request(&mut stream);
+        let response = format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", body.len(), body);
+        std::io::Write::write_all(&mut stream, response.as_bytes()).expect("fixture response must write");
+        return request;
+    });
+    return (format!("http://{address}"), handle);
+}
+
+fn read_request(stream: &mut std::net::TcpStream) -> std::string::String {
+    let mut bytes = std::vec::Vec::new();
+    let mut buffer = [0_u8; 1024];
+    loop {
+        let count = std::io::Read::read(stream, &mut buffer).expect("fixture request must read");
+        if count == 0 {
+            break;
+        }
+        bytes.extend_from_slice(&buffer[..count]);
+        if request_complete(bytes.as_slice()) {
+            break;
+        }
+    }
+    return std::string::String::from_utf8(bytes).expect("fixture request must be UTF-8");
+}
+
+fn request_complete(bytes: &[u8]) -> bool {
+    let text = match std::str::from_utf8(bytes) {
+        std::result::Result::Ok(text) => text,
+        std::result::Result::Err(_) => return false,
+    };
+    let header_end = match text.find("\r\n\r\n") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return false,
+    };
+    let mut content_length = 0_usize;
+    for line in text[..header_end].lines() {
+        let (name, value) = match line.split_once(':') {
+            std::option::Option::Some(parts) => parts,
+            std::option::Option::None => continue,
+        };
+        if name.eq_ignore_ascii_case("content-length") {
+            content_length = value.trim().parse::<usize>().expect("content length must parse");
+        }
+    }
+    return bytes.len() >= header_end.saturating_add(4).saturating_add(content_length);
+}
+
+fn request_body(request: &str) -> serde_json::Value {
+    let body = request.split("\r\n\r\n").nth(1).expect("fixture request body must exist");
+    return serde_json::from_str(body).expect("fixture request body must be JSON");
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn typed_get_block_commitment_serializes_slot_and_preserves_distribution() {
+    let (url, handle) = serve_once(include_str!("../fixtures/http/get_block_commitment.success.json"));
+    let pool = pool_for_url(url.as_str());
+    let result = pool.get_block_commitment(&crate::HttpRoleName::new("default"), 430_000_123).await.expect("block commitment fixture must succeed");
+    assert_eq!(result.commitment(), std::option::Option::Some(&[1, 2, 3, 4][..]));
+    assert_eq!(result.total_stake(), 1_000_000_000);
+    let request = handle.join().expect("fixture server must join");
+    let body = request_body(request.as_str());
+    assert_eq!(body["method"], serde_json::json!("getBlockCommitment"));
+    assert_eq!(body["params"], serde_json::json!([430000123]));
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn typed_get_block_height_serializes_context_config() {
+    let (url, handle) = serve_once(include_str!("../fixtures/http/get_block_height.success.json"));
+    let pool = pool_for_url(url.as_str());
+    let config = crate::SolanaContextConfig::new(std::option::Option::Some(crate::SolanaCommitment::Finalized), std::option::Option::Some(429_000_000));
+    let height = pool
+        .get_block_height(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
+        .await
+        .expect("block height fixture must succeed");
+    assert_eq!(height, 410_000_000);
+    let request = handle.join().expect("fixture server must join");
+    assert_eq!(request_body(request.as_str())["params"], serde_json::json!([{"commitment":"finalized","minContextSlot":429000000}]));
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn typed_get_block_height_omits_explicitly_empty_config() {
+    let (url, handle) = serve_once(include_str!("../fixtures/http/get_block_height.success.json"));
+    let pool = pool_for_url(url.as_str());
+    let config = crate::SolanaContextConfig::default();
+    let height = pool
+        .get_block_height(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
+        .await
+        .expect("block height fixture must succeed");
+    assert_eq!(height, 410_000_000);
+    let request = handle.join().expect("fixture server must join");
+    assert_eq!(request_body(request.as_str())["params"], serde_json::json!([]));
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn typed_get_block_time_preserves_timestamp_and_null() {
+    let (url, handle) = serve_once(include_str!("../fixtures/http/get_block_time.success.json"));
+    let pool = pool_for_url(url.as_str());
+    let timestamp = pool.get_block_time(&crate::HttpRoleName::new("default"), 430_000_123).await.expect("block time fixture must succeed");
+    assert_eq!(timestamp, std::option::Option::Some(1_787_072_400));
+    let request = handle.join().expect("fixture server must join");
+    assert_eq!(request_body(request.as_str())["params"], serde_json::json!([430000123]));
+
+    let (url, handle) = serve_once(include_str!("../fixtures/http/get_block_time.null.json"));
+    let pool = pool_for_url(url.as_str());
+    let timestamp = pool.get_block_time(&crate::HttpRoleName::new("default"), 430_000_124).await.expect("null block time fixture must succeed");
+    assert_eq!(timestamp, std::option::Option::None);
+    handle.join().expect("fixture server must join");
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn typed_get_first_available_block_has_no_params() {
+    let (url, handle) = serve_once(include_str!("../fixtures/http/get_first_available_block.success.json"));
+    let pool = pool_for_url(url.as_str());
+    let slot = pool.get_first_available_block(&crate::HttpRoleName::new("default")).await.expect("first available block fixture must succeed");
+    assert_eq!(slot, 250_000);
+    let request = handle.join().expect("fixture server must join");
+    let body = request_body(request.as_str());
+    assert_eq!(body["method"], serde_json::json!("getFirstAvailableBlock"));
+    assert_eq!(body["params"], serde_json::json!([]));
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn typed_minimum_ledger_slot_has_no_params() {
+    let (url, handle) = serve_once(include_str!("../fixtures/http/minimum_ledger_slot.success.json"));
+    let pool = pool_for_url(url.as_str());
+    let slot = pool.minimum_ledger_slot(&crate::HttpRoleName::new("default")).await.expect("minimum ledger slot fixture must succeed");
+    assert_eq!(slot, 123_456);
+    let request = handle.join().expect("fixture server must join");
+    let body = request_body(request.as_str());
+    assert_eq!(body["method"], serde_json::json!("minimumLedgerSlot"));
+    assert_eq!(body["params"], serde_json::json!([]));
+}