MapProxy 2.1.0__py3-none-any.whl

mapproxy/test/unit/test_seed_cachelock.py

@@ -0,0 +1,91 @@
+# 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 multiprocessing
+import time
+import sys
+
+import pytest
+
+from mapproxy.seed.cachelock import CacheLocker, CacheLockedError
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="test not supported for Windows")
+@pytest.mark.skipif(sys.platform == "darwin" and sys.version_info >= (3, 8),
+                    reason="test not supported for MacOS with Python >=3.8")
+class TestCacheLock(object):
+
+    @pytest.fixture
+    def lock_file(self, tmpdir):
+        return (tmpdir / "lock").strpath
+
+    def test_free_lock(self, lock_file):
+        locker = CacheLocker(lock_file)
+        with locker.lock("foo"):
+            assert True
+
+    def test_locked_by_process_no_block(self, lock_file):
+        proc_is_locked = multiprocessing.Event()
+
+        def lock():
+            locker = CacheLocker(lock_file)
+            with locker.lock("foo"):
+                proc_is_locked.set()
+                time.sleep(10)
+
+        p = multiprocessing.Process(target=lock)
+        p.start()
+        # wait for process to start
+        proc_is_locked.wait()
+
+        locker = CacheLocker(lock_file)
+
+        # test unlocked bar
+        with locker.lock("bar", no_block=True):
+            assert True
+
+        # test locked foo
+        try:
+            with locker.lock("foo", no_block=True):
+                assert False
+        except CacheLockedError:
+            pass
+        finally:
+            p.terminate()
+            p.join()
+
+    def test_locked_by_process_waiting(self, lock_file):
+        proc_is_locked = multiprocessing.Event()
+
+        def lock():
+            locker = CacheLocker(lock_file)
+            with locker.lock("foo"):
+                proc_is_locked.set()
+                time.sleep(.1)
+
+        p = multiprocessing.Process(target=lock)
+        start_time = time.time()
+        p.start()
+        # wait for process to start
+        proc_is_locked.wait()
+
+        locker = CacheLocker(lock_file, polltime=0.02)
+        try:
+            with locker.lock("foo", no_block=False):
+                diff = time.time() - start_time
+                assert diff > 0.1
+        finally:
+            p.terminate()
+            p.join()

mapproxy/test/unit/test_srs.py

