c2cgeoportal-admin 2.5.0.100__py3-none-any.whl → 2.7.1.156__py3-none-any.whl

tests/test_role.py

@@ -3,14 +3,12 @@
 import json
 import re
 
+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 +16,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 +38,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,7 +67,7 @@ def roles_test_data(dbsession, transact):
 
 
 @pytest.mark.usefixtures("roles_test_data", "test_app")
-class TestRole(AbstractViewsTests):
+class TestRole(TestTreeGroup):
 
     _prefix = "/admin/roles"
 
@@ -87,24 +86,80 @@ 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 Role
+
+        roles = 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]}
 
     def test_edit(self, dbsession, test_app, roles_test_data):
         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 +176,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 +212,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 +239,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 +270,18 @@ 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}
 
     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,26 +292,24 @@ 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
 
         role_id = dbsession.query(Role.id).first().id
-        test_app.delete("/admin/roles/{}".format(role_id), status=200)
+        test_app.delete(f"/admin/roles/{role_id}", status=200)
         assert dbsession.query(Role).get(role_id) is None
 
     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):
@@ -253,34 +318,3 @@ class TestRole(AbstractViewsTests):
         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)

tests/test_themes.py

@@ -13,33 +13,38 @@ def theme_test_data(dbsession, transact):
     del transact
 
     from c2cgeoportal_commons.models.main import (
-        Theme,
-        Role,
         Functionality,
-        LayergroupTreeitem,
         Interface,
-        Metadata,
         LayerGroup,
+        LayergroupTreeitem,
         LayerWMS,
+        Metadata,
         OGCServer,
+        Role,
+        Theme,
     )
 
     interfaces = [Interface(name) for name in ["desktop", "mobile", "edit", "routing"]]
+    dbsession.add_all(interfaces)
 
-    groups = [LayerGroup(name="layer_group_{}".format(i)) for i in range(0, 5)]
+    groups = [LayerGroup(name=f"layer_group_{i}") for i in range(0, 5)]
+    dbsession.add_all(groups)
 
     layer = LayerWMS(name="layer_wms")
     layer.ogc_server = OGCServer(name="server")
-    dbsession.add(layer)
     layers = [layer]
+    dbsession.add_all(layers)
 
+    # Note that "default_theme" is not relevant for themes
     functionalities = [
-        Functionality(name=name, value="value_{}".format(v))
-        for name in ("default_basemap", "location")
+        Functionality(name=name, value=f"value_{v}")
+        for name in ("default_basemap", "default_theme")
         for v in range(0, 4)
     ]
+    dbsession.add_all(functionalities)
 
     roles = [Role("secretary_" + str(i)) for i in range(0, 4)]
+    dbsession.add_all(roles)
 
     metadatas_protos = [
         ("copyable", "true"),
@@ -48,7 +53,7 @@ def theme_test_data(dbsession, transact):
     ]
     themes = []
     for i in range(0, 25):
-        theme = Theme(name="theme_{}".format(i), ordering=1, icon="icon_{}".format(i))
+        theme = Theme(name=f"theme_{i}", ordering=1, icon=f"icon_{i}")
         theme.public = 1 == i % 2
         theme.interfaces = [interfaces[i % 4], interfaces[(i + 2) % 4]]
         theme.metadatas = [
@@ -57,7 +62,7 @@ def theme_test_data(dbsession, transact):
         ]
         for metadata in theme.metadatas:
             metadata.item = theme
