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

tests/test_metadatas.py

@@ -85,7 +85,9 @@ class TestMetadatasView(AbstractViewsTests):
             return None
         return metadata.value
 
-    def _check_metadatas(self, test_app, item, metadatas):
+    def _check_metadatas(self, test_app, item, metadatas, model):
+        from c2cgeoportal_admin.schemas.metadata import metadata_definitions
+
         settings = test_app.app.registry.settings
         self._check_sequence(
             item,
@@ -96,9 +98,7 @@ class TestMetadatasView(AbstractViewsTests):
                         "name": "name",
                         "value": [
                             {"text": s_m["name"], "value": s_m["name"], "selected": s_m["name"] == m.name}
-                            for s_m in sorted(
-                                settings["admin_interface"]["available_metadata"], key=lambda m: m["name"]
-                            )
+                            for s_m in sorted(metadata_definitions(settings, model), key=lambda m: m["name"])
                         ],
                         "label": "Name",
                     },
@@ -131,7 +131,7 @@ class TestMetadatasView(AbstractViewsTests):
         resp = self._post_metadata(test_app, url, base_mapping, name, value, 200)
         assert (
             error_msg
-            == resp.html.select_one(".item-{} .help-block".format(self.__metadata_ui_type(test_app, name)))
+            == resp.html.select_one(f".item-{self.__metadata_ui_type(test_app, name)} .help-block")
             .getText()
             .strip()
         )
@@ -156,12 +156,16 @@ class TestMetadatasView(AbstractViewsTests):
         )
 
     def test_get_true_boolean_metadata(self, metadatas_test_data, test_app):
-        metadatas_test_data["layer_wms"].get_metadatas("_boolean")[0].value = "true"
-        self._test_edit_treeitem("layers_wms", metadatas_test_data["layer_wms"], test_app)
+        from c2cgeoportal_commons.models.main import LayerWMS
+
+        metadatas_test_data["layer_wms"].get_metadata("_boolean")[0].value = "true"
+        self._test_edit_treeitem("layers_wms", metadatas_test_data["layer_wms"], test_app, LayerWMS)
 
     def test_get_false_boolean_metadata(self, metadatas_test_data, test_app):
-        metadatas_test_data["layer_wms"].get_metadatas("_boolean")[0].value = "false"
-        self._test_edit_treeitem("layers_wms", metadatas_test_data["layer_wms"], test_app)
+        from c2cgeoportal_commons.models.main import LayerWMS
+
+        metadatas_test_data["layer_wms"].get_metadata("_boolean")[0].value = "false"
+        self._test_edit_treeitem("layers_wms", metadatas_test_data["layer_wms"], test_app, LayerWMS)
 
     def test_post_true_boolean_metadata(self, test_app, metadatas_test_data, dbsession):
         from c2cgeoportal_commons.models.main import LayerWMS
@@ -175,7 +179,7 @@ class TestMetadatasView(AbstractViewsTests):
             302,
         )
         layer = dbsession.query(LayerWMS).filter(LayerWMS.name == "new_name").one()
-        assert layer.get_metadatas("_boolean")[0].value == "true"
+        assert layer.get_metadata("_boolean")[0].value == "true"
 
     def test_post_false_boolean_metadata(self, test_app, metadatas_test_data, dbsession):
         from c2cgeoportal_commons.models.main import LayerWMS
@@ -189,7 +193,7 @@ class TestMetadatasView(AbstractViewsTests):
             302,
         )
         layer = dbsession.query(LayerWMS).filter(LayerWMS.name == "new_name").one()
-        assert layer.get_metadatas("_boolean")[0].value == "false"
+        assert layer.get_metadata("_boolean")[0].value == "false"
 
     def test_valid_float_metadata(self, test_app, metadatas_test_data):
         self._post_metadata(
@@ -304,31 +308,41 @@ class TestMetadatasView(AbstractViewsTests):
             302,
         )
 
-    def _test_edit_treeitem(self, prefix, item, test_app):
-        resp = self.get(test_app, "{}/{}".format(prefix, item.id))
-        self._check_metadatas(test_app, resp.html.select_one(".item-metadatas"), item.metadatas)
+    def _test_edit_treeitem(self, prefix, item, test_app, model):
+        resp = self.get(test_app, f"{prefix}/{item.id}")
+        self._check_metadatas(test_app, resp.html.select_one(".item-metadatas"), item.metadatas, model)
         resp.form.submit("submit", status=302)
 
     def test_layer_wms_metadatas(self, metadatas_test_data, test_app):
-        self._test_edit_treeitem("layers_wms", metadatas_test_data["layer_wms"], test_app)
+        from c2cgeoportal_commons.models.main import LayerWMS
+
+        self._test_edit_treeitem("layers_wms", metadatas_test_data["layer_wms"], test_app, LayerWMS)
 
     def test_layer_wmts_metadatas(self, metadatas_test_data, test_app):
