Example #1
0
    def test_route_with_all(self):
        from c2cgeoportal_geoportal.views.dynamic import DynamicView

        with testConfig(
            settings=self._get_settings(
                {
                    "test": {
                        "routes": {
                            "XTest": {
                                "name": "route_with_all",
                                "kw": {"key1": "v1", "key2": "v2"},
                                "elements": ["s1", "s2"],
                                "params": {"test": "value"},
                            }
                        }
                    }
                }
            )
        ) as config:
            config.add_static_view(name="static", path="/etc/geomapfish/static")
            config.add_route("base", "/", static=True)
            config.add_route("test", "/test")
            config.add_route("route_with_all", "/test/{key1}/{key2}")
            request = DummyRequest({"interface": "test"})
            request.get_organization_interface = lambda interface: interface
            dynamic = DynamicView(request).dynamic()

        assert "XTest" in dynamic["constants"], dynamic
        assert dynamic["constants"]["XTest"] == "http://example.com/test/v1/v2/s1/s2?test=value"
Example #2
0
    def test_shortener_create_1(self):
        from tests import DummyRequest
        from pyramid.httpexceptions import HTTPFound
        from c2cgeoportal_geoportal.views.shortener import Shortener

        def route_url(name, *elements, **kw):
            return "https://example.com/short/" + kw["ref"]

        request = DummyRequest()
        request.user = None
        request.host = "example.com:443"
        request.server_name = "example.com"
        request.route_url = route_url
        request.registry.settings["shortener"] = {
            "base_url": "https://example.com/s/"
        }
        shortener = Shortener(request)

        request.params = {"url": "https://example.com/hi"}
        result = shortener.create()
        index = result["short_url"].rfind("/")
        self.assertEqual(result["short_url"][:index], "https://example.com/s")

        request.params = {}
        # fmt: off
        request.matchdict = {"ref": result["short_url"][index + 1:]}
        # fmt: on
        result = shortener.get()
        self.assertEqual(type(result), HTTPFound)
        self.assertEqual(result.location, "https://example.com/hi")
    def test_theme(self):
        from c2cgeoportal_geoportal.views.theme import Theme

        request = DummyRequest()
        request.static_url = lambda url: "http://example.com/dummy/static/url"
        request.route_url = lambda url, _query={}: mapserv_url
        request.user = None
        theme_view = Theme(request)
        _, errors = theme_view._themes("desktop2", True, 2)
        self.assertEqual(
            len([e for e in errors if e == "Too many recursions with group '__test_layer_group'"]), 1
        )
Example #4
0
 def _request(query={}):
     query_ = {"interface": "test"}
     query_.update(query)
     request = DummyRequest(query_)
     request.route_url = (
         lambda url, _query=None: "/dummy/route/url/{}".format(url)
         if _query is None else "/dummy/route/url/{}?{}".format(
             url, "&".join(["=".join(e) for e in _query.items()])))
     request.static_url = (
         lambda url, _query=None: "/dummy/static/url/{}".format(url)
         if _query is None else "/dummy/static/url/{}?{}".format(
             url, "&".join(["=".join(e) for e in _query.items()])))
     return request
 def _request(query={}):
     query_ = {"interface": "test"}
     query_.update(query)
     request = DummyRequest(query_)
     request.route_url = (
         lambda url, _query=None: "/dummy/route/url/{}".format(url)
         if _query is None
         else "/dummy/route/url/{}?{}".format(url, pyramid.url.urlencode(_query))
     )
     request.static_url = (
         lambda url, _query=None: "/dummy/static/url/{}".format(url)
         if _query is None
         else "/dummy/static/url/{}?{}".format(url, pyramid.url.urlencode(_query))
     )
     return request
Example #6
0
 def _request(query={}):
     query_ = {"interface": "test"}
     query_.update(query)
     request = DummyRequest(query_)
     request.route_url = (
         lambda url, _query=None: f"/dummy/route/url/{url}"
         if _query is None
         else f"/dummy/route/url/{url}?{pyramid.url.urlencode(_query)}"
     )
     request.static_url = (
         lambda url, _query=None: f"/dummy/static/url/{url}"
         if _query is None
         else f"/dummy/static/url/{url}?{pyramid.url.urlencode(_query)}"
     )
     request.get_organization_interface = lambda interface: interface
     return request
