MapProxy 1.16.1__py3-none-any.whl

mapproxy/test/system/test_cache_mbtiles.py

@@ -0,0 +1,85 @@
+# 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
+
+from io import BytesIO
+
+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
+
+import pytest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "cache_mbtiles.yaml"
+
+
+@pytest.fixture(scope="class")
+def fixture_gpkg(base_dir):
+    shutil.copy(
+        os.path.join(os.path.dirname(__file__), "fixture", "cache.mbtiles"),
+        base_dir.strpath,
+    )
+
+
+@pytest.mark.usefixtures("fixture_gpkg")
+class TestMBTilesCache(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="mb",
+                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):
+        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)

mapproxy/test/system/test_cache_s3.py

@@ -0,0 +1,115 @@
+# 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.
+
+from __future__ import division
+
+import sys
+
+from io import BytesIO
+
+from mapproxy.request.wms import WMS111MapRequest
+from mapproxy.test.image import is_png, create_tmp_image
+from mapproxy.test.system import SysTest
+
+import pytest
+
+
+try:
+    import boto3
+    from moto import mock_s3
+except ImportError:
+    boto3 = None
+    mock_s3 = None
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "cache_s3.yaml"
+
+
+@pytest.fixture(scope="module")
+def s3_buckets():
+    with mock_s3():
+        boto3.client("s3").create_bucket(Bucket="default_bucket")
+        boto3.client("s3").create_bucket(Bucket="tiles")
+        boto3.client("s3").create_bucket(Bucket="reversetiles")
+
+        yield
+
+
+@pytest.mark.skipif(not (boto3 and mock_s3), reason="boto3 and moto required")
+@pytest.mark.xfail(
+    sys.version_info[:2] in ((3, 4), (3, 5)),
+    reason="moto tests unreliable with Python 3.4/3.5",
+)
+@pytest.mark.usefixtures("s3_buckets")
+class TestS3Cache(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):
+        # mock_s3 interferes with MockServ, use boto to manually upload tile
+        tile = create_tmp_image((256, 256))
+        boto3.client("s3").upload_fileobj(
+            BytesIO(tile),
+            Bucket="default_bucket",
+            Key="default_cache/WebMerc/4/1/9.png",
+        )
+
+        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):
+        # mock_s3 interferes with MockServ, use boto to manually upload tile
+        tile = create_tmp_image((256, 256))
+        boto3.client("s3").upload_fileobj(
+            BytesIO(tile), Bucket="tiles", Key="quadkeytiles/2003.png"
+        )
+
+        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):
+        # mock_s3 interferes with MockServ, use boto to manually upload tile
+        tile = create_tmp_image((256, 256))
+        boto3.client("s3").upload_fileobj(
+            BytesIO(tile), Bucket="tiles", Key="reversetiles/9/1/4.png"
+        )
+
+        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_source.py

