c2cgeoportal-admin 2.6.0__py3-none-any.whl → 2.9rc44__py3-none-any.whl

tests/test_ogc_servers.py

@@ -1,6 +1,7 @@
 # pylint: disable=no-self-use
 
 import re
+from unittest.mock import patch
 
 import pytest
 
@@ -17,8 +18,8 @@ def ogc_server_test_data(dbsession, transact):
     auth = ["No auth", "Standard auth", "Geoserver auth", "Proxy"]
     servers = []
     for i in range(0, 8):
-        server = OGCServer(name="server_{}".format(i), description="description_{}".format(i))
-        server.url = "https://somebasicurl_{}.com".format(i)
+        server = OGCServer(name=f"server_{i}", description=f"description_{i}")
+        server.url = f"https://somebasicurl_{i}.com"
         server.image_type = "image/jpeg" if i % 2 == 0 else "image/png"
         server.auth = auth[i % 4]
         dbsession.add(server)
@@ -31,7 +32,6 @@ def ogc_server_test_data(dbsession, transact):
 
 @pytest.mark.usefixtures("ogc_server_test_data", "test_app")
 class TestOGCServer(AbstractViewsTests):
-
     _prefix = "/admin/ogc_servers"
 
     def test_index_rendering(self, test_app):
@@ -59,54 +59,82 @@ class TestOGCServer(AbstractViewsTests):
         self.check_search(test_app, "server_0", total=1)
 
     def test_submit_new(self, dbsession, test_app):
-        from c2cgeoportal_commons.models.main import OGCServer
-
-        resp = test_app.post(
-            "/admin/ogc_servers/new",
-            {
-                "name": "new_name",
-                "description": "new description",
-                "url": "www.randomurl.com",
-                "type": "mapserver",
-                "auth": "No auth",
-                "image_type": "image/png",
-            },
-            status=302,
-        )
+        from c2cgeoportal_commons.models.main import Log, LogAction, OGCServer
+
+        with patch("c2cgeoportal_admin.views.ogc_servers.OGCServerViews._update_cache"):
+            resp = test_app.post(
+                "/admin/ogc_servers/new",
+                {
+                    "name": "new_name",
+                    "description": "new description",
+                    "url": "www.randomurl.com",
+                    "type": "mapserver",
+                    "auth": "No auth",
+                    "image_type": "image/png",
+                },
+                status=302,
+            )
         ogc_server = dbsession.query(OGCServer).filter(OGCServer.name == "new_name").one()
         assert str(ogc_server.id) == re.match(
             r"http://localhost/admin/ogc_servers/(.*)\?msg_col=submit_ok", resp.location
         ).group(1)
         assert ogc_server.name == "new_name"
 
-    def test_edit(self, test_app, ogc_server_test_data):
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.INSERT
+        assert log.element_type == "ogc_server"
+        assert log.element_id == ogc_server.id
+        assert log.element_name == ogc_server.name
+        assert log.username == "test_user"
+
+    def test_edit(self, test_app, ogc_server_test_data, dbsession):
+        from c2cgeoportal_commons.models.main import Log, LogAction
+
         ogc_server = ogc_server_test_data["ogc_servers"][0]
-        resp = test_app.get("/admin/ogc_servers/{}".format(ogc_server.id), status=200)
+        resp = test_app.get(f"/admin/ogc_servers/{ogc_server.id}", status=200)
         form = resp.form
         assert str(ogc_server.id) == self.get_first_field_named(form, "id").value
         assert "hidden" == self.get_first_field_named(form, "id").attrs["type"]
         assert ogc_server.name == form["name"].value
         form["description"] = "new_description"
-        assert form.submit().status_int == 302
+        with patch("c2cgeoportal_admin.views.ogc_servers.OGCServerViews._update_cache"):
+            assert form.submit().status_int == 302
         assert ogc_server.description == "new_description"
 
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.UPDATE
+        assert log.element_type == "ogc_server"
+        assert log.element_id == ogc_server.id
+        assert log.element_name == ogc_server.name
+        assert log.username == "test_user"
+
     def test_delete(self, test_app, ogc_server_test_data, dbsession):