@@ -0,0 +1,215 @@
+# 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.
+
+import os
+
+import pytest
+
+from mapproxy.config import base_config
+from mapproxy import srs, proj
+from mapproxy.srs import SRS, PreferredSrcSRS, SupportedSRS
+
+
+class TestSRS(object):
+
+    def test_epsg4326(self):
+        srs = SRS(4326)
+
+        assert srs.is_latlong
+        assert not srs.is_axis_order_en
+        assert srs.is_axis_order_ne
+
+        assert srs.get_geographic_srs() == srs
+
+    def test_crs84(self):
+        srs = SRS("CRS:84")
+
+        assert srs.is_latlong
+        assert srs.is_axis_order_en
+        assert not srs.is_axis_order_ne
+
+        assert srs == SRS("EPSG:4326")
+
+    def test_epsg31467(self):
+        srs = SRS("EPSG:31467")
+
+        assert not srs.is_latlong
+        assert not srs.is_axis_order_en
+        assert srs.is_axis_order_ne
+
+        assert srs.get_geographic_srs() == SRS(4326)
+
+    def test_epsg900913(self):
+        srs = SRS("epsg:900913")
+
+        assert not srs.is_latlong
+        assert srs.is_axis_order_en
+        assert not srs.is_axis_order_ne
+
+    def test_non_epsg_auth(self):
+        srs = SRS("IGNF:ETRS89UTM28")
+
+        assert not srs.is_latlong
+        assert srs.is_axis_order_en
+        assert not srs.is_axis_order_ne
+
+        assert srs.get_geographic_srs() == SRS(4326)
+
+    def test_iau_crs(self):
+        try:
+            srs = SRS("IAU:49900")  # "Mars (2015) - Sphere / Ocentric"
+        except Exception:
+            pytest.skip('Requires recent pyproj version')
+
+        assert srs.is_latlong
+        assert '49900' in str(srs.get_geographic_srs())
+
+    def test_iau_crs_projected(self):
+        try:
+            srs = SRS("IAU:49910")  # "Mars (2015) - Sphere / Ocentric / Equirectangular, clon = 0"
+        except Exception:
+            pytest.skip('Requires recent pyproj version')
+
+        assert not srs.is_latlong
+        assert '49900' in str(srs.get_geographic_srs())
+
+    def test_from_srs(self):
+        srs1 = SRS("epsg:4326")
+        srs2 = SRS(srs1)
+        assert srs1 == srs2
+
+# proj_data_dir test relies on old Proj4 epsg files.
+
+
+@pytest.mark.skipif(not proj.USE_PROJ4_API, reason="only for old proj4 lib")
+class Test_0_ProjDefaultDataPath(object):
+
+    def test_known_srs(self):
+        srs.SRS(4326)
+
+    def test_unknown_srs(self):
+        with pytest.raises(RuntimeError):
+            srs.SRS(1234)
+
+
+@pytest.fixture(scope="class")
+def custom_proj_data_dir():
+    srs._proj_initalized = False
+    srs._srs_cache = {}
+    base_config().srs.proj_data_dir = os.path.dirname(__file__)
+
+    yield
+
+    srs._proj_initalized = False
+    srs._srs_cache = {}
+    srs.set_datapath(None)
+    base_config().srs.proj_data_dir = None
+
+
+@pytest.mark.skipif(not proj.USE_PROJ4_API, reason="only for old proj4 lib")
+@pytest.mark.usefixtures("custom_proj_data_dir")
+class Test_1_ProjDataPath(object):
+
+    def test_dummy_srs(self):
+        srs.SRS(1234)
+
+    def test_unknown_srs(self):
+        with pytest.raises(RuntimeError):
+            srs.SRS(2339)
+
+
+class TestPreferredSrcSRS(object):
+
+    # test selection of preferred SRS
+    # unprojected: 4326, 4258
+    # projected: 3857, 25831, 25832, 31467
+    @pytest.mark.parametrize("target,available,expected", [
+
+        # always return target if available
+        (4326, [25832, 4326, 3857], 4326),
+
+        (4326, [25832, 4326, 3857], 4326),
+        (4326, [25831, 3857], 3857),
+
+        (3857, [25832, 4258, 3857, 31466], 3857),
+        (3857, [25832, 4258, 31467, 25831, 31466], 25832),
+        (3857, [4258, 31467, 25831, 31466], 25831),
+        (3857, [4258, 31467, 31466], 31467),
+        (3857, [4258, 31466], 31466),
+        (3857, [4258], 4258),
+
+        # always return first preferred, regardless of order in available
+        (4326, [3857, 4258], 4258),
+        (4326, [4258, 3857], 4258),
+
+        # no preferred, return first that is also projected/unprojected
+        (31467, [4326, 25831, 3857], 25831),
+        (4258, [25831, 4326, 3857], 4326),
+
+        # no preferred and no srs that is also projected/unprojected, return first
+        (31467, [4326, 4258], 4326),
+        (4258, [3857, 25832, 31467], 3857),
+    ])
+    def test_preferred(self, target, available, expected):
+        preferredSRS = PreferredSrcSRS()
+        preferredSRS.add(SRS(4326), [SRS(4258), SRS(3857)])
+        preferredSRS.add(SRS(3857), [SRS(25832), SRS(25831), SRS(31467), SRS(4326)])
+
+        assert preferredSRS.preferred_src(SRS(target), [SRS(c) for c in available]) == SRS(expected)
+
+    def test_no_available(self):
+        preferredSRS = PreferredSrcSRS()
+        preferredSRS.add(SRS(4326), [SRS(4258), SRS(3857)])
+
+        with pytest.raises(ValueError):
+            preferredSRS.preferred_src(SRS(4326), [])
+
+
+class TestSupportedSRS(object):
+    @pytest.fixture
+    def preferred(self):
+        preferredSRS = PreferredSrcSRS()
+        preferredSRS.add(SRS(4326), [SRS(4258), SRS(3857)])
+        preferredSRS.add(SRS(3857), [SRS(25832), SRS(25831), SRS(31467), SRS(4326)])
+        return preferredSRS
+
+    def test_supported(self, preferred):
+        supported = SupportedSRS([SRS(4326), SRS(25832)], preferred)
+        assert SRS(4326) in supported
+        assert SRS(4258) not in supported
+        assert SRS(25832) in supported
+
+    def test_iter(self, preferred):
+        supported = SupportedSRS([SRS(4326), SRS(25832)], preferred)
+        assert [SRS(4326), SRS(25832)] == [srs for srs in supported]
+
+    def test_best_srs(self, preferred):
+        supported = SupportedSRS([SRS(4326), SRS(25832)], preferred)
+        assert supported.best_srs(SRS(4326)) == SRS(4326)
+        assert supported.best_srs(SRS(4258)) == SRS(4326)
+        assert supported.best_srs(SRS(25832)) == SRS(25832)
+        assert supported.best_srs(SRS(25831)) == SRS(25832)
+        assert supported.best_srs(SRS(3857)) == SRS(25832)
+        supported = SupportedSRS([SRS(4326), SRS(31467), SRS(25831)], preferred)
+        assert supported.best_srs(SRS(3857)) == SRS(25831)
+        assert supported.best_srs(SRS(25831)) == SRS(25831)
+
+    def test_best_srs_no_preferred(self, preferred):
+        supported = SupportedSRS([SRS(4326), SRS(25832)], None)
+        assert supported.best_srs(SRS(4326)) == SRS(4326)
+        assert supported.best_srs(SRS(4258)) == SRS(4326)
+        assert supported.best_srs(SRS(25832)) == SRS(25832)
+        assert supported.best_srs(SRS(25831)) == SRS(25832)
+        assert supported.best_srs(SRS(3857)) == SRS(25832)

