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

tests/test_restriction_areas.py

@@ -4,40 +4,52 @@
 import json
 import re
 
-from geoalchemy2.shape import from_shape
 import pytest
+from geoalchemy2.shape import from_shape
 from shapely.geometry import Polygon, box, shape
 
-from . import AbstractViewsTests
+from .test_treegroup import TestTreeGroup
 
 
 @pytest.fixture(scope="function")
 @pytest.mark.usefixtures("dbsession", "transact")
 def restriction_area_test_data(dbsession, transact):
     del transact
-    from c2cgeoportal_commons.models.main import RestrictionArea, Role
+    from c2cgeoportal_commons.models.main import LayerWMS, OGCServer, RestrictionArea, Role
 
     roles = []
     for i in range(0, 4):
         roles.append(Role("secretary_" + str(i)))
-        dbsession.add(roles[i])
+    dbsession.add_all(roles)
+
+    ogc_server = OGCServer(name="test_server")
+    layers = []
+    for i in range(0, 4):
+        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)
         restrictionareas.append(restrictionarea)
 
     dbsession.flush()
-    yield {"restriction_areas": restrictionareas, "roles": roles}
+    yield {
+        "layers": layers,
+        "restriction_areas": restrictionareas,
+        "roles": roles,
+    }
 
 
 @pytest.mark.usefixtures("restriction_area_test_data", "test_app")
-class TestRestrictionAreaViews(AbstractViewsTests):
-
+class TestRestrictionAreaViews(TestTreeGroup):
     _prefix = "/admin/restriction_areas"
 
     def test_index_rendering(self, test_app):
@@ -59,31 +71,75 @@ class TestRestrictionAreaViews(AbstractViewsTests):
     def test_grid_search(self, test_app):
         self.check_search(test_app, "restrictionarea_1", total=1)
 
-    def test_submit_new(self, dbsession, test_app):
-        from c2cgeoportal_commons.models.main import RestrictionArea
+    def test_submit_new(self, dbsession, test_app, restriction_area_test_data):
+        from c2cgeoportal_commons.models.main import Log, LogAction, RestrictionArea
+
+        roles = restriction_area_test_data["roles"]
+        layers = restriction_area_test_data["layers"]
 
         resp = test_app.post(
-            "/admin/restriction_areas/new", {"name": "new_name", "description": "new_description"}, status=302
+            "/admin/restriction_areas/new",
+            (
+                ("_charset_", "UTF-8"),
+                ("__formid__", "deform"),
+                ("id", ""),
+                ("name", "new_name"),
+                ("description", "new_description"),
+                ("readwrite", "true"),
+                ("area", ""),
+                ("__start__", "roles:sequence"),
+                ("roles", str(roles[0].id)),
+                ("roles", str(roles[1].id)),
+                ("__end__", "roles:sequence"),
+                ("__start__", "layers:sequence"),
+                ("__start__", "layer:mapping"),
+                ("id", str(layers[0].id)),
+                ("__end__", "layer:mapping"),
+                ("__start__", "layer:mapping"),
+                ("id", str(layers[1].id)),
+                ("__end__", "layer:mapping"),
+                ("__end__", "layers:sequence"),
+                ("formsubmit", "formsubmit"),
+            ),
+            status=302,
         )
 
         restriction_area = dbsession.query(RestrictionArea).filter(RestrictionArea.name == "new_name").one()
         assert str(restriction_area.id) == re.match(
             r"http://localhost/admin/restriction_areas/(.*)\?msg_col=submit_ok", resp.location
         ).group(1)
+
         assert restriction_area.name == "new_name"
+        assert restriction_area.description == "new_description"
+        assert restriction_area.readwrite
+        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"]
 
+        # Ensure restriction_area.layers is loaded with relationship "order_by"
+        dbsession.expire(restriction_area)
+
         form = self.get_item(test_app, restriction_area.id).form
 
         assert str(restriction_area.id) == self.get_first_field_named(form, "id").value
@@ -100,6 +156,14 @@ class TestRestrictionAreaViews(AbstractViewsTests):
         )
         assert expected.almost_equals(shape(json.loads(form["area"].value)), decimal=0)
         self._check_roles(form, roles, restriction_area)
