MapProxy 2.1.0__py3-none-any.whl

mapproxy/test/system/test_mixed_mode_format.py

@@ -0,0 +1,201 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010 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
+
+from contextlib import contextmanager
+from io import BytesIO
+
+import pytest
+
+from mapproxy.compat.image import Image, ImageDraw, ImageColor
+from mapproxy.request.wms import WMS111MapRequest
+from mapproxy.request.wmts import WMTS100TileRequest
+from mapproxy.test.image import check_format, is_transparent
+from mapproxy.test.http import mock_httpd
+from mapproxy.test.system import SysTest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "mixed_mode.yaml"
+
+
+class TestWMS(SysTest):
+
+    def setup_method(self):
+        self.common_map_req = WMS111MapRequest(
+            url="/service?",
+            param=dict(
+                service="WMS",
+                version="1.1.1",
+                bbox="0,0,180,80",
+                width="200",
+                height="200",
+                layers="mixed_mode",
+                srs="EPSG:4326",
+                format="image/png",
+                styles="",
+                request="GetMap",
+                transparent="true",
+            ),
+        )
+        self.expected_base_path = "/service?SERVICE=WMS&REQUEST=GetMap&HEIGHT=256"\
+                                  "&SRS=EPSG%3A900913&styles=&VERSION=1.1.1&WIDTH=512"\
+                                  "&BBOX=-20037508.3428,0.0,20037508.3428,20037508.3428"
+
+    def test_mixed_mode(self, app, cache_dir):
+        req_format = "png"
+        transparent = "True"
+        with create_mixed_mode_img((512, 256)) as img:
+            expected_req = (
+                {
+                    "path": self.expected_base_path
+                    + "&layers=mixedsource"
+                    + "&format=image%2F"
+                    + req_format
+                    + "&transparent="
+                    + transparent
+                },
+                {
+                    "body": img.read(),
+                    "headers": {"content-type": "image/" + req_format},
+                },
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                self.common_map_req.params["format"] = "image/" + req_format
+                resp = app.get(self.common_map_req)
+
+                assert resp.content_type == "image/" + req_format
+                check_format(BytesIO(resp.body), req_format)
+                # GetMap Request is fully within the opaque tile
+                assert not is_transparent(resp.body)
+
+        # check cache formats
+        for f, format in [
+            ["mixed_cache_EPSG900913/01/000/000/000/000/000/001.mixed", "png"],
+            ["mixed_cache_EPSG900913/01/000/000/001/000/000/001.mixed", "jpeg"],
+        ]:
+            assert cache_dir.join(f).check()
+            check_format(cache_dir.join(f).read_binary(), format)
+
+
+class TestTMS(SysTest):
+
+    def setup_method(self):
+        self.expected_base_path = "/service?SERVICE=WMS&REQUEST=GetMap&HEIGHT=256"\
+                                  "&SRS=EPSG%3A900913&styles=&VERSION=1.1.1&WIDTH=512"\
+                                  "&BBOX=-20037508.3428,-20037508.3428,20037508.3428,0.0"
+
+    def test_mixed_mode(self, app, cache_dir):
+        with create_mixed_mode_img((512, 256)) as img:
+            expected_req = (
+                {
+                    "path": self.expected_base_path
+                    + "&layers=mixedsource"
+                    + "&format=image%2Fpng"
+                    + "&transparent=True"
+                },
+                {"body": img.read(), "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tms/1.0.0/mixed_mode/0/0/0.png")
+                assert resp.content_type == "image/png"
+                assert is_transparent(resp.body)
+
+                resp = app.get("/tms/1.0.0/mixed_mode/0/1/0.png")
+
+                assert resp.content_type == "image/jpeg"
+        assert cache_dir.join(
+            "mixed_cache_EPSG900913/01/000/000/000/000/000/000.mixed"
+        ).check()
+        assert cache_dir.join(
+            "mixed_cache_EPSG900913/01/000/000/001/000/000/000.mixed"
+        ).check()
+
+
+class TestWMTS(SysTest):
+
+    def setup_method(self):
+        self.common_tile_req = WMTS100TileRequest(
+            url="/service?",
+            param=dict(
+                service="WMTS",
+                version="1.0.0",
+                tilerow="0",
+                tilecol="0",
+                tilematrix="01",
+                tilematrixset="GLOBAL_MERCATOR",
+                layer="mixed_mode",
+                format="image/png",
+                style="",
+                request="GetTile",
+                transparent="True",
+            ),
+        )
+        self.expected_base_path = "/service?SERVICE=WMS&REQUEST=GetMap&HEIGHT=256"\
+                                  "&SRS=EPSG%3A900913&styles=&VERSION=1.1.1&WIDTH=512"\
+                                  "&BBOX=-20037508.3428,0.0,20037508.3428,20037508.3428"
+
+    def test_mixed_mode(self, app, cache_dir):
+        with create_mixed_mode_img((512, 256)) as img:
+            expected_req = (
+                {
+                    "path": self.expected_base_path
+                    + "&layers=mixedsource"
+                    + "&format=image%2Fpng"
+                    + "&transparent=True"
+                },
+                {"body": img.read(), "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get(self.common_tile_req)
+                assert resp.content_type == "image/png"
+                assert is_transparent(resp.body)
+
+                self.common_tile_req.params["tilecol"] = "1"
+                resp = app.get(self.common_tile_req)
+                assert resp.content_type == "image/jpeg"
+        assert cache_dir.join(
+            "mixed_cache_EPSG900913/01/000/000/000/000/000/001.mixed"
+        ).check()
+        assert cache_dir.join(
+            "mixed_cache_EPSG900913/01/000/000/001/000/000/001.mixed"
+        ).check()
+
+
+@contextmanager
+def create_mixed_mode_img(size, format="png"):
+    img = Image.new("RGBA", size)
+
+    # draw a black rectangle into the image, rect_width = 3/4 img_width
+    # thus 1/4 of the image is transparent and with square tiles, one of two
+    # tiles (img size = 512x256) will be fully opaque and the other
+    # has transparency
+    draw = ImageDraw.Draw(img)
+    w, h = size
+    red_color = ImageColor.getrgb("red")
+    draw.rectangle((w / 4, 0, w, h), fill=red_color)
+
+    data = BytesIO()
+    img.save(data, format)
+    data.seek(0)
+    yield data

mapproxy/test/system/test_multi_cache_layers.py

@@ -0,0 +1,169 @@
+# -:- encoding: utf8 -:-
+# This file is part of the MapProxy project.
+# Copyright (C) 2015 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
+
+from io import BytesIO
+
+import pytest
+
+from mapproxy.request.wmts import WMTS100TileRequest, WMTS100CapabilitiesRequest
+from mapproxy.request.wms import WMS111CapabilitiesRequest
+from mapproxy.test.image import is_png, create_tmp_image
+from mapproxy.test.http import MockServ
+from mapproxy.test.helper import validate_with_xsd
+from mapproxy.test.system import SysTest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "multi_cache_layers.yaml"
+
+
+ns_wmts = {
+    "wmts": "http://www.opengis.net/wmts/1.0",
+    "ows": "http://www.opengis.net/ows/1.1",
+    "xlink": "http://www.w3.org/1999/xlink",
+}
+
+
+TEST_TILE = create_tmp_image((256, 256))
+
+
+class TestMultiCacheLayer(SysTest):
+
+    def setup_method(self):
+        self.common_cap_req = WMTS100CapabilitiesRequest(
+            url="/service?",
+            param=dict(service="WMTS", version="1.0.0", request="GetCapabilities"),
+        )
+        self.common_tile_req = WMTS100TileRequest(
+            url="/service?",
+            param=dict(
+                service="WMTS",
+                version="1.0.0",
+                tilerow="0",
+                tilecol="0",
+                tilematrix="01",
+                tilematrixset="GLOBAL_WEBMERCATOR",
+                layer="multi_cache",
+                format="image/png",
+                style="",
+                request="GetTile",
+            ),
+        )
+
+    def test_image_config(self, app):
+        resp = app.get("/tms/1.0.0/")
+        assert "http://localhost/tms/1.0.0/cache_image/EPSG25832" in resp
+
+    def test_tms_capabilities(self, app):
+        resp = app.get("/tms/1.0.0/")
+        assert "http://localhost/tms/1.0.0/multi_cache/EPSG25832" in resp
+        assert "http://localhost/tms/1.0.0/multi_cache/EPSG3857" in resp
+        assert "http://localhost/tms/1.0.0/multi_cache/CRS84" in resp
+        assert "http://localhost/tms/1.0.0/multi_cache/EPSG31467" in resp
+        assert "http://localhost/tms/1.0.0/cache/EPSG25832" in resp
+        xml = resp.lxml
+        assert xml.xpath("count(//TileMap)") == 8
+
+    def test_wmts_capabilities(self, app):
+        req = str(self.common_cap_req)
+        resp = app.get(req)
+        assert resp.content_type == "application/xml"
+        xml = resp.lxml
+
+        assert validate_with_xsd(
+            xml, xsd_name="wmts/1.0/wmtsGetCapabilities_response.xsd"
+        )
+        assert set(
+            xml.xpath("//wmts:Layer/ows:Identifier/text()", namespaces=ns_wmts)
+        ) == set(["cache", "multi_cache", "cache_image"])
+        assert set(
+            xml.xpath(
+                "//wmts:Contents/wmts:TileMatrixSet/ows:Identifier/text()",
+                namespaces=ns_wmts,
+            )
+        ) == set(["gk3", "GLOBAL_WEBMERCATOR", "utm32", "InspireCrs84Quad"])
+
+    def test_wms_capabilities(self, app):
+        req = WMS111CapabilitiesRequest(url="/service?")
+        resp = app.get(req)
+        assert resp.content_type == "application/vnd.ogc.wms_xml"
+        xml = resp.lxml
+        assert (
+            xml.xpath(
+                "//GetMap//OnlineResource/@xlink:href",
+                namespaces=dict(xlink="http://www.w3.org/1999/xlink"),
+            )[0]
+            == "http://localhost/service?"
+        )
+
+        layer_names = set(xml.xpath("//Layer/Layer/Name/text()"))
+        expected_names = set(["wms_only", "cache", "cache_image"])
+        assert layer_names == expected_names
+
+    def test_get_tile_webmerc(self, app):
+        serv = MockServ(42423, bbox_aware_query_comparator=True)
+        serv.expects(
+            "/service?layers=foo,bar&width=256&version=1.1.1&bbox=-20037508.3428,0.0,0.0,20037508.3428&service=WMS&format=image%2Fpng&styles=&srs=EPSG%3A3857&request=GetMap&height=256"  # noqa
+        ).returns(TEST_TILE)
+        with serv:
+            resp = app.get(str(self.common_tile_req))
+        assert resp.content_type == "image/png"
+        data = BytesIO(resp.body)
+        assert is_png(data)
+
+    def test_get_tile_utm(self, app):
+        serv = MockServ(42423, bbox_aware_query_comparator=True)
+        serv.expects(
+            "/service?layers=foo,bar&width=256&version=1.1.1&bbox=-46133.17,5675047.40429,580038.965712,6301219.54&service=WMS&format=image%2Fpng&styles=&srs=EPSG%3A25832&request=GetMap&height=256"  # noqa
+        ).returns(TEST_TILE)
+        self.common_tile_req.params["tilematrixset"] = "utm32"
+
+        with serv:
+            resp = app.get(str(self.common_tile_req))
+        assert resp.content_type == "image/png"
+        data = BytesIO(resp.body)
+        assert is_png(data)
+
+    def test_get_tile_cascaded_cache(self, app):
+        serv = MockServ(42423, bbox_aware_query_comparator=True, unordered=True)
+        # gk3 cache requests UTM tiles
+        serv.expects(
+            "/service?layers=foo,bar&width=256&version=1.1.1&bbox=423495.931784,5596775.88732,501767.448748,5675047.40429&service=WMS&format=image%2Fpng&styles=&srs=EPSG%3A25832&request=GetMap&height=256"  # noqa
+        ).returns(TEST_TILE)
+        serv.expects(
+            "/service?layers=foo,bar&width=256&version=1.1.1&bbox=345224.41482,5596775.88732,423495.931784,5675047.40429&service=WMS&format=image%2Fpng&styles=&srs=EPSG%3A25832&request=GetMap&height=256"  # noqa
+        ).returns(TEST_TILE)
+        serv.expects(
+            "/service?layers=foo,bar&width=256&version=1.1.1&bbox=345224.41482,5518504.37036,423495.931784,5596775.88732&service=WMS&format=image%2Fpng&styles=&srs=EPSG%3A25832&request=GetMap&height=256"  # noqa
+        ).returns(TEST_TILE)
+        serv.expects(
+            "/service?layers=foo,bar&width=256&version=1.1.1&bbox=423495.931784,5518504.37036,501767.448748,5596775.88732&service=WMS&format=image%2Fpng&styles=&srs=EPSG%3A25832&request=GetMap&height=256"  # noqa
+        ).returns(TEST_TILE)
+        serv.expects(
+            "/service?layers=foo,bar&width=256&version=1.1.1&bbox=345224.41482,5440232.8534,423495.931784,5518504.37036&service=WMS&format=image%2Fpng&styles=&srs=EPSG%3A25832&request=GetMap&height=256"  # noqa
+        ).returns(TEST_TILE)
+        serv.expects(
+            "/service?layers=foo,bar&width=256&version=1.1.1&bbox=423495.931784,5440232.8534,501767.448748,5518504.37036&service=WMS&format=image%2Fpng&styles=&srs=EPSG%3A25832&request=GetMap&height=256"  # noqa
+        ).returns(TEST_TILE)
+        self.common_tile_req.params["tilematrixset"] = "gk3"
+        with serv:
+            resp = app.get(str(self.common_tile_req))
+        assert resp.content_type == "image/png"
+        data = BytesIO(resp.body)
+        assert is_png(data)

mapproxy/test/system/test_multiapp.py

@@ -0,0 +1,92 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010 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 io
+import os
+import shutil
+
+import pytest
+
+from mapproxy.multiapp import make_wsgi_app
+
+from mapproxy.test.system import SysTest, WSGITestApp
+
+
+class TestMultiapp(SysTest):
+
+    @pytest.fixture(scope="class")
+    def app(self, base_dir):
+        app = make_wsgi_app(base_dir.strpath, allow_listing=False)
+        return WSGITestApp(app, use_unicode=False)
+
+    @pytest.fixture(scope="class")
+    def base_dir(self, tmpdir_factory):
+        dir = tmpdir_factory.mktemp("base_dir")
+
+        fixture_dir = os.path.join(os.path.dirname(__file__), "fixture")
+        shutil.copy(os.path.join(fixture_dir, "multiapp1.yaml"), dir.strpath)
+        shutil.copy(os.path.join(fixture_dir, "multiapp2.yaml"), dir.strpath)
+
+        return dir
+
+    def test_index_without_list(self, app):
+        resp = app.get("/")
+        assert "MapProxy" in resp
+        assert "multiapp1" not in resp
+
+    def test_index_with_list(self, app):
+        try:
+            app.app.list_apps = True
+            resp = app.get("/")
+            assert "MapProxy" in resp
+            assert "multiapp1" in resp
+        finally:
+            app.app.list_apps = False
+
+    def test_unknown_app(self, app):
+        app.get("/unknownapp", status=404)
+        # assert status == 404 Not Found in app.get
+
+    def test_known_app(self, app):
+        resp = app.get("/multiapp1")
+        assert "demo" in resp
+
+    def test_reloading(self, app, base_dir):
+        resp = app.get("/multiapp1")
+        assert "demo" in resp
+        app_config = base_dir.join("multiapp1.yaml").strpath
+
+        replace_text_in_file(app_config, "  demo:", "  #demo:", ts_delta=5)
+
+        resp = app.get("/multiapp1")
+        assert "demo" not in resp
+
+        replace_text_in_file(app_config, "  #demo:", "  demo:", ts_delta=10)
+
+        resp = app.get("/multiapp1")
+        assert "demo" in resp
+
+
+def replace_text_in_file(filename, old, new, ts_delta=2):
+    text = io.open(filename, encoding="utf-8").read()
+    text = text.replace(old, new)
+    io.open(filename, "w", encoding="utf-8").write(text)
+
+    # file timestamps are not precise enough (1sec)
+    # add larger delta to force reload
+    m_time = os.path.getmtime(filename)
+    os.utime(filename, (m_time + ts_delta, m_time + ts_delta))

mapproxy/test/system/test_refresh.py

@@ -0,0 +1,206 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010-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 time
+
+from io import BytesIO
+import pytest
+
+from mapproxy.compat.image import Image
+from mapproxy.test.image import tmp_image
+from mapproxy.test.http import mock_httpd
+from mapproxy.test.system import SysTest
+from mapproxy.util.times import timestamp_from_isodate
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "tileservice_refresh.yaml"
+
+
+class TestRefresh(SysTest):
+
+    def test_refresh_tile_1s(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%3A900913&styles="
+                    "&VERSION=1.1.1&BBOX=-20037508.3428,-20037508.3428,0.0,0.0"
+                    "&WIDTH=256"
+                },
+                {"body": img.read(), "headers": {"content-type": "image/jpeg"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache/1/0/0.jpeg")
+                assert resp.content_type == "image/jpeg"
+                file_path = cache_dir.join(
+                    "wms_cache_EPSG900913/01/000/000/000/000/000/000.jpeg"
+                )
+                assert file_path.check()
+                t1 = file_path.mtime()
+                # file_path.remove()
+                # assert not file_path.check()
+            resp = app.get("/tiles/wms_cache/1/0/0.jpeg")
+            assert resp.content_type == "image/jpeg"
+            assert file_path.check()
+            t2 = file_path.mtime()
+            # tile is expired after 1 sec, so it will be fetched again from mock server
+            time.sleep(1.2)
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache/1/0/0.jpeg")
+                assert resp.content_type == "image/jpeg"
+                assert file_path.check()
+                t3 = file_path.mtime()
+        assert t2 == t1
+        assert t3 > t2
+
+    def test_refresh_tile_mtime(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%3A900913&styles="
+                    "&VERSION=1.1.1&BBOX=-20037508.3428,-20037508.3428,0.0,0.0"
+                    "&WIDTH=256"
+                },
+                {"body": img.read(), "headers": {"content-type": "image/jpeg"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache_isotime/1/0/0.jpeg")
+                assert resp.content_type == "image/jpeg"
+                file_path = cache_dir.join(
+                    "wms_cache_isotime_EPSG900913/01/000/000/000/000/000/000.jpeg"
+                )
+                assert file_path.check()
+                timestamp = timestamp_from_isodate("2009-02-15T23:31:30")
+                file_path.setmtime(timestamp + 1.2)
+                t1 = file_path.mtime()
+            resp = app.get("/tiles/wms_cache_isotime/1/0/0.jpeg")
+            assert resp.content_type == "image/jpeg"
+            t2 = file_path.mtime()
+            file_path.setmtime(timestamp - 1.2)
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache_isotime/1/0/0.jpeg")
+                assert resp.content_type == "image/jpeg"
+                assert file_path.check()
+                t3 = file_path.mtime()
+            assert t2 == t1
+            assert t3 > t2
+
+    def test_refresh_tile_source_error_no_stale(self, app, cache_dir):
+        source_request = {
+            "path": r"/service?LAYERs=bar&SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=256&SRS=EPSG%3A900913&styles="
+            "&VERSION=1.1.1&BBOX=-20037508.3428,-20037508.3428,0.0,0.0"
+            "&WIDTH=256"
+        }
+        with tmp_image((256, 256), format="png") as img:
+            expected_req = (
+                source_request,
+                {"body": img.read(), "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache_png/1/0/0.png")
+                assert resp.content_type == "image/png"
+                img.seek(0)
+                assert resp.body == img.read()
+            resp = app.get("/tiles/wms_cache_png/1/0/0.png")
+            assert resp.content_type == "image/png"
+            img.seek(0)
+            assert resp.body == img.read()
+            # tile is expired after 1 sec, so it will be requested again from mock server
+            time.sleep(1.2)
+            expected_req = (
+                source_request,
+                {"body": "", "status": 404},
+            )
+            with mock_httpd(
+                    ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache_png/1/0/0.png")
+                assert resp.content_type == "image/png"
+                # error handler for 404 does not authorise stale tiles, so transparent tile will be rendered
+                resp_img = Image.open(BytesIO(resp.body))
+                # check response transparency
+                assert resp_img.getbands() == ('R', 'G', 'B', 'A')
+                assert resp_img.getextrema()[3] == (0, 0)
+
+            expected_req = (
+                source_request,
+                {"body": "", "status": 405},
+            )
+            with mock_httpd(
+                    ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache_png/1/0/0.png")
+                assert resp.content_type == "image/png"
+                # error handler for 405 does not authorise stale tiles, so red tile will be rendered
+                resp_img = Image.open(BytesIO(resp.body))
+                # check response red color
+                assert resp_img.getbands() == ('R', 'G', 'B')
+                assert resp_img.getextrema() == ((255, 255), (0, 0), (0, 0))
+
+    def test_refresh_tile_source_error_stale(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%3A900913&styles="
+                    "&VERSION=1.1.1&BBOX=-20037508.3428,-20037508.3428,0.0,0.0"
+                    "&WIDTH=256"
+                },
+                {"body": img.read(), "headers": {"content-type": "image/jpeg"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache/1/0/0.jpeg")
+                assert resp.content_type == "image/jpeg"
+                img.seek(0)
+                assert resp.body == img.read()
+            resp = app.get("/tiles/wms_cache/1/0/0.jpeg")
+            assert resp.content_type == "image/jpeg"
+            img.seek(0)
+            assert resp.body == img.read()
+            # tile is expired after 1 sec, so it will be fetched again from mock server
+            time.sleep(1.2)
+            expected_req = (
+                {
+                    "path": r"/service?LAYERs=bar&SERVICE=WMS&FORMAT=image%2Fjpeg"
+                    "&REQUEST=GetMap&HEIGHT=256&SRS=EPSG%3A900913&styles="
+                    "&VERSION=1.1.1&BBOX=-20037508.3428,-20037508.3428,0.0,0.0"
+                    "&WIDTH=256"
+                },
+                {"body": "", "status": 406},
+            )
+            with mock_httpd(
+                    ("localhost", 42423), [expected_req], bbox_aware_query_comparator=True
+            ):
+                resp = app.get("/tiles/wms_cache/1/0/0.jpeg")
+                assert resp.content_type == "image/jpeg"
+                # Check that initial non empty img is served as a stale tile
+                img.seek(0)
+                assert resp.body == img.read()