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

tests/test_interface.py

@@ -12,18 +12,18 @@ from . import AbstractViewsTests
 def interface_test_data(dbsession, transact):
     del transact
 
-    from c2cgeoportal_commons.models.main import Interface, Theme, OGCServer, LayerWMS
+    from c2cgeoportal_commons.models.main import Interface, LayerWMS, OGCServer, Theme
 
     themes = []
     for i in range(0, 5):
-        theme = Theme(name="theme_{}".format(i), ordering=1)
+        theme = Theme(name=f"theme_{i}", ordering=1)
         themes.append(theme)
 
-    servers = [OGCServer(name="server_{}".format(i)) for i in range(0, 4)]
+    servers = [OGCServer(name=f"server_{i}") for i in range(0, 4)]
 
     layers = []
     for i in range(0, 15):
-        layer = LayerWMS(name="layer_wms_{}".format(i))
+        layer = LayerWMS(name=f"layer_wms_{i}")
         layer.public = 1 == i % 2
         layer.ogc_server = servers[i % 4]
         dbsession.add(layer)
@@ -31,7 +31,7 @@ def interface_test_data(dbsession, transact):
 
     interfaces = []
     for i in range(0, 5):
-        interface = Interface(name="interface_{}".format(i), description="description_{}".format(i))
+        interface = Interface(name=f"interface_{i}", description=f"description_{i}")
         interface.themes = [themes[i % 2], themes[(i + 5) % 5]]
         interface.layers = [layers[i % 2], layers[(i + 4) % 5]]
 
@@ -45,7 +45,6 @@ def interface_test_data(dbsession, transact):
 
 @pytest.mark.usefixtures("interface_test_data", "test_app")
 class TestInterface(AbstractViewsTests):
-
     _prefix = "/admin/interfaces"
 
     def test_index_rendering(self, test_app):
@@ -82,7 +81,7 @@ class TestInterface(AbstractViewsTests):
         self.check_search(test_app, "interface_0", total=1)
 
     def test_submit_new(self, dbsession, test_app):
-        from c2cgeoportal_commons.models.main import Interface
+        from c2cgeoportal_commons.models.main import Interface, Log, LogAction
 
         resp = test_app.post(
             "/admin/interfaces/new", {"name": "new_name", "description": "new description"}, status=302
@@ -94,14 +93,22 @@ class TestInterface(AbstractViewsTests):
         ).group(1)
         assert interface.name == "new_name"
 
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.INSERT
+        assert log.element_type == "interface"
+        assert log.element_id == interface.id
+        assert log.element_name == interface.name
+        assert log.username == "test_user"
+
     def test_edit(self, test_app, interface_test_data, dbsession):
-        from c2cgeoportal_commons.models.main import Interface
+        from c2cgeoportal_commons.models.main import Interface, Log, LogAction
 
         interface = interface_test_data["interfaces"][0]
         descriptions = "{}, {}".format(
             interface_test_data["interfaces"][0].description, interface_test_data["interfaces"][1].description
         )
-        resp = test_app.get("/admin/interfaces/{}".format(interface.id), status=200)
+        resp = test_app.get(f"/admin/interfaces/{interface.id}", status=200)
         form = resp.form
         form["description"] = descriptions
         assert str(interface.id) == self.get_first_field_named(form, "id").value
@@ -110,16 +117,32 @@ class TestInterface(AbstractViewsTests):
         assert form.submit().status_int == 302
         assert len(dbsession.query(Interface).filter(Interface.description == descriptions).all()) == 1
 
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.UPDATE
+        assert log.element_type == "interface"
+        assert log.element_id == interface.id
+        assert log.element_name == interface.name
+        assert log.username == "test_user"
+
     def test_delete(self, test_app, interface_test_data, dbsession):
-        from c2cgeoportal_commons.models.main import Interface
+        from c2cgeoportal_commons.models.main import Interface, Log, LogAction
 
         interface = interface_test_data["interfaces"][0]
