gatewayd: mm, Mattermost's events and REST calls, typed

Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)
2026-09-23 21:04:00 -07:00
parent 74e08a5b1a
commit 18fddd03d9
7 changed files with 912 additions and 0 deletions
@@ -0,0 +1,173 @@
+//! Mattermost's JSON: events as the server sends them (v11.11.0 shapes), the typing request, and
+//! the `posts?since` list, whose edited, deleted and root-only posts must not be answered (M4a spec,
+//! sections 7 and 9). Do not edit.
+
+use gatewayd::mm::{Event, MmError, SINCE_LIMIT, parse_event, since_list, typing};
+use serde_json::json;
+
+const KYLE: &str = "k0000000000000000000000000";
+const DM: &str = "d0000000000000000000000000";
+
+fn post(id: &str, create_at: i64) -> serde_json::Value {
+    json!({
+        "id": id, "create_at": create_at, "update_at": create_at, "edit_at": 0, "delete_at": 0,
+        "is_pinned": false, "user_id": KYLE, "channel_id": DM, "root_id": "", "original_id": "",
+        "message": "hello", "type": "", "props": {"from_bot": "true"}, "hashtags": "",
+        "pending_post_id": "", "reply_count": 0, "metadata": {}
+    })
+}
+
+fn id(n: u32) -> String {
+    format!("p{n:025}")
+}
+
+fn posted(post: &serde_json::Value, channel_type: &str) -> String {
+    json!({
+        "event": "posted",
+        "data": {
+            "channel_display_name": "@kyle", "channel_name": "x__y", "channel_type": channel_type,
+            "post": post.to_string(), "sender_name": "@kyle", "set_online": true, "team_id": ""
+        },
+        "broadcast": {"omit_users": null, "user_id": "", "channel_id": DM, "team_id": ""},
+        "seq": 3
+    })
+    .to_string()
+}
+
+#[test]
+fn hello_replies_and_other_events() {
+    let hello =
+        json!({"event": "hello", "data": {"server_version": "11.11.0"}, "broadcast": {}, "seq": 0});
+    assert_eq!(parse_event(&hello.to_string()).unwrap(), Event::Hello);
+    assert_eq!(
+        parse_event(r#"{"status":"OK","seq_reply":1}"#).unwrap(),
+        Event::Other(String::new())
+    );
+    let typing = json!({"event": "typing", "data": {"parent_id": ""}, "broadcast": {}, "seq": 4});
+    assert_eq!(
+        parse_event(&typing.to_string()).unwrap(),
+        Event::Other("typing".to_string())
+    );
+}
+
+#[test]
+fn a_posted_event_carries_the_post_as_a_string() {
+    let mut p = post(&id(1), 1_758_650_000_123);
+    p["root_id"] = json!(id(0));
+    p["message"] = json!("line one\nline two");
+    let Event::Posted { post, channel_type } = parse_event(&posted(&p, "D")).unwrap() else {
+        panic!("not a post")
+    };
+    assert_eq!(channel_type, "D");
+    assert_eq!(
+        (post.id.as_str(), post.root_id.as_str()),
+        (id(1).as_str(), id(0).as_str())
+    );
+    assert_eq!(
+        (post.user_id.as_str(), post.channel_id.as_str()),
+        (KYLE, DM)
+    );
+    assert_eq!(
+        (post.message.as_str(), post.create_at, post.kind.as_str()),
+        ("line one\nline two", 1_758_650_000_123, "")
+    );
+    let mut s = self::post(&id(2), 5);
+    s["type"] = json!("system_join_channel");
+    let Event::Posted { post, .. } = parse_event(&posted(&s, "O")).unwrap() else {
+        panic!()
+    };
+    assert_eq!(post.kind, "system_join_channel");
+}
+
+#[test]
+fn bad_posts_are_errors_not_panics() {
+    let p = post(&id(1), 5);
+    let as_object =
+        json!({"event": "posted", "data": {"post": p, "channel_type": "D"}}).to_string();
+    let mut cases = vec![
+        as_object,
+        "not json".to_string(),
+        "[1,2]".to_string(),
+        "{\"event\":5}".to_string(),
+    ];
+    for (field, value) in [
+        ("id", json!("../../etc")),
+        ("user_id", json!("")),
+        ("channel_id", json!("A0000000000000000000000000")),
+        ("root_id", json!("short")),
+        ("create_at", json!("soon")),
+    ] {
+        let mut bad = post(&id(1), 5);
+        bad[field] = value;
+        cases.push(posted(&bad, "D"));
+    }
+    let mut missing = post(&id(1), 5);
+    missing.as_object_mut().unwrap().remove("create_at");
+    cases.push(posted(&missing, "D"));
+    for case in cases {
+        assert!(
+            matches!(parse_event(&case), Err(MmError::Json(_))),
+            "{case}"
+        );
+    }
+}
+
+#[test]
+fn the_typing_request() {
+    let got: serde_json::Value = serde_json::from_str(&typing(7, DM, &id(0))).unwrap();
+    assert_eq!(
+        got,
+        json!({"action": "user_typing", "seq": 7, "data": {"channel_id": DM, "parent_id": id(0)}})
+    );
+}
+
+#[test]
+fn since_keeps_new_posts_in_order_and_nothing_else() {
+    let since = 1000;
+    let mut edited = post(&id(1), 900);
+    edited["update_at"] = json!(1500);
+    let mut deleted = post(&id(2), 1100);
+    deleted["delete_at"] = json!(1200);
+    let root_only = post(&id(3), 10);
+    let later = post(&id(4), 1300);
+    let earlier = post(&id(5), 1200);
+    let at_since = post(&id(6), 1000);
+    let mut posts = serde_json::Map::new();
+    for p in [&edited, &deleted, &root_only, &later, &earlier, &at_since] {
+        posts.insert(p["id"].as_str().unwrap().to_string(), p.clone());
+    }
+    let order = json!([id(4), id(2), id(1), id(5), id(9), id(6)]);
+    let body = json!({"order": order, "posts": posts, "next_post_id": "", "prev_post_id": "", "has_next": false});
+    let got = since_list(body.to_string().as_bytes(), since).unwrap();
+    let ids: Vec<&str> = got.posts.iter().map(|p| p.id.as_str()).collect();
+    assert_eq!(ids, [id(5), id(4)]);
+    assert!(!got.full);
+}
+
+#[test]
+fn a_full_since_answer_says_so() {
+    let mut posts = serde_json::Map::new();
+    let mut order = Vec::new();
+    for n in 0..SINCE_LIMIT {
+        let n = u32::try_from(n).unwrap();
+        posts.insert(id(n), post(&id(n), 2000 + i64::from(n)));
+        order.push(id(n));
+    }
+    let body = json!({"order": order, "posts": posts});
+    let got = since_list(body.to_string().as_bytes(), 1000).unwrap();
+    assert!(got.full);
+    assert_eq!(got.posts.len(), SINCE_LIMIT);
+    let empty = since_list(br#"{"order":[],"posts":{}}"#, 0).unwrap();
+    assert!(empty.posts.is_empty() && !empty.full);
+}
+
+#[test]
+fn a_server_error_body_is_quoted_in_messages() {
+    let e = MmError::Status(500, "boom\ngatewayd: a forged line".to_string());
+    let text = e.to_string();
+    assert!(!text.contains('\n'), "{text}");
+    assert_eq!(
+        MmError::Auth(401).to_string(),
+        "Mattermost refused the token (401)"
+    );
+}