esi-openapi 0.2.0

Rust API for EVE Online's ESI, based on the OpenAPI specification (fork of rfesi)
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

//! Endpoint groups

mod access_list;
pub use access_list::*;
mod activities;
pub use activities::*;
mod alliance;
pub use alliance::*;
mod assets;
pub use assets::*;
mod bookmarks;
pub use bookmarks::*;
mod calendar;
pub use calendar::*;
mod character;
pub use character::*;
mod clones;
pub use clones::*;
mod contacts;
pub use contacts::*;
mod contracts;
pub use contracts::*;
mod corporation;
pub use corporation::*;
mod corporation_projects;
pub use corporation_projects::*;
mod cosmetics;
pub use cosmetics::*;
mod dogma;
pub use dogma::*;
mod faction_warfare;
pub use faction_warfare::*;
mod fittings;
pub use fittings::*;
mod freelance_jobs;
pub use freelance_jobs::*;
mod fleets;
pub use fleets::*;
mod incursions;
pub use incursions::*;
mod industry;
pub use industry::*;
mod insurance;
pub use insurance::*;
mod killmails;
pub use killmails::*;
mod location;
pub use location::*;
mod loyalty;
pub use loyalty::*;
mod mail;
pub use mail::*;
mod market;
pub use market::*;
mod military_campaigns;
pub use military_campaigns::*;
mod opportunities;
pub use opportunities::*;
mod paragon_hub;
pub use paragon_hub::*;
mod planetary_interaction;
pub use planetary_interaction::*;
mod routes;
pub use routes::*;
mod meta;
pub use meta::*;
mod search;
pub use search::*;
mod skills;
pub use skills::*;
mod sovereignty;
pub use sovereignty::*;
mod structures;
pub use structures::*;
mod status;
pub use status::*;
mod universe;
pub use universe::*;
mod user_interface;
pub use user_interface::*;
mod wallet;
pub use wallet::*;
mod wars;
pub use wars::*;

/// Cursor for walking through paginated listings.
///
/// Pass `after` or `before` from a page as the matching parameter of the next request.
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
pub struct Cursor {
    /// Cursor to continue walking forwards in time.
    pub after: Option<String>,
    /// Cursor to continue walking backwards in time.
    pub before: Option<String>,
}

/// One page of a cursor-paginated listing, with the cursors to continue walking it.
///
/// ESI names the array of records after what the endpoint lists (`projects`,
/// `listings`, `objectives`, ...); here it is always [`Page::items`]. A response
/// without the array reads as a page without records.
#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
pub struct Page<T> {
    /// Cursors to continue walking the list.
    pub cursor: Option<Cursor>,
    /// The records in the page.
    #[serde(
        default = "Vec::new",
        alias = "projects",
        alias = "contributors",
        alias = "freelance_jobs",
        alias = "participants",
        alias = "objectives",
        alias = "listings"
    )]
    pub items: Vec<T>,
}

#[cfg(test)]
mod page_tests {
    use super::Page;

    #[test]
    fn test_page_reads_every_key_esi_uses() {
        for key in [
            "projects",
            "contributors",
            "freelance_jobs",
            "participants",
            "objectives",
            "listings",
        ] {
            let json =
                format!(r#"{{"cursor": {{"after": "a", "before": null}}, "{key}": [1, 2]}}"#);
            let page: Page<i64> = serde_json::from_str(&json).unwrap();
            assert_eq!(page.items, [1, 2], "{key}");
            assert_eq!(page.cursor.unwrap().after.as_deref(), Some("a"));
        }
    }

    #[test]
    fn test_page_without_records_or_cursor_is_empty() {
        let page: Page<i64> = serde_json::from_str("{}").unwrap();
        assert!(page.items.is_empty() && page.cursor.is_none());
        let page: Page<i64> =
            serde_json::from_str(r#"{"cursor": {"after": null, "before": null}}"#).unwrap();
        assert!(page.items.is_empty());
    }

    #[test]
    fn test_page_round_trips() {
        let page = Page {
            cursor: None,
            items: vec![1_i64, 2],
        };
        let json = serde_json::to_string(&page).unwrap();
        assert_eq!(serde_json::from_str::<Page<i64>>(&json).unwrap(), page);
    }
}