emmental/curds/test_playlist.py

# Copyright 2019 (c) Anna Schumaker.
from . import data
from . import notify
from . import playlist
from . import trak
import os
import random
import unittest

test_album   = os.path.abspath("./trier/Test Album")
test_library = os.path.abspath("./trier/Test Library")

class TestPlaylist(unittest.TestCase):
    def setUp(self):
        data.DataFile("playlists.pickle", data.WRITE).remove()
        trak.reset()
        playlist.reset()
        self.orig = playlist.Root

    def tearDown(self):
        notify.clear()
        playlist.Root = self.orig
        playlist.Root.reset()

    def test_current_shortcut(self):
        self.assertEqual(playlist.current(), playlist.lookup("Collection"))
        playlist.select(playlist.Starred)
        self.assertEqual(playlist.current(), playlist.Starred)

    def test_lookup_shortcut(self):
        self.assertEqual(playlist.lookup("Collection"), playlist.Root.lookup("Collection"))
        self.assertEqual(playlist.lookup("Playlists"),  playlist.Root.lookup("Playlists"))

    def test_starred_shortcut(self):
        self.assertEqual(playlist.Starred, playlist.lookup("Playlists").lookup("Starred"))
        playlist.Starred = None

        playlist.reset()
        self.assertEqual(playlist.Starred, playlist.lookup("Playlists").lookup("Starred"))

    def test_up_next_shortcut(self):
        self.assertEqual(playlist.UpNext, playlist.lookup("Up Next"))
        playlist.UpNext = None

        playlist.reset()
        self.assertEqual(playlist.UpNext, playlist.lookup("Up Next"))

    def test_next_prev(self):
        self.assertIsNone(playlist.next())
        self.assertIsNone(playlist.previous())
        self.assertIsNone(playlist.Track)

        clist = playlist.lookup("Collection")
        prev  = playlist.lookup("Previous")
        upnxt = playlist.lookup("Up Next")
        plist = playlist.lookup("Libraries").lookup(test_album)

        playlist.library.join()
        upnxt.add(clist[3])
        playlist.Current.insert(0, upnxt)

        track1 = playlist.next()
        self.assertEqual(playlist.Track, track1)
        self.assertEqual(playlist.Current, [ clist ])

        self.assertEqual(len(prev), 1)
        self.assertEqual(prev[0], track1)

        track2 = playlist.next()
        self.assertEqual(playlist.Current, [ clist ])
        self.assertEqual(playlist.Track, track2)
        self.assertEqual(clist.current, 0)
        self.assertEqual(track2, clist[0])

        self.assertEqual(len(prev), 2)
        self.assertEqual(prev[0], track2)
        self.assertEqual(prev[1], track1)

        track3 = playlist.next()
        self.assertEqual(playlist.Track, track3)
        self.assertEqual(clist.current, 1)
        self.assertEqual(track3, clist[1])

        self.assertEqual(len(prev), 3)
        self.assertEqual(prev[0], track3)
        self.assertEqual(prev[1], track2)
        self.assertEqual(prev[2], track1)

        self.assertEqual(playlist.previous(), track2)
        self.assertEqual(playlist.Track, track2)

        playlist.reset()
        self.assertEqual(len(prev), 0)
        self.assertIsNone(playlist.Track)

    def test_peek(self):
        self.assertEqual(playlist.peek(3), [ ])

        clist = playlist.lookup("Collection")
        plist = playlist.lookup("Libraries").lookup(test_album)
        playlist.library.join()
        random.seed(1)

        clist.set_random(False)
        tracks = playlist.peek(0)
        self.assertEqual(tracks, [ ])
        self.assertEqual(clist.current, -1)

        tracks = playlist.peek(5)
        self.assertEqual(tracks, [ clist[i] for i in range(5) ])
        self.assertEqual(clist.current, -1)

        clist.set_random(True)
        tracks = playlist.peek(5)
        self.assertEqual(len(tracks), 5)
        self.assertEqual(clist.current, -1)

        for i in range(5):
            self.assertEqual(playlist.next(), tracks[i])

    def test_save_playlists(self):
        dfile = data.DataFile("playlists.pickle", data.READ)
        track = trak.lookup(os.path.join(test_album, "01 - Test Track.ogg"))

        playlist.Root  = None
        playlist.Track = 1234

        self.assertFalse(dfile.exists())
        playlist.load()
        self.assertIsInstance(playlist.Root, playlist.root.PlaylistRoot)
        self.assertIsNone(playlist.Track)
        self.assertEqual(playlist.Starred, playlist.lookup("Playlists").lookup("Starred"))
        self.assertEqual(playlist.UpNext,  playlist.lookup("Up Next"))
        root = playlist.Root
        playlist.Track = track
        playlist.Current = [ playlist.lookup("Up Next"), playlist.lookup("Collection") ]

        self.assertFalse(dfile.exists())
        playlist.Starred.changed()
        notify.notify_idle()
        self.assertTrue(dfile.exists())

        playlist.Current = [ ]
        playlist.Root    = None
        playlist.Track   = None

        playlist.load()
        self.assertIsNotNone(playlist.Root)
        self.assertNotEqual(playlist.Root, root)
        self.assertEqual(playlist.Track, track)
        self.assertEqual(playlist.Current, [ playlist.lookup("Up Next"),
                                             playlist.lookup("Collection") ])
        self.assertEqual(playlist.Starred, playlist.lookup("Playlists").lookup("Starred"))
        self.assertEqual(playlist.UpNext,  playlist.lookup("Up Next"))

    def test_select_playlist(self):
        clist = playlist.lookup("Collection")
        plist = playlist.lookup("Libraries").lookup(test_library)
        playlist.library.join()
        glist = playlist.lookup("Genres").lookup("Test Genre 1")

        self.assertEqual(playlist.Current, [ clist ])
        playlist.select(plist)
        self.assertEqual(playlist.Current, [ plist, clist ])
        playlist.select(glist)
        self.assertEqual(playlist.Current, [ glist, plist, clist ])
        playlist.select(plist)
        self.assertEqual(playlist.Current, [ plist, glist, clist ])
        playlist.select(playlist.lookup("Previous"))
        self.assertEqual(playlist.Current, [ plist, glist, clist ])

        plist.current = 1247
        peek = playlist.peek(4)
        self.assertEqual(len(peek), 4)
        self.assertEqual(peek[0], plist[-2])
        self.assertEqual(peek[1], plist[-1])
        self.assertEqual(peek[2], glist[ 0])
        self.assertEqual(peek[3], glist[ 1])

        self.assertEqual(playlist.next(), plist[-2])
        self.assertEqual(playlist.next(), plist[-1])
        self.assertEqual(playlist.Current, [ plist, glist, clist ])
        self.assertEqual(playlist.next(), glist[0])
        self.assertEqual(playlist.Current, [ glist, clist ])

        playlist.select(plist)
        self.assertEqual(playlist.Current, [ plist, glist, clist ])
        playlist.select(clist)
        self.assertEqual(playlist.Current, [ clist ])

        playlist.select(plist)
        playlist.reset()
        self.assertEqual(playlist.Current, [ clist ])