Panel: plugin integrations (LuckPerms ranks + group mapping, reports), server event queue, developer API endpoints

panel/server/tests/integrations.rs

@@ -0,0 +1,160 @@
+//! Plugin integrations (LuckPerms ranks and group mapping) and the events
+//! handed back to game servers with their sync.
+
+mod common;
+use common::*;
+
+struct Env {
+    t: TestApp,
+    admin: String,
+    server: String,
+    sid: i64,
+}
+
+async fn env() -> Env {
+    let t = setup().await;
+    let admin = t.login("admin", "supersecret").await;
+    let (_, srv) = t.call("POST", "/api/admin/servers", Some(&admin), Some(json!({"name": "SMP", "instance_id": "smp"}))).await;
+    Env { sid: srv["server"]["id"].as_i64().unwrap(), server: srv["token"].as_str().unwrap().to_string(), t, admin }
+}
+
+impl Env {
+    async fn player(&self, name: &str) -> (String, String) {
+        self.t.call("POST", "/api/admin/users", Some(&self.admin), Some(json!({"username": name, "password": "password123"}))).await;
+        (self.t.login(name, "password123").await, self.t.uuid(name).await)
+    }
+    async fn report(&self, name: &str, data: Value) -> (StatusCode, Value) {
+        self.t.call("POST", "/api/server/v1/integrations/report", Some(&self.server), Some(json!({"name": name, "version": "5.4.1", "data": data}))).await
+    }
+    async fn sync(&self, online: &[(&str, &str)]) -> Value {
+        let online: Vec<Value> = online.iter().map(|(u, n)| json!({"uuid": u, "name": n})).collect();
+        let (s, v) = self.t.call("POST", "/api/server/v1/sync", Some(&self.server), Some(json!({"online": online}))).await;
+        assert_eq!(s, StatusCode::OK, "{v}");
+        v
+    }
+    async fn groups_of(&self, name: &str) -> Vec<String> {
+        sqlx::query_scalar("SELECT g.name FROM groups g JOIN user_groups ug ON ug.group_id = g.id JOIN users u ON u.id = ug.user_id WHERE u.username = ? ORDER BY g.name")
+            .bind(name).fetch_all(&self.t.db).await.unwrap()
+    }
+}
+
+#[tokio::test]
+async fn luckperms_ranks_mapping_and_sync_modes() {
+    let e = env().await;
+    let (_, steve) = e.player("Steve").await;
+    let (_, alex) = e.player("Alex").await;
+    for g in ["VIP", "Staff"] {
+        e.t.call("POST", "/api/admin/groups", Some(&e.admin), Some(json!({"name": g, "color": "#ff0000"}))).await;
+    }
+    let (_, groups) = e.t.call("GET", "/api/admin/groups", Some(&e.admin), None).await;
+    let id = |n: &str| groups.as_array().unwrap().iter().find(|g| g["name"] == n).unwrap()["id"].as_i64().unwrap();
+    let (s, _) = e.t.call("PUT", &format!("/api/admin/groups/{}/luckperms", id("VIP")), Some(&e.admin), Some(json!({"luckperms_group": "vip"}))).await;
+    assert_eq!(s, StatusCode::OK);
+    let (s, _) = e.t.call("PUT", &format!("/api/admin/groups/{}/luckperms", id("Staff")), Some(&e.admin), Some(json!({"luckperms_group": "bad group!"}))).await;
+    assert_eq!(s, StatusCode::BAD_REQUEST);
+    e.t.call("PUT", &format!("/api/admin/groups/{}/luckperms", id("Staff")), Some(&e.admin), Some(json!({"luckperms_group": "Moderator"}))).await;
+
+    let lp = |steve_groups: Value| json!({
+        "groups": [{"name": "vip", "weight": 10}, {"name": "moderator", "weight": 50}],
+        "players": [
+            {"uuid": steve, "primary": "VIP", "display": "VIP", "prefix": "§6[VIP] ", "weight": 10, "groups": steve_groups, "permissions": ["scopenet.command.*", "essentials.fly"]},
+            {"uuid": alex, "primary": "default", "groups": ["default"]},
+            {"uuid": "not-a-uuid", "primary": "x"}
+        ]});
+
+    // Default mode is display-only: ranks are stored, no group changes.
+    let (s, r) = e.report("luckperms", lp(json!(["default", "vip"]))).await;
+    assert_eq!(s, StatusCode::OK, "{r}");
+    assert_eq!(r["config"]["mode"], "off");
+    assert!(e.groups_of("Steve").await.is_empty());
+    let (_, view) = e.t.call("GET", &format!("/api/admin/servers/{}/integrations", e.sid), Some(&e.admin), None).await;
+    let ranks = view["ranks"].as_array().unwrap();
+    assert_eq!(ranks.len(), 2);
+    assert_eq!(ranks[0]["name"], "Steve");
+    assert_eq!(ranks[0]["primary"], "vip");
+    assert_eq!(ranks[0]["prefix"], "§6[VIP] ");
+    assert_eq!(view["integrations"][0]["name"], "luckperms");
+    assert_eq!(view["integrations"][0]["data"]["groups"][1]["name"], "moderator");
+
+    // game_to_panel: mapped groups follow LuckPerms, including removal.
+    let (s, _) = e.t.call("PUT", "/api/admin/integrations/settings", Some(&e.admin), Some(json!({"luckperms_sync": "game_to_panel"}))).await;
+    assert_eq!(s, StatusCode::OK);
+    e.report("luckperms", lp(json!(["default", "vip", "moderator"]))).await;
+    assert_eq!(e.groups_of("Steve").await, ["Staff", "VIP"]);
+    let (_, r) = e.report("luckperms", lp(json!(["default"]))).await;
+    assert!(e.groups_of("Steve").await.is_empty(), "removed in LuckPerms, removed here");
+    assert!(r["config"]["assign"].as_array().unwrap().is_empty());
+
+    // panel_to_game: the panel's groups are pushed to the game as assignments.
+    sqlx::query("INSERT INTO user_groups (user_id, group_id) SELECT u.id, ? FROM users u WHERE u.username = 'Alex'").bind(id("VIP")).execute(&e.t.db).await.unwrap();
+    e.t.call("PUT", "/api/admin/integrations/settings", Some(&e.admin), Some(json!({"luckperms_sync": "panel_to_game"}))).await;
+    let (_, r) = e.report("luckperms", lp(json!(["default", "moderator"]))).await;
+    let assign = r["config"]["assign"].as_array().unwrap();
+    let for_alex = assign.iter().find(|a| a["uuid"] == alex).unwrap();
+    assert_eq!(for_alex["add"], json!(["vip"]));
+    let for_steve = assign.iter().find(|a| a["uuid"] == steve).unwrap();
+    assert_eq!(for_steve["remove"], json!(["moderator"]), "LuckPerms has a mapped group the panel doesn't");
+
+    let (s, _) = e.t.call("PUT", "/api/admin/integrations/settings", Some(&e.admin), Some(json!({"luckperms_sync": "sideways"}))).await;
+    assert_eq!(s, StatusCode::BAD_REQUEST);
+    let (s, _) = e.report("nonsense", json!({})).await;
+    assert_eq!(s, StatusCode::BAD_REQUEST);
+    let (s, _) = e.t.call("POST", "/api/server/v1/integrations/report", None, Some(json!({"name": "spark"}))).await;
+    assert_eq!(s, StatusCode::UNAUTHORIZED);
+}
+
+#[tokio::test]
+async fn other_integrations_are_stored_per_server() {
+    let e = env().await;
+    e.report("spark", json!({"tps": {"m1": 19.98}, "mspt": {"mean": 12.5, "p95": 31.0}})).await;
+    e.report("worldguard", json!({"regions": [{"world": "world", "id": "spawn", "min": [-50, 0, -50], "max": [50, 255, 50], "owners": ["admin"]}]})).await;
+    e.report("spark", json!({"tps": {"m1": 20.0}})).await;
+    let (_, view) = e.t.call("GET", &format!("/api/admin/servers/{}/integrations", e.sid), Some(&e.admin), None).await;
+    let names: Vec<&str> = view["integrations"].as_array().unwrap().iter().map(|i| i["name"].as_str().unwrap()).collect();
+    assert_eq!(names, ["spark", "worldguard"]);
+    assert_eq!(view["integrations"][0]["data"]["tps"]["m1"], 20.0, "the latest report replaces the previous one");
+    let big = json!({"pad": "x".repeat(1_100_000)});
+    assert_eq!(e.report("worldguard", big).await.0, StatusCode::BAD_REQUEST);
+}
+
+#[tokio::test]
+async fn game_servers_receive_events_with_their_sync() {
+    let e = env().await;
+    let (_, steve) = e.player("Steve").await;
+    let (_, alex) = e.player("Alex").await;
+    assert!(e.sync(&[(&steve, "Steve")]).await["notifications"].as_array().unwrap().is_empty());
+
+    // Level-ups: global and per-server.
+    let adjust = |scope: &str, mode: &str, amount: i64| {
+        let (t, admin, uuid, sid) = (&e.t, e.admin.clone(), steve.clone(), e.sid);
+        let body = if scope == "global" { json!({"scope": "global", "mode": mode, "amount": amount}) } else { json!({"scope": "server", "server_id": sid, "mode": mode, "amount": amount}) };
+        async move { t.call("POST", &format!("/api/admin/progression/players/{uuid}/adjust"), Some(&admin), Some(body)).await }
+    };
+    adjust("global", "set_xp", 10).await;
+    adjust("global", "set_xp", 1200).await; // level 1 -> 5
+    adjust("server", "set_xp", 10).await;
+    adjust("server", "set_xp", 300).await; // level 1 -> 2
+    let n = e.sync(&[(&steve, "Steve")]).await["notifications"].clone();
+    let kinds: Vec<(&str, &str)> = n.as_array().unwrap().iter().map(|x| (x["kind"].as_str().unwrap(), x["data"]["scope"].as_str().unwrap_or(""))).collect();
+    assert_eq!(kinds, [("level_up", "global"), ("level_up", "server")], "{n}");
+    assert_eq!((n[0]["data"]["previous"].as_i64(), n[0]["data"]["level"].as_i64()), (Some(1), Some(5)));
+    assert_eq!(n[0]["uuid"], steve);
+    // Delivered once.
+    assert!(e.sync(&[(&steve, "Steve")]).await["notifications"].as_array().unwrap().is_empty());
+    // Dropping levels doesn't announce anything.
+    adjust("global", "reset", 0).await;
+    assert!(e.sync(&[(&steve, "Steve")]).await["notifications"].as_array().unwrap().is_empty());
+
+    // Achievements and guild changes.
+    let ach: String = sqlx::query_scalar("SELECT id FROM achievements LIMIT 1").fetch_one(&e.t.db).await.unwrap();
+    sqlx::query("INSERT INTO user_achievements (user_uuid, achievement_id, unlocked_at) VALUES (?, ?, 'now')").bind(&steve).bind(&ach).execute(&e.t.db).await.unwrap();
+    sqlx::query("INSERT INTO guilds (id, instance_id, name, tag, leader_uuid, created_at) VALUES ('g1', 'smp', 'Iron', 'IRON', ?, 'now')").bind(&alex).execute(&e.t.db).await.unwrap();
+    sqlx::query("INSERT INTO guild_members (guild_id, uuid, name, role, joined_at) VALUES ('g1', ?, 'Steve', 'member', 'now')").bind(&steve).execute(&e.t.db).await.unwrap();
+    sqlx::query("INSERT INTO guild_members (guild_id, uuid, name, role, joined_at) VALUES ('g1', ?, 'Alex', 'leader', 'now')").bind(&alex).execute(&e.t.db).await.unwrap();
+    sqlx::query("DELETE FROM guild_members WHERE uuid = ?").bind(&steve).execute(&e.t.db).await.unwrap();
+    let n = e.sync(&[(&steve, "Steve")]).await["notifications"].clone();
+    let kinds: Vec<&str> = n.as_array().unwrap().iter().map(|x| x["kind"].as_str().unwrap()).collect();
+    assert_eq!(kinds, ["achievement", "guild_join", "guild_leave"], "Alex was offline, so only Steve's events: {n}");
+    assert_eq!(n[0]["data"]["id"], ach);
+    assert_eq!(n[1]["data"]["tag"], "IRON");
+}