-        test_app.delete("/admin/interfaces/{}".format(interface.id), status=200)
+        test_app.delete(f"/admin/interfaces/{interface.id}", status=200)
         assert len(dbsession.query(Interface).filter(Interface.id == interface.id).all()) == 0
 
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.DELETE
+        assert log.element_type == "interface"
+        assert log.element_id == interface.id
+        assert log.element_name == interface.name
+        assert log.username == "test_user"
+
     def test_duplicate(self, interface_test_data, test_app):
         interface = interface_test_data["interfaces"][3]
-        resp = test_app.get("/admin/interfaces/{}/duplicate".format(interface.id), status=200)
+        resp = test_app.get(f"/admin/interfaces/{interface.id}/duplicate", status=200)
         form = resp.form
         assert "" == self.get_first_field_named(form, "id").value
         assert str(interface.description or "") == "description_3"

tests/test_layer_groups.py

@@ -12,7 +12,7 @@ from .test_treegroup import TestTreeGroup
 def layer_groups_test_data(dbsession, transact):
     del transact
 
-    from c2cgeoportal_commons.models.main import LayerGroup, Metadata, LayergroupTreeitem
+    from c2cgeoportal_commons.models.main import LayerGroup, LayergroupTreeitem, Metadata
 
     metadatas_protos = [
         ("copyable", "true"),
@@ -22,7 +22,7 @@ def layer_groups_test_data(dbsession, transact):
 
     groups = []
     for i in range(0, 12):
-        group = LayerGroup(name="groups_{num:02d}".format(num=i), is_expanded=False)
+        group = LayerGroup(name=f"groups_{i:02d}")
         group.metadatas = [
             Metadata(name=metadatas_protos[id][0], value=metadatas_protos[id][1])
             for id in [i % 3, (i + 2) % 3]
@@ -60,7 +60,6 @@ def layer_groups_test_data(dbsession, transact):
 
 @pytest.mark.usefixtures("layer_groups_test_data", "test_app")
 class TestLayersGroups(TestTreeGroup):
-
     _prefix = "/admin/layer_groups"
 
     def test_index_rendering(self, test_app):
@@ -73,7 +72,6 @@ class TestLayersGroups(TestTreeGroup):
             ("id", "id", "true"),
             ("name", "Name"),
             ("description", "Description"),
-            ("is_expanded", "Expanded"),
             ("parents_relation", "Parents", "false"),
             ("metadatas", "Metadatas", "false"),
         ]
@@ -90,15 +88,13 @@ class TestLayersGroups(TestTreeGroup):
         assert "groups_02, groups_06" == row["parents_relation"]
         assert "disclaimer: © le momo, copyable: true" == row["metadatas"]
 
-    @pytest.mark.skip(reason="use value to be defined")
-    def test_grid_filter_on_parents(self, test_app):
-        self.check_search(test_app, "groups_11", total=4)
-
     def test_grid_search(self, test_app):
         # search on metadatas
         self.check_search(test_app, "copyable", total=8)
 
     def test_edit(self, test_app, layer_groups_test_data, dbsession):
+        from c2cgeoportal_commons.models.main import Log, LogAction
+
         group = layer_groups_test_data["groups"][1]
 
         form = self.get_item(test_app, group.id).form
@@ -107,8 +103,6 @@ class TestLayersGroups(TestTreeGroup):
         assert "hidden" == self.get_first_field_named(form, "id").attrs["type"]
         assert group.name == self.get_first_field_named(form, "name").value
         assert str(group.description or "") == self.get_first_field_named(form, "description").value
-        assert group.is_expanded is False
-        assert group.is_expanded == form["is_expanded"].checked
 
         self.check_children(
             form,
@@ -125,7 +119,6 @@ class TestLayersGroups(TestTreeGroup):
         new_values = {
             "name": "new_name",
             "description": "new description",
-            "is_expanded": True,
         }
         for key, value in new_values.items():
             self.set_first_field_named(form, key, value)
@@ -142,13 +135,21 @@ class TestLayersGroups(TestTreeGroup):
             else:
                 assert str(value or "") == str(getattr(group, key) or "")
 
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.UPDATE
+        assert log.element_type == "layergroup"
+        assert log.element_id == group.id
+        assert log.element_name == group.name
+        assert log.username == "test_user"
+
     def test_post_new_with_children_invalid(self, test_app, layer_groups_test_data):
         """
         Check there is no rendering error when validation fails.
         """
         groups = layer_groups_test_data["groups"]
         resp = test_app.post(
-            "{}/new".format(self._prefix),
+            f"{self._prefix}/new",
             (
                 ("_charset_", "UTF-8"),
                 ("__formid__", "deform"),
@@ -167,9 +168,11 @@ class TestLayersGroups(TestTreeGroup):
         assert "Required" == resp.html.select_one(".item-name .help-block").getText().strip()
 
     def test_post_new_with_children_success(self, test_app, dbsession, layer_groups_test_data):
+        from c2cgeoportal_commons.models.main import Log, LogAction
+
         groups = layer_groups_test_data["groups"]
         resp = test_app.post(
-            "{}/new".format(self._prefix),
+            f"{self._prefix}/new",
             (
                 ("_charset_", "UTF-8"),
                 ("__formid__", "deform"),
@@ -210,11 +213,21 @@ class TestLayersGroups(TestTreeGroup):
             rel.treeitem_id for rel in group.children_relation
         ]
 
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.INSERT
+        assert log.element_type == "layergroup"
+        assert log.element_id == group.id
+        assert log.element_name == group.name
+        assert log.username == "test_user"
+
     def test_post_with_ancestor(self, layer_groups_test_data, test_app):
-        """Check that ancestors are refused to avoid cycles"""
+        """
+        Check that ancestors are refused to avoid cycles.
+        """
         groups = layer_groups_test_data["groups"]
         resp = test_app.post(
-            "{}/{}".format(self._prefix, groups[3].id),
+            f"{self._prefix}/{groups[3].id}",
             (
                 ("_charset_", "UTF-8"),
                 ("__formid__", "deform"),
@@ -232,7 +245,7 @@ class TestLayersGroups(TestTreeGroup):
             status=200,
         )
         assert (
-            "Value {} does not exist in table treeitem or is not allowed to avoid cycles".format(groups[1].id)
+            f"Value {groups[1].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()
         )
 
@@ -241,7 +254,7 @@ class TestLayersGroups(TestTreeGroup):
 
         group = layer_groups_test_data["groups"][1]
 
-        resp = test_app.get("{}/{}/duplicate".format(self._prefix, group.id), status=200)
+        resp = test_app.get(f"{self._prefix}/{group.id}/duplicate", status=200)
         form = resp.form
 
         group = dbsession.query(LayerGroup).filter(LayerGroup.id == group.id).one()
@@ -249,8 +262,6 @@ class TestLayersGroups(TestTreeGroup):
         assert "" == self.get_first_field_named(form, "id").value
         assert group.name == self.get_first_field_named(form, "name").value
         assert str(group.description or "") == self.get_first_field_named(form, "description").value
-        assert group.is_expanded is False
-        assert group.is_expanded == form["is_expanded"].checked
 
         self.check_children(
             form,
@@ -267,7 +278,7 @@ class TestLayersGroups(TestTreeGroup):
         duplicated = dbsession.query(LayerGroup).filter(LayerGroup.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 != group.id
         assert duplicated.children_relation[0].id != group.children_relation[0].id
@@ -275,41 +286,56 @@ class TestLayersGroups(TestTreeGroup):
 
     def test_unicity_validator(self, layer_groups_test_data, test_app):
         group = layer_groups_test_data["groups"][1]
-        resp = test_app.get("{}/{}/duplicate".format(self._prefix, group.id), status=200)
+        resp = test_app.get(f"{self._prefix}/{group.id}/duplicate", status=200)
 
         resp = resp.form.submit("submit")
 
-        self._check_submission_problem(resp, "{} is already used.".format(group.name))
+        self._check_submission_problem(resp, f"{group.name} is already used.")
 
     def test_delete(self, test_app, dbsession, layer_groups_test_data):
-        from c2cgeoportal_commons.models.main import LayerGroup, TreeGroup, TreeItem, LayergroupTreeitem
+        from c2cgeoportal_commons.models.main import (
+            LayerGroup,
+            LayergroupTreeitem,
+            Log,
+            LogAction,
+            TreeGroup,
+            TreeItem,
+        )
 
-        group_id = layer_groups_test_data["groups"][9].id
+        group = layer_groups_test_data["groups"][9]
 
         assert (
             3
-            == dbsession.query(LayergroupTreeitem).filter(LayergroupTreeitem.treegroup_id == group_id).count()
+            == dbsession.query(LayergroupTreeitem).filter(LayergroupTreeitem.treegroup_id == group.id).count()
         )
 
         assert (
             1
-            == dbsession.query(LayergroupTreeitem).filter(LayergroupTreeitem.treeitem_id == group_id).count()
+            == dbsession.query(LayergroupTreeitem).filter(LayergroupTreeitem.treeitem_id == group.id).count()
         )
 
-        test_app.delete("/admin/layer_groups/{}".format(group_id), status=200)
+        test_app.delete(f"/admin/layer_groups/{group.id}", status=200)
 
         dbsession.expire_all()
 
-        assert dbsession.query(LayerGroup).get(group_id) is None
-        assert dbsession.query(TreeGroup).get(group_id) is None
-        assert dbsession.query(TreeItem).get(group_id) is None
+        assert dbsession.query(LayerGroup).get(group.id) is None
+        assert dbsession.query(TreeGroup).get(group.id) is None
+        assert dbsession.query(TreeItem).get(group.id) is None
 
         assert (
             0
-            == dbsession.query(LayergroupTreeitem).filter(LayergroupTreeitem.treegroup_id == group_id).count()
+            == dbsession.query(LayergroupTreeitem).filter(LayergroupTreeitem.treegroup_id == group.id).count()
         )
 
         assert (
             0
-            == dbsession.query(LayergroupTreeitem).filter(LayergroupTreeitem.treeitem_id == group_id).count()
+            == dbsession.query(LayergroupTreeitem).filter(LayergroupTreeitem.treeitem_id == group.id).count()
         )
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.DELETE
+        assert log.element_type == "layergroup"
+        assert log.element_id == group.id
+        assert log.element_name == group.name
+        assert log.username == "test_user"

tests/test_layers_cog.py

@@ -0,0 +1,243 @@
+# pylint: disable=no-self-use
+
+import re
+from typing import Any
+
+import pytest
+from sqlalchemy.orm import Session, SessionTransaction
+from webtest import TestApp as WebTestApp  # Avoid warning with pytest
+
+from . import AbstractViewsTests, factory_build_layers, get_test_default_layers
+
+
+@pytest.fixture(scope="function")
+@pytest.mark.usefixtures("dbsession", "transact")
+def layer_cog_test_data(dbsession: Session, transact: SessionTransaction) -> dict[str, Any]:
+    del transact
+
+    from c2cgeoportal_commons.models.main import LayerCOG
+
+    def layer_builder(i: int) -> LayerCOG:
+        name = f"layer_cog_{i}"
+        layer = LayerCOG(name=name)
+        layer.public = 1 == i % 2
+        layer.url = "https://example.com/image.tiff"
+        return layer
+
+    data = factory_build_layers(layer_builder, dbsession, add_dimension=False)
+    data["default"] = get_test_default_layers(dbsession, None)
+
+    dbsession.flush()
+
+    yield data
+
+
+@pytest.mark.usefixtures("layer_cog_test_data", "test_app")
+class TestLayerVectortiles(AbstractViewsTests):
+    _prefix = "/admin/layers_cog"
+
+    def test_index_rendering(self, test_app: WebTestApp) -> None:
+        resp = self.get(test_app)
+
+        self.check_left_menu(resp, "COG Layers")
+
+        expected = [
+            ("actions", "", "false"),
+            ("id", "id", "true"),
+            ("name", "Name"),
+            ("description", "Description"),
+            ("public", "Public"),
+            ("geo_table", "Geo table"),
+            ("exclude_properties", "Exclude properties"),
+            ("url", "URL"),
+            ("interfaces", "Interfaces"),
+            ("restrictionareas", "Restriction areas", "false"),
+            ("parents_relation", "Parents", "false"),
+            ("metadatas", "Metadatas", "false"),
+        ]
+        self.check_grid_headers(resp, expected)
+
+    def test_grid_complex_column_val(self, test_app: WebTestApp, layer_cog_test_data: dict[str, Any]) -> None:
+        json = self.check_search(test_app, search="layer", sort="name")
+
+        row = json["rows"][0]
+        layer = layer_cog_test_data["layers"][0]
+
+        assert layer.name == row["name"]
+        assert layer.id == int(row["_id_"])
+
+    def test_new(self, test_app: WebTestApp, layer_cog_test_data: dict[str, Any], dbsession: Session) -> None:
+        default_cog = layer_cog_test_data["default"]["cog"]
+        default_cog.name = "so can I not be found"
+        dbsession.flush()
+
+        form = self.get_item(test_app, "new").form
+
+        assert "" == self.get_first_field_named(form, "name").value
+        assert "" == self.get_first_field_named(form, "id").value
+        assert "" == self.get_first_field_named(form, "url").value
+
+    def test_grid_search(self, test_app: WebTestApp) -> None:
+        self.check_search(test_app, "layer_cog_10", total=1)
+
+    def test_base_edit(self, test_app: WebTestApp, layer_cog_test_data: dict[str, Any]) -> None:
+        layer = layer_cog_test_data["layers"][10]
+
+        form = self.get_item(test_app, layer.id).form
+
+        assert "layer_cog_10" == self.get_first_field_named(form, "name").value
+        assert "" == self.get_first_field_named(form, "description").value
+
+    def test_public_checkbox_edit(self, test_app: WebTestApp, layer_cog_test_data: dict[str, Any]) -> None:
+        layer = layer_cog_test_data["layers"][10]
+        form = self.get_item(test_app, layer.id).form
+        assert not form["public"].checked
+
+        layer = layer_cog_test_data["layers"][11]
+        form = self.get_item(test_app, layer.id).form
+        assert form["public"].checked
+
+    def test_edit(
+        self, test_app: WebTestApp, layer_cog_test_data: dict[str, Any], dbsession: Session
+    ) -> None:
+        from c2cgeoportal_commons.models.main import Log, LogAction
+
+        layer = layer_cog_test_data["layers"][0]
+
+        form = self.get_item(test_app, layer.id).form
+
+        assert str(layer.id) == self.get_first_field_named(form, "id").value
+        assert "hidden" == self.get_first_field_named(form, "id").attrs["type"]
+        assert layer.name == self.get_first_field_named(form, "name").value
+        assert str(layer.description or "") == self.get_first_field_named(form, "description").value
+        assert layer.public is False
+        assert layer.public == form["public"].checked
+        assert str(layer.geo_table or "") == form["geo_table"].value
+        assert str(layer.exclude_properties or "") == form["exclude_properties"].value
+        # assert str(layer.url or "") == form["url"].value
+
+        interfaces = layer_cog_test_data["interfaces"]
+        assert {interfaces[0].id, interfaces[2].id} == {i.id for i in layer.interfaces}
+        self._check_interfaces(form, interfaces, layer)
+
+        ras = layer_cog_test_data["restrictionareas"]
+        assert {ras[0].id, ras[2].id} == {i.id for i in layer.restrictionareas}
+        self._check_restrictionsareas(form, ras, layer)
+
+        new_values = {
+            "name": "new_name",
+            "description": "new description",
+            "public": True,
+            "geo_table": "new_geo_table",
+            "exclude_properties": "property1,property2",
+            "url": "https://example.com/image.tiff",
+        }
+
+        for key, value in new_values.items():
+            self.set_first_field_named(form, key, value)
+        form["interfaces"] = [interfaces[1].id, interfaces[3].id]
+        form["restrictionareas"] = [ras[1].id, ras[3].id]
+
+        resp = form.submit("submit")
+        assert str(layer.id) == re.match(
+            rf"http://localhost{self._prefix}/(.*)\?msg_col=submit_ok", resp.location
+        ).group(1)
+
+        dbsession.expire(layer)
+        for key, value in new_values.items():
+            if isinstance(value, bool):
+                assert value == getattr(layer, key)
+            else:
+                assert str(value or "") == str(getattr(layer, key) or "")
+        assert {interfaces[1].id, interfaces[3].id} == {interface.id for interface in layer.interfaces}
+        assert {ras[1].id, ras[3].id} == {ra.id for ra in layer.restrictionareas}
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.UPDATE
+        assert log.element_type == "layer_cog"
+        assert log.element_id == layer.id
+        assert log.element_name == layer.name
+        assert log.username == "test_user"
+
+    def test_submit_new(
+        self, dbsession: Session, test_app: WebTestApp, layer_cog_test_data: dict[str, Any]
+    ) -> None:
+        from c2cgeoportal_commons.models.main import LayerCOG, Log, LogAction
+
+        resp = test_app.post(
+            "/admin/layers_cog/new",
+            {
+                "name": "new_name",
+                "description": "new description",
+                "public": True,
+                "url": "https://example.com/image.tiff",
+            },
+            status=302,
+        )
+
+        layer = dbsession.query(LayerCOG).filter(LayerCOG.name == "new_name").one()
+        assert str(layer.id) == re.match(
+            r"http://localhost/admin/layers_cog/(.*)\?msg_col=submit_ok", resp.location
+        ).group(1)
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.INSERT
+        assert log.element_type == "layer_cog"
+        assert log.element_id == layer.id
+        assert log.element_name == layer.name
+        assert log.username == "test_user"
+
+    def test_duplicate(
+        self, layer_cog_test_data: dict[str, Any], test_app: WebTestApp, dbsession: Session
+    ) -> None:
+        from c2cgeoportal_commons.models.main import LayerCOG
+
+        layer = layer_cog_test_data["layers"][3]
+
+        resp = test_app.get(f"/admin/layers_cog/{layer.id}/duplicate", status=200)
+        form = resp.form
+
+        assert "" == self.get_first_field_named(form, "id").value
+        assert layer.name == self.get_first_field_named(form, "name").value
+        assert str(layer.description or "") == self.get_first_field_named(form, "description").value
+        assert layer.public is True
+        assert layer.public == form["public"].checked
+        assert str(layer.geo_table or "") == form["geo_table"].value
+        assert str(layer.exclude_properties or "") == form["exclude_properties"].value
+        # assert str(layer.url or "") == form["url"].value
+        interfaces = layer_cog_test_data["interfaces"]
+        assert {interfaces[3].id, interfaces[1].id} == {i.id for i in layer.interfaces}
+        self._check_interfaces(form, interfaces, layer)
+
+        self.set_first_field_named(form, "name", "clone")
+        resp = form.submit("submit")
+
+        layer = dbsession.query(LayerCOG).filter(LayerCOG.name == "clone").one()
+        assert str(layer.id) == re.match(
+            r"http://localhost/admin/layers_cog/(.*)\?msg_col=submit_ok", resp.location
+        ).group(1)
+
+        assert layer.id == layer.metadatas[0].item_id
+        assert layer_cog_test_data["layers"][3].metadatas[0].name == layer.metadatas[0].name
+        assert layer_cog_test_data["layers"][3].metadatas[1].name == layer.metadatas[1].name
+
+    def test_delete(self, test_app: WebTestApp, dbsession: Session) -> None:
+        from c2cgeoportal_commons.models.main import Layer, LayerCOG, Log, LogAction, TreeItem
+
+        layer = dbsession.query(LayerCOG).first()
+
+        test_app.delete(f"/admin/layers_cog/{layer.id}", status=200)
+
+        assert dbsession.query(LayerCOG).get(layer.id) is None
+        assert dbsession.query(Layer).get(layer.id) is None
+        assert dbsession.query(TreeItem).get(layer.id) is None
+
+        log = dbsession.query(Log).one()
+        assert log.date != None
+        assert log.action == LogAction.DELETE
+        assert log.element_type == "layer_cog"
+        assert log.element_id == layer.id
+        assert log.element_name == layer.name
+        assert log.username == "test_user"