litchee 0.1.2

Async, builder-pattern Rust client for the Lichess API: full endpoint coverage, NDJSON streaming, and OAuth2 PKCE ('Log in with Lichess').
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

//! Integration tests for the Bulk Pairing API.

use futures_util::StreamExt;
use litchee::LichessClient;
use wiremock::matchers::{body_string_contains, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

fn client(server: &MockServer) -> LichessClient {
    LichessClient::builder()
        .base_url(&server.uri().parse().expect("mock uri is a valid url"))
        .token("test-token")
        .build()
        .expect("client builds")
}

const PAIRING: &str = r#"{"id":"RV","games":[{"id":"g","white":"a","black":"b"}],
    "variant":"standard","clock":{"limit":300,"increment":0},
    "pairAt":1,"pairedAt":null,"rated":false,"startClocksAt":2,"scheduledAt":3}"#;

#[tokio::test]
async fn list_returns_pairings() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/api/bulk-pairing"))
        .respond_with(ResponseTemplate::new(200).set_body_string(format!("[{PAIRING}]")))
        .mount(&server)
        .await;

    let pairings = client(&server).bulk_pairing().list().await.unwrap();

    assert_eq!(pairings.len(), 1);
    assert_eq!(pairings[0].id, "RV");
}

#[tokio::test]
async fn get_returns_a_pairing() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/api/bulk-pairing/RV"))
        .respond_with(ResponseTemplate::new(200).set_body_string(PAIRING))
        .mount(&server)
        .await;

    let pairing = client(&server).bulk_pairing().get("RV").await.unwrap();

    assert_eq!(pairing.id, "RV");
}

#[tokio::test]
async fn games_streams_games() {
    let server = MockServer::start().await;
    let body = "{\"id\":\"g1\"}\n{\"id\":\"g2\"}\n";
    Mock::given(method("GET"))
        .and(path("/api/bulk-pairing/RV/games"))
        .respond_with(ResponseTemplate::new(200).set_body_string(body))
        .mount(&server)
        .await;

    let stream = client(&server).bulk_pairing().games("RV").await.unwrap();
    let games: Vec<_> = stream.collect().await;

    assert_eq!(games.len(), 2);
    assert_eq!(games[0].as_ref().unwrap().id, "g1");
}

#[tokio::test]
async fn create_posts_players_and_clock() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/api/bulk-pairing"))
        .and(body_string_contains("players=t1%3At2"))
        .and(body_string_contains("clock.limit=300"))
        .respond_with(ResponseTemplate::new(200).set_body_string(PAIRING))
        .mount(&server)
        .await;

    let pairing = client(&server)
        .bulk_pairing()
        .create("t1:t2")
        .clock(300, 0)
        .rated(false)
        .send()
        .await
        .unwrap();

    assert_eq!(pairing.id, "RV");
}

#[tokio::test]
async fn delete_removes_a_pairing() {
    let server = MockServer::start().await;
    Mock::given(method("DELETE"))
        .and(path("/api/bulk-pairing/RV"))
        .respond_with(ResponseTemplate::new(200).set_body_string(r#"{"ok":true}"#))
        .mount(&server)
        .await;

    client(&server).bulk_pairing().delete("RV").await.unwrap();
}

#[tokio::test]
async fn start_clocks_posts_to_the_path() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/api/bulk-pairing/RV/start-clocks"))
        .respond_with(ResponseTemplate::new(200).set_body_string(r#"{"ok":true}"#))
        .mount(&server)
        .await;

    client(&server)
        .bulk_pairing()
        .start_clocks("RV")
        .await
        .unwrap();
}