oauth_fcm 0.2.0

A library for sending both data and notification Firebase Cloud Messaging (FCM) messages
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
155
156
157
158
159
160
161

use std::fs::File;
use std::sync::Once;

use oauth_fcm::create_shared_token_manager;
use oauth_fcm::send_fcm_message_with_url;
use serde_json::json;

use crate::test_helpers::FcmBaseTest;
use crate::test_helpers::TestData;

mod test_helpers;

static TRACING: Once = Once::new();

#[tokio::test]
async fn successful_fcm_test() {
    // Output logs to the console
    TRACING.call_once(tracing_subscriber::fmt::init);

    let mut server = mockito::Server::new_async().await;

    let project_id = "mock_project_id";
    let base = FcmBaseTest::new(
        server.url(),
        "/token".to_string(),
        server.url(),
        format!("/v1/projects/{}/messages:send", project_id),
    );

    let mock_auth = server
        .mock("POST", base.oauth_path.as_str())
        .with_status(200)
        .with_body(
            json!({
                "access_token": base.access_token,
                "scope": "https://www.googleapis.com/auth/prediction",
                "token_type": "Bearer",
                "expires_in": 3600,
            })
            .to_string(),
        )
        .create();

    let mock_fcm = server
        .mock("POST", base.fcm_path.as_str())
        .with_status(200)
        .create();

    let shared_token_manager =
        create_shared_token_manager(File::open("tests/mock_credentials.json").unwrap())
            .expect("Failed to create SharedTokenManager");

    {
        let mut guard = shared_token_manager.lock().await;

        assert!(guard.is_token_expired());

        // Get a valid first token from the mock instead of the real server
        guard
            .refresh_token_with_url(&base.mock_auth_url())
            .await
            .expect("Failed to refresh token");

        assert!(!guard.is_token_expired());
        assert!(guard.get_token().await.is_ok());
        assert!(!guard.get_token().await.unwrap().is_empty());
    }

    let data = TestData {
        title: "Test title".to_string(),
        description: "Test description".to_string(),
    };

    let result = send_fcm_message_with_url(
        &base.device_token,
        None,
        Some(data),
        &shared_token_manager,
        &base.mock_fcm_url(),
    )
    .await;

    assert!(result.is_ok());

    mock_auth.assert_async().await;
    mock_fcm.assert_async().await;
}

#[tokio::test]
async fn successful_fcm_test_from_string() {
    // Output logs to the console
    TRACING.call_once(tracing_subscriber::fmt::init);

    let mut server = mockito::Server::new_async().await;

    let project_id = "mock_project_id";
    let base = FcmBaseTest::new(
        server.url(),
        "/token".to_string(),
        server.url(),
        format!("/v1/projects/{}/messages:send", project_id),
    );

    let mock_auth = server
        .mock("POST", base.oauth_path.as_str())
        .with_status(200)
        .with_body(
            json!({
                "access_token": base.access_token,
                "scope": "https://www.googleapis.com/auth/prediction",
                "token_type": "Bearer",
                "expires_in": 3600,
            })
            .to_string(),
        )
        .create();

    let mock_fcm = server
        .mock("POST", base.fcm_path.as_str())
        .with_status(200)
        .create();

    let creds = std::fs::read_to_string("tests/mock_credentials.json").unwrap();
    let shared_token_manager =
        create_shared_token_manager(creds.as_bytes()).expect("Failed to create SharedTokenManager");

    {
        let mut guard = shared_token_manager.lock().await;

        assert!(guard.is_token_expired());

        // Get a valid first token from the mock instead of the real server
        guard
            .refresh_token_with_url(&base.mock_auth_url())
            .await
            .expect("Failed to refresh token");

        assert!(!guard.is_token_expired());
        assert!(guard.get_token().await.is_ok());
        assert!(!guard.get_token().await.unwrap().is_empty());
    }

    let data = TestData {
        title: "Test title".to_string(),
        description: "Test description".to_string(),
    };

    let result = send_fcm_message_with_url(
        &base.device_token,
        None,
        Some(data),
        &shared_token_manager,
        &base.mock_fcm_url(),
    )
    .await;

    assert!(result.is_ok());

    mock_auth.assert_async().await;
    mock_fcm.assert_async().await;
}