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

tests/test_metadatas.py

@@ -2,8 +2,7 @@
 
 import pytest
 
-from . import AbstractViewsTests, skip_if_ci
-from .selenium.page import IndexPage
+from . import AbstractViewsTests
 
 
 @pytest.fixture(scope="function")
@@ -11,7 +10,7 @@ from .selenium.page import IndexPage
 def metadatas_test_data(dbsession, transact):
     del transact
 
-    from c2cgeoportal_commons.models.main import LayerWMS, LayerWMTS, OGCServer, Metadata, Theme, LayerGroup
+    from c2cgeoportal_commons.models.main import LayerGroup, LayerWMS, LayerWMTS, Metadata, OGCServer, Theme
 
     ogc_server = OGCServer(name="ogc_server")
 
@@ -77,7 +76,18 @@ class TestMetadatasView(AbstractViewsTests):
             "string",
         )
 
-    def _check_metadatas(self, test_app, item, metadatas):
+    def expected_value(self, test_app, metadata):
+        if self.__metadata_ui_type(test_app, metadata.name) == "boolean":
+            if metadata.value == "true":
+                return True
+            if metadata.value == "false":
+                return False
+            return None
+        return metadata.value
+
+    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,
@@ -88,13 +98,14 @@ 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",
                     },
-                    {"name": self.__metadata_ui_type(test_app, m.name), "value": m.value},
+                    {
+                        "name": self.__metadata_ui_type(test_app, m.name),
+                        "value": self.expected_value(test_app, m),
+                    },
                     {"name": "description", "value": m.description, "label": "Description"},
                 ]
                 for m in metadatas
@@ -120,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()
         )
@@ -144,6 +155,46 @@ class TestMetadatasView(AbstractViewsTests):
             '"number" is not a number',
         )
 
+    def test_get_true_boolean_metadata(self, metadatas_test_data, 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):
+        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
+
+        self._post_metadata(
+            test_app,
+            "/admin/layers_wms/new",
+            self._base_metadata_params(metadatas_test_data),
+            "_boolean",
+            "true",
+            302,
+        )
+        layer = dbsession.query(LayerWMS).filter(LayerWMS.name == "new_name").one()
+        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
+
+        self._post_metadata(
+            test_app,
+            "/admin/layers_wms/new",
+            self._base_metadata_params(metadatas_test_data),
+            "_boolean",
+            "false",
+            302,
+        )
+        layer = dbsession.query(LayerWMS).filter(LayerWMS.name == "new_name").one()
+        assert layer.get_metadata("_boolean")[0].value == "false"
+
     def test_valid_float_metadata(self, test_app, metadatas_test_data):
         self._post_metadata(
             test_app,
@@ -257,85 +308,43 @@ 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 accross 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]
         assert metadata.name == "_undefined"
         assert metadata.value == "This is an undefined metadata"
