let notification flows start from submitted pull request reviews

swarm-notify-router/src/route.rs

@@ -78,7 +78,7 @@ pub fn route(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use swarm_wire::notify_flows::builtins;
+    use swarm_wire::notify_flows::{Condition, Edge, Node, NodeKind, builtins};
 
     fn delivery(action: &str, assignees: &[&str]) -> Delivery {
         Delivery {
@@ -248,4 +248,88 @@ mod tests {
         assert!(r.actions.is_empty());
         assert_eq!(r.next, before);
     }
+
+    /// The body Forgejo sends for a submitted review: a pull request payload
+    /// whose `sender` is the reviewer.
+    fn review_body(reviewer: &str) -> Vec<u8> {
+        serde_json::to_vec(&serde_json::json!({
+            "action": "reviewed",
+            "number": 9,
+            "pull_request": {
+                "number": 9,
+                "title": "t",
+                "html_url": "u",
+                "assignees": [],
+            },
+            "repository": { "id": 1, "full_name": "o/r" },
+            "sender": { "login": reviewer },
+            "review": { "type": "pull_request_review_approved", "content": "" },
+        }))
+        .expect("encodes")
+    }
+
+    /// "A review by the classifier on a PR → request argus's review", as a
+    /// user builds it: valid, routed from the delivery body, and gated on the
+    /// reviewer.
+    #[test]
+    fn a_review_by_the_classifier_requests_argus() {
+        let id = |s: &str| s.to_owned();
+        let flow = Flow {
+            id: id("classifier-then-argus"),
+            name: id("classifier-then-argus"),
+            enabled: true,
+            nodes: vec![
+                Node {
+                    id: id("source"),
+                    kind: NodeKind::Source {
+                        events: vec![id("pull_request_review_approved")],
+                    },
+                },
+                Node {
+                    id: id("match"),
+                    kind: NodeKind::Match {
+                        when: vec![Condition {
+                            field: id("sender"),
+                            equals: id("review-classifier"),
+                        }],
+                    },
+                },
+                Node {
+                    id: id("request"),
+                    kind: NodeKind::RequestReviewer {
+                        reviewer: id("argus"),
+                    },
+                },
+            ],
+            edges: vec![
+                Edge {
+                    from: id("source"),
+                    to: id("match"),
+                },
+                Edge {
+                    from: id("match"),
+                    to: id("request"),
+                },
+            ],
+        };
+        assert_eq!(flow.validate(), Ok(()));
+        let flows = [flow];
+        let routed = |event: &str, reviewer: &str| {
+            let d = Delivery::parse(&review_body(reviewer)).expect("parses");
+            route(event, &d, &Snapshot::default(), &flows, |_| true).requests
+        };
+        assert_eq!(
+            routed("pull_request_review_approved", "review-classifier"),
+            [ReviewRequest {
+                flow: "classifier-then-argus".to_owned(),
+                node: "request".to_owned(),
+                repo: "o/r".to_owned(),
+                number: 9,
+                reviewer: "argus".to_owned(),
+            }]
+        );
+        // Another reviewer, and another review event, request nothing.
+        assert!(routed("pull_request_review_approved", "mara").is_empty());
+        assert!(routed("pull_request_review_rejected", "review-classifier").is_empty());
+    }
 }