octocrab 0.48.1

A modern, extensible GitHub API client.
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

use http::StatusCode;
use wiremock::{
    matchers::{method, path},
    Mock, MockServer, ResponseTemplate,
};

use mock_error::setup_error_handler;
use octocrab::models::UserEmailInfo;
use octocrab::params::users::emails::EmailVisibilityState;
use octocrab::Octocrab;

/// Tests API calls related to check runs of a specific commit.
mod mock_error;

async fn setup_emails_mock(
    http_method: &str,
    mocked_path: &str,
    template: ResponseTemplate,
) -> MockServer {
    let mock_server = MockServer::start().await;

    Mock::given(method(http_method))
        .and(path(mocked_path))
        .respond_with(template.clone())
        .mount(&mock_server)
        .await;
    setup_error_handler(
        &mock_server,
        &format!("http method {http_method} on {mocked_path} was not received"),
    )
    .await;
    mock_server
}

fn setup_octocrab(uri: &str) -> Octocrab {
    Octocrab::builder().base_uri(uri).unwrap().build().unwrap()
}

#[tokio::test]
async fn should_respond_to_primary_email_visibility() {
    let mocked_response: Vec<UserEmailInfo> =
        serde_json::from_str(include_str!("resources/user_emails.json")).unwrap();
    let template = ResponseTemplate::new(200).set_body_json(&mocked_response);
    let mock_server = setup_emails_mock("PATCH", "/user/email/visibility", template).await;
    let client = setup_octocrab(&mock_server.uri());
    let result = client
        .users("some_other_user")
        .set_primary_email_visibility(EmailVisibilityState::Private)
        .await;
    assert!(
        result.is_ok(),
        "expected successful result, got error: {:#?}",
        result
    );
    let response = result.unwrap();
    let visibility = response.first().unwrap().visibility;
    assert_eq!(visibility, Some(EmailVisibilityState::Private));
}

#[tokio::test]
async fn should_respond_to_email_list() {
    let mocked_response: Vec<UserEmailInfo> =
        serde_json::from_str(include_str!("resources/user_emails.json")).unwrap();
    let template = ResponseTemplate::new(200).set_body_json(&mocked_response);
    let mock_server = setup_emails_mock("GET", "/user/emails", template).await;
    let client = setup_octocrab(&mock_server.uri());
    let result = client
        .users("some_other_user")
        .emails()
        .per_page(42)
        .page(3u32)
        .list()
        .await;
    assert!(
        result.is_ok(),
        "expected successful result, got error: {:#?}",
        result
    );
    let response = result.unwrap();
    let visibility = response.items.first().unwrap().visibility;
    assert_eq!(visibility, Some(EmailVisibilityState::Private));

    let visibility = response.items[1].visibility;
    assert_eq!(visibility, None);
}

#[tokio::test]
async fn should_respond_to_public_email_list() {
    let mocked_response: Vec<UserEmailInfo> =
        serde_json::from_str(include_str!("resources/user_emails.json")).unwrap();
    let template = ResponseTemplate::new(200).set_body_json(&mocked_response);
    let mock_server = setup_emails_mock("GET", "/user/public_emails", template).await;
    let client = setup_octocrab(&mock_server.uri());
    let result = client
        .users("some_other_user")
        .emails()
        .per_page(42)
        .page(3u32)
        .list_public()
        .await;
    assert!(
        result.is_ok(),
        "expected successful result, got error: {:#?}",
        result
    );
    let response = result.unwrap();
    let visibility = response.items.first().unwrap().visibility;
    assert_eq!(visibility, Some(EmailVisibilityState::Private));
}

#[tokio::test]
async fn should_respond_to_emails_add() {
    let mocked_response: Vec<UserEmailInfo> =
        serde_json::from_str(include_str!("resources/user_emails.json")).unwrap();
    let template = ResponseTemplate::new(StatusCode::CREATED).set_body_json(&mocked_response);
    let mock_server = setup_emails_mock("POST", "/user/emails", template).await;
    let client = setup_octocrab(&mock_server.uri());
    let result = client
        .users("some_other_user")
        .emails()
        .add(vec!["newemail1@mail.com".to_string()])
        .await;
    assert!(
        result.is_ok(),
        "expected successful result, got error: {:#?}",
        result
    );
}

#[tokio::test]
async fn should_respond_to_emails_delete() {
    let template = ResponseTemplate::new(StatusCode::NO_CONTENT);
    let mock_server = setup_emails_mock("DELETE", "/user/emails", template).await;
    let client = setup_octocrab(&mock_server.uri());
    let result = client
        .users("some_other_user")
        .emails()
        .delete(vec!["newemail1@mail.com".to_string()])
        .await;
    assert!(
        result.is_ok(),
        "expected successful result, got error: {:#?}",
        result
    );
}