rtz 0.8.0

A tool to easily work with geo lookups via a binary, a library, or a server.
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

//! The web module.

// Modules.

pub(crate) mod config;
pub(crate) mod response_types;
pub(crate) mod server;
pub(crate) mod types;
pub(crate) mod utilities;

// Imports.

use log::LevelFilter;
use simple_logger::SimpleLogger;

use rtz_core::base::types::Void;

use crate::web::config::Config;

const VERSION: &str = env!("CARGO_PKG_VERSION");

/// Starts the web server.
pub fn server_start(config_path: String, bind_address: Option<String>, port: Option<u16>, should_log: Option<bool>) -> Void {
    tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
        // Spew version.

        println!("Version: v{}", VERSION);

        // Ingest config.

        let config = Config::new(&config_path, bind_address, port, should_log)?;

        // Set up logging.

        let log_level = if config.should_log { LevelFilter::Info } else { LevelFilter::Off };
        SimpleLogger::new().with_level(log_level).init().unwrap();

        // Start server.

        server::start(&config).await?;

        Ok::<_, rtz_core::base::types::Err>(())
    })?;

    Ok(())
}

// Tests.

#[cfg(test)]
mod tests {
    use super::*;
    use axum::{body::Body, Router};
    use http_body_util::BodyExt;
    use hyper::{Request, StatusCode};
    use pretty_assertions::assert_eq;
    use tower::{Service, ServiceExt};

    fn get_client() -> Router {
        let config = Config::new("", None, None, Some(false)).unwrap();

        server::create_axum_app(&config)
    }

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

        let request = Request::get("/api/v1/ned/tz/-121.0/46.0").body(Body::empty()).unwrap();
        let response = client.oneshot(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);

        let body = response.into_body().collect().await.unwrap_or_default().to_bytes();
        let expected = r#"[{"id":20,"identifier":"America/Los_Angeles","description":"Canada (most of British Columbia), Mexico (Baja California), United States (California, most of Nevada, most of Oregon, Washington (state))","dstDescription":"Canada (most of British Columbia), Mexico (Baja California), United States (California, most of Nevada, most of Oregon, Washington (state))","offset":"UTC-08:00","zone":-8.0,"rawOffset":-28800}]"#;

        assert_eq!(body, expected);
    }

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

        let request = Request::get("/api/v1/ned/tz/179.9968/-67.0959").body(Body::empty()).unwrap();
        let response = client.oneshot(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);

        let body = response.into_body().collect().await.unwrap_or_default().to_bytes();
        let expected = r#"[]"#;

        assert_eq!(body, expected);
    }

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

        let request = Request::get("/api/v1/ned/tz/-121.0/46.0").body(Body::empty()).unwrap();
        // This is required because there are multiple impls of `ready` for `Router`. 🙄
        let response = <axum::Router as tower::ServiceExt<Request<Body>>>::ready(&mut client).await.unwrap().call(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);

        let if_modified_since = response.headers().get("If-Modified-Since").unwrap().as_bytes();

        let request = Request::get("/api/v1/ned/tz/-121.0/46.0").header("If-Modified-Since", if_modified_since).body(Body::empty()).unwrap();
        let response = <axum::Router as tower::ServiceExt<Request<Body>>>::ready(&mut client).await.unwrap().call(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
    }

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

        let request = Request::get("/api/v1/osm/tz/-112/33").body(Body::empty()).unwrap();
        let response = client.oneshot(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);

        let body = response.into_body().collect().await.unwrap_or_default().to_bytes();
        // Assert the meaningful field (the resolved timezone), not the exact body: `id` is a
        // regen-unstable index and the other fields track the upstream tz-data version.
        let parsed: serde_json::Value = serde_json::from_slice(&body).unwrap();
        let identifiers = parsed.as_array().unwrap().iter().filter_map(|v| v["identifier"].as_str()).collect::<Vec<_>>();
        assert!(identifiers.contains(&"America/Phoenix"), "expected America/Phoenix in {identifiers:?}");
    }

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

        let request = Request::get("/api/v1/osm/admin/30/30").body(Body::empty()).unwrap();
        let response = client.oneshot(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);

        let body = response.into_body().collect().await.unwrap_or_default().to_bytes();
        // Assert set membership of (name, level, relationId), not the exact body: `id` is a
        // regen-unstable index and result order isn't stable, but `relationId` (the OSM relation
        // id) IS stable across regens — so we can pin it.
        let parsed: serde_json::Value = serde_json::from_slice(&body).unwrap();
        let admins = parsed
            .as_array()
            .unwrap()
            .iter()
            .map(|v| (v["name"].as_str().unwrap(), v["level"].as_u64().unwrap(), v["relationId"].as_u64().unwrap()))
            .collect::<Vec<_>>();
        assert!(admins.contains(&("مصر", 2, 1473947)), "expected Egypt (level 2, rel 1473947) in {admins:?}");
        assert!(admins.contains(&("مطروح", 4, 3061826)), "expected Matrouh (level 4, rel 3061826) in {admins:?}");
    }

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

        let a = client.clone().oneshot(Request::get("/api/ned/tz/-121.0/46.0").body(Body::empty()).unwrap()).await.unwrap();
        let a_body = a.into_body().collect().await.unwrap().to_bytes();

        let b = client.oneshot(Request::get("/api/v1/ned/tz/-121.0/46.0").body(Body::empty()).unwrap()).await.unwrap();
        let b_body = b.into_body().collect().await.unwrap().to_bytes();

        assert_eq!(a_body, b_body);
    }

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

        let request = Request::get("/api/v1/ned/tz/not-a-number/46.0").body(Body::empty()).unwrap();
        let response = client.oneshot(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
    }

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

        let request = Request::get("/api/does-not-exist").body(Body::empty()).unwrap();
        let response = client.oneshot(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::NOT_FOUND);
    }

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

        let request = Request::get("/api/health").body(Body::empty()).unwrap();
        let response = client.oneshot(request).await.unwrap();

        assert_eq!(response.status(), StatusCode::OK);
    }
}