+        self.check_children(
+            form,
+            "layers",
+            [
+                {"label": layer.name, "values": {"id": str(layer.id)}}
+                for layer in sorted(restriction_area.layers, key=lambda l: l.name)
+            ],
+        )
 
         form["description"] = "new_description"
         form["roles"] = [roles[i].id for i in range(0, 3)]
@@ -107,28 +171,53 @@ class TestRestrictionAreaViews(AbstractViewsTests):
 
         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
 
         restriction_area = restriction_area_test_data["restriction_areas"][3]
         roles = restriction_area_test_data["roles"]
 
-        form = test_app.get(
-            "/admin/restriction_areas/{}/duplicate".format(restriction_area.id), status=200
-        ).form
+        # Ensure restriction_area.layers is loaded with relationship "order_by"
+        dbsession.expire(restriction_area)
+
+        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)
+        self.check_children(
+            form,
+            "layers",
+            [
+                {"label": layer.name, "values": {"id": str(layer.id)}}
+                for layer in sorted(restriction_area.layers, key=lambda l: l.name)
+            ],
+        )
 
         self.set_first_field_named(form, "name", "clone")
         resp = form.submit("submit")

tests/test_role.py

@@ -3,14 +3,13 @@
 import json
 import re
 
+import pyramid.httpexceptions
+import pytest
 from geoalchemy2.shape import from_shape, to_shape
 from pyramid.testing import DummyRequest
-import pytest
-from selenium.webdriver.common.by import By
 from shapely.geometry import Polygon, box, shape
 
-from . import AbstractViewsTests, skip_if_ci
-from .selenium.page import IndexPage
+from .test_treegroup import TestTreeGroup
 
 
 @pytest.fixture(scope="function")
@@ -18,20 +17,21 @@ from .selenium.page import IndexPage
 def roles_test_data(dbsession, transact):
     del transact
 
-    from c2cgeoportal_commons.models.main import Role, Functionality, RestrictionArea
+    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)
 
@@ -39,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)
@@ -68,8 +68,7 @@ def roles_test_data(dbsession, transact):
 
 
 @pytest.mark.usefixtures("roles_test_data", "test_app")
-class TestRole(AbstractViewsTests):
-
+class TestRole(TestTreeGroup):
     _prefix = "/admin/roles"
 
     def test_index_rendering(self, test_app):
@@ -87,24 +86,90 @@ class TestRole(AbstractViewsTests):
         ]
         self.check_grid_headers(resp, expected)
 
-    @pytest.mark.skip(reason="Translation is not finished")
+    @pytest.mark.skip(reason="Translation seems not available in tests")
     def test_index_rendering_fr(self, test_app):
         resp = self.get(test_app, locale="fr")
 
-        self.check_left_menu(resp, "Roles")
+        self.check_left_menu(resp, "Rôles")
 
         expected = [
-            ("_id_", "", "false"),
-            ("name", "Name"),
+            ("actions", "", "false"),
+            ("id", "id", "true"),
+            ("name", "Nom"),
             ("description", "Description"),
-            ("functionalities", "Fonctionalités", "false"),
-            ("restrictionareas", "Aires de restriction", "false"),
+            ("functionalities", "Fonctionnalités", "false"),
+            ("restrictionareas", "Zones de restriction", "false"),
         ]
