sockchat-rs/tests/frames_probe.rs

//! Dumps raw websocket frames so we can see every key the server sends, not
//! just the ones the client currently deserializes.
//!
//! Uses the saved session; no credentials needed.
//!
//!   cargo test --test frames_probe -- --ignored --nocapture

use std::collections::BTreeSet;
use std::time::Duration;

use futures_util::{SinkExt, StreamExt};
use sockchat::config::Config;
use sockchat::net::Transport;
use sockchat::net::http::{CookieJar, HttpClient};
use tokio_tungstenite::tungstenite::Message as WsMessage;

#[tokio::test]
#[ignore = "requires network and bootstraps Tor"]
async fn probe_socket_frames() {
    sockchat::net::init_crypto();
    let cfg = Config::load().expect("config");
    let transport = Transport::bootstrap_tor().await.expect("Tor bootstrap");

    // Clear the gate over HTTP first so the upgrade is not challenged.
    let jar = CookieJar::new();
    jar.seed(&cfg.cookies);
    let _ = sockchat::auth::store::load(&jar);
    let http = HttpClient::new(transport.clone(), jar.clone(), cfg.user_agent.clone());
    match sockchat::net::kiwiflare::clear(&http, &cfg.http_url(), 8).await {
        Ok(n) => eprintln!("cleared gate ({n})"),
        Err(e) => eprintln!("gate: {e:#}"),
    }

    let ws = sockchat::chat::socket::connect(&cfg, &transport, jar.header())
        .await
        .expect("websocket");
    let (mut sink, mut stream) = ws.split();
    sink.send(WsMessage::text(format!("/join {}", cfg.room)))
        .await
        .expect("join");

    let mut keys_seen: BTreeSet<String> = BTreeSet::new();
    let deadline = tokio::time::Instant::now() + Duration::from_secs(45);

    for i in 0..40 {
        let frame = match tokio::time::timeout_at(deadline, stream.next()).await {
            Ok(Some(Ok(f))) => f,
            Ok(Some(Err(e))) => {
                eprintln!("stream error: {e}");
                break;
            }
            Ok(None) => break,
            Err(_) => {
                eprintln!("-- no more frames within the deadline --");
                break;
            }
        };

        let text = match frame {
            WsMessage::Text(t) => t.to_string(),
            WsMessage::Binary(b) => String::from_utf8_lossy(&b).into_owned(),
            other => {
                eprintln!("[{i}] non-text frame: {other:?}");
                continue;
            }
        };

        // Record the top-level keys of every JSON object we see.
        if let Ok(serde_json::Value::Object(map)) = serde_json::from_str::<serde_json::Value>(&text)
        {
            for k in map.keys() {
                keys_seen.insert(k.clone());
            }
            eprintln!("[{i}] object keys: {:?}", map.keys().collect::<Vec<_>>());
            // Print anything that is not the bulk message/user payload in full.
            for (k, v) in &map {
                if k == "messages" || k == "users" {
                    eprintln!(
                        "      {k}: <{} entries>",
                        v.as_array().map(|a| a.len()).unwrap_or(0)
                    );
                    continue;
                }
                let rendered = serde_json::to_string(v).unwrap_or_default();
                eprintln!(
                    "      {k}: {}",
                    rendered.chars().take(1200).collect::<String>()
                );
            }
        } else {
            eprintln!(
                "[{i}] plaintext: {}",
                text.chars().take(200).collect::<String>()
            );
        }
    }

    eprintln!("\n=== all top-level keys observed ===\n{keys_seen:?}");
}