Tests take into account new document CRUD interface

Author: jerome-white

backend/app/tests/crud/documents/test_delete.py

@@ -1,5 +1,6 @@
 import pytest
 from sqlmodel import Session, select
+from sqlalchemy.exc import NoResultFound
 
 from app.crud import DocumentCrud
 from app.models import Document
@@ -11,8 +12,8 @@ def document(db: Session):
     store = DocumentStore(db)
     document = store.put()
 
-    crud = DocumentCrud(db)
-    crud.delete(document.id, document.owner_id)
+    crud = DocumentCrud(db, document.owner_id)
+    crud.delete(document.id)
 
     statement = (
         select(Document)
@@ -29,3 +30,12 @@ def test_delete_marks_deleted(self, document: Document):
 
     def test_delete_follows_insert(self, document: Document):
         assert document.created_at <= document.deleted_at
+
+    def test_cannot_delete_others_documents(self, db: Session):
+        store = DocumentStore(db)
+        document = store.put()
+        other_owner_id = store.documents.index.peek()
+
+        crud = DocumentCrud(db, other_owner_id)
+        with pytest.raises(NoResultFound):
+            crud.delete(document.id)

backend/app/tests/crud/documents/test_read_many.py

@@ -3,14 +3,7 @@
 
 from app.crud import DocumentCrud
 
-from app.tests.utils.document import (
-    DocumentStore,
-    int_to_uuid,
-)
-
-@pytest.fixture
-def crud(db: Session):
-    return DocumentCrud(db)
+from app.tests.utils.document import DocumentStore, DocumentIndexGenerator
 
 @pytest.fixture
 def store(db: Session):
@@ -25,68 +18,76 @@ class TestDatabaseReadMany:
 
     def test_number_read_is_expected(
             self,
-            crud: DocumentCrud,
+            db: Session,
             store: DocumentStore,
     ):
-        docs = crud.read_many(store.owner)
+        crud = DocumentCrud(db, store.owner)
+        docs = crud.read_many()
         assert len(docs) == self._ndocs
 
     def test_deleted_docs_are_excluded(
             self,
-            crud: DocumentCrud,
+            db: Session,
             store: DocumentStore,
     ):
-        assert all(x.deleted_at is None for x in crud.read_many(store.owner))
+        crud = DocumentCrud(db, store.owner)
+        assert all(x.deleted_at is None for x in crud.read_many())
 
     def test_skip_is_respected(
             self,
-            crud: DocumentCrud,
+            db: Session,
             store: DocumentStore,
     ):
+        crud = DocumentCrud(db, store.owner)
         skip = self._ndocs // 2
-        doc_ids = set(x.id for x in crud.read_many(store.owner, skip=skip))
+        doc_ids = set(x.id for x in crud.read_many(skip=skip))
+        index = DocumentIndexGenerator(skip)
 
-        for i in range(skip, self._ndocs):
-            doc = int_to_uuid(i) # see DocumentMaker
+        for (_, doc) in zip(range(skip, self._ndocs), index):
             assert doc in doc_ids
 
     def test_zero_skip_includes_all(
             self,
-            crud: DocumentCrud,
+            db: Session,
             store: DocumentStore,
     ):
-        docs = crud.read_many(store.owner, skip=0)
+        crud = DocumentCrud(db, store.owner)
+        docs = crud.read_many(skip=0)
         assert len(docs) == self._ndocs
 
     def test_negative_skip_raises_exception(
             self,
-            crud: DocumentCrud,
+            db: Session,
             store: DocumentStore,
     ):
+        crud = DocumentCrud(db, store.owner)
         with pytest.raises(ValueError):
-            crud.read_many(store.owner, skip=-1)
+            crud.read_many(skip=-1)
 
     def test_limit_is_respected(
             self,
-            crud: DocumentCrud,
+            db: Session,
             store: DocumentStore,
     ):
+        crud = DocumentCrud(db, store.owner)
         limit = self._ndocs // 2
-        docs = crud.read_many(store.owner, limit=limit)
+        docs = crud.read_many(limit=limit)
 
         assert len(docs) == limit
 
     def test_zero_limit_includes_nothing(
             self,
-            crud: DocumentCrud,
+            db: Session,
             store: DocumentStore,
     ):
-        assert not crud.read_many(store.owner, limit=0)
+        crud = DocumentCrud(db, store.owner)
+        assert not crud.read_many(limit=0)
 
     def test_negative_limit_raises_exception(
             self,
-            crud: DocumentCrud,
+            db: Session,
             store: DocumentStore,
     ):
+        crud = DocumentCrud(db, store.owner)
         with pytest.raises(ValueError):
-            crud.read_many(store.owner, limit=-1)
+            crud.read_many(limit=-1)

backend/app/tests/crud/documents/test_read_one.py

@@ -14,14 +14,26 @@ class TestDatabaseReadOne:
     def test_can_select_valid_id(self, db: Session, store: DocumentStore):
         document = store.put()
 
-        crud = DocumentCrud(db)
+        crud = DocumentCrud(db, store.owner)
         result = crud.read_one(document.id)
 
         assert result.id == document.id
 
     def test_cannot_select_invalid_id(self, db: Session, store: DocumentStore):
-        document = next(store.maker)
+        document = next(store.documents)
 
-        crud = DocumentCrud(db)
+        crud = DocumentCrud(db, store.owner)
+        with pytest.raises(NoResultFound):
+            crud.read_one(document.id)
+
+    def test_cannot_read_others_documents(
+            self,
+            db: Session,
+            store: DocumentStore,
+    ):
+        document = store.put()
+        other = DocumentStore(db)
+
+        crud = DocumentCrud(db, other.owner)
         with pytest.raises(NoResultFound):
             crud.read_one(document.id)

backend/app/tests/crud/documents/test_update.py

@@ -8,36 +8,58 @@
 @pytest.fixture
 def documents(db: Session):
     store = DocumentStore(db)
-    return store.maker
-
-@pytest.fixture
-def crud(db: Session):
-    return DocumentCrud(db)
+    return store.documents
 
 class TestDatabaseUpdate:
-    def test_update_adds_one(
-            self,
-            crud: DocumentCrud,
-            documents: DocumentMaker,
-    ):
-        before = crud.read_many(documents.owner_id)
+    def test_update_adds_one(self, db: Session, documents: DocumentMaker):
+        crud = DocumentCrud(db, documents.owner_id)
+
+        before = crud.read_many()
         crud.update(next(documents))
-        after = crud.read_many(documents.owner_id)
+        after = crud.read_many()
 
         assert len(before) + 1 == len(after)
 
     def test_sequential_update_is_ordered(
             self,
-            crud: DocumentCrud,
+            db: Session,
             documents: DocumentMaker,
     ):
+        crud = DocumentCrud(db, documents.owner_id)
         (a, b) = (crud.update(y) for (_, y) in zip(range(2), documents))
+
         assert a.created_at <= b.created_at
 
     def test_insert_does_not_delete(
             self,
-            crud: DocumentCrud,
+            db: Session,
             documents: DocumentMaker,
     ):
+        crud = DocumentCrud(db, documents.owner_id)
         document = crud.update(next(documents))
+
         assert document.deleted_at is None
+
+    def test_update_sets_default_owner(
+            self,
+            db: Session,
+            documents: DocumentMaker,
+    ):
+        crud = DocumentCrud(db, documents.owner_id)
+        document = next(documents)
+        document.owner_id = None
+        result = crud.update(document)
+
+        assert result.owner_id == document.owner_id
+
+    def test_update_respects_owner(
+            self,
+            db: Session,
+            documents: DocumentMaker,
+    ):
+        document = next(documents)
+        document.owner_id = documents.index.peek()
+
+        crud = DocumentCrud(db, documents.owner_id)
+        with pytest.raises(PermissionError):
+            crud.update(document)