passed all tests written

birdxplorer/routers/data.py

@@ -6,12 +6,14 @@
 
 from ..models import (
     BaseModel,
+    LanguageIdentifier,
     Note,
     NoteId,
     ParticipantId,
     Post,
     PostId,
     Topic,
+    TopicId,
     TweetId,
     TwitterTimestamp,
     UserEnrollment,
@@ -66,28 +68,24 @@ def get_topics() -> TopicListResponse:
     @router.get("/notes", response_model=NoteListResponse)
     def get_notes(
         note_ids: Union[List[NoteId], None] = Query(default=None, alias="noteIds"),
-        created_at_from: Union[None, int] = Query(default=None, alias="createdAtFrom"),
-        created_at_to: Union[None, int] = Query(default=None, alias="createdAtTo"),
-        topic_ids: Union[List[str], None] = Query(default=None, alias="topicIds"),
+        created_at_from: Union[None, TwitterTimestamp] = Query(default=None, alias="createdAtFrom"),
+        created_at_to: Union[None, TwitterTimestamp] = Query(default=None, alias="createdAtTo"),
+        topic_ids: Union[List[TopicId], None] = Query(default=None, alias="topicIds"),
         post_ids: Union[List[TweetId], None] = Query(default=None, alias="postIds"),
-        language: Union[str, None] = Query(default=None),
+        language: Union[LanguageIdentifier, None] = Query(default=None),
     ) -> NoteListResponse:
-        filters = {}
-
-        if note_ids is not None:
-            filters["note_ids"] = note_ids
-        if created_at_from is not None:
-            filters["created_at_from"] = TwitterTimestamp.from_int(created_at_from)
-        if created_at_to is not None:
-            filters["created_at_to"] = TwitterTimestamp.from_int(created_at_to)
-        if topic_ids is not None:
-            filters["topic_ids"] = topic_ids
-        if post_ids is not None:
-            filters["post_ids"] = post_ids
-        if language is not None:
-            filters["language"] = language
-
-        return NoteListResponse(data=list(storage.get_notes(**filters)))
+        return NoteListResponse(
+            data=list(
+                storage.get_notes(
+                    note_ids=note_ids,
+                    created_at_from=created_at_from,
+                    created_at_to=created_at_to,
+                    topic_ids=topic_ids,
+                    post_ids=post_ids,
+                    language=language,
+                )
+            )
+        )
 
     @router.get("/posts", response_model=PostListResponse)
     def get_posts(

birdxplorer/storage.py

@@ -1,4 +1,4 @@
-from typing import Generator, List
+from typing import Generator, List, Union
 
 from psycopg2.extensions import AsIs, register_adapter
 from pydantic import AnyUrl, HttpUrl
@@ -149,7 +149,13 @@ def get_topics(self) -> Generator[TopicModel, None, None]:
                 )
 
     def get_notes(
-        self, note_ids=None, created_at_from=None, created_at_to=None, topic_ids=None, post_ids=None, language=None
+        self,
+        note_ids: Union[List[NoteId], None] = None,
+        created_at_from: Union[None, TwitterTimestamp] = None,
+        created_at_to: Union[None, TwitterTimestamp] = None,
+        topic_ids: Union[List[TopicId], None] = None,
+        post_ids: Union[List[TweetId], None] = None,
+        language: Union[LanguageIdentifier, None] = None,
     ) -> Generator[NoteModel, None, None]:
         with Session(self.engine) as sess:
             query = sess.query(NoteRecord)

tests/conftest.py

@@ -1,7 +1,7 @@
 import os
 import random
 from collections.abc import Generator
-from typing import List, Type
+from typing import List, Type, Union
 from unittest.mock import MagicMock, patch
 
 from dotenv import load_dotenv
@@ -18,11 +18,15 @@
 
 from birdxplorer.exceptions import UserEnrollmentNotFoundError
 from birdxplorer.models import (
+    LanguageIdentifier,
     Note,
+    NoteId,
     ParticipantId,
     Post,
     PostId,
     Topic,
+    TopicId,
+    TweetId,
     TwitterTimestamp,
     UserEnrollment,
     XUser,
@@ -133,7 +137,12 @@ def _get_topics() -> Generator[Topic, None, None]:
         yield from topic_samples
 
     def _get_notes(
-        note_ids=None, created_at_from=None, created_at_to=None, topic_ids=None, post_ids=None, language=None
+        note_ids: Union[List[NoteId], None] = None,
+        created_at_from: Union[None, TwitterTimestamp] = None,
+        created_at_to: Union[None, TwitterTimestamp] = None,
+        topic_ids: Union[List[TopicId], None] = None,
+        post_ids: Union[List[TweetId], None] = None,
+        language: Union[LanguageIdentifier, None] = None,
     ) -> Generator[Note, None, None]:
         for note in note_samples:
             if note_ids is not None and note.note_id not in note_ids:

tests/test_storage.py

@@ -2,7 +2,17 @@
 
 from sqlalchemy.engine import Engine
 
-from birdxplorer.models import Note, Post, PostId, Topic, TweetId, TwitterTimestamp
+from birdxplorer.models import (
+    LanguageIdentifier,
+    Note,
+    NoteId,
+    Post,
+    PostId,
+    Topic,
+    TopicId,
+    TweetId,
+    TwitterTimestamp,
+)
 from birdxplorer.storage import NoteRecord, PostRecord, Storage, TopicRecord
 
 
@@ -120,7 +130,7 @@ def test_get_notes_by_ids_empty(
     note_records_sample: List[NoteRecord],
 ) -> None:
     storage = Storage(engine=engine_for_test)
-    note_ids: List[int] = []
+    note_ids: List[NoteId] = []
     expected: List[Note] = []
     actual = list(storage.get_notes(note_ids=note_ids))
     assert expected == actual
@@ -170,7 +180,7 @@ def test_get_notes_by_topic_ids(
 ) -> None:
     storage = Storage(engine=engine_for_test)
     topics = note_samples[0].topics
-    topic_ids = [0]
+    topic_ids: List[TopicId] = [TopicId.from_int(0)]
     expected = sorted([note for note in note_samples if note.topics == topics], key=lambda note: note.note_id)
     actual = sorted(list(storage.get_notes(topic_ids=topic_ids)), key=lambda note: note.note_id)
     assert expected == actual
@@ -182,7 +192,7 @@ def test_get_notes_by_topic_ids_empty(
     note_records_sample: List[NoteRecord],
 ) -> None:
     storage = Storage(engine=engine_for_test)
-    topic_ids: List[int] = []
+    topic_ids: List[TopicId] = []
     expected: List[Note] = []
     actual = list(storage.get_notes(topic_ids=topic_ids))
     assert expected == actual
@@ -206,7 +216,7 @@ def test_get_notes_by_post_ids_empty(
     note_records_sample: List[NoteRecord],
 ) -> None:
     storage = Storage(engine=engine_for_test)
-    post_ids: List[int] = []
+    post_ids: List[TweetId] = []
     expected: List[Note] = []
     actual = list(storage.get_notes(post_ids=post_ids))
     assert expected == actual
@@ -218,19 +228,7 @@ def test_get_notes_by_language(
     note_records_sample: List[NoteRecord],
 ) -> None:
     storage = Storage(engine=engine_for_test)
-    language = "en"
+    language = LanguageIdentifier("en")
     expected = [note for note in note_samples if note.language == language]
     actual = list(storage.get_notes(language=language))
     assert expected == actual
-
-
-def test_get_notes_by_language_empty(
-    engine_for_test: Engine,
-    note_samples: List[Note],
-    note_records_sample: List[NoteRecord],
-) -> None:
-    storage = Storage(engine=engine_for_test)
-    language = ""
-    expected: List[Note] = []
-    actual = list(storage.get_notes(language=language))
-    assert expected == actual