imks/tests/engine_io_tests.rs

use imks::engine::codec;
use imks::engine::packet::{HandshakeData, Packet, PacketData, PacketType};

#[test]
fn test_engine_io_handshake_encoding() {
    let handshake = HandshakeData {
        sid: "lv_VI97HAXpY6yYWAAAC".to_string(),
        upgrades: vec!["websocket".to_string()],
        ping_interval: 25000,
        ping_timeout: 20000,
        max_payload: 1000000,
    };

    let packet = Packet::open(&handshake);
    let encoded = codec::encode_packet(&packet);

    assert!(encoded.starts_with('0'));
    assert!(encoded.contains("\"sid\":\"lv_VI97HAXpY6yYWAAAC\""));
    assert!(encoded.contains("\"upgrades\":[\"websocket\"]"));
    assert!(encoded.contains("\"pingInterval\":25000"));
    assert!(encoded.contains("\"pingTimeout\":20000"));
    assert!(encoded.contains("\"maxPayload\":1000000"));
}

#[test]
fn test_engine_io_packet_types() {
    let open = Packet::open(&HandshakeData {
        sid: "test".to_string(),
        upgrades: vec![],
        ping_interval: 25000,
        ping_timeout: 20000,
        max_payload: 1000000,
    });
    assert_eq!(open.packet_type, PacketType::Open);

    let close = Packet::close();
    assert_eq!(close.packet_type, PacketType::Close);

    let ping = Packet::ping("test");
    assert_eq!(ping.packet_type, PacketType::Ping);

    let pong = Packet::pong("test");
    assert_eq!(pong.packet_type, PacketType::Pong);

    let msg = Packet::message_text("hello");
    assert_eq!(msg.packet_type, PacketType::Message);

    let upgrade = Packet::upgrade();
    assert_eq!(upgrade.packet_type, PacketType::Upgrade);

    let noop = Packet::noop();
    assert_eq!(noop.packet_type, PacketType::Noop);
}

#[test]
fn test_engine_io_polling_payload() {
    let packets = vec![
        Packet::message_text("hello"),
        Packet::ping(""),
        Packet::message_text("world"),
    ];

    let encoded = codec::encode_payload(&packets);
    assert_eq!(encoded, "4hello\x1e2\x1e4world");

    let decoded = codec::decode_payload(&encoded).unwrap();
    assert_eq!(decoded.len(), 3);
    assert_eq!(decoded[0].packet_type, PacketType::Message);
    assert_eq!(decoded[1].packet_type, PacketType::Ping);
    assert_eq!(decoded[2].packet_type, PacketType::Message);
}

#[test]
fn test_engine_io_binary_encoding() {
    let packet = Packet::message_binary(vec![0x01, 0x02, 0x03, 0x04]);
    let encoded = codec::encode_packet(&packet);
    assert_eq!(encoded, "4bAQIDBA==");

    let decoded = codec::decode_packet(&encoded).unwrap();
    assert_eq!(decoded.packet_type, PacketType::Message);
    assert_eq!(decoded.data, PacketData::Binary(vec![0x01, 0x02, 0x03, 0x04]));
}

#[test]
fn test_engine_io_webtransport_header_encoding() {
    let header = codec::encode_webtransport_header(6, false);
    assert_eq!(header, vec![0x06]);

    let header = codec::encode_webtransport_header(200, true);
    assert_eq!(header.len(), 3);
    assert_eq!(header[0], 0x80 | 126);

    let header = codec::encode_webtransport_header(70000, false);
    assert_eq!(header.len(), 9);
    assert_eq!(header[0], 127);
}

#[test]
fn test_engine_io_webtransport_header_decoding() {
    let header = vec![0x06];
    let (len, is_binary) = codec::decode_webtransport_header(&header).unwrap();
    assert_eq!(len, 6);
    assert!(!is_binary);

    let header = vec![0x80 | 126, 0x00, 0xC8];
    let (len, is_binary) = codec::decode_webtransport_header(&header).unwrap();
    assert_eq!(len, 200);
    assert!(is_binary);
}

#[test]
fn test_engine_io_probe_ping_pong() {
    let ping = Packet::ping("probe");
    let encoded = codec::encode_packet(&ping);
    assert_eq!(encoded, "2probe");

    let decoded = codec::decode_packet(&encoded).unwrap();
    assert_eq!(decoded.packet_type, PacketType::Ping);
    assert_eq!(decoded.data, PacketData::Text("probe".to_string()));

    let pong = Packet::pong("probe");
    let encoded = codec::encode_packet(&pong);
    assert_eq!(encoded, "3probe");

    let decoded = codec::decode_packet(&encoded).unwrap();
    assert_eq!(decoded.packet_type, PacketType::Pong);
    assert_eq!(decoded.data, PacketData::Text("probe".to_string()));
}

#[test]
fn test_engine_io_upgrade_packet() {
    let upgrade = Packet::upgrade();
    let encoded = codec::encode_packet(&upgrade);
    assert_eq!(encoded, "5");

    let decoded = codec::decode_packet(&encoded).unwrap();
    assert_eq!(decoded.packet_type, PacketType::Upgrade);
}

#[test]
fn test_engine_io_noop_packet() {
    let noop = Packet::noop();
    let encoded = codec::encode_packet(&noop);
    assert_eq!(encoded, "6");

    let decoded = codec::decode_packet(&encoded).unwrap();
    assert_eq!(decoded.packet_type, PacketType::Noop);
}

#[test]
fn test_engine_io_close_packet() {
    let close = Packet::close();
    let encoded = codec::encode_packet(&close);
    assert_eq!(encoded, "1");

    let decoded = codec::decode_packet(&encoded).unwrap();
    assert_eq!(decoded.packet_type, PacketType::Close);
}