Example #7
0
    def test_route_with_keywords(self):
        from c2cgeoportal_geoportal.views.dynamic import DynamicView

        with testConfig(settings=self._get_settings({
                "test": {
                    "routes": {
                        "XTest": {
                            "name": "route_with_keywords",
                            "kw": {
                                "key1": "v1",
                                "key2": "v2"
                            }
                        }
                    }
                }
        })) as config:
            config.add_static_view(name="static",
                                   path="/etc/geomapfish/static")
            config.add_route("test", "/test")
            config.add_route("route_with_keywords", "/test/{key1}/{key2}")
            request = DummyRequest({"interface": "test"})
            dynamic = DynamicView(request).dynamic()

        assert "XTest" in dynamic["constants"], dynamic
        assert dynamic["constants"]["XTest"] == "http://example.com/test/v1/v2"
    def test_shortener_dev(self):
        from tests import DummyRequest

        from c2cgeoportal_geoportal.views.shortener import Shortener

        def route_url(name, *elements, **kw):
            return "https://localhost:8484/s/" + kw["ref"]

        request = DummyRequest()
        request.user = None
        request.host = "localhost:8484"
        request.server_name = "0.0.0.0"
        request.route_url = route_url
        request.registry.settings["shortener"] = {
            "base_url": "https://localhost:8484/s/",
            "allowed_hosts": [
                "localhost:8484",
            ],
        }
        shortener = Shortener(request)

        request.params = {"url": "https://localhost:8484/theme/Demo"}
        result = shortener.create()
        index = result["short_url"].rfind("/")
        self.assertEqual(result["short_url"][:index],
                         "https://localhost:8484/s")
Example #9
0
    def _do(method, headers, credentials=False, settings=SETTINGS):
        request = DummyRequest({}, method=method, headers=headers)
        if settings is not None:
            request.registry.settings = {"headers": {"foo": settings}}
        else:
            request.registry.settings = {"headers": {}}
        set_common_headers(request, "foo", Cache.NO, credentials=credentials)

        return dict(request.response.headers)
Example #10
0
 def test_build_url_forward_headers(self):
     request = DummyRequest()
     request.registry.settings = {
         "checker": {
             "base_internal_url": "http://localhost",
             "forward_headers": ["Cookie"]
         }
     }
     request.headers["Cookie"] = "test"
     self.assertEqual(
         build_url("Test", "/toto?titi#tutu", request),
         {
             "url": "http://localhost/toto?titi#tutu",
             "headers": {
                 "Cache-Control": "no-cache",
                 "Cookie": "test"
             },
         },
     )
Example #11
0
    def test_raster(self):
        from decimal import Decimal

        from pyramid.httpexceptions import HTTPNotFound
        from tests import DummyRequest

        from c2cgeoportal_geoportal.views.raster import Raster

        request = DummyRequest()
        request.registry.settings = {
            "raster": {
                "dem1": {
                    "file": "/opt/c2cgeoportal/geoportal/tests/data/dem.shp",
                    "round": 0.1
                },
                "dem2": {
                    "file": "/opt/c2cgeoportal/geoportal/tests/data/dem.shp",
                    "round": 1
                },
                "dem3": {
                    "file": "/opt/c2cgeoportal/geoportal/tests/data/dem.shp"
                },
            }
        }
        raster = Raster(request)

        request.params["lon"] = "565000"
        request.params["lat"] = "218000"
        result = raster.raster()
        self.assertEqual(result["dem1"], None)
        self.assertEqual(result["dem2"], None)
        self.assertEqual(result["dem3"], None)

        request.params["lon"] = "548000"
        request.params["lat"] = "216000"
        result = raster.raster()
        self.assertAlmostEqual(result["dem1"], Decimal("1171.6"))
        self.assertAlmostEqual(result["dem2"], Decimal("1172"))
        self.assertAlmostEqual(result["dem3"], Decimal("1171.62"))

        request.params["layers"] = "dem2"
        result = raster.raster()
        self.assertFalse("dem1" in result)
        self.assertFalse("dem3" in result)
        self.assertAlmostEqual(result["dem2"], Decimal("1172"))

        # test wrong layer name
        request.params["layers"] = "wrong"
        self.assertRaises(HTTPNotFound, raster.raster)
