phabricator_api/phid/
lookup.rs

1use crate::ApiRequest;
2use serde::de::Deserializer;
3use serde::Deserialize;
4use serde::Serialize;
5use std::collections::HashMap;
6
7use super::Item;
8
9#[derive(Serialize)]
10pub struct Lookup {
11    pub names: Vec<String>,
12}
13
14fn data_or_no_data<'de, D>(deserializer: D) -> Result<HashMap<String, Item>, D::Error>
15where
16    D: Deserializer<'de>,
17{
18    #[derive(Deserialize)]
19    #[serde(untagged)]
20    enum DorNd {
21        Data(HashMap<String, Item>),
22        NoData([(); 0]),
23    }
24
25    let d = DorNd::deserialize(deserializer)?;
26    let v = match d {
27        DorNd::Data(v) => v,
28        DorNd::NoData(_) => HashMap::new(),
29    };
30    Ok(v)
31}
32
33#[derive(Deserialize, Debug)]
34#[serde(transparent)]
35pub struct LookupResult(#[serde(deserialize_with = "data_or_no_data")] HashMap<String, Item>);
36
37impl ApiRequest for Lookup {
38    type Reply = LookupResult;
39    const ROUTE: &'static str = "api/phid.lookup";
40}
41
42#[cfg(test)]
43mod test {
44    use super::*;
45    use phabricator_mock::PhabMockServer;
46
47    #[tokio::test]
48    async fn simple() {
49        let m = PhabMockServer::start().await;
50
51        let user = m.new_user("user", "Test User");
52        m.new_simple_task(100, &user);
53
54        let client = crate::Client::new(m.uri(), m.token().to_string());
55
56        let l = Lookup {
57            names: vec!["T100".to_owned()],
58        };
59        let r = client.request(&l).await.unwrap();
60
61        assert!(r.0.contains_key("T100"));
62    }
63
64    #[tokio::test]
65    async fn multiple() {
66        let m = PhabMockServer::start().await;
67        let user = m.new_user("user", "Test User");
68        m.new_simple_task(100, &user);
69        m.new_simple_task(200, &user);
70
71        let client = crate::Client::new(m.uri(), m.token().to_string());
72
73        let l = Lookup {
74            names: vec!["T100".to_owned(), "T200".to_owned()],
75        };
76        let r = client.request(&l).await.unwrap();
77
78        for n in l.names {
79            assert!(r.0.contains_key(&n), "missing task {}", &n);
80        }
81    }
82
83    #[tokio::test]
84    async fn no_result() {
85        let m = PhabMockServer::start().await;
86        let client = crate::Client::new(m.uri(), m.token().to_string());
87
88        let l = Lookup {
89            names: vec!["T100".to_owned(), "T200".to_owned()],
90        };
91        let r = client.request(&l).await.unwrap();
92        assert_eq!(r.0.len(), 0);
93    }
94}