MapProxy 1.16.1__py3-none-any.whl

mapproxy/test/system/test_behind_proxy.py

@@ -0,0 +1,75 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2011 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import division
+
+import pytest
+
+from mapproxy.test.system import SysTest
+
+
+class TestWMSBehindProxy(SysTest):
+    """
+    Check WMS OnlineResources for requests behind HTTP proxies.
+    """
+    @pytest.fixture(scope='class')
+    def config_file(self):
+        return 'layer.yaml'
+
+    def test_no_proxy(self, app):
+        resp = app.get('http://localhost/service?SERVICE=WMS&REQUEST=GetCapabilities'
+                            '&VERSION=1.1.0')
+        assert '"http://localhost/service' in resp
+
+    def test_with_script_name(self, app):
+        resp = app.get('http://localhost/service?SERVICE=WMS&REQUEST=GetCapabilities'
+                            '&VERSION=1.1.0', extra_environ={'HTTP_X_SCRIPT_NAME': '/foo'})
+        assert '"http://localhost/service' not in resp
+        assert '"http://localhost/foo/service' in resp
+
+    def test_with_host(self, app):
+        resp = app.get('http://localhost/service?SERVICE=WMS&REQUEST=GetCapabilities'
+                            '&VERSION=1.1.0', extra_environ={'HTTP_HOST': 'example.org'})
+        assert '"http://localhost/service' not in resp
+        assert '"http://example.org/service' in resp
+
+    def test_with_host_and_script_name(self, app):
+        resp = app.get('http://localhost/service?SERVICE=WMS&REQUEST=GetCapabilities'
+            '&VERSION=1.1.0', extra_environ={'HTTP_X_SCRIPT_NAME': '/foo', 'HTTP_HOST': 'example.org'})
+        assert '"http://localhost/service' not in resp
+        assert '"http://example.org/foo/service' in resp
+
+    def test_with_forwarded_host(self, app):
+        resp = app.get('http://localhost/service?SERVICE=WMS&REQUEST=GetCapabilities'
+                            '&VERSION=1.1.0', extra_environ={'HTTP_X_FORWARDED_HOST': 'example.org, bar.org'})
+        assert '"http://localhost/service' not in resp
+        assert '"http://example.org/service' in resp
+
+    def test_with_forwarded_host_and_script_name(self, app):
+        resp = app.get('http://localhost/service?SERVICE=WMS&REQUEST=GetCapabilities'
+            '&VERSION=1.1.0', extra_environ={'HTTP_X_FORWARDED_HOST': 'example.org', 'HTTP_X_SCRIPT_NAME': '/foo'})
+        assert '"http://localhost/service' not in resp
+        assert '"http://example.org/foo/service' in resp
+
+    def test_with_forwarded_proto_and_script_name_and_host(self, app):
+        resp = app.get('http://localhost/service?SERVICE=WMS&REQUEST=GetCapabilities'
+            '&VERSION=1.1.0', extra_environ={
+                'HTTP_X_FORWARDED_PROTO': 'https',
+                'HTTP_X_SCRIPT_NAME': '/foo',
+                'HTTP_HOST': 'example.org:443'
+            })
+        assert '"http://localhost/service' not in resp
+        assert '"https://example.org/foo/service' in resp
+

mapproxy/test/system/test_bulk_meta_tiles.py