@@ -0,0 +1,146 @@
+# 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.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_source.yaml"
+
+
+class TestCacheSource(SysTest):
+
+    def test_tms_capabilities(self, app):
+        resp = app.get("/tms/1.0.0/")
+        assert "transformed tile source" in resp
+        xml = resp.lxml
+
+        assert xml.xpath("count(//TileMap)") == 3
+
+    def test_get_map_through_cache(self, app):
+        map_req = WMS111MapRequest(
+            url="/service?",
+            param=dict(
+                service="WMS",
+                version="1.1.1",
+                width="100",
+                height="100",
+                bbox="432890.564641,5872387.45834,466833.867667,5928359.08814",
+                layers="tms_transf",
+                srs="EPSG:25832",
+                format="image/png",
+                styles="",
+                request="GetMap",
+            ),
+        )
+
+        expected_reqs = []
+        with tmp_image((256, 256), format="jpeg") as img:
+            img = img.read()
+            # tms_cache_out has meta_size of [2, 2] but we need larger extent for transformation
+            for tile in [
+                (132, 172, 8),
+                (133, 172, 8),
+                (134, 172, 8),
+                (132, 173, 8),
+                (133, 173, 8),
+                (134, 173, 8),
+                (132, 174, 8),
+                (133, 174, 8),
+                (134, 174, 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_through_cache(self, app, cache_dir):
+        # request tile from tms_transf,
+        # should get tile from tms_source via tms_cache_in/out
+        expected_reqs = []
+        with tmp_image((256, 256), format="jpeg") as img:
+            for tile in [(8, 11, 4), (8, 10, 4)]:
+                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("/tms/1.0.0/tms_transf/EPSG25832/0/0/0.png")
+                assert resp.content_type == "image/png"
+
+        assert cache_dir.join(
+            "tms_cache_out_EPSG25832/00/000/000/000/000/000/000.png"
+        ).check()
+
+    def test_get_tile_from_sub_grid(self, app, cache_dir):
+        # create tile in old cache
+        tile_filename = cache_dir.join(
+            "old_cache_EPSG3857/01/000/000/001/000/000/000.png"
+        )
+        # use text to check that mapproxy does not access the tile as image
+        tile_filename.write_binary(b"foo", ensure=True)
+
+        # access new cache, should get existing tile from old cache
+        resp = app.get("/tiles/new_cache_EPSG3857/0/0/0.png")
+        assert resp.content_type == "image/png"
+        assert resp.body == b"foo"
+
+        assert cache_dir.join(
+            "old_cache_EPSG3857/01/000/000/001/000/000/000.png"
+        ).check()
+        assert cache_dir.join(
+            "new_cache_EPSG3857/00/000/000/000/000/000/000.png"
+        ).check()
+
+    def test_get_tile_combined_cache(self, app):
+        # request from cache with two cache sources where only one
+        # is compatible (supports tiled_only)
+        expected_reqs = []
+        with tmp_image((256, 256), format="jpeg") as img:
+            img = img.read()
+            for tile in [
+                r"/tiles/04/000/000/008/000/000/011.png",
+                r"/tiles/04/000/000/008/000/000/010.png",
+                r"/tiles/utm/00/000/000/000/000/000/000.png",
+            ]:
+                expected_reqs.append(
+                    (
+                        {"path": tile},
+                        {"body": img, "headers": {"content-type": "image/png"}},
+                    )
+                )
+
+            with mock_httpd(("localhost", 42423), expected_reqs, unordered=True):
+                resp = app.get("/tms/1.0.0/combined/EPSG25832/0/0/0.png")
+                assert resp.content_type == "image/png"

mapproxy/test/system/test_combined_sources.py

@@ -0,0 +1,335 @@
+# 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 io import BytesIO
+
+import pytest
+
+from mapproxy.request.wms import WMS111MapRequest
+from mapproxy.compat.image import Image
+from mapproxy.test.image import is_png, tmp_image, create_tmp_image
+from mapproxy.test.http import mock_httpd
+from mapproxy.test.system import SysTest
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "combined_sources.yaml"
+
+
+class TestCoverageWMS(SysTest):
+
+    def setup(self):
+        self.common_map_req = WMS111MapRequest(
+            url="/service?",
+            param=dict(
+                service="WMS",
+                version="1.1.1",
+                bbox="9,50,10,51",
+                width="200",
+                height="200",
+                layers="combinable",
+                srs="EPSG:4326",
+                format="image/png",
+                styles="",
+                request="GetMap",
+            ),
+        )
+
+    def test_combined(self, app):
+        common_params = (
+            r"?SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+            "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+            "&WIDTH=200&transparent=True"
+        )
+
+        with tmp_image((200, 200), format="png") as img:
+            img = img.read()
+            expected_req = [
+                (
+                    {
+                        "path": "/service_a"
+                        + common_params
+                        + "&layers=a_one,a_two,a_three,a_four"
+                    },
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+                (
+                    {"path": "/service_b" + common_params + "&layers=b_one"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+            ]
+
+            with mock_httpd(("localhost", 42423), expected_req):
+                self.common_map_req.params.layers = "combinable"
+                resp = app.get(self.common_map_req)
+                assert resp.content_type == "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+
+    def test_uncombined(self, app):
+        common_params = (
+            r"?SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+            "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+            "&WIDTH=200&transparent=True"
+        )
+
+        with tmp_image((200, 200), format="png") as img:
+            img = img.read()
+            expected_req = [
+                (
+                    {"path": "/service_a" + common_params + "&layers=a_one"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+                (
+                    {"path": "/service_b" + common_params + "&layers=b_one"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+                (
+                    {"path": "/service_a" + common_params + "&layers=a_two,a_three"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+            ]
+
+            with mock_httpd(("localhost", 42423), expected_req):
+                self.common_map_req.params.layers = "uncombinable"
+                resp = app.get(self.common_map_req)
+                assert resp.content_type == "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+
+    def test_combined_layers(self, app):
+        common_params = (
+            r"?SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+            "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+            "&WIDTH=200&transparent=True"
+        )
+
+        with tmp_image((200, 200), format="png") as img:
+            img = img.read()
+            expected_req = [
+                (
+                    {"path": "/service_a" + common_params + "&layers=a_one"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+                (
+                    {"path": "/service_b" + common_params + "&layers=b_one"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+                (
+                    {
+                        "path": "/service_a"
+                        + common_params
+                        + "&layers=a_two,a_three,a_four"
+                    },
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+            ]
+
+            with mock_httpd(("localhost", 42423), expected_req):
+                self.common_map_req.params.layers = "uncombinable,single"
+                resp = app.get(self.common_map_req)
+                assert resp.content_type == "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+
+    def test_layers_with_opacity(self, app):
+        # overlay with opacity -> request should not be combined
+        common_params = (
+            r"?SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+            "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+            "&WIDTH=200"
+        )
+
+        img_bg = create_tmp_image((200, 200), color=(0, 0, 0))
+        img_fg = create_tmp_image((200, 200), color=(255, 0, 128))
+
+        expected_req = [
+            (
+                {"path": "/service_a" + common_params + "&layers=a_one"},
+                {"body": img_bg, "headers": {"content-type": "image/png"}},
+            ),
+            (
+                {"path": "/service_a" + common_params + "&layers=a_two"},
+                {"body": img_fg, "headers": {"content-type": "image/png"}},
+            ),
+        ]
+
+        with mock_httpd(("localhost", 42423), expected_req):
+            self.common_map_req.params.layers = "opacity_base,opacity_overlay"
+            resp = app.get(self.common_map_req)
+            assert resp.content_type == "image/png"
+            data = BytesIO(resp.body)
+            assert is_png(data)
+            img = Image.open(data)
+            assert img.getcolors()[0] == ((200 * 200), (127, 0, 64))
+
+    def test_combined_transp_color(self, app):
+        # merged to one request because both layers share the same transparent_color
+        common_params = (
+            r"?SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+            "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+            "&WIDTH=200&transparent=True"
+        )
+
+        with tmp_image((200, 200), color=(255, 0, 0), format="png") as img:
+            img = img.read()
+            expected_req = [
+                (
+                    {
+                        "path": "/service_a"
+                        + common_params
+                        + "&layers=a_iopts_one,a_iopts_two"
+                    },
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                )
+            ]
+
+            with mock_httpd(("localhost", 42423), expected_req):
+                self.common_map_req.params.layers = (
+                    "layer_image_opts1,layer_image_opts2"
+                )
+                self.common_map_req.params.transparent = True
+                resp = app.get(self.common_map_req)
+                resp.content_type = "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+                img = Image.open(data)
+                assert img.getcolors()[0] == ((200 * 200), (255, 0, 0, 0))
+
+    def test_combined_mixed_transp_color(self, app):
+        # not merged to one request because only one layer has transparent_color
+        common_params = (
+            r"?SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+            "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+            "&WIDTH=200&transparent=True"
+        )
+
+        with tmp_image((200, 200), color=(255, 0, 0), format="png") as img:
+            img = img.read()
+            expected_req = [
+                (
+                    {"path": "/service_a" + common_params + "&layers=a_four"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+                (
+                    {"path": "/service_a" + common_params + "&layers=a_iopts_one"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+            ]
+
+            with mock_httpd(("localhost", 42423), expected_req):
+                self.common_map_req.params.layers = "single,layer_image_opts1"
+                self.common_map_req.params.transparent = True
+                resp = app.get(self.common_map_req)
+                resp.content_type = "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+
+    def test_combined_same_fwd_req_params(self, app):
+        # merged to one request because all layers share the same time param in
+        # fwd_req_params config
+        with tmp_image((200, 200), format="png") as img:
+            img = img.read()
+            expected_req = [
+                (
+                    {
+                        "path": "/service_a?SERVICE=WMS&FORMAT=image%2Fpng"
+                        "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+                        "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+                        "&WIDTH=200&transparent=True&TIME=20041012"
+                        "&layers=a_one,a_two,a_three,a_four"
+                    },
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                )
+            ]
+
+            with mock_httpd(("localhost", 42423), expected_req):
+                self.common_map_req.params.layers = "layer_fwdparams1,layer_fwdparams2"
+                self.common_map_req.params["time"] = "20041012"
+                self.common_map_req.params.transparent = True
+                resp = app.get(self.common_map_req)
+                resp.content_type = "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+
+    def test_combined_no_fwd_req_params(self, app):
+        # merged to one request because no vendor param is set
+        with tmp_image((200, 200), format="png") as img:
+            img = img.read()
+            expected_req = [
+                (
+                    {
+                        "path": "/service_a?SERVICE=WMS&FORMAT=image%2Fpng"
+                        "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+                        "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+                        "&WIDTH=200&transparent=True"
+                        "&layers=a_one,a_two,a_four"
+                    },
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                )
+            ]
+
+            with mock_httpd(("localhost", 42423), expected_req):
+                self.common_map_req.params.layers = "layer_fwdparams1,single"
+                self.common_map_req.params.transparent = True
+                resp = app.get(self.common_map_req)
+                resp.content_type = "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+
+    def test_combined_mixed_fwd_req_params(self, app):
+        # not merged to one request because fwd_req_params are different
+        common_params = (
+            r"/service_a?SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326&styles="
+            "&VERSION=1.1.1&BBOX=9.0,50.0,10.0,51.0"
+            "&WIDTH=200&transparent=True"
+        )
+
+        with tmp_image((200, 200), format="png") as img:
+            img = img.read()
+            expected_req = [
+                (
+                    {"path": common_params + "&layers=a_one&TIME=20041012"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+                (
+                    {"path": common_params + "&layers=a_two&TIME=20041012&VENDOR=foo"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+                (
+                    {"path": common_params + "&layers=a_four"},
+                    {"body": img, "headers": {"content-type": "image/png"}},
+                ),
+            ]
+
+            with mock_httpd(("localhost", 42423), expected_req):
+                self.common_map_req.params.layers = "layer_fwdparams1,single"
+                self.common_map_req.params["time"] = "20041012"
+                self.common_map_req.params["vendor"] = "foo"
+                self.common_map_req.params.transparent = True
+                resp = app.get(self.common_map_req)
+                resp.content_type = "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)