mapproxy/test/unit/test_tiled_source.py

@@ -0,0 +1,122 @@
+# 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.
+
+
+from mapproxy.client.tile import TileClient, TileURLTemplate
+from mapproxy.grid import TileGrid
+from mapproxy.srs import SRS
+from mapproxy.source.tile import TiledSource
+from mapproxy.source.error import HTTPSourceErrorHandler
+from mapproxy.layer import MapQuery
+from mapproxy.test.http import mock_httpd
+
+
+TEST_SERVER_ADDRESS = ("127.0.0.1", 56413)
+TESTSERVER_URL = ("http://%s:%d" % TEST_SERVER_ADDRESS) + "/%(tms_path)s.png"
+
+
+class TestTileClientOnError(object):
+
+    def setup_method(self):
+        self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
+        self.client = TileClient(TileURLTemplate(TESTSERVER_URL))
+
+    def test_cacheable_response(self):
+        error_handler = HTTPSourceErrorHandler()
+        error_handler.add_handler(500, (255, 0, 0), cacheable=True)
+        self.source = TiledSource(self.grid, self.client, error_handler=error_handler)
+
+        with mock_httpd(
+            TEST_SERVER_ADDRESS,
+            [
+                (
+                    {"path": "/1/0/0.png"},
+                    {
+                        "body": b"error",
+                        "status": 500,
+                        "headers": {"content-type": "text/plain"},
+                    },
+                )
+            ],
+        ):
+            resp = self.source.get_map(
+                MapQuery([-180, -90, 0, 90], (256, 256), SRS(4326), format="png")
+            )
+            assert resp.cacheable
+            assert resp.as_image().getcolors() == [((256 * 256), (255, 0, 0))]
+
+    def test_image_response(self):
+        error_handler = HTTPSourceErrorHandler()
+        error_handler.add_handler(500, (255, 0, 0), cacheable=False)
+        self.source = TiledSource(self.grid, self.client, error_handler=error_handler)
+
+        with mock_httpd(
+            TEST_SERVER_ADDRESS,
+            [
+                (
+                    {"path": "/1/0/0.png"},
+                    {
+                        "body": b"error",
+                        "status": 500,
+                        "headers": {"content-type": "text/plain"},
+                    },
+                )
+            ],
+        ):
+            resp = self.source.get_map(
+                MapQuery([-180, -90, 0, 90], (256, 256), SRS(4326), format="png")
+            )
+            assert not resp.cacheable
+            assert resp.as_image().getcolors() == [((256 * 256), (255, 0, 0))]
+
+    def test_multiple_image_responses(self):
+        error_handler = HTTPSourceErrorHandler()
+        error_handler.add_handler(500, (255, 0, 0), cacheable=False)
+        error_handler.add_handler(204, (255, 0, 127, 200), cacheable=True)
+        self.source = TiledSource(self.grid, self.client, error_handler=error_handler)
+
+        with mock_httpd(
+            TEST_SERVER_ADDRESS,
+            [
+                (
+                    {"path": "/1/0/0.png"},
+                    {
+                        "body": b"error",
+                        "status": 500,
+                        "headers": {"content-type": "text/plain"},
+                    },
+                ),
+                (
+                    {"path": "/1/0/0.png"},
+                    {
+                        "body": b"error",
+                        "status": 204,
+                        "headers": {"content-type": "text/plain"},
+                    },
+                ),
+            ],
+        ):
+
+            resp = self.source.get_map(
+                MapQuery([-180, -90, 0, 90], (256, 256), SRS(4326), format="png")
+            )
+            assert not resp.cacheable
+            assert resp.as_image().getcolors() == [((256 * 256), (255, 0, 0))]
+
+            resp = self.source.get_map(
+                MapQuery([-180, -90, 0, 90], (256, 256), SRS(4326), format="png")
+            )
+            assert resp.cacheable
+            assert resp.as_image().getcolors() == [((256 * 256), (255, 0, 127, 200))]