Example #12
0
    def test_raster_vrt(self):
        from decimal import Decimal

        from tests import DummyRequest

        from c2cgeoportal_geoportal.views.raster import Raster

        request = DummyRequest()
        request.registry.settings = {
            "raster": {
                "dem6": {
                    "file": "/opt/c2cgeoportal/geoportal/tests/data/dem4.vrt",
                    "type": "gdal",
                    "round": 0.01,
                }
            }
        }
        raster = Raster(request)

        # Upper left
        request.params["lon"] = "547990.4"
        request.params["lat"] = "216009.5"
        result = raster.raster()
        self.assertEqual(result["dem6"], Decimal("1164.2"))
Example #13
0
 def test_build_url_docker(self):
     request = DummyRequest()
     request.registry.settings = {
         "checker": {
             "base_internal_url": "http://localhost:8080"
         }
     }
     self.assertEqual(
         build_url("Test", "/toto?titi#tutu", request),
         {
             "url": "http://localhost:8080/toto?titi#tutu",
             "headers": {
                 "Cache-Control": "no-cache"
             }
         },
     )
Example #14
0
 def test_build_url_https(self):
     request = DummyRequest()
     request.registry.settings = {
         "checker": {
             "base_internal_url": "https://localhost",
             "forward_host": True
         }
     }
     self.assertEqual(
         build_url("Test", "/toto?titi#tutu", request),
         {
             "url": "https://localhost/toto?titi#tutu",
             "headers": {
                 "Cache-Control": "no-cache",
                 "Host": "example.com:80"
             },
         },
     )
Example #15
0
    def test_shortener_noreplace_2(self):
        from tests import DummyRequest
        from c2cgeoportal_geoportal.views.shortener import Shortener

        def route_url(name, *elements, **kw):
            return "https://example.com/short/" + kw["ref"]

        request = DummyRequest()
        request.user = None
        request.host = "example.com:443"
        request.server_name = "example.com"
        request.route_url = route_url
        request.registry.settings["shortener"] = {
            "base_url": "https://example.com/s/"
        }
        shortener = Shortener(request)

        request.params = {"url": "https://example.com/s/truite"}
        result = shortener.create()
        self.assertEqual(result["short_url"], "https://example.com/s/truite")
Example #16
0
 def match(reference, value, expected):
     r = DummyRequest()
     r.referer = value
     self.assertEqual(is_valid_referer(r, {"authorized_referers": [reference]}), expected)
Example #17
0
    def test_lang_param(self):
        from c2cgeoportal_geoportal import locale_negotiator

        request = DummyRequest(params=dict(lang="fr"))
        lang = locale_negotiator(request)
        self.assertEqual(lang, "fr")
