Prevent orphaning nodes by deleting a non-empty container

tiled/_tests/test_writing.py

@@ -346,3 +346,31 @@ async def test_delete(tree):
             metadata={"date": datetime.now(), "array": numpy.array([1, 2, 3])},
             key="x",
         )
+
+
+@pytest.mark.asyncio
+async def test_delete_non_empty_node(tree):
+    with Context.from_app(build_app(tree)) as context:
+        client = from_context(context)
+        a = client.create_container("a")
+        b = a.create_container("b")
+        c = b.create_container("c")
+        d = c.create_container("d")
+
+        # Cannot delete non-empty nodes
+        assert "a" in client
+        with fail_with_status_code(409):
+            client.delete("a")
+        assert "b" in a
+        with fail_with_status_code(409):
+            a.delete("b")
+        assert "c" in b
+        with fail_with_status_code(409):
+            b.delete("c")
+        assert "d" in c
+        assert not list(d)  # leaf is empty
+        # Delete from the bottom up.
+        c.delete("d")
+        b.delete("c")
+        a.delete("b")
+        client.delete("a")

tiled/catalog/node.py

@@ -15,6 +15,7 @@
     Revision,
     SortingItem,
 )
+from ..utils import Conflicts
 from . import orm
 from .utils import safe_path
 
@@ -91,6 +92,14 @@ async def revisions(self, offset, limit):
 
     async def delete(self):
         async with self._context.session() as db:
+            is_child = orm.Node.ancestors == self.ancestors + [self.key]
+            num_children = (
+                await db.execute(select(func.count(orm.Node.key)).where(is_child))
+            ).scalar()
+            if num_children:
+                raise Conflicts(
+                    "Cannot delete container that is not empty. Delete contents first."
+                )
             for data_source in self.data_sources:
                 if data_source.management != Management.external:
                     # TODO Handle case where the same Asset is associated

tiled/client/__init__.py

@@ -1,3 +1,4 @@
+from ..utils import tree  # noqa: F401
 from .constructors import from_context, from_profile, from_uri  # noqa: F401
 from .container import ASCENDING, DESCENDING  # noqa: F401
 from .context import Context  # noqa: F401

tiled/server/app.py

@@ -25,7 +25,7 @@
 from ..media_type_registration import (
     compression_registry as default_compression_registry,
 )
-from ..utils import SHARE_TILED_PATH, UnsupportedQueryType
+from ..utils import SHARE_TILED_PATH, Conflicts, UnsupportedQueryType
 from ..validation_registration import validation_registry as default_validation_registry
 from . import schemas
 from .authentication import get_current_principal
@@ -271,8 +271,15 @@ async def index(
             async def tiled_ui_settings():
                 return ui_settings
 
+    @app.exception_handler(Conflicts)
+    async def conflicts_exception_handler(request: Request, exc: Conflicts):
+        message = exc.args[0]
+        return JSONResponse(status_code=409, content={"detail": message})
+
     @app.exception_handler(UnsupportedQueryType)
-    async def unicorn_exception_handler(request: Request, exc: UnsupportedQueryType):
+    async def unsupported_query_type_exception_handler(
+        request: Request, exc: UnsupportedQueryType
+    ):
         query_type = exc.args[0]
         return JSONResponse(
             status_code=400,

tiled/utils.py

@@ -545,6 +545,11 @@ class UnsupportedQueryType(TypeError):
     pass
 
 
+class Conflicts(Exception):
+    "Prompts the server to send 409 Conflicts with message"
+    pass
+
+
 # Arrow obtained an official MIME type 2021-06-23.
 # https://www.iana.org/assignments/media-types/application/vnd.apache.arrow.file
 APACHE_ARROW_FILE_MIME_TYPE = "application/vnd.apache.arrow.file"