-        theme.functionalities = [functionalities[i % 8], functionalities[(i + 3) % 8]]
+        theme.functionalities = [functionalities[i % 4]]
         theme.restricted_roles = [roles[i % 4], roles[(i + 2) % 4]]
 
         dbsession.add(
@@ -117,7 +122,7 @@ class TestTheme(TestTreeGroup):
 
         assert first_theme.id == int(first_row["_id_"])
         assert first_theme.name == first_row["name"]
-        assert "default_basemap=value_0, default_basemap=value_3" == first_row["functionalities"]
+        assert "default_basemap=value_0" == first_row["functionalities"]
         assert "secretary_0, secretary_2" == first_row["restricted_roles"]
         assert "desktop, edit" == first_row["interfaces"]
         assert 'copyable: true, snappingConfig: {"tolerance": 50}' == first_row["metadatas"]
@@ -146,16 +151,16 @@ class TestTheme(TestTreeGroup):
 
     def test_public_checkbox_edit(self, test_app, theme_test_data):
         theme = theme_test_data["themes"][10]
-        form10 = test_app.get("/admin/themes/{}".format(theme.id), status=200).form
+        form10 = test_app.get(f"/admin/themes/{theme.id}", status=200).form
         assert not form10["public"].checked
         theme = theme_test_data["themes"][11]
-        form11 = test_app.get("/admin/themes/{}".format(theme.id), status=200).form
+        form11 = test_app.get(f"/admin/themes/{theme.id}", status=200).form
         assert form11["public"].checked
 
     def test_edit(self, test_app, theme_test_data, dbsession):
         theme = theme_test_data["themes"][0]
 
-        resp = test_app.get("/admin/themes/{}".format(theme.id), status=200)
+        resp = test_app.get(f"/admin/themes/{theme.id}", status=200)
         form = resp.form
 
         assert str(theme.id) == self.get_first_field_named(form, "id").value
@@ -166,21 +171,24 @@ class TestTheme(TestTreeGroup):
         assert theme.public == form["public"].checked
 
         interfaces = theme_test_data["interfaces"]
-        assert set((interfaces[0].id, interfaces[2].id)) == set(i.id for i in theme.interfaces)
+        assert {interfaces[0].id, interfaces[2].id} == {i.id for i in theme.interfaces}
         self._check_interfaces(form, interfaces, theme)
 
         functionalities = theme_test_data["functionalities"]
-        assert set((functionalities[0].id, functionalities[3].id)) == set(f.id for f in theme.functionalities)
+        assert {functionalities[0].id} == {f.id for f in theme.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 theme.functionalities,
                 }
-                for f in sorted(functionalities, key=lambda f: (f.name, f.value))
+                for f in sorted(
+                    [f for f in functionalities if f.name in ("default_basemap")],
+                    key=lambda f: (f.name, f.value),
+                )
             ],
         )
 
@@ -220,12 +228,8 @@ class TestTheme(TestTreeGroup):
                 assert value == getattr(theme, key)
             else:
                 assert str(value or "") == str(getattr(theme, key) or "")
-        assert set([interfaces[1].id, interfaces[3].id]) == set(
-            [interface.id for interface in theme.interfaces]
-        )
-        assert set([functionalities[2].id]) == set(
-            [functionality.id for functionality in theme.functionalities]
-        )
+        assert {interfaces[1].id, interfaces[3].id} == {interface.id for interface in theme.interfaces}
+        assert {functionalities[2].id} == {functionality.id for functionality in theme.functionalities}
         assert 0 == len(theme.restricted_roles)
 
     def test_post_new_with_children_invalid(self, test_app, theme_test_data):
