Files
cngo/tests/e2e.rs
T
rong cb28bbb49e feat: 围棋在线对战(Rust 服务端 + 零构建前端)
- 规则引擎:提子、禁自杀、全局同形(超级劫)、中国规则数子(白贴 7.5 目)、停一手终局
- 服务端:axum + tokio,房间/观战/包干计时/断线重连/语音中继,前端资源内嵌单文件
- 前端:Canvas 木纹棋盘(9/13/19 路、星位、四边坐标、翻转视角)、WebAudio 合成落子声、
  本机双人模式、终局数子面板
- 测试:16 组规则断言 + 5 组 e2e(提子/劫/数子/观战/语音/静态资源)
- 构建缓存遵循 dev-cache-layout:target/ 留项目内并忽略,前端零构建不产生包缓存
2026-10-23 10:12:55 +08:00

331 lines
11 KiB
Rust

//! 联机 e2e:双客户端 + 观战 + 落子 + 提子 + 停一手数子 + 认输 + 再来一局 + HTTP 静态资源
use std::time::Duration;
use futures_util::{SinkExt, StreamExt};
use serde_json::{json, Value};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tokio_tungstenite::tungstenite::Message;
use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
use cngo::server::{self, App};
type Ws = WebSocketStream<MaybeTlsStream<TcpStream>>;
const TIMEOUT: Duration = Duration::from_secs(5);
async fn start() -> u16 {
let app = App::new();
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
let _ = server::serve(listener, app).await;
});
port
}
async fn conn(port: u16) -> Ws {
let (ws, _) = connect_async(format!("ws://127.0.0.1:{port}/ws"))
.await
.expect("连不上 websocket");
ws
}
async fn send(ws: &mut Ws, v: Value) {
ws.send(Message::Text(v.to_string().into()))
.await
.expect("发送失败");
}
async fn recv_json(ws: &mut Ws) -> Value {
loop {
let next = tokio::time::timeout(TIMEOUT, ws.next())
.await
.expect("等服务端消息超时")
.expect("连接已关闭")
.expect("websocket 错误");
if let Message::Text(t) = next {
return serde_json::from_str(&t).expect("服务端返回的不是 JSON");
}
}
}
/// 跳过 clock 心跳,只取全量 state
async fn recv_state(ws: &mut Ws) -> Value {
loop {
let v = recv_json(ws).await;
if v["t"] == "state" {
return v;
}
}
}
/// 一直读到满足条件的 state(广播会积压,用条件筛而不是按顺序数)
async fn state_where(ws: &mut Ws, mut f: impl FnMut(&Value) -> bool) -> Value {
loop {
let v = recv_state(ws).await;
if f(&v) {
return v;
}
}
}
/// 一直读到指定类型的消息
async fn msg_of(ws: &mut Ws, tag: &str) -> Value {
loop {
let v = recv_json(ws).await;
if v["t"] == tag {
return v;
}
}
}
fn idx(x: i64, y: i64) -> i64 {
y * 9 + x
}
#[tokio::test]
async fn two_players_play_a_short_game() {
let port = start().await;
let mut black = conn(port).await;
let mut white = conn(port).await;
// 黑方建房(9 路,5 分钟)
send(&mut black, json!({"t": "create", "minutes": 5, "size": 9})).await;
let s = recv_state(&mut black).await;
let code = s["code"].as_str().unwrap().to_string();
assert_eq!(code.len(), 4);
assert_eq!(s["size"], 9);
assert_eq!(s["you"], "b");
assert_eq!(s["turn"], "b");
assert_eq!(s["totalMs"], 300_000);
assert_eq!(s["board"].as_str().unwrap().len(), 81);
assert_eq!(s["spectating"], false);
assert_eq!(s["passes"], 0);
assert_eq!(s["komi"], 7.5);
// 白方加入
send(&mut white, json!({"t": "join", "code": code})).await;
let s = recv_state(&mut white).await;
assert_eq!(s["you"], "w");
assert_eq!(s["players"]["b"]["connected"], true);
assert_eq!(s["players"]["w"]["connected"], true);
let _ = state_where(&mut black, |v| v["players"]["w"]["connected"] == true).await;
// 黑落天元 E5
send(&mut black, json!({"t": "move", "at": idx(4, 4)})).await;
let s = state_where(&mut black, |v| {
v["history"].as_array().is_some_and(|h| !h.is_empty())
})
.await;
assert_eq!(s["turn"], "w");
assert_eq!(s["history"][0]["note"], "E5");
assert_eq!(s["history"][0]["at"], idx(4, 4));
assert_eq!(s["history"][0]["color"], "b");
// 黑连着走两手:第二手会被挡回来
send(&mut black, json!({"t": "move", "at": idx(2, 2)})).await;
let e = msg_of(&mut black, "error").await;
assert_eq!(e["msg"], "还没轮到你落子");
// 白走 D7,黑再走同一个点 → 已经有子
send(&mut white, json!({"t": "move", "at": idx(3, 2)})).await;
let _ = state_where(&mut white, |v| v["turn"] == "b").await;
send(&mut black, json!({"t": "move", "at": idx(4, 4)})).await;
let e = msg_of(&mut black, "error").await;
assert_eq!(e["msg"], "这里已经有子了");
// 观战者
let mut spec = conn(port).await;
send(&mut spec, json!({"t": "join", "code": code, "spectate": true})).await;
let s = recv_state(&mut spec).await;
assert_eq!(s["spectating"], true);
assert!(s["you"].is_null());
assert_eq!(s["spectators"], 1);
send(&mut spec, json!({"t": "move", "at": idx(0, 0)})).await;
let e = msg_of(&mut spec, "error").await;
assert_eq!(e["msg"], "你在观战,不能落子");
// 黑停一手,白也停一手 → 数子终局
send(&mut black, json!({"t": "pass"})).await;
let _ = state_where(&mut black, |v| v["passes"] == 1).await;
send(&mut white, json!({"t": "pass"})).await;
let s = state_where(&mut black, |v| v["over"] == true).await;
assert_eq!(s["reason"], "scored");
assert!(s["score"].is_object(), "数子结果要带出来");
assert_eq!(s["score"]["komi"], 7.5);
assert_eq!(s["history"].as_array().unwrap().len(), 4);
assert_eq!(s["history"][3]["note"], "停一手");
assert!(s["history"][3]["at"].is_null());
// 双方都点再来一局 → 重置
send(&mut black, json!({"t": "rematch"})).await;
let _ = state_where(&mut black, |v| {
v["rematch"].as_array().is_some_and(|r| !r.is_empty())
})
.await;
send(&mut white, json!({"t": "rematch"})).await;
let s = state_where(&mut black, |v| v["over"] == false).await;
assert_eq!(s["turn"], "b");
assert_eq!(s["history"].as_array().unwrap().len(), 0);
assert_eq!(s["clocks"]["b"], 300_000);
assert!(s["score"].is_null());
assert_eq!(s["passes"], 0);
// 离开
send(&mut white, json!({"t": "leave"})).await;
let v = msg_of(&mut white, "left").await;
assert_eq!(v["t"], "left");
}
#[tokio::test]
async fn capture_and_resign() {
let port = start().await;
let mut black = conn(port).await;
let mut white = conn(port).await;
send(&mut black, json!({"t": "create", "minutes": 0, "size": 9})).await;
let s = recv_state(&mut black).await;
let code = s["code"].as_str().unwrap().to_string();
send(&mut white, json!({"t": "join", "code": code})).await;
let _ = recv_state(&mut white).await;
// 黑 B9 → 白 A9(角上)→ 黑 A8 提掉角上一子
send(&mut black, json!({"t": "move", "at": idx(1, 0)})).await;
let _ = state_where(&mut white, |v| v["turn"] == "w").await;
send(&mut white, json!({"t": "move", "at": idx(0, 0)})).await;
let _ = state_where(&mut black, |v| v["turn"] == "b").await;
send(&mut black, json!({"t": "move", "at": idx(0, 1)})).await;
let s = state_where(&mut black, |v| {
v["history"].as_array().is_some_and(|h| h.len() == 3)
})
.await;
assert_eq!(s["history"][2]["cap"], 1, "角上一子被提");
assert_eq!(s["captures"]["b"], 1);
assert_eq!(s["captures"]["w"], 0);
let board = s["board"].as_str().unwrap();
assert_eq!(board.as_bytes()[0], b'.', "提掉之后 A9 应该空出来");
assert_eq!(s["history"][2]["note"], "A8");
// 白认输
send(&mut white, json!({"t": "resign"})).await;
let s = state_where(&mut black, |v| v["over"] == true).await;
assert_eq!(s["winner"], "b");
assert_eq!(s["reason"], "resign");
assert!(s["score"].is_null(), "认输不数子");
}
#[tokio::test]
async fn join_unknown_room_reports_error() {
let port = start().await;
let mut ws = conn(port).await;
send(&mut ws, json!({"t": "join", "code": "ZZZZ"})).await;
let v = recv_json(&mut ws).await;
assert_eq!(v["t"], "error");
assert!(v["msg"].as_str().unwrap().contains("房间不存在"));
}
#[tokio::test]
async fn static_and_health_endpoints() {
let port = start().await;
let body = http_get(port, "/health").await;
assert!(body.contains(r#""ok":true"#), "health 返回:{body}");
assert!(body.contains(r#""engine":"rust""#));
assert!(body.contains(r#""game":"go""#));
let html = http_get(port, "/").await;
assert!(html.contains("围棋"), "首页没内嵌进来");
assert!(html.contains("/js/client/main.js"), "首页没引用静态模块");
let js = http_get(port, "/js/client/main.js").await;
assert!(js.contains("from '../shared/rules.js'"), "静态 JS 没被服务");
let rules = http_get(port, "/js/shared/rules.js").await;
assert!(rules.contains("scoreArea"), "规则镜像没被服务");
// 未知路径回退首页(支持 #房号 邀请链接)
let fallback = http_get(port, "/some/deep/link").await;
assert!(fallback.contains("围棋"));
}
async fn http_get(port: u16, path: &str) -> String {
let mut stream = TcpStream::connect(("127.0.0.1", port)).await.unwrap();
let req = format!("GET {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n");
stream.write_all(req.as_bytes()).await.unwrap();
let mut buf = Vec::new();
tokio::time::timeout(TIMEOUT, stream.read_to_end(&mut buf))
.await
.expect("HTTP 读取超时")
.unwrap();
String::from_utf8_lossy(&buf).to_string()
}
#[tokio::test]
async fn voice_clips_roundtrip() {
let port = start().await;
let mut black = conn(port).await;
let mut white = conn(port).await;
send(&mut black, json!({"t": "create", "minutes": 0, "size": 13})).await;
let s = recv_state(&mut black).await;
let code = s["code"].as_str().unwrap().to_string();
assert_eq!(s["size"], 13);
assert!(s["voices"].as_array().unwrap().is_empty());
send(&mut white, json!({"t": "join", "code": code})).await;
let _ = recv_state(&mut white).await;
// 黑方按住说话发一条(这里只验证传输链路,data 是占位字节)
send(
&mut black,
json!({"t": "voice", "mime": "audio/webm", "durationMs": 1200, "data": "QUJDRA=="}),
)
.await;
let a = msg_of(&mut black, "voice").await;
let b = msg_of(&mut white, "voice").await;
assert_eq!(a["id"], 1);
assert_eq!(b["id"], 1, "对方也要收到同一条");
assert_eq!(a["from"], "b");
assert_eq!(a["durationMs"], 1200);
assert_eq!(a["mime"], "audio/webm");
assert_eq!(a["data"], "QUJDRA==");
// 观战者进房间:state 里只带元信息,不带音频本体
let mut spec = conn(port).await;
send(&mut spec, json!({"t": "join", "code": code, "spectate": true})).await;
let s = recv_state(&mut spec).await;
let voices = s["voices"].as_array().unwrap();
assert_eq!(voices.len(), 1);
assert_eq!(voices[0]["id"], 1);
assert_eq!(voices[0]["from"], "b");
assert!(voices[0].get("data").is_none(), "state 不该塞音频本体");
// 点历史记录才单独取音频
send(&mut spec, json!({"t": "voiceGet", "id": 1})).await;
let d = msg_of(&mut spec, "voiceData").await;
assert_eq!(d["id"], 1);
assert_eq!(d["data"], "QUJDRA==");
// 观战只能听不能发
send(
&mut spec,
json!({"t": "voice", "mime": "audio/webm", "durationMs": 800, "data": "QUJDRA=="}),
)
.await;
let e = msg_of(&mut spec, "error").await;
assert_eq!(e["msg"], "观战不能发语音");
// 超长语音被拒
let big = "A".repeat(700 * 1024);
send(
&mut black,
json!({"t": "voice", "mime": "audio/webm", "durationMs": 30000, "data": big}),
)
.await;
let e = msg_of(&mut black, "error").await;
assert!(e["msg"].as_str().unwrap().contains("太长"));
}