-        from c2cgeoportal_commons.models.main import OGCServer
+        from c2cgeoportal_commons.models.main import Log, LogAction, OGCServer
 
         ogc_server = ogc_server_test_data["ogc_servers"][0]
-        deleted_id = ogc_server.id
-        test_app.delete("/admin/ogc_servers/{}".format(deleted_id), status=200)
-        assert dbsession.query(OGCServer).get(deleted_id) is None
+        test_app.delete(f"/admin/ogc_servers/{ogc_server.id}", status=200)
+        assert dbsession.query(OGCServer).get(ogc_server.id) is None
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.DELETE
+        assert log.element_type == "ogc_server"
+        assert log.element_id == ogc_server.id
+        assert log.element_name == ogc_server.name
+        assert log.username == "test_user"
 
     def test_duplicate(self, ogc_server_test_data, test_app, dbsession):
         from c2cgeoportal_commons.models.main import OGCServer
 
         ogc_server = ogc_server_test_data["ogc_servers"][3]
-        resp = test_app.get("/admin/ogc_servers/{}/duplicate".format(ogc_server.id), status=200)
+        resp = test_app.get(f"/admin/ogc_servers/{ogc_server.id}/duplicate", status=200)
         form = resp.form
         assert "" == self.get_first_field_named(form, "id").value
         self.set_first_field_named(form, "name", "clone")