Example #18
0
    def test_login_0(self):
        from tests import DummyRequest
        from c2cgeoportal_geoportal.views.login import Login

        request = DummyRequest()
        request.is_valid_referer = True
        request.user = None
        login = Login(request)

        request.path = "/for_test"
        responce = login.loginform403()
        assert responce["came_from"] == "/for_test"

        request.params = {"came_from": "/for_a_second_test"}
        login = Login(request)
        responce = login.loginform()
        assert responce["came_from"] == "/for_a_second_test"

        login = Login(request)
        request.params = {}
        responce = login.loginform()
        assert responce["came_from"] == "/"

        request.registry.settings = {
            "functionalities": {
                "available_in_templates": ["func"]
            },
            "admin_interface": {
                "available_functionalities": [{
                    "name": "func"
                }]
            },
        }
        fill_tech_user_functionality("anonymous", (("func", "anon"),
                                                   ("toto", "anon_value2")))
        fill_tech_user_functionality("registered", (("func", "reg"), ))
        login = Login(request)
        self.assertEqual(login.loginuser()["functionalities"],
                         {"func": ["anon"]})

        class R:
            id = 123

            def __init__(self, name, functionalities):
                self.name = name
                self.functionalities = functionalities

        class U:
            username = "******"
            is_password_changed = True
            email = "*****@*****.**"
            settings_role = None

            def __init__(self, role="__test_role", functionalities=None):
                if functionalities is None:
                    functionalities = []
                self.roles = [R(role, functionalities)]

        request.user = U()
        login = Login(request)
        expected = {
            "username": "******",
            "email": "*****@*****.**",
            "is_intranet": False,
            "two_factor_enable": False,
            "roles": [{
                "name": "__test_role",
                "id": 123
            }],
            "functionalities": {
                "func": ["reg"]
            },
        }
        self.assertEqual(login.loginuser(), expected)

        class F:
            name = "func"
            value = "value"

        request.user = U("__test_role2", [F()])
        login = Login(request)
        expected = {
            "username": "******",
            "email": "*****@*****.**",
            "is_intranet": False,
            "two_factor_enable": False,
            "roles": [{
                "name": "__test_role2",
                "id": 123
            }],
            "functionalities": {
                "func": ["value"]
            },
        }
        self.assertEqual(login.loginuser(), expected)
Example #19
0
    def test_intranet(self):
        from tests import DummyRequest
        from c2cgeoportal_geoportal.views.login import Login

        request = DummyRequest()
        request.registry.settings = {
            "intranet": {
                "networks": ["192.168.1.0/255.255.255.0"]
            }
        }
        request.user = None

        login = Login(request)
        self.assertEqual(
            login.loginuser(), {
                "is_intranet": False,
                "functionalities": {},
                "two_factor_enable": False
            })

        request.client_addr = "192.168.1.20"
        login = Login(request)
        self.assertEqual(login.loginuser(), {
            "is_intranet": True,
            "functionalities": {},
            "two_factor_enable": False
        })

        class G:
            id = 123

            def __init__(self, name, functionalities):
                self.name = name
                self.functionalities = functionalities

        class U:
            username = "******"
            is_password_changed = True
            email = "*****@*****.**"

            def __init__(self, role="__test_role", functionalities=None):
                if functionalities is None:
                    functionalities = []
                self.roles = [G(role, functionalities)]

        request.user = U()

        login = Login(request)
        request.client_addr = "192.168.2.20"
        self.assertEqual(
            login.loginuser(),
            {
                "email": "*****@*****.**",
                "functionalities": {},
                "is_intranet": False,
                "roles": [{
                    "id": 123,
                    "name": "__test_role"
                }],
                "two_factor_enable": False,
                "username": "******",
            },
        )

        login = Login(request)
        request.client_addr = "192.168.1.20"
        self.assertEqual(
            login.loginuser(),
            {
                "email": "*****@*****.**",
                "functionalities": {},
                "is_intranet": True,
                "roles": [{
                    "id": 123,
                    "name": "__test_role"
                }],
                "two_factor_enable": False,
                "username": "******",
            },
        )
Example #20
0
    def test_shortener(self):
        from tests import DummyRequest
        from pyramid.httpexceptions import HTTPNotFound, HTTPBadRequest
        from c2cgeoportal_geoportal.views.shortener import Shortener

        def route_url(name, *args, **kwargs):
            del name  # Unused
            del args  # Unused
            return "https://example.com/short/" + kwargs["ref"]

        request = DummyRequest()
        request.user = None
        request.host = "example.com:443"
        request.server_name = "example.com"
        request.route_url = route_url
        request.registry.settings["shortener"] = {
            "base_url": "https://example.com/s/"
        }
        shortener = Shortener(request)

        request.params = {}
        request.matchdict = {"ref": "AAAAAA"}
        self.assertRaises(HTTPNotFound, shortener.get)

        request.params = {}
        request.matchdict = {}
        self.assertRaises(HTTPBadRequest, shortener.create)

        request.params = {"url": "https://other-site.com/hi"}
        self.assertRaises(HTTPBadRequest, shortener.create)
