363 lines
15 KiB
Python
363 lines
15 KiB
Python
# Copyright 2023 (c) Anna Schumaker.
|
|
"""Test our Playlist Manager object."""
|
|
import io
|
|
import pathlib
|
|
import unittest.mock
|
|
import emmental.playlist
|
|
import tests.util
|
|
from gi.repository import GObject
|
|
|
|
|
|
@unittest.mock.patch("sys.stdout", new_callable=io.StringIO)
|
|
class TestFactory(tests.util.TestCase):
|
|
"""Test the Playlist Factory class."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.sql.playlists.load(now=True)
|
|
self.user_plist = self.sql.playlists.create("User Playlist")
|
|
self.factory = emmental.playlist.Factory(self.sql)
|
|
|
|
def test_init(self, mock_stdout: io.StringIO):
|
|
"""Check that the Playlist Factory is set up properly."""
|
|
self.assertIsInstance(self.factory, GObject.GObject)
|
|
self.assertEqual(self.factory.sql, self.sql)
|
|
|
|
def test_active(self, mock_stdout: io.StringIO):
|
|
"""Test the active playlist property."""
|
|
self.assertIsNone(self.factory.db_active)
|
|
|
|
self.sql.set_active_playlist(self.user_plist)
|
|
self.assertEqual(self.factory.db_active, self.user_plist)
|
|
self.assertRegex(mock_stdout.getvalue(),
|
|
"factory: active playlist is: User Playlist")
|
|
|
|
self.sql.set_active_playlist(None)
|
|
self.assertIsNone(self.factory.db_active)
|
|
self.assertRegex(mock_stdout.getvalue(), "active playlist is: <None>")
|
|
|
|
def test_active_playlist(self, mock_stdout: io.StringIO):
|
|
"""Test creating a Playlist when setting the dv_visible property."""
|
|
self.assertIsNone(self.factory.active_playlist)
|
|
|
|
self.factory.db_active = self.user_plist
|
|
self.assertIsInstance(self.factory.active_playlist,
|
|
emmental.playlist.playlist.Playlist)
|
|
self.assertEqual(self.factory.active_playlist.sql, self.sql)
|
|
self.assertEqual(self.factory.active_playlist.playlist,
|
|
self.user_plist)
|
|
|
|
orig_id = id(self.factory.active_playlist)
|
|
self.factory.db_active = self.sql.playlists.collection
|
|
self.assertEqual(id(self.factory.active_playlist), orig_id)
|
|
self.assertEqual(self.factory.active_playlist.playlist,
|
|
self.sql.playlists.collection)
|
|
|
|
active = self.factory.active_playlist
|
|
self.factory.db_active = None
|
|
self.assertIsNone(self.factory.active_playlist)
|
|
self.assertIsNone(active.playlist)
|
|
|
|
def test_active_visible_playlist(self, mock_stdout: io.StringIO):
|
|
"""Test setting the active playlist to the visible playlist."""
|
|
self.factory.db_visible = self.user_plist
|
|
self.factory.db_active = self.user_plist
|
|
self.assertEqual(id(self.factory.active_playlist),
|
|
id(self.factory.visible_playlist))
|
|
|
|
self.factory.db_active = self.user_plist
|
|
self.assertEqual(id(self.factory.active_playlist),
|
|
id(self.factory.visible_playlist))
|
|
|
|
self.factory.db_active = self.sql.playlists.collection
|
|
self.assertNotEqual(id(self.factory.active_playlist),
|
|
id(self.factory.visible_playlist))
|
|
|
|
active = self.factory.active_playlist
|
|
self.factory.db_active = self.user_plist
|
|
self.assertEqual(id(self.factory.active_playlist),
|
|
id(self.factory.visible_playlist))
|
|
self.assertIsNone(active.playlist)
|
|
|
|
active = self.factory.active_playlist
|
|
self.factory.db_active = None
|
|
self.assertEqual(active.playlist, self.user_plist)
|
|
self.assertIsNone(self.factory.active_playlist)
|
|
|
|
def test_active_loop(self, mock_stdout: io.StringIO):
|
|
"""Test changing the loop property of the active playlist."""
|
|
notify = unittest.mock.Mock()
|
|
self.factory.connect("notify::active-loop", notify)
|
|
|
|
self.assertEqual(self.factory.active_loop, "None")
|
|
self.factory.active_loop = "Playlist"
|
|
self.assertEqual(self.factory.active_loop, "None")
|
|
notify.assert_not_called()
|
|
|
|
self.factory.db_active = self.user_plist
|
|
self.assertEqual(self.factory.active_loop, "None")
|
|
notify.assert_called()
|
|
|
|
notify.reset_mock()
|
|
self.factory.active_loop = "Playlist"
|
|
self.assertEqual(self.user_plist.loop, "Playlist")
|
|
self.assertEqual(self.factory.active_loop, "Playlist")
|
|
notify.assert_called()
|
|
|
|
notify.reset_mock()
|
|
self.factory.active_loop = "Playlist"
|
|
notify.assert_not_called()
|
|
|
|
def test_active_shuffle(self, mock_stdout: io.StringIO):
|
|
"""Test changing the shuffle property of the active playlist."""
|
|
notify = unittest.mock.Mock()
|
|
self.factory.connect("notify::active-shuffle", notify)
|
|
|
|
self.assertFalse(self.factory.active_shuffle)
|
|
self.factory.active_shuffle = True
|
|
self.assertFalse(self.factory.active_shuffle)
|
|
notify.assert_not_called()
|
|
|
|
self.factory.db_active = self.user_plist
|
|
self.assertFalse(self.factory.active_shuffle)
|
|
notify.assert_called()
|
|
|
|
notify.reset_mock()
|
|
self.factory.active_shuffle = True
|
|
self.assertTrue(self.user_plist.shuffle)
|
|
self.assertTrue(self.factory.active_shuffle)
|
|
notify.assert_called()
|
|
|
|
notify.reset_mock()
|
|
self.factory.active_shuffle = True
|
|
notify.assert_not_called()
|
|
|
|
def test_previous(self, mock_stdout: io.StringIO):
|
|
"""Test the previous playlist property."""
|
|
self.assertIsNone(self.factory.db_previous)
|
|
|
|
self.factory.db_previous = self.sql.playlists.previous
|
|
self.assertEqual(self.factory.db_previous, self.sql.playlists.previous)
|
|
self.assertRegex(mock_stdout.getvalue(),
|
|
r"factory: previous playlist is: Previous Tracks")
|
|
|
|
self.factory.db_previous = None
|
|
self.assertRegex(mock_stdout.getvalue(),
|
|
"factory: previous playlist is: <None>")
|
|
|
|
def test_previous_playlist(self, mock_stdout: io.StringIO):
|
|
"""Test creating a Playlist when setting the db_previous property."""
|
|
self.assertIsNone(self.factory.previous_playlist)
|
|
|
|
self.factory.db_previous = self.sql.playlists.previous
|
|
self.assertIsInstance(self.factory.previous_playlist,
|
|
emmental.playlist.previous.Previous)
|
|
self.assertEqual(self.factory.previous_playlist.sql, self.sql)
|
|
self.assertEqual(self.factory.previous_playlist.playlist,
|
|
self.sql.playlists.previous)
|
|
|
|
previous = self.factory.previous_playlist
|
|
self.factory.db_previous = None
|
|
self.assertIsNone(self.factory.previous_playlist)
|
|
self.assertIsNone(previous.playlist)
|
|
|
|
def test_visible(self, mock_stdout: io.StringIO):
|
|
"""Test the visible playlist property."""
|
|
self.assertIsNone(self.factory.db_visible)
|
|
|
|
self.factory.db_visible = self.user_plist
|
|
self.assertEqual(self.factory.db_visible, self.user_plist)
|
|
self.assertRegex(mock_stdout.getvalue(),
|
|
"factory: visible playlist is: User Playlist")
|
|
|
|
self.factory.db_visible = None
|
|
self.assertRegex(mock_stdout.getvalue(),
|
|
"factory: visible playlist is: <None>")
|
|
|
|
def test_visible_playlist(self, mock_stdout: io.StringIO):
|
|
"""Test creating a Playlist when setting the db_visible property."""
|
|
self.assertIsNone(self.factory.visible_playlist)
|
|
|
|
self.factory.db_visible = self.user_plist
|
|
self.assertIsInstance(self.factory.visible_playlist,
|
|
emmental.playlist.playlist.Playlist)
|
|
self.assertEqual(self.factory.visible_playlist.sql, self.sql)
|
|
self.assertEqual(self.factory.visible_playlist.playlist,
|
|
self.user_plist)
|
|
|
|
orig_id = id(self.factory.visible_playlist)
|
|
self.factory.db_visible = self.sql.playlists.collection
|
|
self.assertEqual(id(self.factory.visible_playlist), orig_id)
|
|
self.assertEqual(self.factory.visible_playlist.playlist,
|
|
self.sql.playlists.collection)
|
|
|
|
visible = self.factory.visible_playlist
|
|
self.factory.db_visible = None
|
|
self.assertIsNone(self.factory.visible_playlist)
|
|
self.assertIsNone(visible.playlist)
|
|
|
|
def test_visible_active_playlist(self, mock_stdout: io.StringIO):
|
|
"""Test setting the visible playlist to the active playlist."""
|
|
self.factory.db_active = self.user_plist
|
|
self.factory.db_visible = self.user_plist
|
|
self.assertEqual(id(self.factory.visible_playlist),
|
|
id(self.factory.active_playlist))
|
|
|
|
self.factory.db_visible = self.user_plist
|
|
self.assertEqual(id(self.factory.visible_playlist),
|
|
id(self.factory.active_playlist))
|
|
|
|
self.factory.db_visible = self.sql.playlists.collection
|
|
self.assertNotEqual(id(self.factory.visible_playlist),
|
|
id(self.factory.active_playlist))
|
|
|
|
visible = self.factory.visible_playlist
|
|
self.factory.db_visible = self.user_plist
|
|
self.assertEqual(id(self.factory.visible_playlist),
|
|
id(self.factory.active_playlist))
|
|
self.assertIsNone(visible.playlist)
|
|
|
|
visible = self.factory.visible_playlist
|
|
self.factory.db_visible = None
|
|
self.assertEqual(visible.playlist, self.user_plist)
|
|
self.assertIsNone(self.factory.visible_playlist)
|
|
|
|
def test_visible_previous_playlist(self, mock_stdout: io.StringIO):
|
|
"""Test setting the visible playlist to the previous playlist."""
|
|
self.factory.db_previous = self.sql.playlists.previous
|
|
self.factory.db_visible = self.sql.playlists.previous
|
|
self.assertEqual(id(self.factory.visible_playlist),
|
|
id(self.factory.previous_playlist))
|
|
|
|
self.factory.db_visible = self.user_plist
|
|
self.assertNotEqual(id(self.factory.visible_playlist),
|
|
id(self.factory.previous_playlist))
|
|
|
|
|
|
@unittest.mock.patch("sys.stdout", new_callable=io.StringIO)
|
|
class TestFactoryNextPreviousTrack(tests.util.TestCase):
|
|
"""Test the Factory next_track() and previous_track() functions."""
|
|
|
|
def setUp(self):
|
|
"""Set up common variables."""
|
|
super().setUp()
|
|
self.sql.playlists.load(now=True)
|
|
self.user_plist = self.sql.playlists.create("User Playlist")
|
|
|
|
self.factory = emmental.playlist.Factory(self.sql)
|
|
|
|
self.library = self.sql.libraries.create(pathlib.Path("/a/b"))
|
|
self.album = self.sql.albums.create("Test Album", "Artist", "2023")
|
|
self.medium = self.sql.media.create(self.album, "", number=1)
|
|
self.year = self.sql.years.create(2023)
|
|
|
|
self.tracks = [self.sql.tracks.create(self.library,
|
|
pathlib.Path(f"/a/b/{i}.ogg"),
|
|
self.medium, self.year, number=i)
|
|
for i in range(1, 4)]
|
|
|
|
def test_can_go_next(self, mock_stdout: io.StringIO):
|
|
"""Test the can-go-next property."""
|
|
self.assertFalse(self.factory.can_go_next)
|
|
|
|
self.sql.playlists.have_collection_tracks = True
|
|
self.assertTrue(self.factory.can_go_next)
|
|
self.sql.playlists.have_collection_tracks = False
|
|
self.assertFalse(self.factory.can_go_next)
|
|
|
|
self.factory.db_active = self.user_plist
|
|
self.factory.active_playlist.can_go_next = True
|
|
self.assertTrue(self.factory.can_go_next)
|
|
self.factory.active_playlist.can_go_next = False
|
|
self.assertFalse(self.factory.can_go_next)
|
|
|
|
self.factory.db_previous = self.sql.playlists.previous
|
|
self.factory.previous_playlist.can_go_forward = True
|
|
self.assertTrue(self.factory.can_go_next)
|
|
self.factory.previous_playlist.can_go_forward = False
|
|
self.assertFalse(self.factory.can_go_next)
|
|
|
|
def test_can_go_previous(self, mock_stdout: io.StringIO):
|
|
"""Test the can-go-previous property."""
|
|
self.assertFalse(self.factory.can_go_previous)
|
|
|
|
self.factory.db_previous = self.sql.playlists.previous
|
|
self.assertFalse(self.factory.can_go_previous)
|
|
self.tracks[0].start()
|
|
self.assertFalse(self.factory.can_go_previous)
|
|
self.tracks[1].start()
|
|
self.assertTrue(self.factory.can_go_previous)
|
|
|
|
self.factory.db_previous = None
|
|
self.assertFalse(self.factory.can_go_previous)
|
|
self.tracks[2].start()
|
|
self.assertFalse(self.factory.can_go_previous)
|
|
|
|
def test_next_track(self, mock_stdout: io.StringIO):
|
|
"""Test the next_track() function."""
|
|
self.sql.set_active_playlist(None)
|
|
self.assertTupleEqual(self.factory.next_track(),
|
|
(None, "track", False))
|
|
self.assertEqual(self.sql.active_playlist,
|
|
self.sql.playlists.collection)
|
|
|
|
self.sql.set_active_playlist(self.user_plist)
|
|
self.user_plist.add_track(self.tracks[0])
|
|
self.user_plist.add_track(self.tracks[1])
|
|
self.assertTupleEqual(self.factory.next_track(),
|
|
(self.tracks[0], "track", False))
|
|
self.assertTupleEqual(self.factory.next_track(),
|
|
(self.tracks[1], "track", False))
|
|
|
|
self.sql.playlists.collection.add_track(self.tracks[0])
|
|
self.assertTupleEqual(self.factory.next_track(),
|
|
(self.tracks[0], "track", False))
|
|
self.assertEqual(self.factory.db_active,
|
|
self.sql.playlists.collection)
|
|
self.assertEqual(self.sql.active_playlist,
|
|
self.sql.playlists.collection)
|
|
|
|
self.album.add_track(self.tracks[2])
|
|
self.factory.db_active = self.album
|
|
self.assertTupleEqual(self.factory.next_track(),
|
|
(self.tracks[2], "album", False))
|
|
|
|
self.medium.add_track(self.tracks[2])
|
|
self.factory.db_active = self.medium
|
|
self.assertTupleEqual(self.factory.next_track(),
|
|
(self.tracks[2], "album", False))
|
|
|
|
def test_next_track_user(self, mock_stdout: io.StringIO):
|
|
"""Test calling next_track() with user=True."""
|
|
self.factory.db_active = self.user_plist
|
|
self.factory.db_previous = self.sql.playlists.previous
|
|
|
|
self.user_plist.add_track(self.tracks[2])
|
|
self.tracks[0].start()
|
|
self.tracks[1].start()
|
|
self.factory.previous_track()
|
|
|
|
self.assertEqual(self.factory.next_track(user=True),
|
|
(self.tracks[1], "track", True))
|
|
self.assertEqual(self.factory.next_track(user=True),
|
|
(self.tracks[2], "track", False))
|
|
|
|
def test_previous_track(self, mock_stdout: io.StringIO):
|
|
"""Test the previous_track() function."""
|
|
self.assertIsNone(self.factory.previous_track())
|
|
|
|
self.factory.db_previous = self.sql.playlists.previous
|
|
self.assertIsNone(self.factory.previous_track())
|
|
self.tracks[0].start()
|
|
self.assertIsNone(self.factory.previous_track())
|
|
|
|
self.tracks[1].start()
|
|
self.assertEqual(self.factory.previous_track(), self.tracks[0])
|
|
self.assertIsNone(self.factory.previous_track())
|
|
|
|
self.tracks[2].start()
|
|
self.assertEqual(self.factory.previous_track(), self.tracks[1])
|
|
self.assertEqual(self.factory.previous_track(), self.tracks[0])
|
|
self.assertIsNone(self.factory.previous_track())
|