All tests working

app/playlistmodel.py

@@ -155,7 +155,7 @@ class PlaylistModel(QAbstractTableModel):
         Add track to existing header row
         """
 
-        log.info(f"add_track_to_header({row_number=}, {track_id=}, {note=}")
+        log.debug(f"add_track_to_header({row_number=}, {track_id=}, {note=}")
 
         # Get existing row
         try:
@@ -909,7 +909,7 @@ class PlaylistModel(QAbstractTableModel):
         Move the playlist rows given to to_row and below of to_playlist.
         """
 
-        log.info(
+        log.debug(
             f"move_rows_between_playlists({from_rows=}, {to_row_number=}, {to_playlist_id=}"
         )
 
@@ -1139,7 +1139,7 @@ class PlaylistModel(QAbstractTableModel):
             return: [[20, 21], [17], [13], [9, 10], [7], [2, 3, 4, 5]]
         """
 
-        log.info(f"_reversed_contiguous_row_groups({row_numbers=} called")
+        log.debug(f"_reversed_contiguous_row_groups({row_numbers=} called")
 
         result: List[List[int]] = []
         temp: List[int] = []
@@ -1155,7 +1155,7 @@ class PlaylistModel(QAbstractTableModel):
             result.append(temp)
         result.reverse()
 
-        log.info(f"_reversed_contiguous_row_groups() returned: {result=}")
+        log.debug(f"_reversed_contiguous_row_groups() returned: {result=}")
         return result
 
     def rowCount(self, index: QModelIndex = QModelIndex()) -> int:
@@ -1168,7 +1168,7 @@ class PlaylistModel(QAbstractTableModel):
         Signal handler for when row ordering has changed
         """
 
-        log.info(f"row_order_changed({playlist_id=}) {self.playlist_id=}")
+        log.debug(f"row_order_changed({playlist_id=}) {self.playlist_id=}")
 
         # Only action if this is for us
         if playlist_id != self.playlist_id:

tests/test_helpers.py

@@ -1,5 +1,7 @@
 # Standard library imports
 import datetime as dt
+import shutil
+import tempfile
 import unittest
 
 # PyQt imports
@@ -14,6 +16,7 @@ from helpers import (
     get_relative_date,
     leading_silence,
     ms_to_mmss,
+    normalise_track,
 )
 
 
@@ -85,3 +88,14 @@ class TestMMHelpers(unittest.TestCase):
         assert ms_to_mmss(None) == "-"
         assert ms_to_mmss(59600) == "0:59"
         assert ms_to_mmss((5 * 60 * 1000) + 23000) == "5:23"
+
+    def test_normalise(self):
+        """Make copies to normalise to avoid corrupting source"""
+
+        _, mp3_temp_path = tempfile.mkstemp(suffix=".mp3")
+        shutil.copyfile("testdata/isa.mp3", mp3_temp_path)
+        normalise_track(mp3_temp_path)
+
+        _, flac_temp_path = tempfile.mkstemp(suffix=".flac")
+        shutil.copyfile("testdata/isa.flac", flac_temp_path)
+        normalise_track(flac_temp_path)

tests/test_models.py

@@ -35,8 +35,6 @@ class TestMMModels(unittest.TestCase):
             track1_path = "testdata/isa.mp3"
             metadata1 = helpers.get_file_metadata(track1_path)
             self.track1 = Tracks(session, **metadata1)
-            # Test repr
-            _ = str(self.track1)
 
             track2_path = "testdata/mom.mp3"
             metadata2 = helpers.get_file_metadata(track2_path)
@@ -45,6 +43,11 @@ class TestMMModels(unittest.TestCase):
     def tearDown(self):
         db.drop_all()
 
+    def test_track_repr(self):
+        with db.Session() as session:
+            session.add(self.track1)
+            _ =str(self.track1)
+
     def test_notecolours_get_colour(self):
         """Create a colour record and retrieve all colours"""
 

tests/test_playlistmodel.py

@@ -39,6 +39,7 @@ class TestMMMiscTracks(unittest.TestCase):
             "testdata/lovecats.mp3",
             "testdata/mom.mp3",
             "testdata/sitting.mp3",
+            "testdata/wrb.flac",
         ]
 
         db.create_all()