Example #21
0
    def test_raster_angle(self):
        from decimal import Decimal

        from tests import DummyRequest

        from c2cgeoportal_geoportal.views.raster import Raster

        request = DummyRequest()
        request.registry.settings = {
            "raster": {
                "dem5": {
                    "file": "/opt/c2cgeoportal/geoportal/tests/data/dem4.bt",
                    "type": "gdal",
                    "round": 0.01,
                }
            }
        }
        raster = Raster(request)

        # Upper left
        request.params["lon"] = "547990.0"
        request.params["lat"] = "216009.1"
        result = raster.raster()
        self.assertEqual(result["dem5"], Decimal("1164.2"))
        request.params["lon"] = "547990.9"
        request.params["lat"] = "216010.0"
        result = raster.raster()
        self.assertEqual(result["dem5"], Decimal("1164.2"))

        # Lower right
        request.params["lon"] = "547996.0"
        request.params["lat"] = "216003.1"
        result = raster.raster()
        self.assertEqual(result["dem5"], Decimal("1180.77"))
        request.params["lon"] = "547996.9"
        request.params["lat"] = "216004.0"
        result = raster.raster()
        self.assertEqual(result["dem5"], Decimal("1180.77"))

        # Out
        request.params["lon"] = "547997.4"
        request.params["lat"] = "216003.5"
        result = raster.raster()
        self.assertEqual(result["dem5"], None)