-
-
-@skip_if_ci
-@pytest.mark.selenium
-@pytest.mark.usefixtures("selenium", "selenium_app", "metadatas_test_data")
-class TestMetadatasSelenium:
-    def test_hidden_type_validator_does_not_take_precedence_over_visible(
-        self, selenium, selenium_app, metadatas_test_data
-    ):
-        layer = metadatas_test_data["layer_wms"]
-        selenium.get(selenium_app + "/admin/layers_wms/{}".format(layer.id))
-        selenium.execute_script("window.scrollBy(0,3000)", "")
-        selenium.find_element_by_xpath(
-            """//div[contains(., "Metadatas")]
-            /following-sibling::div[@class="panel-footer"]/a[@href="#"]"""
-        ).click()
-        selenium.execute_script("window.scrollBy(0,3000)", "")
-        selenium.find_elements_by_xpath(
-            """//div[contains(., "Metadatas")]//label[contains(., "Name")]
-            /following-sibling::select/option[contains(.,"_int")]"""
-        )[9].click()
-        selenium.find_elements_by_xpath('//div[contains(., "Metadatas")]//input[@name="int"]')[9].send_keys(
-            "AAA"
-        )
-
-        selenium.find_element_by_id("deformformsubmit").click()
-
-        assert '"AAA" is not a number' == selenium.find_element_by_xpath('//p[@class="help-block"]').text
-
-        selenium.find_elements_by_xpath(
-            """//div[contains(., "Metadatas")]//label[contains(., "Name")]
-            /following-sibling::select/option[contains(.,"_color")]"""
-        )[9].click()
-        selenium.find_elements_by_xpath('//div[contains(., "Metadatas")]//input[@name="string"]')[
-            9
-        ].send_keys("BBB")
-
-        selenium.find_element_by_id("deformformsubmit").click()
-
-        assert (
-            "Expecting hex format for color, e.g. #007DCD"
-            == selenium.find_element_by_xpath('//p[@class="help-block"]').text
-        )
-
-        # have to check there are no side effects, especially that modifications held at template side
-        # don't trigger "are you sure you want to leave alert"
-        layer = metadatas_test_data["layer_wms"]
-        IndexPage(selenium)
-        selenium.get(selenium_app + "/admin/layers_wms/{}".format(layer.id))
-
-        selenium.find_element_by_xpath('//a[contains(@href, "roles")]').click()
-        assert selenium.current_url.endswith("/roles")

tests/test_oauth2_clients.py

