v0.3.15-pre.002

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

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/unit_tests/ws_settings.rs
-// version: 2
+// version: 3
 
 fn valid_endpoint(name: &str, url_text: &str) -> crate::WsEndpointSettings {
     return crate::WsEndpointSettings::new(
@@ -148,3 +148,80 @@ fn websocket_transport_settings_debug_never_exposes_endpoint_url() {
     assert!(!rendered.contains("provider.invalid"));
     assert!(!rendered.contains("password"));
 }
+
+#[test]
+fn v0_3_15_pre_002_undeclared_websocket_capabilities_fail_closed_without_breaking_legacy_settings() {
+    let endpoint = valid_endpoint("legacy", "wss://legacy.invalid/ws");
+    assert_eq!(endpoint.subscription_capabilities(), std::option::Option::None);
+    assert!(!endpoint.supports_subscription(crate::WsSubscriptionKind::Logs));
+    assert!(!endpoint.supports_subscription(crate::WsSubscriptionKind::Block));
+    let settings = crate::WsTransportSettings::new(std::vec![endpoint]);
+    assert!(settings.validate().is_ok());
+}
+
+#[test]
+fn v0_3_15_pre_002_standard_endpoint_declares_exact_typed_subscription_capabilities() {
+    let endpoint = valid_endpoint("typed", "wss://typed.invalid/ws")
+        .with_subscription_capabilities(std::vec![crate::WsSubscriptionKind::Logs, crate::WsSubscriptionKind::Block,]);
+    assert_eq!(
+        endpoint.subscription_capabilities(),
+        std::option::Option::Some([crate::WsSubscriptionKind::Logs, crate::WsSubscriptionKind::Block].as_slice())
+    );
+    assert!(endpoint.supports_subscription(crate::WsSubscriptionKind::Logs));
+    assert!(endpoint.supports_subscription(crate::WsSubscriptionKind::Block));
+    assert!(!endpoint.supports_subscription(crate::WsSubscriptionKind::Vote));
+    assert!(!endpoint.supports_subscription(crate::WsSubscriptionKind::HeliusTransaction));
+    let settings = crate::WsTransportSettings::new(std::vec![endpoint]);
+    assert!(settings.validate().is_ok());
+}
+
+#[test]
+fn v0_3_15_pre_002_explicit_capability_set_rejects_empty_and_duplicate_entries() {
+    let empty = valid_endpoint("empty", "wss://empty.invalid/ws").with_subscription_capabilities(std::vec![]);
+    let empty_error = crate::WsTransportSettings::new(std::vec![empty]).validate().expect_err("explicit empty capabilities must fail");
+    assert_eq!(empty_error.code(), crate::ERROR_CODE_INVALID_SETTINGS);
+    let duplicate = valid_endpoint("duplicate_caps", "wss://duplicate.invalid/ws")
+        .with_subscription_capabilities(std::vec![crate::WsSubscriptionKind::Logs, crate::WsSubscriptionKind::Logs,]);
+    let duplicate_error = crate::WsTransportSettings::new(std::vec![duplicate]).validate().expect_err("duplicate capabilities must fail");
+    assert_eq!(duplicate_error.code(), crate::ERROR_CODE_INVALID_SETTINGS);
+}
+
+#[test]
+fn v0_3_15_pre_002_capabilities_must_belong_to_selected_protocol_surface() {
+    let standard =
+        valid_endpoint("standard_bad", "wss://standard.invalid/ws").with_subscription_capabilities(std::vec![crate::WsSubscriptionKind::HeliusTransaction]);
+    assert!(!standard.supports_subscription(crate::WsSubscriptionKind::HeliusTransaction));
+    let standard_error =
+        crate::WsTransportSettings::new(std::vec![standard]).validate().expect_err("standard protocol must reject Helius transaction capability");
+    assert_eq!(standard_error.code(), crate::ERROR_CODE_INVALID_SETTINGS);
+    let helius_block = crate::WsEndpointSettings::new(
+        "helius_block",
+        true,
+        crate::WsProviderName::new("helius"),
+        crate::WsClusterName::new("mainnet"),
+        crate::WsProtocolKind::HeliusLaserStream,
+        crate::WsEndpointUrl::parse("wss://helius.invalid/ws").expect("test URL must parse"),
+        crate::WsSessionSettings::default(),
+    )
+    .with_subscription_capabilities(std::vec![crate::WsSubscriptionKind::Block]);
+    assert!(!helius_block.supports_subscription(crate::WsSubscriptionKind::Block));
+    let helius_block_error =
+        crate::WsTransportSettings::new(std::vec![helius_block]).validate().expect_err("Helius protocol must reject unsupported block capability");
+    assert_eq!(helius_block_error.code(), crate::ERROR_CODE_INVALID_SETTINGS);
+    let helius_supported = crate::WsEndpointSettings::new(
+        "helius_supported",
+        true,
+        crate::WsProviderName::new("helius"),
+        crate::WsClusterName::new("mainnet"),
+        crate::WsProtocolKind::HeliusLaserStream,
+        crate::WsEndpointUrl::parse("wss://helius-supported.invalid/ws").expect("test URL must parse"),
+        crate::WsSessionSettings::default(),
+    )
+    .with_subscription_capabilities(std::vec![crate::WsSubscriptionKind::Logs, crate::WsSubscriptionKind::HeliusTransaction]);
+    assert!(helius_supported.supports_subscription(crate::WsSubscriptionKind::Logs));
+    assert!(helius_supported.supports_subscription(crate::WsSubscriptionKind::HeliusTransaction));
+    assert!(!helius_supported.supports_subscription(crate::WsSubscriptionKind::Block));
+    assert!(!helius_supported.supports_subscription(crate::WsSubscriptionKind::Vote));
+    let helius_settings = crate::WsTransportSettings::new(std::vec![helius_supported]);
+    assert!(helius_settings.validate().is_ok());
+}