-        resp = form.submit("submit")
+        with patch("c2cgeoportal_admin.views.ogc_servers.OGCServerViews._update_cache"):
+            resp = form.submit("submit")
         assert resp.status_int == 302
         server = dbsession.query(OGCServer).filter(OGCServer.name == "clone").one()
         assert str(server.id) == re.match(
@@ -115,18 +143,18 @@ class TestOGCServer(AbstractViewsTests):
 
     def test_unicity_validator(self, ogc_server_test_data, test_app):
         ogc_server = ogc_server_test_data["ogc_servers"][3]
-        resp = test_app.get("/admin/ogc_servers/{}/duplicate".format(ogc_server.id), status=200)
+        resp = test_app.get(f"/admin/ogc_servers/{ogc_server.id}/duplicate", status=200)
 
         resp = resp.form.submit("submit")
 
-        self._check_submission_problem(resp, "{} is already used.".format(ogc_server.name))
+        self._check_submission_problem(resp, f"{ogc_server.name} is already used.")
 
     def test_check_success(self, ogc_server_test_data, test_app):
         ogc_server = ogc_server_test_data["ogc_servers"][3]
         ogc_server.url = "config://mapserver"
-        resp = test_app.get("/admin/ogc_servers/{}/synchronize".format(ogc_server.id), status=200)
+        resp = test_app.get(f"/admin/ogc_servers/{ogc_server.id}/synchronize", status=200)
 
-        resp = resp.forms["form-check"].submit("submit")
+        resp = resp.forms["form-check"].submit("check")
 
         assert list(resp.html.find("div", class_="alert-success").stripped_strings) == [
             "OGC Server has been successfully synchronized."
@@ -135,20 +163,41 @@ class TestOGCServer(AbstractViewsTests):
     def test_dry_run_success(self, ogc_server_test_data, test_app):
         ogc_server = ogc_server_test_data["ogc_servers"][3]
         ogc_server.url = "config://mapserver"
-        resp = test_app.get("/admin/ogc_servers/{}/synchronize".format(ogc_server.id), status=200)
+        resp = test_app.get(f"/admin/ogc_servers/{ogc_server.id}/synchronize", status=200)
 
-        resp = resp.forms["form-dry-run"].submit("submit")
+        resp = resp.forms["form-dry-run"].submit("dry-run")
 
         assert list(resp.html.find("div", class_="alert-success").stripped_strings) == [
             "OGC Server has been successfully synchronized."
         ]
 
-    def test_synchronize_success(self, ogc_server_test_data, test_app):
+    def test_synchronize_success(self, ogc_server_test_data, test_app, dbsession):
+        from c2cgeoportal_commons.models.main import Log, LogAction
+
         ogc_server = ogc_server_test_data["ogc_servers"][3]
         ogc_server.url = "config://mapserver"
-        resp = test_app.get("/admin/ogc_servers/{}/synchronize".format(ogc_server.id), status=200)
+        resp = test_app.get(f"/admin/ogc_servers/{ogc_server.id}/synchronize", status=200)
+
+        resp = resp.forms["form-synchronize"].submit("synchronize")
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.SYNCHRONIZE
+        assert log.element_type == "ogc_server"
+        assert log.element_id == ogc_server.id
+        assert log.element_name == ogc_server.name
+        assert log.username == "test_user"
+
+        assert list(resp.html.find("div", class_="alert-success").stripped_strings) == [
+            "OGC Server has been successfully synchronized."
+        ]
+
+        form = resp.forms["form-synchronize"]
+        form["force-parents"].checked = True
+        form["force-ordering"].checked = True
+        form["clean"].checked = True
 
-        resp = resp.forms["form-synchronize"].submit("submit")
+        resp = form.submit("synchronize")
 
         assert list(resp.html.find("div", class_="alert-success").stripped_strings) == [
             "OGC Server has been successfully synchronized."

tests/test_restriction_areas.py

@@ -25,16 +25,16 @@ def restriction_area_test_data(dbsession, transact):
     ogc_server = OGCServer(name="test_server")
     layers = []
     for i in range(0, 4):
-        layer = LayerWMS(name="layer_{}".format(i), layer="layer_{}".format(i), public=False)
+        layer = LayerWMS(name=f"layer_{i}", layer=f"layer_{i}", public=False)
         layer.ogc_server = ogc_server
         layers.append(layer)
     dbsession.add_all(layers)
 
     restrictionareas = []
     for i in range(0, 4):
-        restrictionarea = RestrictionArea(name="restrictionarea_{}".format(i))
+        restrictionarea = RestrictionArea(name=f"restrictionarea_{i}")
         restrictionarea.area = from_shape(box(485869.5728, 76443.1884, 837076.5648, 299941.7864), srid=21781)
-        restrictionarea.description = "description_{}".format(i)
+        restrictionarea.description = f"description_{i}"
         restrictionarea.roles = [roles[i % 4], roles[(i + 2) % 4]]
         restrictionarea.layers = [layers[i % 4], layers[(i + 2) % 4]]
         dbsession.add(restrictionarea)
@@ -50,7 +50,6 @@ def restriction_area_test_data(dbsession, transact):
 
 @pytest.mark.usefixtures("restriction_area_test_data", "test_app")
 class TestRestrictionAreaViews(TestTreeGroup):
-
     _prefix = "/admin/restriction_areas"
 
     def test_index_rendering(self, test_app):
@@ -73,7 +72,7 @@ class TestRestrictionAreaViews(TestTreeGroup):
         self.check_search(test_app, "restrictionarea_1", total=1)
 
     def test_submit_new(self, dbsession, test_app, restriction_area_test_data):
-        from c2cgeoportal_commons.models.main import RestrictionArea
+        from c2cgeoportal_commons.models.main import Log, LogAction, RestrictionArea
 
         roles = restriction_area_test_data["roles"]
         layers = restriction_area_test_data["layers"]
@@ -113,18 +112,28 @@ class TestRestrictionAreaViews(TestTreeGroup):
         assert restriction_area.name == "new_name"
         assert restriction_area.description == "new_description"
         assert restriction_area.readwrite
-        assert set(restriction_area.roles) == set([roles[0], roles[1]])
-        assert set(restriction_area.layers) == set([layers[0], layers[1]])
+        assert set(restriction_area.roles) == {roles[0], roles[1]}
+        assert set(restriction_area.layers) == {layers[0], layers[1]}
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.INSERT
+        assert log.element_type == "restrictionarea"
+        assert log.element_id == restriction_area.id
+        assert log.element_name == restriction_area.name
+        assert log.username == "test_user"
 
     def test_unicity_validator(self, restriction_area_test_data, test_app):
         restriction_area = restriction_area_test_data["restriction_areas"][2]
 
-        resp = test_app.get("/admin/restriction_areas/{}/duplicate".format(restriction_area.id), status=200)
+        resp = test_app.get(f"/admin/restriction_areas/{restriction_area.id}/duplicate", status=200)
         resp = resp.form.submit("submit")
 
-        self._check_submission_problem(resp, "{} is already used.".format(restriction_area.name))
+        self._check_submission_problem(resp, f"{restriction_area.name} is already used.")
 
     def test_edit(self, test_app, restriction_area_test_data, dbsession):
+        from c2cgeoportal_commons.models.main import Log, LogAction
+
         restriction_area = restriction_area_test_data["restriction_areas"][0]
         roles = restriction_area_test_data["roles"]
 
@@ -162,16 +171,32 @@ class TestRestrictionAreaViews(TestTreeGroup):
 
         dbsession.expire(restriction_area)
         assert restriction_area.description == "new_description"
-        assert set(restriction_area.roles) == set([roles[i] for i in range(0, 3)])
+        assert set(restriction_area.roles) == {roles[i] for i in range(0, 3)}
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.UPDATE
+        assert log.element_type == "restrictionarea"
+        assert log.element_id == restriction_area.id
+        assert log.element_name == restriction_area.name
+        assert log.username == "test_user"
 
     def test_delete(self, test_app, restriction_area_test_data, dbsession):
-        from c2cgeoportal_commons.models.main import RestrictionArea
+        from c2cgeoportal_commons.models.main import Log, LogAction, RestrictionArea
 
         restriction_area = restriction_area_test_data["restriction_areas"][0]
         deleted_id = restriction_area.id
-        test_app.delete("/admin/restriction_areas/{}".format(deleted_id), status=200)
+        test_app.delete(f"/admin/restriction_areas/{deleted_id}", status=200)
         assert dbsession.query(RestrictionArea).get(deleted_id) is None
 
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.DELETE
+        assert log.element_type == "restrictionarea"
+        assert log.element_id == restriction_area.id
+        assert log.element_name == restriction_area.name
+        assert log.username == "test_user"
+
     def test_duplicate(self, restriction_area_test_data, test_app, dbsession):
         from c2cgeoportal_commons.models.main import RestrictionArea
 
@@ -181,9 +206,7 @@ class TestRestrictionAreaViews(TestTreeGroup):
         # Ensure restriction_area.layers is loaded with relationship "order_by"
         dbsession.expire(restriction_area)
 
-        form = test_app.get(
-            "/admin/restriction_areas/{}/duplicate".format(restriction_area.id), status=200
-        ).form
+        form = test_app.get(f"/admin/restriction_areas/{restriction_area.id}/duplicate", status=200).form
 
         assert "" == self.get_first_field_named(form, "id").value
         self._check_roles(form, roles, restriction_area)

tests/test_role.py

@@ -3,6 +3,7 @@
 import json
 import re
 
+import pyramid.httpexceptions
 import pytest
 from geoalchemy2.shape import from_shape, to_shape
 from pyramid.testing import DummyRequest
@@ -19,17 +20,18 @@ def roles_test_data(dbsession, transact):
     from c2cgeoportal_commons.models.main import Functionality, RestrictionArea, Role
     from c2cgeoportal_commons.models.static import User
 
+    # Note that "default_basemap" is not relevant for roles
     functionalities = {}
-    for name in ("default_basemap", "location"):
+    for name in ("default_basemap", "default_theme", "print_template"):
         functionalities[name] = []
         for v in range(0, 4):
-            functionality = Functionality(name=name, value="value_{}".format(v))
+            functionality = Functionality(name=name, value=f"value_{v}")
             dbsession.add(functionality)
             functionalities[name].append(functionality)
 
     restrictionareas = []
     for i in range(0, 5):
-        restrictionarea = RestrictionArea(name="restrictionarea_{}".format(i))
+        restrictionarea = RestrictionArea(name=f"restrictionarea_{i}")
         dbsession.add(restrictionarea)
         restrictionareas.append(restrictionarea)
 
@@ -37,9 +39,9 @@ def roles_test_data(dbsession, transact):
     for i in range(0, 23):
         role = Role("secretary_" + str(i))
         role.functionalities = [
-            functionalities["default_basemap"][0],
-            functionalities["location"][0],
-            functionalities["location"][1],
+            functionalities["default_theme"][0],
+            functionalities["print_template"][0],
+            functionalities["print_template"][1],
         ]
         role.restrictionareas = [restrictionareas[0], restrictionareas[1]]
         role.extent = from_shape(box(485869.5728, 76443.1884, 837076.5648, 299941.7864), srid=21781)
@@ -67,7 +69,6 @@ def roles_test_data(dbsession, transact):
 
 @pytest.mark.usefixtures("roles_test_data", "test_app")
 class TestRole(TestTreeGroup):
-
     _prefix = "/admin/roles"
 
     def test_index_rendering(self, test_app):
@@ -102,9 +103,9 @@ class TestRole(TestTreeGroup):
         self.check_grid_headers(resp, expected, new="Nouveau")
 
     def test_submit_new(self, dbsession, test_app, roles_test_data):
-        from c2cgeoportal_commons.models.main import Role
+        from c2cgeoportal_commons.models.main import Log, LogAction, Role
 
-        roles = roles_test_data["roles"]
+        roles_test_data["roles"]
         functionalities = roles_test_data["functionalities"]
         restrictionareas = roles_test_data["restrictionareas"]
         users = roles_test_data["users"]
@@ -120,7 +121,7 @@ class TestRole(TestTreeGroup):
                 ("extent", ""),
                 ("__start__", "functionalities:sequence"),
                 ("functionalities", str(functionalities["default_basemap"][0].id)),
-                ("functionalities", str(functionalities["location"][1].id)),
+                ("functionalities", str(functionalities["print_template"][1].id)),
                 ("__end__", "functionalities:sequence"),
                 ("__start__", "restrictionareas:sequence"),
                 ("restrictionareas", str(restrictionareas[0].id)),
@@ -146,13 +147,24 @@ class TestRole(TestTreeGroup):
 
         assert role.name == "new_name"
         assert role.description == "new_description"
-        assert set(role.functionalities) == set(
-            [functionalities["default_basemap"][0], functionalities["location"][1]]
-        )
-        assert set(role.restrictionareas) == set([restrictionareas[0], restrictionareas[1]])
-        assert set(role.users) == set([users[0], users[1]])
+        assert set(role.functionalities) == {
+            functionalities["default_basemap"][0],
+            functionalities["print_template"][1],
+        }
+        assert set(role.restrictionareas) == {restrictionareas[0], restrictionareas[1]}
+        assert set(role.users) == {users[0], users[1]}
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.INSERT
+        assert log.element_type == "role"
+        assert log.element_id == role.id
+        assert log.element_name == role.name
+        assert log.username == "test_user"
 
     def test_edit(self, dbsession, test_app, roles_test_data):
+        from c2cgeoportal_commons.models.main import Log, LogAction
+
         role = roles_test_data["roles"][10]
 
         # Ensure role.users is loaded with relationship "order_by"
@@ -174,33 +186,33 @@ class TestRole(TestTreeGroup):
         assert expected.almost_equals(shape(json.loads(form["extent"].value)), decimal=0)
 
         functionalities = roles_test_data["functionalities"]
-        assert (
-            set(
-                (
-                    functionalities["default_basemap"][0].id,
-                    functionalities["location"][0].id,
-                    functionalities["location"][1].id,
-                )
-            )
-            == set(f.id for f in role.functionalities)
-        )
+        assert {
+            functionalities["default_theme"][0].id,
+            functionalities["print_template"][0].id,
+            functionalities["print_template"][1].id,
+        } == {f.id for f in role.functionalities}
         self.check_checkboxes(
             form,
             "functionalities",
             [
                 {
-                    "label": "{}={}".format(f.name, f.value),
+                    "label": f"{f.name}={f.value}",
                     "value": str(f.id),
                     "checked": f in role.functionalities,
                 }
-                for f in sum(
-                    [roles_test_data["functionalities"][name] for name in ("default_basemap", "location")], []
+                for f in sorted(
+                    [
+                        f
+                        for f in sum(functionalities.values(), [])
+                        if f.name in ("default_theme", "print_template")
+                    ],
+                    key=lambda f: (f.name, f.value),
                 )
             ],
         )
 
         ras = roles_test_data["restrictionareas"]
-        assert set((ras[0].id, ras[1].id)) == set(ra.id for ra in role.restrictionareas)
+        assert {ras[0].id, ras[1].id} == {ra.id for ra in role.restrictionareas}
         self.check_checkboxes(
             form,
             "restrictionareas",
@@ -237,9 +249,9 @@ class TestRole(TestTreeGroup):
         )
 
         functionality_ids = [
-            roles_test_data["functionalities"]["default_basemap"][1].id,
-            roles_test_data["functionalities"]["location"][1].id,
-            roles_test_data["functionalities"]["default_basemap"][2].id,
+            roles_test_data["functionalities"]["default_theme"][1].id,
+            roles_test_data["functionalities"]["print_template"][1].id,
+            roles_test_data["functionalities"]["print_template"][2].id,
         ]
         form["functionalities"] = [str(id) for id in functionality_ids]
 
@@ -268,15 +280,23 @@ class TestRole(TestTreeGroup):
         )
         assert expected.almost_equals(to_shape(role.extent), decimal=0)
 
-        assert set(functionality_ids) == set([f.id for f in role.functionalities])
-        assert set(ra_ids) == set([f.id for f in role.restrictionareas])
+        assert set(functionality_ids) == {f.id for f in role.functionalities}
+        assert set(ra_ids) == {f.id for f in role.restrictionareas}
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.UPDATE
+        assert log.element_type == "role"
+        assert log.element_id == role.id
+        assert log.element_name == role.name
+        assert log.username == "test_user"
 
     def test_duplicate(self, roles_test_data, test_app, dbsession):
         from c2cgeoportal_commons.models.main import Role
 
         role_proto = roles_test_data["roles"][7]
 
-        resp = test_app.get("/admin/roles/{}/duplicate".format(role_proto.id), status=200)
+        resp = test_app.get(f"/admin/roles/{role_proto.id}/duplicate", status=200)
         form = resp.form
 
         assert "" == self.get_first_field_named(form, "id").value
@@ -295,24 +315,32 @@ class TestRole(TestTreeGroup):
         assert set(role_proto.users) == set(role.users)
 
     def test_delete(self, test_app, dbsession):
-        from c2cgeoportal_commons.models.main import Role
+        from c2cgeoportal_commons.models.main import Log, LogAction, Role
+
+        role = dbsession.query(Role).first()
+        test_app.delete(f"/admin/roles/{role.id}", status=200)
+        assert dbsession.query(Role).get(role.id) is None
 
-        role_id = dbsession.query(Role.id).first().id
-        test_app.delete("/admin/roles/{}".format(role_id), status=200)
-        assert dbsession.query(Role).get(role_id) is None
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.DELETE
+        assert log.element_type == "role"
+        assert log.element_id == role.id
+        assert log.element_name == role.name
+        assert log.username == "test_user"
 
     def test_unicity_validator(self, roles_test_data, test_app):
         role_proto = roles_test_data["roles"][7]
-        resp = test_app.get("/admin/roles/{}/duplicate".format(role_proto.id), status=200)
+        resp = test_app.get(f"/admin/roles/{role_proto.id}/duplicate", status=200)
 
         resp = resp.form.submit("submit")
 
-        self._check_submission_problem(resp, "{} is already used.".format(role_proto.name))
+        self._check_submission_problem(resp, f"{role_proto.name} is already used.")
 
     @pytest.mark.usefixtures("raise_db_error_on_query")
     def test_grid_dberror(self, dbsession):
         from c2cgeoportal_admin.views.roles import RoleViews
 
         request = DummyRequest(dbsession=dbsession, params={"offset": 0, "limit": 10})
-        info = RoleViews(request).grid()
-        assert info.status_int == 500, "Expected 500 status when db error"
+        with pytest.raises(pyramid.httpexceptions.HTTPInternalServerError):
+            RoleViews(request).grid()