@@ -0,0 +1,106 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2016 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from mapproxy.request.wms import WMS111MapRequest
+from mapproxy.test.image import tmp_image
+from mapproxy.test.http import mock_httpd
+from mapproxy.test.system import SysTest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "cache_bulk_meta_tiles.yaml"
+
+
+class TestCacheSource(SysTest):
+
+    def test_tms_capabilities(self, app):
+        resp = app.get("/tms/1.0.0/")
+        xml = resp.lxml
+
+        assert xml.xpath("count(//TileMap)") == 1
+
+    def test_get_map(self, app):
+        # request single tile via WMS and check that
+        map_req = WMS111MapRequest(
+            url="/service?",
+            param=dict(
+                service="WMS",
+                version="1.1.1",
+                width="100",
+                height="100",
+                bbox="0,0,100000,100000",
+                layers="bulk",
+                srs="EPSG:3857",
+                format="image/png",
+                styles="",
+                request="GetMap",
+            ),
+        )
+
+        expected_reqs = []
+        with tmp_image((256, 256), format="jpeg") as img:
+            img = img.read()
+            # bulk_cache has meta_size of [2, 2]
+            for tile in [(128, 128, 8), (128, 129, 8), (129, 128, 8), (129, 129, 8)]:
+                expected_reqs.append(
+                    (
+                        {
+                            "path": r"/tiles/%02d/000/000/%03d/000/000/%03d.png"
+                            % (tile[2], tile[0], tile[1])
+                        },
+                        {"body": img, "headers": {"content-type": "image/png"}},
+                    )
+                )
+            with mock_httpd(("localhost", 42423), expected_reqs, unordered=True):
+                resp = app.get(map_req)
+                assert resp.content_type == "image/png"
+
+    def test_get_tile(self, app, cache_dir):
+        expected_reqs = []
+        with tmp_image((256, 256), format="jpeg") as img:
+            # bulk_cache has meta_size of [2, 2]
+            for tile in [(4, 3, 5), (5, 3, 5), (4, 2, 5), (5, 2, 5)]:
+                expected_reqs.append(
+                    (
+                        {
+                            "path": r"/tiles/%02d/000/000/%03d/000/000/%03d.png"
+                            % (tile[2], tile[0], tile[1])
+                        },
+                        {"body": img.read(), "headers": {"content-type": "image/png"}},
+                    )
+                )
+            with mock_httpd(("localhost", 42423), expected_reqs, unordered=True):
+                resp = app.get("/tiles/1.0.0/bulk/EPSG900913/5/4/3.png")
+                assert resp.content_type == "image/png"
+
+        assert cache_dir.join(
+            "bulk_cache_EPSG900913/05/000/000/004/000/000/002.png"
+        ).check()
+        assert cache_dir.join(
+            "bulk_cache_EPSG900913/05/000/000/004/000/000/003.png"
+        ).check()
+        assert cache_dir.join(
+            "bulk_cache_EPSG900913/05/000/000/005/000/000/002.png"
+        ).check()
+        assert cache_dir.join(
+            "bulk_cache_EPSG900913/05/000/000/005/000/000/003.png"
+        ).check()
+
+        # access tile cached by previous bulk_meta_tile request
+        resp = app.get("/tiles/1.0.0/bulk/EPSG900913/5/5/3.png")
+        assert resp.content_type == "image/png"

mapproxy/test/system/test_cache_azureblob.py

@@ -0,0 +1,127 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2022 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import division
+
+import os
+from io import BytesIO
+
+import pytest
+
+from mapproxy.request.wms import WMS111MapRequest
+from mapproxy.test.image import is_png, create_tmp_image
+from mapproxy.test.system import SysTest
+
+try:
+    from mapproxy.cache.azureblob import AzureBlobCache
+except ImportError:
+    AzureBlobCache = None
+
+
+def azureblob_connection():
+    # Use default storage account of Azurite emulator
+    host = os.environ['MAPPROXY_TEST_AZURE_BLOB']
+    return 'DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=' \
+           'Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr' \
+           '/KBHBeksoGMGw==;BlobEndpoint=' + host + '/devstoreaccount1;'
+
+
+def azure_container_client(connection_string, container_name):
+    return AzureBlobCache(
+        base_path="",
+        file_ext="",
+        connection_string=connection_string,
+        container_name=container_name).container_client
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "cache_azureblob.yaml"
+
+
+@pytest.fixture(scope="module")
+def azureblob_containers():
+    container = azure_container_client(azureblob_connection(), 'default-container')
+    if not container.exists():
+        container.create_container()
+    container = azure_container_client(azureblob_connection(), 'tiles')
+    if not container.exists():
+        container.create_container()
+
+    yield
+
+
+@pytest.mark.skipif(not AzureBlobCache or not os.environ.get('MAPPROXY_TEST_AZURE_BLOB'),
+                    reason="azure-storage-blob package and MAPPROXY_TEST_AZURE_BLOB env required")
+@pytest.mark.usefixtures("azureblob_containers")
+class TestAzureBlobCache(SysTest):
+
+    def setup(self):
+        self.common_map_req = WMS111MapRequest(
+            url="/service?",
+            param=dict(
+                service="WMS",
+                version="1.1.1",
+                bbox="-150,-40,-140,-30",
+                width="100",
+                height="100",
+                layers="default",
+                srs="EPSG:4326",
+                format="image/png",
+                styles="",
+                request="GetMap",
+            ),
+        )
+
+    def test_get_map_cached(self, app):
+        tile = create_tmp_image((256, 256))
+        container = azure_container_client(azureblob_connection(), 'default-container')
+        container.upload_blob(
+            name="default_cache/WebMerc/4/1/9.png",
+            data=BytesIO(tile),
+            overwrite=True
+        )
+        resp = app.get(self.common_map_req)
+        assert resp.content_type == "image/png"
+        data = BytesIO(resp.body)
+        assert is_png(data)
+
+    def test_get_map_cached_quadkey(self, app):
+        tile = create_tmp_image((256, 256))
+        container = azure_container_client(azureblob_connection(), 'tiles')
+        container.upload_blob(
+            name="quadkeytiles/2003.png",
+            data=BytesIO(tile),
+            overwrite=True
+        )
+        self.common_map_req.params.layers = "quadkey"
+        resp = app.get(self.common_map_req)
+        assert resp.content_type == "image/png"
+        data = BytesIO(resp.body)
+        assert is_png(data)
+
+    def test_get_map_cached_reverse_tms(self, app):
+        tile = create_tmp_image((256, 256))
+        container = azure_container_client(azureblob_connection(), 'tiles')
+        container.upload_blob(
+            name="reversetiles/9/1/4.png",
+            data=BytesIO(tile),
+            overwrite=True
+        )
+        self.common_map_req.params.layers = "reverse"
+        resp = app.get(self.common_map_req)
+        assert resp.content_type == "image/png"
+        data = BytesIO(resp.body)
+        assert is_png(data)

