pubnub 0.7.0

PubNub SDK for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

#[cfg(test)]
mod integration {
    use pubnub::core::PubNubError;
    use pubnub::{access::*, Keyset, PubNubClientBuilder};
    use std::collections::HashMap;

    /// Keyset with default non-PAM enabled keys.
    fn default_keyset() -> Keyset<String> {
        Keyset {
            subscribe_key: option_env!("SDK_SUB_KEY").unwrap_or("demo").into(),
            publish_key: Some(option_env!("SDK_PUB_KEY").unwrap_or("demo").into()),
            secret_key: Some(option_env!("SDK_PUB_KEY").unwrap_or("demo").into()),
        }
    }

    /// Keyset with PAM enabled keys.
    fn pam_keyset() -> Keyset<String> {
        Keyset {
            subscribe_key: option_env!("SDK_PAM_SUB_KEY").unwrap_or("demo").into(),
            publish_key: Some(option_env!("SDK_PAM_PUB_KEY").unwrap_or("demo").into()),
            secret_key: Some(option_env!("SDK_PAM_SEC_KEY").unwrap_or("demo").into()),
        }
    }

    /// Grant token success
    #[tokio::test]
    async fn should_grant_token() -> Result<(), Box<dyn std::error::Error>> {
        let client = PubNubClientBuilder::with_reqwest_transport()
            .with_keyset(pam_keyset())
            .with_user_id("test")
            .build()?;

        let result = client
            .grant_token(10)
            .resources(&[permissions::channel("test-channel").read().write()])
            .meta(HashMap::from([
                ("string-val".into(), "hello there".into()),
                ("null-val".into(), ().into()),
            ]))
            .execute()
            .await;

        match result {
            Ok(result) => {
                assert!(!result.token.is_empty());
                Ok(())
            }
            Err(err) => {
                panic!("Unexpected error: {}", err);
            }
        }
    }

    /// Grant token failure because of signature mismatch.
    #[tokio::test]
    async fn should_not_grant_token() -> Result<(), Box<dyn std::error::Error>> {
        let client = PubNubClientBuilder::with_reqwest_transport()
            .with_keyset(default_keyset())
            .with_user_id("test")
            .build()?;

        let result = client
            .grant_token(10)
            .resources(&[permissions::channel("test-channel").read().write()])
            .meta(HashMap::from([("string-val".into(), "hello there".into())]))
            .execute()
            .await;

        match result {
            Ok(_) => panic!("Request should fail."),
            Err(err) => {
                if let PubNubError::API { status, .. } = err {
                    assert_eq!(status, 403);
                    Ok(())
                } else {
                    panic!("Unexpected error type.");
                }
            }
        }
    }

    /// Revoke token success
    #[tokio::test]
    async fn should_revoke_token() -> Result<(), Box<dyn std::error::Error>> {
        let client = PubNubClientBuilder::with_reqwest_transport()
            .with_keyset(pam_keyset())
            .with_user_id("test")
            .build()?;

        let result = client
            .grant_token(10)
            .resources(&[permissions::channel("test-channel").read().write()])
            .meta(HashMap::from([("string-val".into(), "hello there".into())]))
            .execute()
            .await?;

        let result = client.revoke_token(result.token).execute().await;

        if let Err(err) = result {
            eprintln!("Revoke token error: {err}");
            panic!("Request shouldn't fail");
        }

        Ok(())
    }

    /// Revoke token failure
    #[tokio::test]
    async fn should_not_revoke_expired_token() -> Result<(), Box<dyn std::error::Error>> {
        let client = PubNubClientBuilder::with_reqwest_transport()
            .with_keyset(pam_keyset())
            .with_user_id("demo")
            .build()?;

        let result = client.revoke_token("some-token-here").execute().await;

        match result {
            Ok(_) => panic!("Request should fail."),
            Err(err) => {
                if let PubNubError::API { status, .. } = err {
                    // We are expecting failure because of wrong access token.
                    assert_eq!(status, 400);
                    Ok(())
                } else {
                    panic!("Unexpected error type.");
                }
            }
        }
    }

    /// Revoke token failure
    #[tokio::test]
    async fn should_not_revoke_malformed_token() -> Result<(), Box<dyn std::error::Error>> {
        let client = PubNubClientBuilder::with_reqwest_transport()
            .with_keyset(pam_keyset())
            .with_user_id("demo")
            .build()?;

        let result = client.revoke_token("some-token-here").execute().await;

        match result {
            Ok(_) => panic!("Request should fail."),
            Err(err) => {
                if let PubNubError::API { status, .. } = err {
                    // We are expecting failure because of wrong access token.
                    assert_eq!(status, 400);
                    Ok(())
                } else {
                    panic!("Unexpected error type.");
                }
            }
        }
    }
}