open-net 0.3.2

A cross-platform async networking library with WebSocket clients and network status monitoring.
Documentation
use super::{validate_credential_version, validate_metadata, validate_metadata_lengths};
use crate::error::{ErrorKind, ErrorStage};
use crate::{Metadata, NetError};

type TestResult = std::result::Result<(), crate::BoxError>;

fn check_config_error(error: NetError, field: &str, limit: &str) -> TestResult {
    if error.kind() != ErrorKind::InvalidConfig
        || error.context().stage != Some(ErrorStage::Configuration)
    {
        return Err("value limit failure lost its configuration classification".into());
    }
    let detail = error
        .config_error()
        .ok_or("configuration details missing")?;
    if detail.field() != field
        || !detail.reason().contains(limit)
        || !detail.reason().contains("UTF-8")
        || !detail.reason().contains("bytes")
    {
        return Err("value limit failure did not identify its field and byte limit".into());
    }
    Ok(())
}

#[test]
fn empty_metadata_is_valid() -> TestResult {
    validate_metadata(&Metadata::new())?;
    validate_metadata(&Metadata::from([(String::new(), String::new())]))?;
    Ok(())
}

#[test]
fn metadata_counts_utf8_bytes_across_keys_and_values() -> TestResult {
    let metadata = Metadata::from([
        ("Γ©".repeat(2_048), "δΈ­".repeat(2_048)),
        ("πŸ˜€".to_owned(), "v".repeat(6_140)),
    ]);
    validate_metadata(&metadata)?;
    let mut over_limit = metadata.clone();
    over_limit.insert(String::new(), "x".to_owned());
    let error = validate_metadata(&over_limit)
        .err()
        .ok_or("metadata above 16384 UTF-8 bytes was accepted")?;
    check_config_error(error, "metadata", "16384")
}

#[test]
fn metadata_key_bytes_alone_can_reach_or_exceed_the_limit() -> TestResult {
    validate_metadata(&Metadata::from([("x".repeat(16_384), String::new())]))?;
    let error = validate_metadata(&Metadata::from([("x".repeat(16_385), String::new())]))
        .err()
        .ok_or("oversized metadata key was accepted")?;
    check_config_error(error, "metadata", "16384")
}

#[test]
fn metadata_validation_preserves_all_input_on_success_and_failure() -> TestResult {
    for (metadata, valid) in [
        (
            Metadata::from([
                ("  label\n".to_owned(), " value πŸ˜€ \0".to_owned()),
                (String::new(), String::new()),
            ]),
            true,
        ),
        (
            Metadata::from([("key".to_owned(), "Γ©".repeat(8_193))]),
            false,
        ),
    ] {
        let before = metadata.clone();
        if validate_metadata(&metadata).is_ok() != valid {
            return Err("metadata validation imposed a constraint beyond its byte limit".into());
        }
        if metadata != before {
            return Err("metadata validation changed its borrowed input".into());
        }
    }
    Ok(())
}

#[test]
fn metadata_length_arithmetic_rejects_overflow_without_large_allocations() -> TestResult {
    for lengths in [vec![(usize::MAX, 1)], vec![(16_384, 0), (usize::MAX, 0)]] {
        let error = validate_metadata_lengths(lengths)
            .err()
            .ok_or("metadata byte count overflow was accepted")?;
        check_config_error(error, "metadata", "16384")?;
    }
    Ok(())
}

#[test]
fn credential_version_uses_utf8_byte_boundaries() -> TestResult {
    validate_credential_version("")?;
    validate_credential_version(&"v".repeat(256))?;
    validate_credential_version(&"πŸ˜€".repeat(64))?;
    for version in ["v".repeat(257), format!("{}a", "πŸ˜€".repeat(64))] {
        let error = validate_credential_version(&version)
            .err()
            .ok_or("credential version above 256 UTF-8 bytes was accepted")?;
        check_config_error(error, "credential_version", "256")?;
    }
    Ok(())
}

#[test]
fn credential_version_validation_preserves_input_on_success_and_failure() -> TestResult {
    for (version, valid) in [
        ("  release δΈ­\n\0".to_owned(), true),
        ("πŸ˜€".repeat(65), false),
    ] {
        let before = version.clone();
        if validate_credential_version(&version).is_ok() != valid {
            return Err(
                "credential version validation imposed a constraint beyond its byte limit".into(),
            );
        }
        if version != before {
            return Err("credential version validation changed its borrowed input".into());
        }
    }
    Ok(())
}