mapproxy/test/system/test_cache_band_merge.py

@@ -0,0 +1,103 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2016 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from mapproxy.request.wms import WMS111MapRequest
+from mapproxy.request.wmts import WMTS100CapabilitiesRequest
+from mapproxy.test.image import img_from_buf
+from mapproxy.test.system import SysTest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "cache_band_merge.yaml"
+
+
+@pytest.mark.usefixtures("fixture_cache_data")
+class TestCacheSource(SysTest):
+
+    # test various band merge configurations with
+    # cached base tile 0/0/0.png (R: 50 G: 100 B: 200)
+
+    def setup(self):
+        self.common_cap_req = WMTS100CapabilitiesRequest(
+            url="/service?",
+            param=dict(service="WMTS", version="1.0.0", request="GetCapabilities"),
+        )
+        self.common_map_req = WMS111MapRequest(
+            url="/service?",
+            param=dict(
+                service="WMS",
+                version="1.1.1",
+                bbox="-180,0,0,80",
+                width="100",
+                height="100",
+                layers="dop_l",
+                srs="EPSG:4326",
+                format="image/png",
+                styles="",
+                request="GetMap",
+            ),
+        )
+
+    def test_capabilities(self, app):
+        req = str(self.common_cap_req)
+        resp = app.get(req)
+        assert resp.content_type == "application/xml"
+
+    def test_get_tile_021(self, app):
+        resp = app.get("/wmts/dop_021/GLOBAL_WEBMERCATOR/0/0/0.png")
+        assert resp.content_type == "image/png"
+        img = img_from_buf(resp.body)
+        assert img.mode == "RGB"
+        assert img.getpixel((0, 0)) == (50, 200, 100)
+
+    def test_get_tile_l(self, app):
+        resp = app.get("/wmts/dop_l/GLOBAL_WEBMERCATOR/0/0/0.png")
+        assert resp.content_type == "image/png"
+        img = img_from_buf(resp.body)
+        assert img.mode == "L"
+        assert img.getpixel((0, 0)) == int(50 * 0.25 + 0.7 * 100 + 0.05 * 200)
+
+    def test_get_tile_0(self, app):
+        resp = app.get("/wmts/dop_0/GLOBAL_WEBMERCATOR/0/0/0.png")
+        assert resp.content_type == "image/png"
+        img = img_from_buf(resp.body)
+        assert img.mode == "RGB"  # forced with image.mode
+        assert img.getpixel((0, 0)) == (50, 50, 50)
+
+    def test_get_tile_0122(self, app):
+        resp = app.get("/wmts/dop_0122/GLOBAL_WEBMERCATOR/0/0/0.png")
+        assert resp.content_type == "image/png"
+        img = img_from_buf(resp.body)
+        assert img.mode == "RGBA"
+        assert img.getpixel((0, 0)) == (50, 100, 200, 50)
+
+    def test_get_map_l(self, app):
+        resp = app.get(str(self.common_map_req))
+        assert resp.content_type == "image/png"
+        img = img_from_buf(resp.body)
+        assert img.mode == "L"
+        assert img.getpixel((0, 0)) == int(50 * 0.25 + 0.7 * 100 + 0.05 * 200)
+
+    def test_get_map_l_jpeg(self, app):
+        self.common_map_req.params.format = "image/jpeg"
+        resp = app.get(str(self.common_map_req))
+        assert resp.content_type == "image/jpeg"
+        img = img_from_buf(resp.body)
+        assert img.mode == "RGB"
+        # L converted to RGB for jpeg
+        assert img.getpixel((0, 0)) == (92, 92, 92)

