MapProxy 2.1.0__py3-none-any.whl

mapproxy/test/system/test_legendgraphic.py

@@ -0,0 +1,308 @@
+# 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
+import json
+
+from mapproxy.compat.image import Image
+from mapproxy.request.wms import (
+    WMS111MapRequest,
+    WMS111CapabilitiesRequest,
+    WMS130CapabilitiesRequest,
+    WMS111LegendGraphicRequest,
+    WMS130LegendGraphicRequest,
+)
+
+from mapproxy.test.image import is_png, tmp_image
+from mapproxy.test.helper import validate_with_dtd, validate_with_xsd
+from mapproxy.test.http import mock_httpd
+from mapproxy.test.system import SysTest
+from mapproxy.test.system.test_wms import is_111_capa, assert_xpath_wms130, ns130
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "legendgraphic.yaml"
+
+
+def is_130_capa(xml):
+    return validate_with_xsd(xml, xsd_name="sld/1.1.0/sld_capabilities.xsd")
+
+
+class TestWMSLegendgraphic(SysTest):
+
+    # we use a class scoped cache_dir as tests build up on each other
+    @pytest.fixture(scope="class")
+    def cache_dir(self, base_dir):
+        return base_dir.join("cache_data")
+
+    def setup_method(self):
+        self.common_req = WMS111MapRequest(
+            url="/service?", param=dict(service="WMS", version="1.1.1")
+        )
+        self.common_lg_req_111 = WMS111LegendGraphicRequest(
+            url="/service?",
+            param=dict(format="image/png", layer="wms_legend", sld_version="1.1.0"),
+        )
+        self.common_lg_req_130 = WMS130LegendGraphicRequest(
+            url="/service?",
+            param=dict(format="image/png", layer="wms_legend", sld_version="1.1.0"),
+        )
+
+    # test_00, test_01, test_02 need to run first in order to run the other tests properly
+    def test_00_get_legendgraphic_multiple_sources_111(self, app):
+        self.common_lg_req_111.params["layer"] = "wms_mult_sources"
+        with tmp_image((256, 256), format="png") as img:
+            img_data = img.read()
+            expected_req1 = (
+                {
+                    "path": r"/service?LAYER=foo&SERVICE=WMS&FORMAT=image%2Fpng"
+                    "&REQUEST=GetLegendGraphic&"
+                    "&VERSION=1.1.1&SLD_VERSION=1.1.0"
+                },
+                {"body": img_data, "headers": {"content-type": "image/png"}},
+            )
+            expected_req2 = (
+                {
+                    "path": r"/service?LAYER=bar&SERVICE=WMS&FORMAT=image%2Fpng"
+                    "&REQUEST=GetLegendGraphic&"
+                    "&VERSION=1.1.1&SLD_VERSION=1.1.0"
+                },
+                {"body": img_data, "headers": {"content-type": "image/png"}},
+            )
+            expected_req3 = (
+                {
+                    "path": r"/service?LAYER=spam&SERVICE=WMS&FORMAT=image%2Fpng"
+                    "&REQUEST=GetLegendGraphic&"
+                    "&VERSION=1.1.1&SLD_VERSION=1.1.0"
+                },
+                {"body": img_data, "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(
+                ("localhost", 42423), [expected_req1, expected_req2, expected_req3]
+            ):
+                resp = app.get(self.common_lg_req_111)
+                assert resp.content_type == "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+                assert Image.open(data).size == (256, 768)
+
+    def test_01_get_legendgraphic_source_static_url(self, app):
+        self.common_lg_req_111.params["layer"] = "wms_source_static_url"
+        with tmp_image((256, 256), format="png") as img:
+            img_data = img.read()
+            expected_req1 = (
+                {"path": r"/staticlegend_source.png"},
+                {"body": img_data, "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(("localhost", 42423), [expected_req1]):
+                resp = app.get(self.common_lg_req_111)
+                assert resp.content_type == "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+                assert Image.open(data).size == (256, 256)
+
+    def test_02_get_legendgraphic_layer_static_url(self, app):
+        self.common_lg_req_111.params["layer"] = "wms_layer_static_url"
+        with tmp_image((256, 256), format="png") as img:
+            img_data = img.read()
+            expected_req1 = (
+                {"path": r"/staticlegend_layer.png"},
+                {"body": img_data, "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(("localhost", 42423), [expected_req1]):
+                resp = app.get(self.common_lg_req_111)
+                assert resp.content_type == "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+                assert Image.open(data).size == (256, 256)
+
+    def test_capabilities_111(self, app):
+        req = WMS111CapabilitiesRequest(url="/service?").copy_with_request_params(
+            self.common_req
+        )
+        resp = app.get(req)
+        xml = resp.lxml
+        assert xml.xpath("//Request/GetLegendGraphic")[0].tag == "GetLegendGraphic"
+        legend_sizes = (
+            xml.xpath("//Layer/Style/LegendURL/@width"),
+            xml.xpath("//Layer/Style/LegendURL/@height"),
+        )
+        assert legend_sizes == (
+            ["256", "256", "256", "256"],
+            ["512", "768", "256", "256"],
+        )
+        layer_urls = xml.xpath(
+            "//Layer/Style/LegendURL/OnlineResource/@xlink:href", namespaces=ns130
+        )
+        for layer_url in layer_urls:
+            assert layer_url.startswith("http://")
+            assert "GetLegendGraphic" in layer_url
+        assert is_111_capa(xml)
+
+    def test_capabilities_130(self, app):
+        req = WMS130CapabilitiesRequest(url="/service?").copy_with_request_params(
+            self.common_req
+        )
+        resp = app.get(req)
+        xml = resp.lxml
+        assert xml.xpath("//wms:Request/sld:GetLegendGraphic", namespaces=ns130)[
+            0
+        ].tag == "{%s}GetLegendGraphic" % (ns130["sld"])
+        layer_urls = xml.xpath(
+            "//Layer/Style/LegendURL/OnlineResource/@xlink:href", namespaces=ns130
+        )
+        for layer_url in layer_urls:
+            assert layer_url.startswith("http://")
+            assert "GetLegendGraphic" in layer_url
+        assert is_130_capa(xml)
+
+    def test_get_legendgraphic_111(self, app):
+        self.common_lg_req_111.params["scale"] = "5.0"
+        with tmp_image((256, 256), format="png") as img:
+            img_data = img.read()
+            expected_req1 = (
+                {
+                    "path": r"/service?LAYER=foo&SERVICE=WMS&FORMAT=image%2Fpng"
+                    "&REQUEST=GetLegendGraphic&SCALE=5.0&"
+                    "&VERSION=1.1.1&SLD_VERSION=1.1.0"
+                },
+                {"body": img_data, "headers": {"content-type": "image/png"}},
+            )
+            expected_req2 = (
+                {
+                    "path": r"/service?LAYER=bar&SERVICE=WMS&FORMAT=image%2Fpng"
+                    "&REQUEST=GetLegendGraphic&SCALE=5.0&"
+                    "&VERSION=1.1.1&SLD_VERSION=1.1.0"
+                },
+                {"body": img_data, "headers": {"content-type": "image/png"}},
+            )
+            with mock_httpd(("localhost", 42423), [expected_req1, expected_req2]):
+                resp = app.get(self.common_lg_req_111)
+                assert resp.content_type == "image/png"
+                data = BytesIO(resp.body)
+                assert is_png(data)
+                assert Image.open(data).size == (256, 512)
+
+    def test_get_legendgraphic_no_legend_111(self, app):
+        self.common_lg_req_111.params["layer"] = "wms_no_legend"
+        resp = app.get(self.common_lg_req_111)
+        assert resp.content_type == "application/vnd.ogc.se_xml"
+        xml = resp.lxml
+        assert (
+            "wms_no_legend has no legend graphic"
+            in xml.xpath("//ServiceException/text()")[0]
+        )
+        assert validate_with_dtd(xml, "wms/1.1.1/exception_1_1_1.dtd")
+
+    def test_get_legendgraphic_missing_params_111(self, app):
+        req = (
+            str(self.common_lg_req_111)
+            .replace("sld_version", "invalid")
+            .replace("format", "invalid")
+        )
+        resp = app.get(req)
+        assert resp.content_type == "application/vnd.ogc.se_xml"
+        xml = resp.lxml
+        assert "missing parameters" in xml.xpath("//ServiceException/text()")[0]
+        assert validate_with_dtd(xml, "wms/1.1.1/exception_1_1_1.dtd")
+
+    def test_get_legendgraphic_invalid_sld_version_111(self, app):
+        req = str(self.common_lg_req_111).replace(
+            "sld_version=1.1.0", "sld_version=1.0.0"
+        )
+        resp = app.get(req)
+        assert resp.content_type == "application/vnd.ogc.se_xml"
+        xml = resp.lxml
+        assert "invalid sld_version" in xml.xpath("//ServiceException/text()")[0]
+        assert validate_with_dtd(xml, "wms/1.1.1/exception_1_1_1.dtd")
+
+    def test_get_legendgraphic_no_legend_130(self, app):
+        self.common_lg_req_130.params["layer"] = "wms_no_legend"
+        resp = app.get(self.common_lg_req_130)
+        assert resp.content_type == "text/xml"
+        xml = resp.lxml
+        assert_xpath_wms130(xml, "/ogc:ServiceExceptionReport/@version", "1.3.0")
+        assert_xpath_wms130(
+            xml,
+            "//ogc:ServiceException/text()",
+            "layer wms_no_legend has no legend graphic",
+        )
+        assert validate_with_xsd(xml, xsd_name="wms/1.3.0/exceptions_1_3_0.xsd")
+
+    def test_get_legendgraphic_missing_params_130(self, app):
+        req = str(self.common_lg_req_130).replace("format", "invalid")
+        resp = app.get(req)
+        assert resp.content_type == "text/xml"
+        xml = resp.lxml
+        assert_xpath_wms130(xml, "/ogc:ServiceExceptionReport/@version", "1.3.0")
+        assert_xpath_wms130(
+            xml, "//ogc:ServiceException/text()", "missing parameters ['format']"
+        )
+        assert validate_with_xsd(xml, xsd_name="wms/1.3.0/exceptions_1_3_0.xsd")
+
+    def test_get_legendgraphic_invalid_sld_version_130(self, app):
+        req = str(self.common_lg_req_130).replace(
+            "sld_version=1.1.0", "sld_version=1.0.0"
+        )
+        resp = app.get(req)
+        assert resp.content_type == "text/xml"
+        xml = resp.lxml
+        assert_xpath_wms130(xml, "/ogc:ServiceExceptionReport/@version", "1.3.0")
+        assert_xpath_wms130(
+            xml, "//ogc:ServiceException/text()", "invalid sld_version 1.0.0"
+        )
+        assert validate_with_xsd(xml, xsd_name="wms/1.3.0/exceptions_1_3_0.xsd")
+
+    def test_get_legendgraphic_json_single_source_multiple_sub_layers(self, app):
+        """
+            this.common_lg_req_130 request fetches layer 'wms_legend'
+            layer 'wms_legend' contains:
+            - single source 'legend_cache'
+            - multiple sub layers: 'foo' and 'bar'
+            - see also 'test/system/fixture/legendgraphic.yaml'
+        """
+        self.common_lg_req_130.params["format"] = "application/json"
+        json_data_foo = "{\"Legend\": [{\"layerName\": \"foo\"}]}"
+        json_data_bar = "{\"Legend\": [{\"layerName\": \"bar\"}]}"
+        expected_req1 = (
+            {
+                "path": r"/service?LAYER=foo&SERVICE=WMS&FORMAT=application%2Fjson"
+                        "&REQUEST=GetLegendGraphic&"
+                        "&VERSION=1.1.1&SLD_VERSION=1.1.0"
+            },
+            {"body": json_data_foo.encode(), "headers": {"content-type": "application/json"}},
+        )
+        expected_req2 = (
+            {
+                "path": r"/service?LAYER=bar&SERVICE=WMS&FORMAT=application%2Fjson"
+                        "&REQUEST=GetLegendGraphic&"
+                        "&VERSION=1.1.1&SLD_VERSION=1.1.0"
+            },
+            {"body": json_data_bar.encode(), "headers": {"content-type": "application/json"}},
+        )
+        with mock_httpd(
+            ("localhost", 42423), [expected_req1, expected_req2]
+        ):
+            resp = app.get(self.common_lg_req_130)
+            assert resp.content_type == "application/json"
+            json_str = resp.body.decode("utf-8")
+            json_data = json.loads(json_str)
+            assert json_data['Legend'][0]['layerName'] == 'foo'
+            assert json_data['Legend'][1]['layerName'] == 'bar'

mapproxy/test/system/test_mapnik.py

@@ -0,0 +1,162 @@
+# 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
+
+from io import BytesIO
+
+import pytest
+
+from mapproxy.compat.image import Image
+from mapproxy.test.system import SysTest
+
+
+has_mapnik = True
+try:
+    import mapnik
+except ImportError:
+    try:
+        import mapnik2 as mapnik  # noqa
+    except ImportError:
+        has_mapnik = False
+
+
+mapnik_xml = (
+    b"""
+<?xml version="1.0"?>
+<!DOCTYPE Map>
+<Map background-color="#ff0000" bgcolor="#ff0000" srs="+proj=latlong +datum=WGS84">
+    <Layer name="marker">
+        <StyleName>marker</StyleName>
+        <Datasource>
+            <Parameter name="type">ogr</Parameter>
+            <Parameter name="file">test_point.geojson</Parameter>
+            <Parameter name="layer">OGRGeoJSON</Parameter>
+        </Datasource>
+    </Layer>
+    <Style name="marker">
+        <Rule>
+            <MarkersSymbolizer fill="transparent" width="10" height="10" stroke="black" stroke-width="3"
+                placement="point" marker-type="ellipse"/>
+        </Rule>
+    </Style>
+</Map>
+""".strip()
+)
+
+test_point_geojson = (
+    b"""
+{"type": "Feature", "geometry": {"type": "Point", "coordinates": [-45, -45]}, "properties": {}}
+""".strip()
+)
+
+mapnik_transp_xml = (
+    b"""
+<?xml version="1.0"?>
+<!DOCTYPE Map>
+<Map background-color="transparent" srs="+proj=latlong +datum=WGS84">
+</Map>
+""".strip()
+)
+
+
+@pytest.mark.skipif(not has_mapnik, reason="requires mapnik")
+class TestMapnikSource(SysTest):
+
+    @pytest.fixture(scope="class")
+    def config_file(self):
+        return "mapnik_source.yaml"
+
+    @pytest.fixture(scope="class")
+    def additional_files(self, base_dir):
+        base_dir.join("test_point.geojson").write_binary(test_point_geojson)
+        base_dir.join("mapnik.xml").write_binary(mapnik_xml)
+        base_dir.join("mapnik-transparent.xml").write_binary(mapnik_transp_xml)
+
+    def test_get_map(self, app):
+        req = (
+            r"/service?LAYERs=mapnik&SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326"
+            "&VERSION=1.1.1&BBOX=-90,-90,0,0&styles="
+            "&WIDTH=200&"
+        )
+
+        resp = app.get(req)
+        data = BytesIO(resp.body)
+        img = Image.open(data)
+        colors = sorted(img.getcolors(), reverse=True)
+        # map bg color + black marker
+        assert 39700 < colors[0][0] < 39900, colors[0][0]
+        assert colors[0][1] == (255, 0, 0, 255)
+        assert 50 < colors[1][0] < 150, colors[1][0]
+        assert colors[1][1] == (0, 0, 0, 255)
+
+    def test_get_map_hq(self, app):
+        req = (
+            r"/service?LAYERs=mapnik_hq&SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326"
+            "&VERSION=1.1.1&BBOX=-90,-90,0,0&styles="
+            "&WIDTH=200&"
+        )
+
+        resp = app.get(req)
+        data = BytesIO(resp.body)
+        img = Image.open(data)
+        colors = sorted(img.getcolors(), reverse=True)
+        # map bg color + black marker (like above, but marker is scaled up)
+        assert 39500 < colors[0][0] < 39600, colors[0][0]
+        assert colors[0][1] == (255, 0, 0, 255)
+        assert 250 < colors[1][0] < 350, colors[1][0]
+        assert colors[1][1] == (0, 0, 0, 255)
+
+    def test_get_map_outside_coverage(self, app):
+        req = (
+            r"/service?LAYERs=mapnik&SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326"
+            "&VERSION=1.1.1&BBOX=-175,-85,-172,-82&styles="
+            "&WIDTH=200&&BGCOLOR=0x00ff00"
+        )
+
+        resp = app.get(req)
+        data = BytesIO(resp.body)
+        img = Image.open(data)
+        colors = sorted(img.getcolors(), reverse=True)
+        # wms request bg color
+        assert colors[0] == (40000, (0, 255, 0))
+
+    def test_get_map_unknown_file(self, app):
+        req = (
+            r"/service?LAYERs=mapnik_unknown&SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326"
+            "&VERSION=1.1.1&BBOX=-90,-90,0,0&styles="
+            "&WIDTH=200&&BGCOLOR=0x00ff00"
+        )
+
+        resp = app.get(req)
+        assert "unknown.xml" in resp.body, resp.body
+
+    def test_get_map_transparent(self, app):
+        req = (
+            r"/service?LAYERs=mapnik_transparent&SERVICE=WMS&FORMAT=image%2Fpng"
+            "&REQUEST=GetMap&HEIGHT=200&SRS=EPSG%3A4326"
+            "&VERSION=1.1.1&BBOX=-90,-90,0,0&styles="
+            "&WIDTH=200&transparent=True"
+        )
+
+        resp = app.get(req)
+        data = BytesIO(resp.body)
+        img = Image.open(data)
+        colors = sorted(img.getcolors(), reverse=True)
+        assert colors[0] == (40000, (0, 0, 0, 0))

mapproxy/test/system/test_mapserver.py

@@ -0,0 +1,83 @@
+# 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 sys
+import stat
+import shutil
+
+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
+from mapproxy.test.system import SysTest
+
+
+pytestmark = pytest.mark.skipif(
+    sys.platform == "win32", reason="CGI tests not ported for Windows"
+)
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "mapserver.yaml"
+
+
+@pytest.mark.skipif(sys.version_info < (3, 0), reason="tests skipped for python 2")
+class TestMapServerCGI(SysTest):
+
+    @pytest.fixture(scope="class")
+    def additional_files(self, base_dir):
+        shutil.copy(
+            os.path.join(os.path.dirname(__file__), "fixture", "minimal_cgi.py"),
+            base_dir.strpath,
+        )
+
+        os.chmod(
+            base_dir.join("minimal_cgi.py").strpath, stat.S_IXUSR | stat.S_IRUSR | stat.S_IWUSR
+        )
+
+        base_dir.join("tmp").mkdir()
+
+    def setup_method(self):
+        self.common_map_req = WMS111MapRequest(
+            url="/service?",
+            param=dict(
+                service="WMS",
+                version="1.1.1",
+                bbox="-180,0,0,80",
+                width="200",
+                height="200",
+                layers="ms",
+                srs="EPSG:4326",
+                format="image/png",
+                styles="",
+                request="GetMap",
+            ),
+        )
+
+    def test_get_map(self, app):
+        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)
+        img = img.convert("RGB")
+        assert img.getcolors() == [(200 * 200, (255, 0, 0))]