lotr-api 0.2.1

Rust wrapper for the one API to rule them all.
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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

use lotr_api::{
    attribute::{Attribute, BookAttribute, CharacterAttribute},
    filter::{Filter, Operator},
    request::{
        sort::{Sort, SortOrder},
        RequestBuilder,
    },
    Client, Item, ItemType, Pagination,
};

pub fn get_client() -> Client {
    let token = std::env::var("API_TOKEN").expect("API_TOKEN not set");
    Client::new(token)
}

#[tokio::test]
async fn test_movie() {
    let client = get_client();
    let movies = client.get_movies().await.unwrap();

    assert!(movies.len() > 0);
}

#[tokio::test]
async fn test_book() {
    let client = get_client();
    let books = client.get_books().await.unwrap();

    assert!(books.len() > 0);
}

#[tokio::test]
async fn test_quote() {
    let client = get_client();
    let quotes = client.get_quotes().await.unwrap();

    assert!(quotes.len() > 0);
}

// Reminder to update the quote limit if it ever changes
#[tokio::test]
async fn test_quote_number() {
    let client = get_client();
    let quotes = client.get_quotes().await.unwrap();

    assert_eq!(quotes.len(), 2384);
}

#[tokio::test]
async fn test_character() {
    let client = get_client();
    let characters = client.get_characters().await.unwrap();

    assert!(characters.len() > 0);
}

#[tokio::test]
async fn test_chapter() {
    let client = get_client();
    let chapters = client.get_chapters().await.unwrap();

    assert!(chapters.len() > 0);
}

#[tokio::test]
async fn test_get_books_request_builder() {
    let client = get_client();
    let request = RequestBuilder::new(ItemType::Book).build().unwrap();
    let books = client.get(request).await.unwrap();

    assert!(books.len() > 0);
}

#[tokio::test]
async fn tets_get_aragorn_ii_quote() {
    let client = get_client();
    let characters = client.get_characters().await.unwrap();
    let id = &characters
        .iter()
        .find(|c| c.name == "Aragorn II Elessar")
        .unwrap()
        ._id;

    let request = RequestBuilder::new(ItemType::Character)
        .id(id.into())
        .secondary_item_type(ItemType::Quote)
        .build()
        .expect("Failed to build request");

    let quotes = client.get(request).await.unwrap();
    assert!(quotes.len() > 0);
}

#[tokio::test]
async fn test_limit_offset_page() {
    let client = get_client();
    let pagination = Pagination::new(10, 10, 2);
    let request = RequestBuilder::new(ItemType::Character)
        .pagination(pagination)
        .build()
        .expect("Failed to build request");
    let characters = client.get(request).await.unwrap();
    assert_eq!(characters.len(), 10);
}

#[tokio::test]
async fn test_sort() {
    let client = get_client();
    let request = RequestBuilder::new(ItemType::Character)
        .sort(Sort::new(
            SortOrder::Ascending,
            Attribute::Character(CharacterAttribute::Name),
        ))
        .build()
        .expect("Failed to build request");
    let characters = client.get(request).await.unwrap();
    assert!(characters.len() > 0);
    match characters.first() {
        Some(Item::Character(character)) => {
            assert_eq!(character.name, "Adaldrida (Bolger) Brandybuck")
        }
        _ => panic!("No character found"),
    }
}

#[tokio::test]
async fn test_filter() {
    let client = get_client();
    let request = RequestBuilder::new(ItemType::Book)
        .filter(Filter::Match(
            Attribute::Book(BookAttribute::Name),
            Operator::Eq,
            vec!["The Fellowship Of The Ring".to_string()],
        ))
        .build()
        .expect("Failed to build request");

    let books = client.get(request).await.unwrap();
    assert!(books.len() > 0);
    match books.first() {
        Some(Item::Book(book)) => assert_eq!(book.name, "The Fellowship Of The Ring"),
        _ => panic!("No books found"),
    }
}

#[tokio::test]
async fn test_filter_include() {
    let client = get_client();

    let request = RequestBuilder::new(ItemType::Character)
        .filter(Filter::Match(
            Attribute::Character(CharacterAttribute::Realm),
            Operator::Eq,
            vec!["Gondor".to_string(), "Rohan".to_string()],
        ))
        .build()
        .expect("Failed to build request");

    let characters = client.get(request).await.unwrap();

    assert!(characters.len() > 0);

    for character in characters {
        match character {
            Item::Character(character) => {
                assert!(
                    character.realm == Some("Gondor".to_string())
                        || character.realm == Some("Rohan".to_string()),
                    "Realm is not Gondor or Rohan, it is {:?}",
                    character.realm
                );
            }
            _ => panic!("No characters found"),
        }
    }
}