mapproxy/test/unit/test_tilefilter.py

@@ -0,0 +1,31 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010, 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 mapproxy.tilefilter import tile_watermark_placement
+
+
+def test_tile_watermark_placement():
+    assert tile_watermark_placement((0, 0, 0)) == "c"
+    assert tile_watermark_placement((1, 0, 0)) == "c"
+    assert tile_watermark_placement((0, 1, 0)) == "b"
+    assert tile_watermark_placement((1, 1, 0)) == "b"
+
+    assert tile_watermark_placement((0, 0, 0), True) is None
+    assert tile_watermark_placement((1, 0, 0), True) == "c"
+    assert tile_watermark_placement((2, 0, 0), True) is None
+
+    assert tile_watermark_placement((0, 1, 0), True) == "c"
+    assert tile_watermark_placement((1, 1, 0), True) is None
+    assert tile_watermark_placement((2, 1, 0), True) == "c"

mapproxy/test/unit/test_times.py

@@ -0,0 +1,25 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010, 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 mapproxy.util.times import timestamp_from_isodate
+
+import pytest
+
+
+def test_timestamp_from_isodate():
+    ts = timestamp_from_isodate("2009-06-09T10:57:00")
+    assert (1244537820.0 - 14 * 3600) < ts < (1244537820.0 + 14 * 3600)
+
+    with pytest.raises(ValueError):
+        timestamp_from_isodate("2009-06-09T10:57")

mapproxy/test/unit/test_timeutils.py

