All test_queries tests pass

app/ds.py

@@ -1051,13 +1051,13 @@ def playdates_get_last(track_id: int, limit: int = 5) -> str:
         )
 
 
-def playdates_update(track_id: int) -> None:
+def playdates_update(track_id: int, when: dt.datetime | None = None) -> None:
     """
     Update playdates for passed track
     """
 
     with db.Session() as session:
-        _ = Playdates(session, track_id)
+        _ = Playdates(session, track_id, when)
 
 
 def playdates_between_dates(

app/models.py

@@ -153,7 +153,7 @@ class NoteColours(dbtables.NoteColoursTable):
 
 class Playdates(dbtables.PlaydatesTable):
     def __init__(
-        self, session: Session, track_id: int, when: Optional[dt.datetime] = None
+        self, session: Session, track_id: int, when: dt.datetime | None = None
     ) -> None:
         """Record that track was played"""
 

tests/test_queries.py

@@ -10,12 +10,12 @@ import unittest
 # App imports
 from app.models import (
     db,
-    Playdates,
     Tracks,
 )
 from classes import (
     Filter,
 )
+import ds
 
 
 class MyTestCase(unittest.TestCase):
@@ -25,35 +25,34 @@ class MyTestCase(unittest.TestCase):
 
         db.create_all()
 
-        with db.Session() as session:
-            # Create some track entries
-            _ = Tracks(**dict(
-                session=session,
-                artist="a",
-                bitrate=0,
-                duration=100,
-                fade_at=0,
-                path="/alpha/bravo/charlie",
-                silence_at=0,
-                start_gap=0,
-                title="abc"
-            ))
-            track2 = Tracks(**dict(
-                session=session,
-                artist="a",
-                bitrate=0,
-                duration=100,
-                fade_at=0,
-                path="/xray/yankee/zulu",
-                silence_at=0,
-                start_gap=0,
-                title="xyz"
-            ))
-            track2_id = track2.id
-            # Add playdates
-            # Track 2 played just over a year ago
-            just_over_a_year_ago = dt.datetime.now() - dt.timedelta(days=367)
-            _ = Playdates(session, track2_id, when=just_over_a_year_ago)
+        # Create some track entries
+        track1_meta = dict(
+            artist="a",
+            bitrate=0,
+            duration=100,
+            fade_at=0,
+            path="/alpha/bravo/charlie",
+            silence_at=0,
+            start_gap=0,
+            title="abc"
+        )
+        _ = ds.track_create(track1_meta)
+        track2_meta = dict(
+            artist="a",
+            bitrate=0,
+            duration=100,
+            fade_at=0,
+            path="/xray/yankee/zulu",
+            silence_at=0,
+            start_gap=0,
+            title="xyz"
+            )
+        track2 = ds.track_create(track2_meta)
+
+        # Add playdates
+        # Track 2 played just over a year ago
+        just_over_a_year_ago = dt.datetime.now() - dt.timedelta(days=367)
+        ds.playdates_update(track2.track_id, when=just_over_a_year_ago)
 
     @classmethod
     def tearDownClass(cls):
@@ -76,55 +75,49 @@ class MyTestCase(unittest.TestCase):
 
         filter = Filter(path="alpha", last_played_comparator="never")
 
-        with db.Session() as session:
-            results = Tracks.get_filtered_tracks(session, filter)
-            assert len(results) == 1
-            assert 'alpha' in results[0].path
+        results = ds.tracks_filtered(filter)
+        assert len(results) == 1
+        assert 'alpha' in results[0].path
 
     def test_search_path_2(self):
         """Search for unplayed track that doesn't exist"""
 
         filter = Filter(path="xray", last_played_comparator="never")
 
-        with db.Session() as session:
-            results = Tracks.get_filtered_tracks(session, filter)
-            assert len(results) == 0
+        results = ds.tracks_filtered(filter)
+        assert len(results) == 0
 
     def test_played_over_a_year_ago(self):
         """Search for tracks played over a year ago"""
 
         filter = Filter(last_played_unit="years", last_played_number=1)
 
-        with db.Session() as session:
-            results = Tracks.get_filtered_tracks(session, filter)
-            assert len(results) == 1
-            assert 'zulu' in results[0].path
+        results = ds.tracks_filtered(filter)
+        assert len(results) == 1
+        assert 'zulu' in results[0].path
 
     def test_played_over_two_years_ago(self):
         """Search for tracks played over 2 years ago"""
 
         filter = Filter(last_played_unit="years", last_played_number=2)
 
-        with db.Session() as session:
-            results = Tracks.get_filtered_tracks(session, filter)
-            assert len(results) == 0
+        results = ds.tracks_filtered(filter)
+        assert len(results) == 0
 
     def test_never_played(self):
         """Search for tracks never played"""
 
         filter = Filter(last_played_comparator="never")
 
-        with db.Session() as session:
-            results = Tracks.get_filtered_tracks(session, filter)
-            assert len(results) == 1
-            assert 'alpha' in results[0].path
+        results = ds.tracks_filtered(filter)
+        assert len(results) == 1
+        assert 'alpha' in results[0].path
 
     def test_played_anytime(self):
         """Search for tracks played over a year ago"""
 
         filter = Filter(last_played_comparator="Any time")
 
-        with db.Session() as session:
-            results = Tracks.get_filtered_tracks(session, filter)
-            assert len(results) == 1
-            assert 'zulu' in results[0].path
+        results = ds.tracks_filtered(filter)
+        assert len(results) == 1
+        assert 'zulu' in results[0].path