@@ -61,27 +62,80 @@ class TestMMMiscTracks(unittest.TestCase):
     def tearDown(self):
         db.drop_all()
 
-    def test_7_row_playlist(self):
+    def test_8_row_playlist(self):
         # Test auto-created playlist
 
-        assert self.model.rowCount() == 7
+        assert self.model.rowCount() == 8
-        assert max(self.model.playlist_rows.keys()) == 6
+        assert max(self.model.playlist_rows.keys()) == 7
         for row in range(self.model.rowCount()):
             assert row in self.model.playlist_rows
             assert self.model.playlist_rows[row].plr_rownum == row
 
+    def test_timing_one_track(self):
+        START_ROW = 0
+        END_ROW = 2
+
+        self.model.insert_row(proposed_row_number=START_ROW, note="start+")
+        self.model.insert_row(proposed_row_number=END_ROW, note="-")
+
+        prd = self.model.playlist_rows[START_ROW]
+        qv_value = self.model.display_role(START_ROW, playlistmodel.HEADER_NOTES_COLUMN, prd)
+        assert qv_value.value() == "start [1 tracks, 4:23 unplayed]"
+
+
+class TestMMMiscNoPlaylist(unittest.TestCase):
+
+    PLAYLIST_NAME = "tracks playlist"
+    test_tracks = [
+        "testdata/isa.mp3",
+        "testdata/isa_with_gap.mp3",
+        "testdata/loser.mp3",
+        "testdata/lovecats-10seconds.mp3",
+        "testdata/lovecats.mp3",
+        "testdata/mom.mp3",
+        "testdata/sitting.mp3",
+    ]
+
+    def setUp(self):
+        db.create_all()
+
+    def tearDown(self):
+        db.drop_all()
+
+    def test_insert_track_new_playlist(self):
+        # insert a track into a new playlist
+        with db.Session() as session:
+            playlist = Playlists(session, self.PLAYLIST_NAME)
+            # Create a model
+            model = playlistmodel.PlaylistModel(playlist.id)
+            # test repr
+            _ = str(model)
+
+            track_path = self.test_tracks[0]
+            metadata = get_file_metadata(track_path)
+            track = Tracks(session, **metadata)
+            model.insert_row(proposed_row_number=0, track_id=track.id)
+
+            prd = model.playlist_rows[model.rowCount() - 1]
+            # test repr
+            _ = str(prd)
+
+            assert (
+                model.edit_role(model.rowCount() - 1, playlistmodel.Col.TITLE.value, prd)
+                == metadata["title"]
+            )
 
 class TestMMMiscRowMove(unittest.TestCase):
-    def setUp(self):
+    PLAYLIST_NAME = "rowmove playlist"
-        PLAYLIST_NAME = "rowmove playlist"
+    ROWS_TO_CREATE = 11
-        ROWS_TO_CREATE = 11
 
+    def setUp(self):
         db.create_all()
 
         with db.Session() as session:
-            self.playlist = Playlists(session, PLAYLIST_NAME)
+            self.playlist = Playlists(session, self.PLAYLIST_NAME)
             self.model = playlistmodel.PlaylistModel(self.playlist.id)
-            for row in range(ROWS_TO_CREATE):
+            for row in range(self.ROWS_TO_CREATE):
                 self.model.insert_row(proposed_row_number=row, note=str(row))
 
         session.commit()
@@ -105,311 +159,230 @@ class TestMMMiscRowMove(unittest.TestCase):
             elif row == 5:
                 assert self.model.playlist_rows[row].note == str(3)
 
