everymap-providers-google 0.2.2

Google Maps provider for EveryMap — geocoding, routing, map matching, and more
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 everymap_core::auth::ApiKeyProvider;
use everymap_core::domains::imaging::{ImageOptions, MapImageProvider};
use everymap_core::types::Coordinate;
use everymap_providers_google::client::GoogleClient;
use everymap_providers_google::GoogleMapImageProvider;
use std::sync::Arc;
use wiremock::matchers::{method, query_param};
use wiremock::{Mock, MockServer, ResponseTemplate};

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

    let png_bytes: &[u8] = &[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]; // PNG header

    // The GoogleMapImageProvider uses base_url directly (no path appended),
    // so when we set base_url to server.uri(), requests go to "/"
    Mock::given(method("GET"))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_bytes(png_bytes)
                .insert_header("content-type", "image/png"),
        )
        .mount(&server)
        .await;

    let auth = Arc::new(ApiKeyProvider::new(
        "test-key".to_string(),
        "key".to_string(),
    ));
    let client = Arc::new(GoogleClient::new(auth));
    let provider = GoogleMapImageProvider::with_base_url(client, server.uri());

    let center = Coordinate::new(52.52, 13.405).unwrap();
    let options = ImageOptions::default();

    let response = provider
        .get_image(&center, 14, (800, 600), &options)
        .await
        .unwrap();

    assert!(!response.data.is_empty());
    assert_eq!(response.content_type, Some("image/png".to_string()));
}

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

    let jpg_bytes: &[u8] = &[0xFF, 0xD8, 0xFF, 0xE0]; // JPEG header

    Mock::given(method("GET"))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_bytes(jpg_bytes)
                .insert_header("content-type", "image/jpeg"),
        )
        .mount(&server)
        .await;

    let auth = Arc::new(ApiKeyProvider::new(
        "test-key".to_string(),
        "key".to_string(),
    ));
    let client = Arc::new(GoogleClient::new(auth));
    let provider = GoogleMapImageProvider::with_base_url(client, server.uri());

    let center = Coordinate::new(40.7128, -74.006).unwrap();
    let options = ImageOptions {
        format: Some("jpg".to_string()),
        language: Some("en".to_string()),
        ..Default::default()
    };

    let response = provider
        .get_image(&center, 10, (600, 400), &options)
        .await
        .unwrap();

    assert!(!response.data.is_empty());
    assert_eq!(response.content_type, Some("image/jpeg".to_string()));
}

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

    let png_bytes: &[u8] = &[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]; // PNG header

    Mock::given(method("GET"))
        .and(query_param("size", "640x480"))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_bytes(png_bytes)
                .insert_header("content-type", "image/png"),
        )
        .mount(&server)
        .await;

    let auth = Arc::new(ApiKeyProvider::new(
        "test-key".to_string(),
        "key".to_string(),
    ));
    let client = Arc::new(GoogleClient::new(auth));
    let provider = GoogleMapImageProvider::with_base_url(client, server.uri());

    let center = Coordinate::new(52.52, 13.405).unwrap();
    let options = ImageOptions {
        width: Some(640),
        height: Some(480),
        ..Default::default()
    };

    let response = provider
        .get_image(&center, 14, (800, 600), &options)
        .await
        .unwrap();

    assert!(!response.data.is_empty());
    assert_eq!(response.content_type, Some("image/png".to_string()));
}