wf-market 0.2.1

A Rust client library for the warframe.market 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

//! HTTP client utilities.

use reqwest::header::{ACCEPT, AUTHORIZATION, CONTENT_TYPE, HeaderMap, HeaderValue, USER_AGENT};

use crate::models::{Language, Platform};

/// Base URL for the V2 API.
pub const BASE_URL: &str = "https://api.warframe.market/v2";

/// Base URL for the V1 API (authentication).
pub const V1_API_URL: &str = "https://api.warframe.market/v1";

/// Default user agent for API requests.
pub const DEFAULT_USER_AGENT: &str = "wf-market-rs/0.2.0";

/// Build default headers for API requests.
pub fn build_default_headers(platform: Platform, language: Language, crossplay: bool) -> HeaderMap {
    let mut headers = HeaderMap::new();

    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
    headers.insert(ACCEPT, HeaderValue::from_static("application/json"));
    headers.insert(USER_AGENT, HeaderValue::from_static(DEFAULT_USER_AGENT));

    // Platform header
    headers.insert(
        "Platform",
        HeaderValue::from_str(platform.as_header_value()).unwrap(),
    );

    // Language header
    headers.insert(
        "Language",
        HeaderValue::from_str(language.as_code()).unwrap(),
    );

    // Crossplay header
    headers.insert(
        "Crossplay",
        HeaderValue::from_str(if crossplay { "true" } else { "false" }).unwrap(),
    );

    headers
}

/// Build an HTTP client without authentication.
pub fn build_http_client(
    platform: Platform,
    language: Language,
    crossplay: bool,
) -> reqwest::Result<reqwest::Client> {
    let headers = build_default_headers(platform, language, crossplay);

    reqwest::Client::builder().default_headers(headers).build()
}

/// Build an HTTP client with bearer token authentication.
pub fn build_authenticated_client(
    platform: Platform,
    language: Language,
    crossplay: bool,
    token: &str,
) -> reqwest::Result<reqwest::Client> {
    let mut headers = build_default_headers(platform, language, crossplay);

    // Add authorization header
    let auth_value = format!("Bearer {}", token);
    headers.insert(
        AUTHORIZATION,
        HeaderValue::from_str(&auth_value).expect("Invalid token format"),
    );

    reqwest::Client::builder().default_headers(headers).build()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_headers() {
        let headers = build_default_headers(Platform::Pc, Language::English, true);

        assert!(headers.contains_key(CONTENT_TYPE));
        assert!(headers.contains_key("Platform"));
        assert!(headers.contains_key("Language"));
        assert!(headers.contains_key("Crossplay"));

        assert_eq!(headers.get("Platform").unwrap(), "pc");
        assert_eq!(headers.get("Language").unwrap(), "en");
        assert_eq!(headers.get("Crossplay").unwrap(), "true");
    }

    #[test]
    fn test_build_client() {
        let client = build_http_client(Platform::Pc, Language::English, true);
        assert!(client.is_ok());
    }

    #[test]
    fn test_build_authenticated_client() {
        let client =
            build_authenticated_client(Platform::Pc, Language::English, true, "test-token");
        assert!(client.is_ok());
    }
}