+    def test_move_rows_test3(self):
+        # move row 4 to row 3
+
+        self.model.move_rows([4], 3)
+
+        # Check we have all rows and plr_rownums are correct
+        for row in range(self.model.rowCount()):
+            assert row in self.model.playlist_rows
+            assert self.model.playlist_rows[row].plr_rownum == row
+            if row not in [3, 4]:
+                assert self.model.playlist_rows[row].note == str(row)
+            elif row == 3:
+                assert self.model.playlist_rows[row].note == str(4)
+            elif row == 4:
+                assert self.model.playlist_rows[row].note == str(3)
+
+    def test_move_rows_test4(self):
+        # move row 4 to row 2
+
+        self.model.move_rows([4], 2)
+
+        # Check we have all rows and plr_rownums are correct
+        for row in range(self.model.rowCount()):
+            assert row in self.model.playlist_rows
+            assert self.model.playlist_rows[row].plr_rownum == row
+            if row not in [2, 3, 4]:
+                assert self.model.playlist_rows[row].note == str(row)
+            elif row == 2:
+                assert self.model.playlist_rows[row].note == str(4)
+            elif row == 3:
+                assert self.model.playlist_rows[row].note == str(2)
+            elif row == 4:
+                assert self.model.playlist_rows[row].note == str(3)
+
+    def test_move_rows_test5(self):
+        # move rows [1, 4, 5, 10] → 8
+
+        self.model.move_rows([1, 4, 5, 10], 8)
+
+        # Check we have all rows and plr_rownums are correct
+        new_order = []
+        for row in range(self.model.rowCount()):
+            assert row in self.model.playlist_rows
+            assert self.model.playlist_rows[row].plr_rownum == row
+            new_order.append(int(self.model.playlist_rows[row].note))
+        assert new_order == [0, 2, 3, 6, 7, 8, 9, 1, 4, 5, 10]
+
+    def test_move_rows_test6(self):
+        # move rows [3, 6] → 5
+
+        self.model.move_rows([3, 6], 5)
+
+        # Check we have all rows and plr_rownums are correct
+        new_order = []
+        for row in range(self.model.rowCount()):
+            assert row in self.model.playlist_rows
+            assert self.model.playlist_rows[row].plr_rownum == row
+            new_order.append(int(self.model.playlist_rows[row].note))
+        assert new_order == [0, 1, 2, 4, 5, 3, 6, 7, 8, 9, 10]
+
+    def test_move_rows_test7(self):
+        # move rows [3, 5, 6] → 8
+
+        self.model.move_rows([3, 5, 6], 8)
+
+        # Check we have all rows and plr_rownums are correct
+        new_order = []
+        for row in range(self.model.rowCount()):
+            assert row in self.model.playlist_rows
+            assert self.model.playlist_rows[row].plr_rownum == row
+            new_order.append(int(self.model.playlist_rows[row].note))
+        assert new_order == [0, 1, 2, 4, 7, 8, 9, 10, 3, 5, 6]
+
+    def test_move_rows_test8(self):
+        # move rows [7, 8, 10] → 5
+
+        self.model.move_rows([7, 8, 10], 5)
+
+        # Check we have all rows and plr_rownums are correct
+        new_order = []
+        for row in range(self.model.rowCount()):
+            assert row in self.model.playlist_rows
+            assert self.model.playlist_rows[row].plr_rownum == row
+            new_order.append(int(self.model.playlist_rows[row].note))
+        assert new_order == [0, 1, 2, 3, 4, 7, 8, 10, 5, 6, 9]
+
+    def test_insert_header_row_end(self):
+        # insert header row at end of playlist
+
+        note_text = "test text"
+
+        assert self.model.rowCount() == self.ROWS_TO_CREATE
+        self.model.insert_row(proposed_row_number=None, note=note_text)
+        assert self.model.rowCount() == self.ROWS_TO_CREATE + 1
+        prd = self.model.playlist_rows[self.model.rowCount() - 1]
+        # Test against edit_role because display_role for headers is
+        # handled differently (sets up row span)
+        assert (
+            self.model.edit_role(
+                self.model.rowCount() - 1, playlistmodel.Col.NOTE.value, prd
+            )
+            == note_text
+        )
+
+    def test_insert_header_row_middle(self):
+        # insert header row in middle of playlist
+
+        note_text = "test text"
+        insert_row = 6
+
+        self.model.insert_row(proposed_row_number=insert_row, note=note_text)
+        assert self.model.rowCount() == self.ROWS_TO_CREATE + 1
+        prd = self.model.playlist_rows[insert_row]
+        # Test against edit_role because display_role for headers is
+        # handled differently (sets up row span)
+        assert (
+            self.model.edit_role(
+                self.model.rowCount() - 1, playlistmodel.Col.NOTE.value, prd
+            )
+            == note_text
+        )
+
+    def test_add_track_to_header(self):
+        note_text = "test text"
+        insert_row = 6
+
+        self.model.insert_row(proposed_row_number=insert_row, note=note_text)
+        assert self.model.rowCount() == self.ROWS_TO_CREATE + 1
+
+        prd = self.model.playlist_rows[1]
+        self.model.add_track_to_header(insert_row, prd.track_id)
+
+    def test_reverse_row_groups_one_row(self):
+
+        rows_to_move = [3]
+
+        result = self.model._reversed_contiguous_row_groups(rows_to_move)
+
+        assert len(result) == 1
+        assert result[0] == [3]
+
+    def test_reverse_row_groups_multiple_row(self):
+
+        rows_to_move = [2, 3, 4, 5, 7, 9, 10, 13, 17, 20, 21]
+
+        result = self.model._reversed_contiguous_row_groups(rows_to_move)
+
+        assert result == [[20, 21], [17], [13], [9, 10], [7], [2, 3, 4, 5]]
+
+    def test_move_one_row_between_playlists_to_end(self):
+        from_rows = [3]
+        to_row = self.ROWS_TO_CREATE
+        destination_playlist = "destination"
+
+        model_src = self.model
+        with db.Session() as session:
+            playlist_dst = Playlists(session, destination_playlist)
+            model_dst = playlistmodel.PlaylistModel(playlist_dst.id)
+            for row in range(self.ROWS_TO_CREATE):
+                model_dst.insert_row(proposed_row_number=row, note=str(row))
+
+        model_src.move_rows_between_playlists(from_rows, to_row, model_dst.playlist_id)
+        model_dst.refresh_data(session)
+
+        assert len(model_src.playlist_rows) == self.ROWS_TO_CREATE - len(from_rows)
+        assert len(model_dst.playlist_rows) == self.ROWS_TO_CREATE + len(from_rows)
+        assert sorted([a.plr_rownum for a in model_src.playlist_rows.values()]) == list(
+            range(len(model_src.playlist_rows))
+        )
+
+    def test_move_one_row_between_playlists_to_middle(self):
+        from_rows = [3]
+        to_row = 2
+        destination_playlist = "destination"
+
+        model_src = self.model
+        with db.Session() as session:
+            playlist_dst = Playlists(session, destination_playlist)
+            model_dst = playlistmodel.PlaylistModel(playlist_dst.id)
+            for row in range(self.ROWS_TO_CREATE):
+                model_dst.insert_row(proposed_row_number=row, note=str(row))
+
+        model_src.move_rows_between_playlists(from_rows, to_row, model_dst.playlist_id)
+        model_dst.refresh_data(session)
+
+        # Check the rows of the destination model
+        row_notes = []
+        for row_number in range(model_dst.rowCount()):
+            index = model_dst.index(
+                row_number, playlistmodel.Col.TITLE.value, QModelIndex()
+            )
+            row_notes.append(model_dst.data(index, Qt.ItemDataRole.EditRole).value())
+
+        assert len(model_src.playlist_rows) == self.ROWS_TO_CREATE - len(from_rows)
+        assert len(model_dst.playlist_rows) == self.ROWS_TO_CREATE + len(from_rows)
+        assert [int(a) for a in row_notes] == [0, 1, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    def test_move_multiple_rows_between_playlists_to_end(self):
+
+        from_rows = [1, 3, 4]
+        to_row = 2
+        destination_playlist = "destination"
+
+        model_src = self.model
+        with db.Session() as session:
+            playlist_dst = Playlists(session, destination_playlist)
+            model_dst = playlistmodel.PlaylistModel(playlist_dst.id)
+            for row in range(self.ROWS_TO_CREATE):
+                model_dst.insert_row(proposed_row_number=row, note=str(row))
+
+        model_src.move_rows_between_playlists(from_rows, to_row, model_dst.playlist_id)
+        model_dst.refresh_data(session)
+
+        # Check the rows of the destination model
+        row_notes = []
+        for row_number in range(model_dst.rowCount()):
+            index = model_dst.index(
+                row_number, playlistmodel.Col.TITLE.value, QModelIndex()
+            )
+            row_notes.append(model_dst.data(index, Qt.ItemDataRole.EditRole).value())
 
-# def test_move_rows_test3(monkeypatch, session):
+        assert len(model_src.playlist_rows) == self.ROWS_TO_CREATE - len(from_rows)
-#     # move row 4 to row 3
+        assert len(model_dst.playlist_rows) == self.ROWS_TO_CREATE + len(from_rows)
-
+        assert [int(a) for a in row_notes] == [0, 1, 3, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     model = create_model_with_playlist_rows(session, 11)
-#     model.move_rows([4], 3)
-
-#     # Check we have all rows and plr_rownums are correct
-#     for row in range(model.rowCount()):
-#         assert row in model.playlist_rows
-#         assert model.playlist_rows[row].plr_rownum == row
-#         if row not in [3, 4]:
-#             assert model.playlist_rows[row].note == str(row)
-#         elif row == 3:
-#             assert model.playlist_rows[row].note == str(4)
-#         elif row == 4:
-#             assert model.playlist_rows[row].note == str(3)
-
-
-# def test_move_rows_test4(monkeypatch, session):
-#     # move row 4 to row 2
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     model = create_model_with_playlist_rows(session, 11)
-#     model.move_rows([4], 2)
-
-#     # Check we have all rows and plr_rownums are correct
-#     for row in range(model.rowCount()):
-#         assert row in model.playlist_rows
-#         assert model.playlist_rows[row].plr_rownum == row
-#         if row not in [2, 3, 4]:
-#             assert model.playlist_rows[row].note == str(row)
-#         elif row == 2:
-#             assert model.playlist_rows[row].note == str(4)
-#         elif row == 3:
-#             assert model.playlist_rows[row].note == str(2)
-#         elif row == 4:
-#             assert model.playlist_rows[row].note == str(3)
-
-
-# def test_move_rows_test5(monkeypatch, session):
-#     # move rows [1, 4, 5, 10] → 8
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     model = create_model_with_playlist_rows(session, 11)
-#     model.move_rows([1, 4, 5, 10], 8)
-
-#     # Check we have all rows and plr_rownums are correct
-#     new_order = []
-#     for row in range(model.rowCount()):
-#         assert row in model.playlist_rows
-#         assert model.playlist_rows[row].plr_rownum == row
-#         new_order.append(int(model.playlist_rows[row].note))
-#     assert new_order == [0, 2, 3, 6, 7, 8, 9, 1, 4, 5, 10]
-
-
-# def test_move_rows_test6(monkeypatch, session):
-#     # move rows [3, 6] → 5
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     model = create_model_with_playlist_rows(session, 11)
-#     model.move_rows([3, 6], 5)
-
-#     # Check we have all rows and plr_rownums are correct
-#     new_order = []
-#     for row in range(model.rowCount()):
-#         assert row in model.playlist_rows
-#         assert model.playlist_rows[row].plr_rownum == row
-#         new_order.append(int(model.playlist_rows[row].note))
-#     assert new_order == [0, 1, 2, 4, 5, 3, 6, 7, 8, 9, 10]
-
-
-# def test_move_rows_test7(monkeypatch, session):
-#     # move rows [3, 5, 6] → 8
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     model = create_model_with_playlist_rows(session, 11)
-#     model.move_rows([3, 5, 6], 8)
-
-#     # Check we have all rows and plr_rownums are correct
-#     new_order = []
-#     for row in range(model.rowCount()):
-#         assert row in model.playlist_rows
-#         assert model.playlist_rows[row].plr_rownum == row
-#         new_order.append(int(model.playlist_rows[row].note))
-#     assert new_order == [0, 1, 2, 4, 7, 8, 9, 10, 3, 5, 6]
-
-
-# def test_move_rows_test8(monkeypatch, session):
-#     # move rows [7, 8, 10] → 5
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     model = create_model_with_playlist_rows(session, 11)
-#     model.move_rows([7, 8, 10], 5)
-
-#     # Check we have all rows and plr_rownums are correct
-#     new_order = []
-#     for row in range(model.rowCount()):
-#         assert row in model.playlist_rows
-#         assert model.playlist_rows[row].plr_rownum == row
-#         new_order.append(int(model.playlist_rows[row].note))
-#     assert new_order == [0, 1, 2, 3, 4, 7, 8, 10, 5, 6, 9]
-
-
-# def test_insert_header_row_end(monkeypatch, session):
-#     # insert header row at end of playlist
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-#     note_text = "test text"
-#     initial_row_count = 11
-
-#     model = create_model_with_playlist_rows(session, initial_row_count)
-#     model.insert_row(proposed_row_number=None, note=note_text)
-#     assert model.rowCount() == initial_row_count + 1
-#     prd = model.playlist_rows[model.rowCount() - 1]
-#     # Test against edit_role because display_role for headers is
-#     # handled differently (sets up row span)
-#     assert (
-#         model.edit_role(model.rowCount() - 1, playlistmodel.Col.NOTE.value, prd)
-#         == note_text
-#     )
-
-
-# def test_insert_header_row_middle(monkeypatch, session):
-#     # insert header row in middle of playlist
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-#     note_text = "test text"
-#     initial_row_count = 11
-#     insert_row = 6
-
-#     model = create_model_with_playlist_rows(session, initial_row_count)
-#     model.insert_row(proposed_row_number=insert_row, note=note_text)
-#     assert model.rowCount() == initial_row_count + 1
-#     prd = model.playlist_rows[insert_row]
-#     # Test against edit_role because display_role for headers is
-#     # handled differently (sets up row span)
-#     assert (
-#         model.edit_role(model.rowCount() - 1, playlistmodel.Col.NOTE.value, prd)
-#         == note_text
-#     )
-
-
-# def test_add_track_to_header(monkeypatch, session):
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-#     note_text = "test text"
-#     initial_row_count = 11
-#     insert_row = 6
-
-#     model = create_model_with_playlist_rows(session, initial_row_count)
-#     model.insert_row(proposed_row_number=insert_row, note=note_text)
-#     assert model.rowCount() == initial_row_count + 1
-
-#     prd = model.playlist_rows[1]
-#     model.add_track_to_header(insert_row, prd.track_id)
-
-
-# def test_create_model_with_tracks(monkeypatch, session):
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-#     model = create_model_with_tracks(session)
-#     assert len(model.playlist_rows) == len(self.test_tracks)
-
-
-# def test_timing_one_track(monkeypatch, session):
-#     START_ROW = 0
-#     END_ROW = 2
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-#     model = create_model_with_tracks(session)
-
-#     model.insert_row(proposed_row_number=START_ROW, note="start+")
-#     model.insert_row(proposed_row_number=END_ROW, note="-")
-
-#     prd = model.playlist_rows[START_ROW]
-#     qv_value = model.display_role(START_ROW, playlistmodel.HEADER_NOTES_COLUMN, prd)
-#     assert qv_value.value() == "start [1 tracks, 4:23 unplayed]"
-
-
-# def test_insert_track_new_playlist(monkeypatch, session):
-#     # insert a track into a new playlist
-
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     playlist = Playlists(session, "test playlist")
-#     # Create a model
-#     model = playlistmodel.PlaylistModel(playlist.id)
-
-#     track_path = self.test_tracks[0]
-#     metadata = get_file_metadata(track_path)
-#     track = Tracks(session, **metadata)
-#     model.insert_row(proposed_row_number=0, track_id=track.id)
-
-#     prd = model.playlist_rows[model.rowCount() - 1]
-#     assert (
-#         model.edit_role(model.rowCount() - 1, playlistmodel.Col.TITLE.value, prd)
-#         == metadata["title"]
-#     )
-
-
-# def test_reverse_row_groups_one_row(monkeypatch, session):
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     rows_to_move = [3]
-
-#     model_src = create_model_with_playlist_rows(session, 5, name="source")
-#     result = model_src._reversed_contiguous_row_groups(rows_to_move)
-
-#     assert len(result) == 1
-#     assert result[0] == [3]
-
-
-# def test_reverse_row_groups_multiple_row(monkeypatch, session):
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     rows_to_move = [2, 3, 4, 5, 7, 9, 10, 13, 17, 20, 21]
-
-#     model_src = create_model_with_playlist_rows(session, 5, name="source")
-#     result = model_src._reversed_contiguous_row_groups(rows_to_move)
-
-#     assert result == [[20, 21], [17], [13], [9, 10], [7], [2, 3, 4, 5]]
-
-
-# def test_move_one_row_between_playlists_to_end(monkeypatch, session):
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     create_rowcount = 5
-#     from_rows = [3]
-#     to_row = create_rowcount
-
-#     model_src = create_model_with_playlist_rows(session, create_rowcount, name="source")
-#     model_dst = create_model_with_playlist_rows(
-#         session, create_rowcount, name="destination"
-#     )
-
-#     model_src.move_rows_between_playlists(from_rows, to_row, model_dst.playlist_id)
-#     model_dst.refresh_data(session)
-
-#     assert len(model_src.playlist_rows) == create_rowcount - len(from_rows)
-#     assert len(model_dst.playlist_rows) == create_rowcount + len(from_rows)
-#     assert sorted([a.plr_rownum for a in model_src.playlist_rows.values()]) == list(
-#         range(len(model_src.playlist_rows))
-#     )
-
-
-# def test_move_one_row_between_playlists_to_middle(monkeypatch, session):
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     create_rowcount = 5
-#     from_rows = [3]
-#     to_row = 2
-
-#     model_src = create_model_with_playlist_rows(session, create_rowcount, name="source")
-#     model_dst = create_model_with_playlist_rows(
-#         session, create_rowcount, name="destination"
-#     )
-
-#     model_src.move_rows_between_playlists(from_rows, to_row, model_dst.playlist_id)
-#     model_dst.refresh_data(session)
-
-#     # Check the rows of the destination model
-#     row_notes = []
-#     for row_number in range(model_dst.rowCount()):
-#         index = model_dst.index(
-#             row_number, playlistmodel.Col.TITLE.value, QModelIndex()
-#         )
-#         row_notes.append(model_dst.data(index, Qt.ItemDataRole.EditRole).value())
-
-#     assert len(model_src.playlist_rows) == create_rowcount - len(from_rows)
-#     assert len(model_dst.playlist_rows) == create_rowcount + len(from_rows)
-#     assert [int(a) for a in row_notes] == [0, 1, 3, 2, 3, 4]
-
-
-# def test_move_multiple_rows_between_playlists_to_end(monkeypatch, session):
-#     monkeypatch.setattr(playlistmodel, "Session", session)
-
-#     create_rowcount = 5
-#     from_rows = [1, 3, 4]
-#     to_row = 2
-
-#     model_src = create_model_with_playlist_rows(session, create_rowcount, name="source")
-#     model_dst = create_model_with_playlist_rows(
-#         session, create_rowcount, name="destination"
-#     )
-
-#     model_src.move_rows_between_playlists(from_rows, to_row, model_dst.playlist_id)
-#     model_dst.refresh_data(session)
-
-#     # Check the rows of the destination model
-#     row_notes = []
-#     for row_number in range(model_dst.rowCount()):
-#         index = model_dst.index(
-#             row_number, playlistmodel.Col.TITLE.value, QModelIndex()
-#         )
-#         row_notes.append(model_dst.data(index, Qt.ItemDataRole.EditRole).value())
-
-#     assert len(model_src.playlist_rows) == create_rowcount - len(from_rows)
-#     assert len(model_dst.playlist_rows) == create_rowcount + len(from_rows)
-#     assert [int(a) for a in row_notes] == [0, 1, 3, 4, 1, 2, 3, 4]
 
 
 # # def test_edit_header(monkeypatch, session): # edit header row in middle of playlist