mapproxy/test/system/test_cache_geopackage.py

@@ -0,0 +1,144 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2011 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import division
+
+import os
+import shutil
+import sqlite3
+
+from io import BytesIO
+
+import pytest
+
+from mapproxy.request.wms import WMS111MapRequest
+from mapproxy.test.http import MockServ
+from mapproxy.test.image import is_png, create_tmp_image
+from mapproxy.test.system import SysTest
+from mapproxy.cache.geopackage import GeopackageCache
+from mapproxy.grid import TileGrid
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "cache_geopackage.yaml"
+
+
+@pytest.fixture(scope="class")
+def fixture_gpkg(base_dir):
+    shutil.copy(
+        os.path.join(os.path.dirname(__file__), "fixture", "cache.gpkg"),
+        base_dir.strpath,
+    )
+
+
+@pytest.mark.usefixtures("fixture_gpkg")
+class TestGeopackageCache(SysTest):
+
+    def setup(self):
+        self.common_map_req = WMS111MapRequest(
+            url="/service?",
+            param=dict(
+                service="WMS",
+                version="1.1.1",
+                bbox="-180,-80,0,0",
+                width="200",
+                height="200",
+                layers="gpkg",
+                srs="EPSG:4326",
+                format="image/png",
+                styles="",
+                request="GetMap",
+            ),
+        )
+
+    def test_get_map_cached(self, app):
+        resp = app.get(self.common_map_req)
+        assert resp.content_type == "image/png"
+        data = BytesIO(resp.body)
+        assert is_png(data)
+
+    def test_get_map_uncached(self, app, base_dir):
+        assert base_dir.join("cache.gpkg").check()
+        # already created on startup
+
+        self.common_map_req.params.bbox = "-180,0,0,80"
+        serv = MockServ(port=42423)
+        serv.expects("/tiles/01/000/000/000/000/000/001.png")
+        serv.returns(create_tmp_image((256, 256)))
+        with serv:
+            resp = app.get(self.common_map_req)
+            assert resp.content_type == "image/png"
+            data = BytesIO(resp.body)
+            assert is_png(data)
+
+        # now cached
+        resp = app.get(self.common_map_req)
+        assert resp.content_type == "image/png"
+        data = BytesIO(resp.body)
+        assert is_png(data)
+
+    def test_bad_config_geopackage_no_gpkg_contents(self, app, base_dir):
+        gpkg_file = base_dir.join("cache.gpkg").strpath
+        table_name = "no_gpkg_contents"
+
+        with sqlite3.connect(gpkg_file) as db:
+            cur = db.execute(
+                """SELECT name FROM sqlite_master WHERE type='table' AND name=?""",
+                (table_name,),
+            )
+            content = cur.fetchone()
+            assert content[0] == table_name
+
+        with sqlite3.connect(gpkg_file) as db:
+            cur = db.execute(
+                """SELECT table_name FROM gpkg_contents WHERE table_name=?""",
+                (table_name,),
+            )
+            content = cur.fetchone()
+            assert not content
+
+        GeopackageCache(gpkg_file, TileGrid(srs=4326), table_name=table_name)
+
+        with sqlite3.connect(gpkg_file) as db:
+            cur = db.execute(
+                """SELECT table_name FROM gpkg_contents WHERE table_name=?""",
+                (table_name,),
+            )
+            content = cur.fetchone()
+            assert content[0] == table_name
+
+    def test_bad_config_geopackage_no_spatial_ref_sys(self, base_dir):
+        gpkg_file = base_dir.join("cache.gpkg").strpath
+        organization_coordsys_id = 3785
+        table_name = "no_gpkg_spatial_ref_sys"
+
+        with sqlite3.connect(gpkg_file) as db:
+            cur = db.execute(
+                """SELECT organization_coordsys_id FROM gpkg_spatial_ref_sys WHERE organization_coordsys_id=?""",
+                (organization_coordsys_id,),
+            )
+            content = cur.fetchone()
+            assert not content
+
+        GeopackageCache(gpkg_file, TileGrid(srs=3785), table_name=table_name)
+
+        with sqlite3.connect(gpkg_file) as db:
+            cur = db.execute(
+                """SELECT organization_coordsys_id FROM gpkg_spatial_ref_sys WHERE organization_coordsys_id=?""",
+                (organization_coordsys_id,),
+            )
+            content = cur.fetchone()
+            assert content[0] == organization_coordsys_id