-        self.check_grid_headers(resp, expected)
+        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 Log, LogAction, Role
+
+        roles_test_data["roles"]
+        functionalities = roles_test_data["functionalities"]
+        restrictionareas = roles_test_data["restrictionareas"]
+        users = roles_test_data["users"]
+
+        resp = test_app.post(
+            "/admin/roles/new",
+            (
+                ("_charset_", "UTF-8"),
+                ("__formid__", "deform"),
+                ("id", ""),
+                ("name", "new_name"),
+                ("description", "new_description"),
+                ("extent", ""),
+                ("__start__", "functionalities:sequence"),
+                ("functionalities", str(functionalities["default_basemap"][0].id)),
+                ("functionalities", str(functionalities["print_template"][1].id)),
+                ("__end__", "functionalities:sequence"),
+                ("__start__", "restrictionareas:sequence"),
+                ("restrictionareas", str(restrictionareas[0].id)),
+                ("restrictionareas", str(restrictionareas[1].id)),
+                ("__end__", "restrictionareas:sequence"),
+                ("__start__", "users:sequence"),
+                ("__start__", "user:mapping"),
+                ("id", str(users[0].id)),
+                ("__end__", "user:mapping"),
+                ("__start__", "user:mapping"),
+                ("id", str(users[1].id)),
+                ("__end__", "user:mapping"),
+                ("__end__", "users:sequence"),
+                ("formsubmit", "formsubmit"),
+            ),
+            status=302,
+        )
+
+        role = dbsession.query(Role).filter(Role.name == "new_name").one()
+        assert str(role.id) == re.match(
+            r"http://localhost/admin/roles/(.*)\?msg_col=submit_ok", resp.location
+        ).group(1)
+
+        assert role.name == "new_name"
+        assert role.description == "new_description"
+        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"
+        dbsession.expire(role)
+
         form = self.get_item(test_app, role.id).form
 
         assert "secretary_10" == form["name"].value
@@ -121,30 +186,33 @@ class TestRole(AbstractViewsTests):
         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",
@@ -154,6 +222,15 @@ class TestRole(AbstractViewsTests):
             ],
         )
 
+        self.check_children(
+            form,
+            "users",
+            [
+                {"label": user.username, "values": {"id": str(user.id)}}
+                for user in sorted(role.users, key=lambda u: u.username)
+            ],
+        )
+
         form["name"] = "New name"
         form["description"] = "New description"
         form["extent"] = json.dumps(
@@ -172,9 +249,9 @@ class TestRole(AbstractViewsTests):
         )
 
         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]
 
@@ -203,18 +280,26 @@ class TestRole(AbstractViewsTests):
         )
         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 "" == form["id"].value
+        assert "" == self.get_first_field_named(form, "id").value
         assert role_proto.name == form["name"].value
         assert role_proto.description == form["description"].value
         form["name"].value = "clone"
@@ -225,62 +310,37 @@ class TestRole(AbstractViewsTests):
             r"http://localhost/admin/roles/(.*)\?msg_col=submit_ok", resp.location
         ).group(1)
         assert role_proto.id != role.id
-        assert role_proto.functionalities[2].name == role.functionalities[2].name
-        assert role_proto.functionalities[2].value == role.functionalities[2].value
-        assert role_proto.functionalities[2].id == role.functionalities[2].id
-        assert role_proto.restrictionareas[1].name == role.restrictionareas[1].name
-        assert role_proto.restrictionareas[1].id == role.restrictionareas[1].id
+        assert set(role_proto.functionalities) == set(role.functionalities)
+        assert set(role_proto.restrictionareas) == set(role.restrictionareas)
+        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_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
+        role = dbsession.query(Role).first()
+        test_app.delete(f"/admin/roles/{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"
-
-
-@skip_if_ci
-@pytest.mark.selenium
-@pytest.mark.usefixtures("selenium", "selenium_app", "roles_test_data")
-class TestRoleSelenium:
-
-    _prefix = "/admin/roles"
-
-    def test_index(self, selenium, selenium_app, roles_test_data, dbsession):
-        from c2cgeoportal_commons.models.static import Role
-
-        selenium.get(selenium_app + self._prefix)
-
-        index_page = IndexPage(selenium)
-        index_page.select_language("en")
-        index_page.check_pagination_info("Showing 1 to 23 of 23 rows", 10)
-        index_page.select_page_size(10)
-        index_page.check_pagination_info("Showing 1 to 10 of 23 rows", 10)
-
-        # delete
-        role = roles_test_data["roles"][3]
-        deleted_id = role.id
-        index_page.click_delete(deleted_id)
-        index_page.check_pagination_info("Showing 1 to 10 of 22 rows", 10)
-        assert dbsession.query(Role).get(deleted_id) is None
-
-        # edit
-        role = roles_test_data["roles"][4]
-        index_page.find_item_action(role.id, "edit").click()
-        index_page.find_element(By.XPATH, "//canvas", timeout=5)
+        with pytest.raises(pyramid.httpexceptions.HTTPInternalServerError):
+            RoleViews(request).grid()