File size: 3,416 Bytes
008947a
 
 
 
4fb118c
 
 
008947a
 
4fb118c
 
 
 
 
 
008947a
 
 
 
 
 
4fb118c
008947a
 
 
4fb118c
008947a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4fb118c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
from __future__ import annotations

from dataclasses import replace

import pytest

import maptoposter.geocoding as geocoding
from maptoposter.cache import DiskCache, map_cache_key
from maptoposter.china import search_china
from maptoposter.geocoding import (
    GeocodingService,
    NominatimProvider,
    nominatim_language,
    parse_coordinate_query,
)
from maptoposter.models import Coordinate, Location


class FakeProvider:
    def __init__(self) -> None:
        self.calls = 0
        self.languages: list[str] = []

    def search(self, query: str, language: str, limit: int) -> list[Location]:
        self.calls += 1
        self.languages.append(language)
        return [Location(query, Coordinate(1.25, 2.5), "Testland", provider="fake")]


def test_map_cache_key_uses_rounded_data_parameters(poster_config) -> None:
    original = map_cache_key(poster_config.map)
    viewport = replace(
        poster_config.map.viewport,
        center=Coordinate(40.0000001, 116.3000001),
    )
    assert map_cache_key(replace(poster_config.map, viewport=viewport)) == original
    assert map_cache_key(replace(poster_config.map, network_type="drive")) != original


def test_disk_json_cache_is_atomic(tmp_path) -> None:
    cache = DiskCache(tmp_path)
    path = cache.geocoding_path("abc")
    cache.write_json(path, {"value": "北京"})
    assert cache.read_json(path) == {"value": "北京"}


def test_coordinate_and_china_local_search_do_not_call_network(tmp_path) -> None:
    coordinate = parse_coordinate_query("39.9042, 116.4074")
    assert coordinate is not None and coordinate.provider == "coordinates"
    assert search_china("北京")[0].provider == "china-local"
    provider = FakeProvider()
    service = GeocodingService(DiskCache(tmp_path), provider)
    assert service.search("北京")[0].provider == "china-local"
    assert provider.calls == 0


def test_external_geocoder_result_is_cached(tmp_path) -> None:
    provider = FakeProvider()
    service = GeocodingService(DiskCache(tmp_path), provider)
    assert service.search("Atlantis")[0].provider == "fake"
    assert service.search("Atlantis")[0].provider == "fake"
    assert provider.calls == 1


@pytest.mark.parametrize(
    ("language", "expected"),
    [
        ("en", "en"),
        ("fr", "en"),
        ("cn", "zh-CN"),
        ("zh", "zh-CN"),
        ("zh-CN", "zh-CN"),
        ("ZH", "zh-CN"),
    ],
)
def test_nominatim_language_maps_chinese_aliases(language: str, expected: str) -> None:
    assert nominatim_language(language) == expected


@pytest.mark.parametrize(
    ("requested", "expected"),
    [("cn", "zh-CN"), ("zh", "zh-CN"), ("zh-CN", "zh-CN"), ("en", "en"), ("fr", "en")],
)
def test_nominatim_provider_forwards_localized_language(monkeypatch, requested: str, expected: str) -> None:
    captured: list[str] = []

    class FakeGeocoder:
        def geocode(self, query: str, **kwargs: object) -> list[object]:
            captured.append(str(kwargs.get("language")))
            return []

    monkeypatch.setattr(geocoding, "Nominatim", lambda **_: FakeGeocoder())

    NominatimProvider().search("Tokyo", requested)

    assert captured == [expected]


def test_geocoding_service_forwards_requested_language(tmp_path) -> None:
    provider = FakeProvider()
    service = GeocodingService(DiskCache(tmp_path), provider)

    service.search("Atlantis", "zh")

    assert provider.languages == ["zh"]