@@ -0,0 +1,50 @@
+# 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 datetime import datetime
+from mapproxy.util.times import parse_httpdate, format_httpdate, timestamp
+
+import pytest
+
+
+class TestHTTPDate(object):
+
+    def test_parse_httpdate(self):
+        for date in (
+            "Fri, 13 Feb 2009 23:31:30 GMT",
+            "Friday, 13-Feb-09 23:31:30 GMT",
+            "Fri Feb 13 23:31:30 2009",
+        ):
+            assert parse_httpdate(date) == 1234567890
+
+    def test_parse_invalid(self):
+        for date in (None, "foobar", "4823764923", "Fri, 13 Foo 2009 23:31:30 GMT"):
+            assert parse_httpdate(date) is None
+
+    def test_format_httpdate(self):
+        assert (
+            format_httpdate(datetime.fromtimestamp(1234567890))
+            == "Fri, 13 Feb 2009 23:31:30 GMT"
+        )
+        assert format_httpdate(1234567890) == "Fri, 13 Feb 2009 23:31:30 GMT"
+
+    def test_format_invalid(self):
+        with pytest.raises(AssertionError):
+            format_httpdate("foobar")
+
+
+def test_timestamp():
+    assert timestamp(1234567890) == 1234567890
+    assert timestamp(datetime.fromtimestamp(1234567890)) == 1234567890

mapproxy/test/unit/test_util_conf_utils.py

@@ -0,0 +1,75 @@
+# -:- 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.
+
+from copy import deepcopy
+
+from mapproxy.script.conf.utils import update_config
+
+
+class TestUpdateConfig(object):
+
+    def test_empty(self):
+        a = {"a": "foo", "b": 42}
+        b = {}
+        assert update_config(deepcopy(a), b) == a
+
+    def test_add(self):
+        a = {"a": "foo", "b": 42}
+        b = {"c": [1, 2, 3]}
+        assert update_config(a, b) == {"a": "foo", "b": 42, "c": [1, 2, 3]}
+
+    def test_mod(self):
+        a = {"a": "foo", "b": 42, "c": {}}
+        b = {"a": [1, 2, 3], "c": 1}
+        assert update_config(a, b) == {"b": 42, "a": [1, 2, 3], "c": 1}
+
+    def test_nested_add_mod(self):
+        a = {"a": "foo", "b": {"ba": 42, "bb": {}}}
+        b = {"b": {"bb": {"bba": 1}, "bc": [1, 2, 3]}}
+        assert update_config(a, b) == {
+            "a": "foo",
+            "b": {"ba": 42, "bb": {"bba": 1}, "bc": [1, 2, 3]},
+        }
+
+    def test_add_all(self):
+        a = {"a": "foo", "b": {"ba": 42, "bb": {}}}
+        b = {"__all__": {"ba": 1}}
+        assert update_config(a, b) == {"a": {"ba": 1}, "b": {"ba": 1, "bb": {}}}
+
+    def test_extend(self):
+        a = {"a": "foo", "b": ["ba"]}
+        b = {"b__extend__": ["bb", "bc"]}
+        assert update_config(a, b) == {"a": "foo", "b": ["ba", "bb", "bc"]}
+
+    def test_prefix_wildcard(self):
+        a = {"test_foo": "foo", "test_bar": "ba", "test2_foo": "test2", "nounderfoo": 1}
+        b = {"____foo": 42}
+        assert update_config(a, b) == {
+            "test_foo": 42,
+            "test_bar": "ba",
+            "test2_foo": 42,
+            "nounderfoo": 1,
+        }
+
+    def test_suffix_wildcard(self):
+        a = {"test_foo": "foo", "test_bar": "ba", "test2_foo": "test2", "nounderfoo": 1}
+        b = {"test____": 42}
+        assert update_config(a, b) == {
+            "test_foo": 42,
+            "test_bar": 42,
+            "test2_foo": "test2",
+            "nounderfoo": 1,
+        }