- 规则引擎:提子、禁自杀、全局同形(超级劫)、中国规则数子(白贴 7.5 目)、停一手终局 - 服务端:axum + tokio,房间/观战/包干计时/断线重连/语音中继,前端资源内嵌单文件 - 前端:Canvas 木纹棋盘(9/13/19 路、星位、四边坐标、翻转视角)、WebAudio 合成落子声、 本机双人模式、终局数子面板 - 测试:16 组规则断言 + 5 组 e2e(提子/劫/数子/观战/语音/静态资源) - 构建缓存遵循 dev-cache-layout:target/ 留项目内并忽略,前端零构建不产生包缓存
331 lines
11 KiB
Rust
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("太长"));
|
|
}
|