-        self._test_edit_treeitem("layers_wmts", metadatas_test_data["layer_wmts"], test_app)
+        from c2cgeoportal_commons.models.main import LayerWMTS
+
+        self._test_edit_treeitem("layers_wmts", metadatas_test_data["layer_wmts"], test_app, LayerWMTS)
 
     def test_theme_metadatas(self, metadatas_test_data, test_app):
-        self._test_edit_treeitem("themes", metadatas_test_data["theme"], test_app)
+        from c2cgeoportal_commons.models.main import Theme
+
+        self._test_edit_treeitem("themes", metadatas_test_data["theme"], test_app, Theme)
 
     def test_group_metadatas(self, metadatas_test_data, test_app):
-        self._test_edit_treeitem("layer_groups", metadatas_test_data["group"], test_app)
+        from c2cgeoportal_commons.models.main import LayerGroup
+
+        self._test_edit_treeitem("layer_groups", metadatas_test_data["group"], test_app, LayerGroup)
 
     def test_undefined_metadata(self, metadatas_test_data, test_app):
-        """Undefined metadata must be kept intact across submissions"""
+        """
+        Undefined metadata must be kept intact across submissions.
+        """
         from c2cgeoportal_commons.models.main import Metadata
 
         layer = metadatas_test_data["layer_wms"]
         layer.metadatas = [Metadata("_undefined", "This is an undefined metadata")]
 
-        resp = self.get(test_app, "layers_wms/{}".format(layer.id))
+        resp = self.get(test_app, f"layers_wms/{layer.id}")
         resp.form.submit("submit", status=302)
 
         metadata = layer.metadatas[0]

tests/test_oauth2_clients.py

@@ -117,7 +117,7 @@ class TestOAuth2Client(TestTreeGroup):
 
         oauth2_client_proto = oauth2_clients_test_data["oauth2_clients"][7]
 
-        resp = test_app.get("/admin/oauth2_clients/{}/duplicate".format(oauth2_client_proto.id), status=200)
+        resp = test_app.get(f"/admin/oauth2_clients/{oauth2_client_proto.id}/duplicate", status=200)
         form = resp.form
 
         assert "" == self.get_first_field_named(form, "id").value
@@ -137,16 +137,16 @@ class TestOAuth2Client(TestTreeGroup):
         from c2cgeoportal_commons.models.static import OAuth2Client
 
         oauth2_client_id = dbsession.query(OAuth2Client.id).first().id
-        test_app.delete("/admin/oauth2_clients/{}".format(oauth2_client_id), status=200)
+        test_app.delete(f"/admin/oauth2_clients/{oauth2_client_id}", status=200)
         assert dbsession.query(OAuth2Client).get(oauth2_client_id) is None
 
     def test_unicity_validator(self, oauth2_clients_test_data, test_app):
         oauth2_client_proto = oauth2_clients_test_data["oauth2_clients"][7]
-        resp = test_app.get("/admin/oauth2_clients/{}/duplicate".format(oauth2_client_proto.id), status=200)
+        resp = test_app.get(f"/admin/oauth2_clients/{oauth2_client_proto.id}/duplicate", status=200)
 
         resp = resp.form.submit("submit")
 
-        self._check_submission_problem(resp, "{} is already used.".format(oauth2_client_proto.client_id))
+        self._check_submission_problem(resp, f"{oauth2_client_proto.client_id} is already used.")
 
     @pytest.mark.usefixtures("raise_db_error_on_query")
     def test_grid_dberror(self, dbsession):

tests/test_ogc_servers.py

@@ -17,8 +17,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)
@@ -81,7 +81,7 @@ class TestOGCServer(AbstractViewsTests):
 
     def test_edit(self, test_app, ogc_server_test_data):
         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"]
@@ -95,14 +95,14 @@ class TestOGCServer(AbstractViewsTests):
 
         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)
+        test_app.delete(f"/admin/ogc_servers/{deleted_id}", status=200)
         assert dbsession.query(OGCServer).get(deleted_id) is None
 
     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")
@@ -115,16 +115,16 @@ 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")
 
@@ -135,7 +135,7 @@ 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")
 
@@ -146,10 +146,21 @@ class TestOGCServer(AbstractViewsTests):
     def test_synchronize_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-synchronize"].submit("submit")
 
         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 = form.submit("submit")
+
+        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)
@@ -113,16 +113,16 @@ 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]}
 
     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):
         restriction_area = restriction_area_test_data["restriction_areas"][0]
@@ -162,14 +162,14 @@ 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)}
 
     def test_delete(self, test_app, restriction_area_test_data, dbsession):
         from c2cgeoportal_commons.models.main import 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
 
     def test_duplicate(self, restriction_area_test_data, test_app, dbsession):
@@ -181,9 +181,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

@@ -19,17 +19,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 +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)
@@ -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,11 +147,12 @@ 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]}
 
     def test_edit(self, dbsession, test_app, roles_test_data):
         role = roles_test_data["roles"][10]
@@ -174,33 +176,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 +239,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 +270,15 @@ 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}
 
     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
@@ -298,16 +300,16 @@ class TestRole(TestTreeGroup):
         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):