MapProxy 1.16.1__py3-none-any.whl

mapproxy/test/system/test_tms.py

@@ -0,0 +1,276 @@
+# 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 os
+import hashlib
+
+from io import BytesIO
+
+import pytest
+
+from mapproxy.compat.image import Image
+from mapproxy.test.image import is_jpeg, tmp_image
+from mapproxy.test.http import mock_httpd
+from mapproxy.test.system import SysTest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "layer.yaml"
+
+
+class TestTMS(SysTest):
+
+    def test_tms_capabilities(self, app):
+        resp = app.get("/tms/1.0.0/")
+        assert "WMS Cache Layer" in resp
+        assert "WMS Cache Multi Layer" in resp
+        assert "TMS Cache Layer" in resp
+        assert "TMS Cache Layer + FI" in resp
+        xml = resp.lxml
+        assert xml.xpath("count(//TileMap)") == 11
+
+        # without trailing space
+        resp2 = app.get("/tms/1.0.0")
+        assert resp.body == resp2.body
+
+    def test_tms_layer_capabilities(self, app):
+        resp = app.get("/tms/1.0.0/wms_cache")
+        assert "WMS Cache Layer" in resp
+        xml = resp.lxml
+        assert xml.xpath("count(//TileSet)") == 19
+
+    def test_tms_root_resource(self, app):
+        resp = app.get("/tms")
+        resp2 = app.get("/tms/")
+        assert "TileMapService" in resp and "TileMapService" in resp2
+        xml = resp.lxml
+        assert xml.xpath("//TileMapService/@version") == ["1.0.0"]
+
+    def test_tms_get_out_of_bounds_tile(self, app):
+        for coord in [(0, 0, -1), (-1, 0, 0), (0, -1, 0), (4, 2, 1), (1, 3, 0)]:
+            x, y, z = coord
+            url = "/tms/1.0.0/wms_cache/%d/%d/%d.jpeg" % (z, x, y)
+            resp = app.get(url, status=404)
+            xml = resp.lxml
+            assert (
+                "outside the bounding box"
+                in xml.xpath("/TileMapServerError/Message/text()")[0]
+            )
+
+    def test_invalid_layer(self, app):
+        resp = app.get("/tms/1.0.0/inVAlid/0/0/0.png", status=404)
+        xml = resp.lxml
+        assert (
+            "unknown layer: inVAlid"
+            in xml.xpath("/TileMapServerError/Message/text()")[0]
+        )
+
+    def test_invalid_format(self, app):
+        resp = app.get("/tms/1.0.0/wms_cache/0/0/1.png", status=404)
+        xml = resp.lxml
+        assert "invalid format" in xml.xpath("/TileMapServerError/Message/text()")[0]
+
+    def test_get_tile_tile_source_error(self, app):
+        resp = app.get("/tms/1.0.0/wms_cache/0/0/0.jpeg", status=500)
+        xml = resp.lxml
+        assert (
+            "No response from URL" in xml.xpath("/TileMapServerError/Message/text()")[0]
+        )
+
+    def test_get_cached_tile(self, app, fixture_cache_data):
+        resp = app.get("/tms/1.0.0/wms_cache/0/0/1.jpeg")
+        assert resp.content_type == "image/jpeg"
+        assert resp.content_length == len(resp.body)
+        data = BytesIO(resp.body)
+        assert is_jpeg(data)
+
+    def test_get_tile(self, app, cache_dir):
+        with tmp_image((256, 256), format="jpeg") as img:
+            expected_req = (
+                {
+                    "path": r"/service?LAYERs=foo,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("/tms/1.0.0/wms_cache/0/0/0.jpeg")
+                assert resp.content_type == "image/jpeg"
+        assert cache_dir.join(
+            "wms_cache_EPSG900913/01/000/000/000/000/000/000.jpeg"
+        ).check()
+
+    def test_get_tile_from_cache_with_tile_source(self, app, cache_dir):
+        with tmp_image((256, 256), format="jpeg") as img:
+            expected_req = (
+                {"path": r"/tiles/01/000/000/000/000/000/001.png"},
+                {"body": img.read(), "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(("localhost", 42423), [expected_req]):
+                resp = app.get("/tms/1.0.0/tms_cache/0/0/1.png")
+                assert resp.content_type == "image/png"
+        assert cache_dir.join(
+            "tms_cache_EPSG900913/01/000/000/000/000/000/001.png"
+        ).check()
+
+    def test_get_tile_with_watermark_cache(self, app):
+        with tmp_image((256, 256), format="png", color=(0, 0, 0)) as img:
+            expected_req = (
+                {"path": r"/tiles/01/000/000/000/000/000/000.png"},
+                {"body": img.read(), "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(("localhost", 42423), [expected_req]):
+                resp = app.get("/tms/1.0.0/watermark_cache/0/0/0.png")
+                assert resp.content_type == "image/png"
+                img = Image.open(BytesIO(resp.body))
+                colors = img.getcolors()
+                assert len(colors) >= 2
+                assert sorted(colors)[-1][1] == (0, 0, 0)
+
+
+class TestTileService(SysTest):
+
+    def test_get_out_of_bounds_tile(self, app):
+        for coord in [(0, 0, -1), (-1, 0, 0), (0, -1, 0), (4, 2, 1), (1, 3, 0)]:
+            x, y, z = coord
+            url = "/tiles/wms_cache/%d/%d/%d.jpeg" % (z, x, y)
+            resp = app.get(url, status=404)
+            assert "outside the bounding box" in resp
+
+    def test_invalid_layer(self, app):
+        resp = app.get("/tiles/inVAlid/0/0/0.png", status=404)
+        assert resp.content_type == "text/plain"
+        assert "unknown layer: inVAlid" in resp
+
+    def test_invalid_format(self, app):
+        resp = app.get("/tiles/wms_cache/0/0/1.png", status=404)
+        assert resp.content_type == "text/plain"
+        assert "invalid format" in resp
+
+    def test_get_tile_tile_source_error(self, app):
+        resp = app.get("/tiles/wms_cache/0/0/0.jpeg", status=500)
+        assert resp.content_type == "text/plain"
+        assert "No response from URL" in resp
+
+    def _check_tile_resp(self, resp):
+        assert resp.content_type == "image/jpeg"
+        assert resp.content_length == len(resp.body)
+        data = BytesIO(resp.body)
+        assert is_jpeg(data)
+
+    def _update_timestamp(self, cache_dir, base_config):
+        timestamp = 1234567890.0
+        size = 10214
+        base_dir = base_config.cache.base_dir
+        os.utime(
+            os.path.join(
+                base_dir, "wms_cache_EPSG900913/01/000/000/000/000/000/001.jpeg"
+            ),
+            (timestamp, timestamp),
+        )
+        max_age = base_config.tiles.expires_hours * 60 * 60
+        etag = hashlib.md5((str(timestamp) + str(size)).encode("ascii")).hexdigest()
+        return etag, max_age
+
+    def _check_cache_control_headers(self, resp, etag, max_age):
+        assert resp.headers["ETag"] == etag
+        assert resp.headers["Last-modified"] == "Fri, 13 Feb 2009 23:31:30 GMT"
+        assert resp.headers["Cache-control"] == "public, max-age=%d, s-maxage=%d" % (
+            max_age,
+            max_age,
+        )
+
+    def test_get_cached_tile(self, app, cache_dir, base_config, fixture_cache_data):
+        etag, max_age = self._update_timestamp(cache_dir, base_config)
+        resp = app.get("/tiles/wms_cache/1/0/1.jpeg")
+        self._check_cache_control_headers(resp, etag, max_age)
+        self._check_tile_resp(resp)
+
+    def test_get_cached_tile_flipped_y(
+        self, app, cache_dir, base_config, fixture_cache_data
+    ):
+        etag, max_age = self._update_timestamp(cache_dir, base_config)
+        resp = app.get("/tiles/wms_cache/1/0/0.jpeg?origin=nw")
+        self._check_cache_control_headers(resp, etag, max_age)
+        self._check_tile_resp(resp)
+
+    def test_if_none_match(self, app, cache_dir, base_config, fixture_cache_data):
+        etag, max_age = self._update_timestamp(cache_dir, base_config)
+        resp = app.get("/tiles/wms_cache/1/0/1.jpeg", headers={"If-None-Match": etag})
+        assert resp.status == "304 Not Modified"
+        self._check_cache_control_headers(resp, etag, max_age)
+
+        resp = app.get(
+            "/tiles/wms_cache/1/0/1.jpeg", headers={"If-None-Match": etag + "foo"}
+        )
+        self._check_cache_control_headers(resp, etag, max_age)
+        assert resp.status == "200 OK"
+        self._check_tile_resp(resp)
+
+    @pytest.mark.parametrize(
+        "date,modified",
+        [
+            ("Fri, 15 Feb 2009 23:31:30 GMT", False),
+            ("Fri, 13 Feb 2009 23:31:31 GMT", False),
+            ("Fri, 13 Feb 2009 23:31:30 GMT", False),
+            ("Fri, 13 Feb 2009 23:31:29 GMT", True),
+            ("Fri, 11 Feb 2009 23:31:29 GMT", True),
+            ("Friday, 13-Feb-09 23:31:30 GMT", False),
+            ("Friday, 13-Feb-09 23:31:29 GMT", True),
+            ("Fri Feb 13 23:31:30 2009", False),
+            ("Fri Feb 13 23:31:29 2009", True),
+            # and some invalid ones
+            ("Fri Foo 13 23:31:29 2009", True),
+            ("1234567890", True),
+        ],
+    )
+    def test_if_modified_since(
+        self, app, cache_dir, base_config, fixture_cache_data, date, modified
+    ):
+        etag, max_age = self._update_timestamp(cache_dir, base_config)
+        resp = app.get(
+            "/tiles/wms_cache/1/0/1.jpeg", headers={"If-Modified-Since": date}
+        )
+        self._check_cache_control_headers(resp, etag, max_age)
+        if modified:
+            assert resp.status == "200 OK"
+            self._check_tile_resp(resp)
+        else:
+            assert resp.status == "304 Not Modified"
+
+    def test_get_tile(self, app, cache_dir):
+        with tmp_image((256, 256), format="jpeg") as img:
+            expected_req = (
+                {
+                    "path": r"/service?LAYERs=foo,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"
+        assert cache_dir.join(
+            "wms_cache_EPSG900913/01/000/000/000/000/000/000.jpeg"
+        ).check()

mapproxy/test/system/test_tms_origin.py

@@ -0,0 +1,46 @@
+# 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 pytest
+
+from mapproxy.test.image import is_jpeg
+from mapproxy.test.system import SysTest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "tileservice_origin.yaml"
+
+
+@pytest.mark.usefixtures("fixture_cache_data")
+class TestTileServicesOrigin(SysTest):
+
+    ###
+    # tile 0/0/1 is cached, check if we can access it with different URLs
+
+    def test_get_cached_tile_tms(self, app):
+        resp = app.get("/tms/1.0.0/wms_cache/0/0/1.jpeg")
+        assert resp.content_type == "image/jpeg"
+        assert is_jpeg(resp.body)
+
+    def test_get_cached_tile_service_origin(self, app):
+        resp = app.get("/tiles/wms_cache/1/0/0.jpeg")
+        assert resp.content_type == "image/jpeg"
+        assert is_jpeg(resp.body)
+
+    def test_get_cached_tile_request_origin(self, app):
+        resp = app.get("/tiles/wms_cache/1/0/1.jpeg?origin=sw")
+        assert resp.content_type == "image/jpeg"
+        assert is_jpeg(resp.body)

mapproxy/test/system/test_util_conf.py

@@ -0,0 +1,304 @@
+# -:- encoding: utf-8 -:-
+# This file is part of the MapProxy project.
+# Copyright (C) 2013 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 os
+import shutil
+import tempfile
+
+import yaml
+
+from mapproxy.script.conf.app import config_command
+from mapproxy.test.helper import capture
+
+
+def filename(name):
+    return os.path.join(os.path.dirname(__file__), "fixture", name)
+
+
+class TestMapProxyConfCmd(object):
+
+    def setup(self):
+        self.dir = tempfile.mkdtemp()
+
+    def teardown(self):
+        if os.path.exists(self.dir):
+            shutil.rmtree(self.dir)
+
+    def tmp_filename(self, name):
+        return os.path.join(self.dir, name)
+
+    def test_cmd_no_args(self):
+        with capture() as (stdout, stderr):
+            assert config_command(["mapproxy-conf"]) == 2
+
+        assert "--capabilities required" in stderr.getvalue()
+
+    def test_stdout_output(self):
+        with capture(bytes=True) as (stdout, stderr):
+            assert (
+                config_command(
+                    [
+                        "mapproxy-conf",
+                        "--capabilities",
+                        filename("util-conf-wms-111-cap.xml"),
+                    ]
+                )
+                == 0
+            )
+
+        assert stdout.getvalue().startswith(b"# MapProxy configuration")
+
+    def test_test_cap_output_no_base(self):
+        with capture(bytes=True) as (stdout, stderr):
+            assert (
+                config_command(
+                    [
+                        "mapproxy-conf",
+                        "--capabilities",
+                        filename("util-conf-wms-111-cap.xml"),
+                        "--output",
+                        self.tmp_filename("mapproxy.yaml"),
+                    ]
+                )
+                == 0
+            )
+
+        with open(self.tmp_filename("mapproxy.yaml"), "rb") as f:
+            conf = yaml.safe_load(f)
+
+            assert "grids" not in conf
+            assert conf["sources"] == {
+                "osm_roads_wms": {
+                    "supported_srs": [
+                        "CRS:84",
+                        "EPSG:25831",
+                        "EPSG:25832",
+                        "EPSG:25833",
+                        "EPSG:31466",
+                        "EPSG:31467",
+                        "EPSG:31468",
+                        "EPSG:3857",
+                        "EPSG:4258",
+                        "EPSG:4326",
+                        "EPSG:900913",
+                    ],
+                    "req": {
+                        "layers": "osm_roads",
+                        "url": "http://osm.omniscale.net/proxy/service?",
+                        "transparent": True,
+                    },
+                    "type": "wms",
+                    "coverage": {
+                        "srs": "EPSG:4326",
+                        "bbox": [-180.0, -85.0511287798, 180.0, 85.0511287798],
+                    },
+                },
+                "osm_wms": {
+                    "supported_srs": [
+                        "CRS:84",
+                        "EPSG:25831",
+                        "EPSG:25832",
+                        "EPSG:25833",
+                        "EPSG:31466",
+                        "EPSG:31467",
+                        "EPSG:31468",
+                        "EPSG:3857",
+                        "EPSG:4258",
+                        "EPSG:4326",
+                        "EPSG:900913",
+                    ],
+                    "req": {
+                        "layers": "osm",
+                        "url": "http://osm.omniscale.net/proxy/service?",
+                        "transparent": True,
+                    },
+                    "type": "wms",
+                    "coverage": {
+                        "srs": "EPSG:4326",
+                        "bbox": [-180.0, -85.0511287798, 180.0, 85.0511287798],
+                    },
+                },
+            }
+
+            assert conf["layers"] == [
+                {
+                    "title": "Omniscale OpenStreetMap WMS",
+                    "layers": [
+                        {
+                            "name": "osm",
+                            "title": "OpenStreetMap (complete map)",
+                            "sources": ["osm_wms"],
+                        },
+                        {
+                            "name": "osm_roads",
+                            "title": "OpenStreetMap (streets only)",
+                            "sources": ["osm_roads_wms"],
+                        },
+                    ],
+                }
+            ]
+            assert len(conf["layers"][0]["layers"]) == 2
+
+    def test_test_cap_output(self):
+        with capture(bytes=True) as (stdout, stderr):
+            assert (
+                config_command(
+                    [
+                        "mapproxy-conf",
+                        "--capabilities",
+                        filename("util-conf-wms-111-cap.xml"),
+                        "--output",
+                        self.tmp_filename("mapproxy.yaml"),
+                        "--base",
+                        filename("util-conf-base-grids.yaml"),
+                    ]
+                )
+                == 0
+            )
+
+        with open(self.tmp_filename("mapproxy.yaml"), "rb") as f:
+            conf = yaml.safe_load(f)
+
+            assert "grids" not in conf
+            assert len(conf["sources"]) == 2
+
+            assert conf["caches"] == {
+                "osm_cache": {
+                    "grids": ["webmercator", "geodetic"],
+                    "sources": ["osm_wms"],
+                },
+                "osm_roads_cache": {
+                    "grids": ["webmercator", "geodetic"],
+                    "sources": ["osm_roads_wms"],
+                },
+            }
+
+            assert conf["layers"] == [
+                {
+                    "title": "Omniscale OpenStreetMap WMS",
+                    "layers": [
+                        {
+                            "name": "osm",
+                            "title": "OpenStreetMap (complete map)",
+                            "sources": ["osm_cache"],
+                        },
+                        {
+                            "name": "osm_roads",
+                            "title": "OpenStreetMap (streets only)",
+                            "sources": ["osm_roads_cache"],
+                        },
+                    ],
+                }
+            ]
+            assert len(conf["layers"][0]["layers"]) == 2
+
+    def test_overwrites(self):
+        with capture(bytes=True) as (stdout, stderr):
+            assert (
+                config_command(
+                    [
+                        "mapproxy-conf",
+                        "--capabilities",
+                        filename("util-conf-wms-111-cap.xml"),
+                        "--output",
+                        self.tmp_filename("mapproxy.yaml"),
+                        "--overwrite",
+                        filename("util-conf-overwrite.yaml"),
+                        "--base",
+                        filename("util-conf-base-grids.yaml"),
+                    ]
+                )
+                == 0
+            )
+
+        with open(self.tmp_filename("mapproxy.yaml"), "rb") as f:
+            conf = yaml.safe_load(f)
+
+            assert "grids" not in conf
+            assert len(conf["sources"]) == 2
+
+            assert conf["sources"] == {
+                "osm_roads_wms": {
+                    "supported_srs": ["EPSG:3857"],
+                    "req": {
+                        "layers": "osm_roads",
+                        "url": "http://osm.omniscale.net/proxy/service?",
+                        "transparent": True,
+                        "param": 42,
+                    },
+                    "type": "wms",
+                    "coverage": {"srs": "EPSG:4326", "bbox": [0, 0, 90, 90]},
+                },
+                "osm_wms": {
+                    "supported_srs": [
+                        "CRS:84",
+                        "EPSG:25831",
+                        "EPSG:25832",
+                        "EPSG:25833",
+                        "EPSG:31466",
+                        "EPSG:31467",
+                        "EPSG:31468",
+                        "EPSG:3857",
+                        "EPSG:4258",
+                        "EPSG:4326",
+                        "EPSG:900913",
+                    ],
+                    "req": {
+                        "layers": "osm",
+                        "url": "http://osm.omniscale.net/proxy/service?",
+                        "transparent": True,
+                        "param": 42,
+                    },
+                    "type": "wms",
+                    "coverage": {
+                        "srs": "EPSG:4326",
+                        "bbox": [-180.0, -85.0511287798, 180.0, 85.0511287798],
+                    },
+                },
+            }
+
+            assert conf["caches"] == {
+                "osm_cache": {
+                    "grids": ["webmercator", "geodetic"],
+                    "sources": ["osm_wms"],
+                    "cache": {"type": "sqlite"},
+                },
+                "osm_roads_cache": {
+                    "grids": ["webmercator"],
+                    "sources": ["osm_roads_wms"],
+                    "cache": {"type": "sqlite"},
+                },
+            }
+
+            assert conf["layers"] == [
+                {
+                    "title": "Omniscale OpenStreetMap WMS",
+                    "layers": [
+                        {
+                            "name": "osm",
+                            "title": "OpenStreetMap (complete map)",
+                            "sources": ["osm_cache"],
+                        },
+                        {
+                            "name": "osm_roads",
+                            "title": "OpenStreetMap (streets only)",
+                            "sources": ["osm_roads_cache"],
+                        },
+                    ],
+                }
+            ]
+            assert len(conf["layers"][0]["layers"]) == 2