Example #22
0
    def test_profile_json(self):
        from decimal import Decimal

        from pyramid.httpexceptions import HTTPNotFound
        from tests import DummyRequest

        from c2cgeoportal_geoportal.views.profile import Profile

        request = DummyRequest()
        request.registry.settings = {
            "raster": {
                "dem": {"file": "/opt/c2cgeoportal/geoportal/tests/data/dem.shp", "round": 4},
                "dem2": {"file": "/opt/c2cgeoportal/geoportal/tests/data/dem.shp", "round": 4},
            }
        }
        profile = Profile(request)

        request.params["nbPoints"] = "3"
        request.params["geom"] = (
            '{"type":"LineString",' '"coordinates":[[548009.5,215990],[547990,216009.5]]}'
        )
        result = profile.json()
        self.assertEqual(len(result["profile"]), 4)
        self.assertAlmostEqual(result["profile"][0]["y"], 215990)
        self.assertAlmostEqual(result["profile"][0]["values"]["dem2"], None)
        self.assertAlmostEqual(result["profile"][0]["values"]["dem"], None)
        self.assertAlmostEqual(result["profile"][0]["dist"], Decimal("0.0"))
        self.assertAlmostEqual(result["profile"][0]["x"], 548009.5)
        self.assertAlmostEqual(result["profile"][1]["y"], 215996.5)
        self.assertAlmostEqual(result["profile"][1]["values"]["dem2"], 1181)
        self.assertAlmostEqual(result["profile"][1]["values"]["dem"], 1181)
        self.assertAlmostEqual(result["profile"][1]["dist"], Decimal("9.2"))
        self.assertAlmostEqual(result["profile"][1]["x"], 548003.0)
        self.assertAlmostEqual(result["profile"][2]["y"], 216003.0)
        self.assertAlmostEqual(result["profile"][2]["values"]["dem"], 1180)
        self.assertAlmostEqual(result["profile"][2]["values"]["dem2"], 1180)
        self.assertAlmostEqual(result["profile"][2]["dist"], Decimal("18.4"))
        self.assertAlmostEqual(result["profile"][2]["x"], 547996.5)
        self.assertAlmostEqual(result["profile"][3]["y"], 216009.5)
        self.assertAlmostEqual(result["profile"][3]["values"]["dem"], 1164)
        self.assertAlmostEqual(result["profile"][3]["values"]["dem2"], 1164)
        self.assertAlmostEqual(result["profile"][3]["dist"], Decimal("27.6"))
        self.assertAlmostEqual(result["profile"][3]["x"], 547990.0)

        request.params["layers"] = "dem"
        result = profile.json()
        self.assertEqual(len(result["profile"]), 4)
        self.assertAlmostEqual(result["profile"][0]["y"], 215990)
        self.assertAlmostEqual(result["profile"][0]["values"]["dem"], None)
        self.assertAlmostEqual(result["profile"][0]["dist"], Decimal("0.0"))
        self.assertAlmostEqual(result["profile"][0]["x"], 548009.5)
        self.assertAlmostEqual(result["profile"][1]["y"], 215996.5)
        self.assertAlmostEqual(result["profile"][1]["values"]["dem"], 1181)
        self.assertAlmostEqual(result["profile"][1]["dist"], Decimal("9.2"))
        self.assertAlmostEqual(result["profile"][1]["x"], 548003.0)
        self.assertAlmostEqual(result["profile"][2]["y"], 216003.0)
        self.assertAlmostEqual(result["profile"][2]["values"]["dem"], 1180)
        self.assertAlmostEqual(result["profile"][2]["dist"], Decimal("18.4"))
        self.assertAlmostEqual(result["profile"][2]["x"], 547996.5)
        self.assertAlmostEqual(result["profile"][3]["y"], 216009.5)
        self.assertAlmostEqual(result["profile"][3]["values"]["dem"], 1164)
        self.assertAlmostEqual(result["profile"][3]["dist"], Decimal("27.6"))
        self.assertAlmostEqual(result["profile"][3]["x"], 547990.0)

        # test length = 0
        request.params["geom"] = '{"type":"LineString",' '"coordinates":[[548000,216000]]}'
        result = profile.json()
        self.assertEqual(len(result["profile"]), 1)
        self.assertAlmostEqual(result["profile"][0]["y"], 216000)
        self.assertAlmostEqual(result["profile"][0]["values"]["dem"], 1172)
        self.assertAlmostEqual(result["profile"][0]["dist"], Decimal("0.0"))
        self.assertAlmostEqual(result["profile"][0]["x"], 548000)

        # test cur_nb_points < 1
        request.params["geom"] = (
            '{"type":"LineString",' '"coordinates":[[548000,216000],[548001,216001],[548009,216009]]}'
        )
        result = profile.json()
        self.assertEqual(len(result["profile"]), 5)
        self.assertAlmostEqual(result["profile"][0]["y"], 216000)
        self.assertAlmostEqual(result["profile"][0]["values"]["dem"], 1172)
        self.assertAlmostEqual(result["profile"][0]["dist"], Decimal("0.0"))
        self.assertAlmostEqual(result["profile"][0]["x"], 548000)
        self.assertAlmostEqual(result["profile"][1]["y"], 216001.0)
        self.assertAlmostEqual(result["profile"][1]["values"]["dem"], 1167)
        self.assertAlmostEqual(result["profile"][1]["dist"], Decimal("1.4"))
        self.assertEqual(result["profile"][1]["x"], 548001.0)
        self.assertAlmostEqual(result["profile"][2]["y"], 216003.66666666666)
        self.assertAlmostEqual(result["profile"][2]["values"]["dem"], 1155)
        self.assertAlmostEqual(result["profile"][2]["dist"], Decimal("5.2"))
        self.assertAlmostEqual(result["profile"][2]["x"], 548003.6666666666)
        self.assertAlmostEqual(result["profile"][3]["y"], 216006.33333333334)
        self.assertAlmostEqual(result["profile"][3]["values"]["dem"], 1154)
        self.assertAlmostEqual(result["profile"][3]["dist"], Decimal("9"))
        self.assertAlmostEqual(result["profile"][3]["x"], 548006.3333333334)
        self.assertAlmostEqual(result["profile"][4]["y"], 216009.0)
        self.assertAlmostEqual(result["profile"][4]["values"]["dem"], 1158)
        self.assertAlmostEqual(result["profile"][4]["dist"], Decimal("12.7"))
        self.assertAlmostEqual(result["profile"][4]["x"], 548009.0)

        # test wrong layer name
        request.params["layers"] = "wrong"
        self.assertRaises(HTTPNotFound, profile.json)