@@ -234,7 +238,7 @@ class TestTheme(TestTreeGroup):
         """
         groups = theme_test_data["groups"]
         resp = test_app.post(
-            "{}/new".format(self._prefix),
+            f"{self._prefix}/new",
             (
                 ("_charset_", "UTF-8"),
                 ("__formid__", "deform"),
@@ -256,7 +260,7 @@ class TestTheme(TestTreeGroup):
     def test_post_new_with_children_success(self, test_app, dbsession, theme_test_data):
         groups = theme_test_data["groups"]
         resp = test_app.post(
-            "{}/new".format(self._prefix),
+            f"{self._prefix}/new",
             (
                 ("_charset_", "UTF-8"),
                 ("__formid__", "deform"),
@@ -304,7 +308,7 @@ class TestTheme(TestTreeGroup):
         """
         layers = theme_test_data["layers"]
         resp = test_app.post(
-            "{}/new".format(self._prefix),
+            f"{self._prefix}/new",
             (
                 ("_charset_", "UTF-8"),
                 ("__formid__", "deform"),
@@ -324,7 +328,7 @@ class TestTheme(TestTreeGroup):
             status=200,
         )
         assert (
-            "Value {} does not exist in table treeitem or is not allowed to avoid cycles".format(layers[0].id)
+            f"Value {layers[0].id} does not exist in table treeitem or is not allowed to avoid cycles"
             == resp.html.select_one(".item-children_relation + .help-block").getText().strip()
         )
 
@@ -333,7 +337,7 @@ class TestTheme(TestTreeGroup):
 
         theme = theme_test_data["themes"][1]
 
-        resp = test_app.get("{}/{}/duplicate".format(self._prefix, theme.id), status=200)
+        resp = test_app.get(f"{self._prefix}/{theme.id}/duplicate", status=200)
         form = resp.form
 
         assert "" == self.get_first_field_named(form, "id").value
@@ -345,22 +349,25 @@ class TestTheme(TestTreeGroup):
         assert theme.public == form["public"].checked
 
         interfaces = theme_test_data["interfaces"]
-        assert set((interfaces[1].id, interfaces[3].id)) == set(i.id for i in theme.interfaces)
+        assert {interfaces[1].id, interfaces[3].id} == {i.id for i in theme.interfaces}
 
         self._check_interfaces(form, interfaces, theme)
 
         functionalities = theme_test_data["functionalities"]
-        assert set((functionalities[1].id, functionalities[4].id)) == set(f.id for f in theme.functionalities)
+        assert {functionalities[1].id} == {f.id for f in theme.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 theme.functionalities,
                 }
-                for f in sorted(functionalities, key=lambda f: (f.name, f.value))
+                for f in sorted(
+                    [f for f in functionalities if f.name in ("default_basemap")],
+                    key=lambda f: (f.name, f.value),
+                )
             ],
         )
 
@@ -381,7 +388,7 @@ class TestTheme(TestTreeGroup):
         duplicated = dbsession.query(Theme).filter(Theme.name == "duplicated").one()
 
         assert str(duplicated.id) == re.match(
-            r"http://localhost{}/(.*)\?msg_col=submit_ok".format(self._prefix), resp.location
+            rf"http://localhost{self._prefix}/(.*)\?msg_col=submit_ok", resp.location
         ).group(1)
         assert duplicated.id != theme.id
         assert duplicated.children_relation[0].id != theme.children_relation[0].id
@@ -391,13 +398,13 @@ class TestTheme(TestTreeGroup):
         from c2cgeoportal_commons.models.main import Theme
 
         theme_id = dbsession.query(Theme.id).first().id
-        test_app.delete("/admin/themes/{}".format(theme_id), status=200)
+        test_app.delete(f"/admin/themes/{theme_id}", status=200)
         assert dbsession.query(Theme).get(theme_id) is None
 
     def test_unicity_validator(self, theme_test_data, test_app):
         theme = theme_test_data["themes"][1]
-        resp = test_app.get("{}/{}/duplicate".format(self._prefix, theme.id), status=200)
+        resp = test_app.get(f"{self._prefix}/{theme.id}/duplicate", status=200)
 
         resp = resp.form.submit("submit")
 
-        self._check_submission_problem(resp, "{} is already used.".format(theme.name))
+        self._check_submission_problem(resp, f"{theme.name} is already used.")

tests/test_themes_ordering.py

@@ -14,7 +14,7 @@ def theme_test_data(dbsession, transact):
 
     themes = []
     for i in range(0, 3):
-        theme = Theme(name="theme_{}".format(i), ordering=i, icon="icon_{}".format(i))
+        theme = Theme(name=f"theme_{i}", ordering=i, icon=f"icon_{i}")
 
         dbsession.add(theme)
         themes.append(theme)

tests/test_treegroup.py

@@ -5,10 +5,10 @@ from . import AbstractViewsTests
 
 class TestTreeGroup(AbstractViewsTests):
     def check_children(self, form, group, expected):
-        form_group = form.html.select_one(".item-{}".format(group))
+        form_group = form.html.select_one(f".item-{group}")
         items = form_group.select(".deform-seq-item")
         assert len(expected) == len(items)
         for item, exp in zip(items, expected):
             assert exp["label"] == item.select_one(".well").getText().strip()
             for key, value in exp["values"].items():
-                assert value == item.select_one('input[name="{}"]'.format(key))["value"]
+                assert value == item.select_one(f'input[name="{key}"]')["value"]