mapproxy/test/system/test_cache_grid_names.py

@@ -0,0 +1,89 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2012 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+from mapproxy.test.image import tmp_image
+from mapproxy.test.http import mock_httpd
+from mapproxy.test.system import SysTest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "cache_grid_names.yaml"
+
+
+class TestCacheGridNames(SysTest):
+
+    def test_tms_capabilities(self, app):
+        resp = app.get("/tms/1.0.0/")
+        assert "Cached Layer" in resp
+        assert "wms_cache/utm32n" in resp
+        assert "wms_cache_utm32n" not in resp
+        xml = resp.lxml
+        assert xml.xpath("count(//TileMap)") == 2
+
+    def test_tms_layer_capabilities(self, app):
+        resp = app.get("/tms/1.0.0/wms_cache/utm32n")
+        assert "Cached Layer" in resp
+        assert "wms_cache/utm32n" in resp
+        assert "wms_cache_utm32n" not in resp
+        xml = resp.lxml
+        assert xml.xpath("count(//TileSet)") == 12
+
+    def test_kml(self, app):
+        resp = app.get("/kml/wms_cache/utm32n/4/2/2.kml")
+        assert b"wms_cache/utm32n" in resp.body
+
+    def test_get_tile(self, app, cache_dir):
+        with tmp_image((256, 256), format="jpeg") as img:
+            expected_req = (
+                {
+                    "path": r"/service?LAYERs=bar&SERVICE=WMS&FORMAT=image%2Fjpeg"
+                    "&REQUEST=GetMap&HEIGHT=256&SRS=EPSG%3A25832&styles="
+                    "&VERSION=1.1.1&&WIDTH=256"
+                    "&BBOX=283803.311362,5609091.90862,319018.942566,5644307.53982"
+                },
+                {"body": img.read(), "headers": {"content-type": "image/jpeg"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tms/1.0.0/wms_cache/utm32n/4/2/2.jpeg")
+                assert resp.content_type == "image/jpeg"
+        assert cache_dir.join(
+            "wms_cache/utm32n/04/000/000/002/000/000/002.jpeg"
+        ).check()
+
+    def test_get_tile_no_grid_name(self, app, cache_dir):
+        # access tiles with grid name from TMS but cache still uses old SRS-code path
+        with tmp_image((256, 256), format="jpeg") as img:
+            expected_req = (
+                {
+                    "path": r"/service?LAYERs=bar&SERVICE=WMS&FORMAT=image%2Fjpeg"
+                    "&REQUEST=GetMap&HEIGHT=256&SRS=EPSG%3A25832&styles="
+                    "&VERSION=1.1.1&WIDTH=256"
+                    "&BBOX=283803.311362,5609091.90862,319018.942566,5644307.53982"
+                },
+                {"body": img.read(), "headers": {"content-type": "image/jpeg"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tms/1.0.0/wms_cache_no_grid_name/utm32n/4/2/2.jpeg")
+                assert resp.content_type == "image/jpeg"
+        assert cache_dir.join(
+            "wms_cache_no_grid_name_EPSG25832/04/000/000/002/000/000/002.jpeg"
+        ).check()