open-net 0.3.5

A cross-platform async networking library for Rust with HTTP and WebSocket clients, network status monitoring, configurable retries, WebSocket reconnection and heartbeats, and managed client lifecycles. Reuse common networking infrastructure across applications to avoid repeated implementation and debugging, helping save development time and AI coding tokens.
Documentation
use super::{HandshakeBodyCaptureState, HandshakeDiagnostic, HandshakeDiagnosticOptions};
use crate::error::ErrorKind;
use crate::module::ws_client::test_support::{check, check_eq, TestResult};

#[test]
fn public_code_configuration_is_borrowed_and_revalidated_after_mutation() -> TestResult {
    let mut options = HandshakeDiagnosticOptions {
        public_json_codes: vec!["CODE_1".to_owned(), "CODE_1".to_owned(), "Z".repeat(64)],
    };
    let pointer = options.public_json_codes.as_ptr();
    let expected = options.public_json_codes.clone();
    options.validate()?;
    check_eq!(options.public_json_codes.as_ptr(), pointer)?;
    check_eq!(options.public_json_codes, expected)?;
    options
        .public_json_codes
        .push("sensitive-invalid-code".to_owned());
    let error = options
        .validate()
        .err()
        .ok_or("invalid public field was accepted")?;
    check_eq!(error.kind(), ErrorKind::InvalidConfig)?;
    let config = error
        .config_error()
        .ok_or("missing diagnostic ConfigError")?;
    check_eq!(config.field(), "diagnostics.public_json_codes")?;
    check!(!config.reason().contains("sensitive-invalid-code"))?;
    check!(!format!("{options:?} {error:?} {error}").contains("sensitive-invalid-code"))?;
    Ok(())
}

#[test]
fn diagnostic_headers_are_an_owned_normalized_header_map() -> TestResult {
    let options = HandshakeDiagnosticOptions {
        public_json_codes: vec!["PUBLIC_CODE".to_owned()],
    };
    options.validate()?;
    let body = br#"{"code":"PUBLIC_CODE","message":"BODY_SECRET"}"#;
    let length = body.len().to_string();
    let diagnostic = HandshakeDiagnostic::http(
        &options,
        [
            (
                "Content-Type",
                b"Application/Problem+JSON; secret=HEADER_SECRET".as_slice(),
            ),
            ("Content-Length", length.as_bytes()),
            ("Retry-After", b" 0007\t".as_slice()),
            ("Set-Cookie", b"COOKIE_SECRET".as_slice()),
        ]
        .into_iter(),
        Some(body),
    );
    let headers: &http::HeaderMap = diagnostic.headers();
    check_eq!(headers.len(), 2)?;
    check_eq!(
        headers
            .get(http::header::CONTENT_TYPE)
            .ok_or("missing safe content-type")?
            .to_str()?,
        "application/problem+json"
    )?;
    check_eq!(
        headers
            .get(http::header::RETRY_AFTER)
            .ok_or("missing safe retry-after")?
            .to_str()?,
        "7"
    )?;
    check_eq!(
        diagnostic.body_capture_state(),
        HandshakeBodyCaptureState::Captured
    )?;
    check_eq!(diagnostic.body_summary(), Some("code=PUBLIC_CODE"))?;
    let owned = diagnostic.clone();
    drop(diagnostic);
    check_eq!(owned.headers().len(), 2)?;
    let debug = format!("{owned:?} {options:?}");
    for hidden in [
        "PUBLIC_CODE",
        "BODY_SECRET",
        "HEADER_SECRET",
        "COOKIE_SECRET",
        "application/problem+json",
    ] {
        check!(!debug.contains(hidden), "Debug leaked {hidden}")?;
    }
    Ok(())
}