scryfall_sdk_rust 0.1.1

A light wrapper (SDK) for Scryfall API (https://scryfall.com/docs/api)
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

use scryfall_sdk_rust::resources::errors::ErrorBody;
use scryfall_sdk_rust::resources::ResourceKind;
use httpmock::Method::GET;
use reqwest::Method;
use serde::{Deserialize, Serialize};
use httpmock::MockServer;
use indoc::indoc;
use rstest::{fixture, rstest};

use scryfall_sdk_rust::{Scryfall, ScryfallBlocking};
use scryfall_sdk_rust::resources::HttpResource;

struct TestEndpoint;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Model {
    pub kind: ResourceKind,
}

impl HttpResource<Model> for TestEndpoint {
    fn method(&self) -> Method {
        Method::GET
    }

    fn path(&self) -> String {
        String::from("test-path")
    }
}

#[fixture]
fn error_json() -> String {
    indoc!(r#"
    {
        "object": "error",
        "code": "not_found",
        "status": 404,
        "details": "No card found with the given ID or set code and collector number."
    }
    "#).into()
}

#[fixture]
fn error() -> ErrorBody {
    ErrorBody {
        code: "not_found".into(),
        details: "No card found with the given ID or set code and collector number.".into(),
        error_type: None,
        kind: ResourceKind::Error,
        status: 404,
        warnings: None,
    }
}

#[test]
fn test_blocking_request() {
    let server = MockServer::start();

    let empty_json = r#"{"kind": "card"}"#;

    server.mock(|when, then| {
        when.method(GET).path("/test-path");
        then.body(empty_json);
    });

    let url = server.base_url();
    let client = ScryfallBlocking::from_url(&url);

    let response = client.request(&TestEndpoint).unwrap();
    assert_eq!(Model {kind: ResourceKind::Card}, response)
}

#[tokio::test]
async fn test_async_request() {
    let server = MockServer::start_async().await;

    let empty_json = r#"{"kind": "card"}"#;

    server.mock(|when, then| {
         when.method(GET).path("/test-path");
         then.body(empty_json);
    });

    let url = server.base_url();
    let client = Scryfall::from_url(&url);

    let response = client.request(&TestEndpoint).await.unwrap();
    assert_eq!(Model {kind: ResourceKind::Card}, response)
}

#[rstest]
fn test_blocking_request_responding_error(error_json: String, error: ErrorBody) {
    let server = MockServer::start();

    server.mock(|when, then| {
         when.method(GET).path("/test-path");
         then.body(error_json);
    });

    let url = server.base_url();
    let client = ScryfallBlocking::from_url(&url);

    let error_response = client.request(&TestEndpoint).unwrap_err();
    assert_eq!(error, error_response)
}

#[rstest]
#[tokio::test]
async fn test_async_request_responding_error(error_json: String, error: ErrorBody) {
    let server = MockServer::start_async().await;

    server.mock(|when, then| {
         when.method(GET).path("/test-path");
         then.body(error_json);
    });

    let url = server.base_url();
    let client = Scryfall::from_url(&url);

    let error_response = client.request(&TestEndpoint).await.unwrap_err();
    assert_eq!(error, error_response)
}