@@ -0,0 +1,157 @@
+# pylint: disable=no-self-use,unsubscriptable-object
+
+import re
+from uuid import uuid4
+
+import pytest
+from pyramid.testing import DummyRequest
+
+from .test_treegroup import TestTreeGroup
+
+
+@pytest.fixture(scope="function")
+@pytest.mark.usefixtures("dbsession", "transact")
+def oauth2_clients_test_data(dbsession, transact):
+    del transact
+
+    from c2cgeoportal_commons.models.static import OAuth2Client
+
+    clients = []
+    for i in range(23):
+        client = OAuth2Client()
+        client.client_id = str(uuid4())
+        client.secret = "1234"
+        client.redirect_uri = "http://127.0.0.1:7070/"
+
+        dbsession.add(client)
+        clients.append(client)
+
+    dbsession.flush()
+
+    yield {
+        "oauth2_clients": clients,
+    }
+
+
+@pytest.mark.usefixtures("oauth2_clients_test_data", "test_app")
+class TestOAuth2Client(TestTreeGroup):
+
+    _prefix = "/admin/oauth2_clients"
+
+    def test_index_rendering(self, test_app):
+        resp = self.get(test_app)
+
+        self.check_left_menu(resp, "OAuth2 Clients")
+
+        expected = [
+            ("actions", "", "false"),
+            ("id", "id", "true"),
+            ("client_id", "Client ID"),
+            ("secret", "Secret"),
+            ("redirect_uri", "Redirect URI"),
+        ]
+        self.check_grid_headers(resp, expected)
+
+    def test_grid_search(self, test_app, oauth2_clients_test_data):
+        self.check_search(test_app, "", total=23)
+
+        client = oauth2_clients_test_data["oauth2_clients"][0]
+        self.check_search(test_app, client.client_id, total=1)
+
+    def test_submit_new(self, dbsession, test_app, oauth2_clients_test_data):
+        from c2cgeoportal_commons.models.static import OAuth2Client
+
+        resp = test_app.post(
+            "/admin/oauth2_clients/new",
+            (
+                ("_charset_", "UTF-8"),
+                ("__formid__", "deform"),
+                ("id", ""),
+                ("client_id", "qgis2"),
+                ("secret", "12345"),
+                ("redirect_uri", "http://127.0.0.1:7070/bis"),
+                ("formsubmit", "formsubmit"),
+            ),
+            status=302,
+        )
+
+        oauth2_client = dbsession.query(OAuth2Client).filter(OAuth2Client.client_id == "qgis2").one()
+        assert str(oauth2_client.id) == re.match(
+            r"http://localhost/admin/oauth2_clients/(.*)\?msg_col=submit_ok", resp.location
+        ).group(1)
+
+        assert oauth2_client.client_id == "qgis2"
+        assert oauth2_client.secret == "12345"
+        assert oauth2_client.redirect_uri == "http://127.0.0.1:7070/bis"
+
+    def test_edit_then_save(self, dbsession, test_app, oauth2_clients_test_data):
+        oauth2_client = oauth2_clients_test_data["oauth2_clients"][10]
+
+        dbsession.expire(oauth2_client)
+
+        form = self.get_item(test_app, oauth2_client.id).form
+
+        assert str(oauth2_client.id) == form["id"].value
+        assert oauth2_client.client_id == form["client_id"].value
+        assert oauth2_client.secret == form["secret"].value
+        assert oauth2_client.redirect_uri == form["redirect_uri"].value
+
+        form["client_id"] = "New client ID"
+        form["secret"] = "New secret"
+        form["redirect_uri"] = "New redirect URI"
+
+        resp = form.submit("submit")
+
+        assert str(oauth2_client.id) == re.match(
+            r"http://localhost/admin/oauth2_clients/(.*)\?msg_col=submit_ok", resp.location
+        ).group(1)
+
+        dbsession.expire(oauth2_client)
+
+        assert "New client ID" == oauth2_client.client_id
+        assert "New secret" == oauth2_client.secret
+        assert "New redirect URI" == oauth2_client.redirect_uri
+
+    def test_duplicate(self, oauth2_clients_test_data, test_app, dbsession):
+        from c2cgeoportal_commons.models.static import OAuth2Client
+
+        oauth2_client_proto = oauth2_clients_test_data["oauth2_clients"][7]
+
+        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
+        assert oauth2_client_proto.client_id == form["client_id"].value
+        assert oauth2_client_proto.secret == form["secret"].value
+        assert oauth2_client_proto.redirect_uri == form["redirect_uri"].value
+        form["client_id"].value = "clone"
+        resp = form.submit("submit")
+
+        oauth2_client = dbsession.query(OAuth2Client).filter(OAuth2Client.client_id == "clone").one()
+        assert str(oauth2_client.id) == re.match(
+            r"http://localhost/admin/oauth2_clients/(.*)\?msg_col=submit_ok", resp.location
+        ).group(1)
+        assert oauth2_client_proto.id != oauth2_client.id
+
+    def test_delete(self, test_app, dbsession):
+        from c2cgeoportal_commons.models.static import OAuth2Client
+
+        oauth2_client_id = dbsession.query(OAuth2Client.id).first().id
+        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(f"/admin/oauth2_clients/{oauth2_client_proto.id}/duplicate", status=200)
+
+        resp = resp.form.submit("submit")
+
+        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):
+        from c2cgeoportal_admin.views.oauth2_clients import OAuth2ClientViews
+
+        request = DummyRequest(dbsession=dbsession, params={"offset": 0, "limit": 10})
+        info = OAuth2ClientViews(request).grid()
+        assert info.status_int == 500, "Expected 500 status when db error"

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,8 +115,52 @@ 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(f"/admin/ogc_servers/{ogc_server.id}/synchronize", status=200)
+
+        resp = resp.forms["form-check"].submit("submit")
+
+        assert list(resp.html.find("div", class_="alert-success").stripped_strings) == [
+            "OGC Server has been successfully synchronized."
+        ]
+
+    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(f"/admin/ogc_servers/{ogc_server.id}/synchronize", status=200)
+
+        resp = resp.forms["form-dry-run"].submit("submit")
+
+        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):
+        ogc_server = ogc_server_test_data["ogc_servers"][3]
+        ogc_server.url = "config://mapserver"
+        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

@@ -4,39 +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"
 
@@ -59,31 +72,65 @@ 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):
+    def test_submit_new(self, dbsession, test_app, restriction_area_test_data):
         from c2cgeoportal_commons.models.main import 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]}
 
     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]
         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 +147,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,14 +162,14 @@ 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)}
 
     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):
@@ -123,12 +178,21 @@ class TestRestrictionAreaViews(AbstractViewsTests):
         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")