MapProxy 2.1.0__py3-none-any.whl

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_method(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()

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_method(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_method(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"