def test_sq_item_exception(self):
     p1 = _mockspotify.mock_playlist("foo", [])
     p2 = _mockspotify.mock_playlist("bar", [])
     pc = _mockspotify.mock_playlistcontainer([p1, p2])
     def _():
         return pc[2]
     self.assertRaises(IndexError, _)
Example #2
0
    def test_sq_item_exception(self):
        p1 = _mockspotify.mock_playlist("foo", [])
        p2 = _mockspotify.mock_playlist("bar", [])
        pc = _mockspotify.mock_playlistcontainer([p1, p2])

        def _():
            return pc[2]

        self.assertRaises(IndexError, _)
Example #3
0
class TestPlaylistContainer(unittest.TestCase):

    owner = mock_user('owner')
    p1 = mock_playlist('foo', [], owner)
    p2 = mock_playlist('bar', [], owner)

    def test_len(self):
        pc = mock_playlistcontainer(self.owner, [self.p1, self.p2])
        self.assertEqual(len(pc), 2)

    def test_sq_item(self):
        pc = mock_playlistcontainer(self.owner, [self.p1, self.p2])
        self.assertEqual(pc[0].name(), "foo")
        self.assertEqual(pc[1].name(), "bar")

    def test_sq_item_exception(self):
        pc = mock_playlistcontainer(self.owner, [self.p1, self.p2])

        def _():
            return pc[2]

        self.assertRaises(IndexError, _)

    def test_add_new_playlist(self):
        pc = mock_playlistcontainer(self.owner, [])
        pc.add_new_playlist('foo')
        self.assertRaises(ValueError, pc.add_new_playlist, 'foo' * 100)

    def test_playlistfolder(self):
        p1 = mock_playlistfolder("folder_start", "foo", folder_id=42)
        p2 = mock_playlistfolder("folder_end", "")
        pc = mock_playlistcontainer(self.owner, [p1, p2])
        f1, f2 = pc[0], pc[1]
        self.assertEqual(f1.name(), u'foo')
        self.assertEqual(f1.type(), 'folder_start')
        self.assertEqual(f2.type(), 'folder_end')
        self.assertEqual(f1.id(), 42)
        self.assertTrue(f1.is_loaded())

    def test_remove_playlist(self):
        pc = mock_playlistcontainer(self.owner, [self.p1, self.p2])
        pc.remove_playlist(1)
        self.assertEqual(len(pc), 1)

    def test_remove_playlist_out_of_range(self):
        pc = mock_playlistcontainer(self.owner, [])
        self.assertRaises(IndexError, pc.remove_playlist, 0)
Example #4
0
 def test_add_tracks_ok(self):
     playlist = mock_playlist(u'foo', [], self.owner)
     playlist.add_tracks(0, self.pure_tracks)
Example #5
0
 def test_add_tracks_wrong_position(self):
     playlist = mock_playlist("foo", [], self.owner)
     playlist.add_tracks(99, self.pure_tracks)
Example #6
0
 def test_track_create_time(self):
     playlist = mock_playlist('foo', self.tracks, self.owner)
     self.assertEqual(playlist.track_create_time(0), 1320961109)
Example #7
0
 def test_num_subscribers(self):
     pl = _mockspotify.mock_playlist('foo', [])
     self.assertEqual(pl.num_subscribers(), 42)
Example #8
0
 def test_subscribers(self):
     pl = _mockspotify.mock_playlist('foo', [])
     self.assertEqual(pl.subscribers(), [u'foo', u'bar', u'baz'])
Example #9
0
 def test_add_tracks_wrong_types(self):
     p1 = self._mock_track("foo")
     pl = mock_playlist("foobar", [p1])
     self.assertRaises(TypeError, pl.add_tracks, 0, True)
     self.assertRaises(TypeError, pl.add_tracks, [False])
 def setUp(self):
     self.manager = MyContainerManager()
     self.playlist = mock_playlist('foo_', [])
     self.container = mock_playlistcontainer([])
Example #11
0
 def test_rename_unicode(self):
     playlist = mock_playlist(u"foo", [], self.owner)
     playlist.rename(u"bąr")
     self.assertEqual(playlist.name(), u"bąr")
Example #12
0
 def test_rename_unicode(self):
     playlist = mock_playlist(u'foo', [], self.owner)
     playlist.rename(u'bąr')
     self.assertEqual(playlist.name(), u'bąr')
Example #13
0
 def test_rename_too_long(self):
     playlist = mock_playlist(u'foo', [], self.owner)
     playlist.rename(u'bar' * 100)
Example #14
0
 def test_name_unicode(self):
     playlist = mock_playlist(u'plåylïst', [], self.owner)
     self.assertEqual(playlist.name(), u'plåylïst')
Example #15
0
 def test_name(self):
     playlist = mock_playlist('playlist', [], self.owner)
     self.assertEqual(playlist.name(), 'playlist')
Example #16
0
 def test_owner(self):
     playlist = mock_playlist('foo', [], self.owner)
     self.assertEqual(playlist.owner().canonical_name(),
                      self.owner.canonical_name())
Example #17
0
 def test_track_create_time(self):
     playlist = mock_playlist("foo", self.tracks, self.owner)
     self.assertEqual(playlist.track_create_time(0), 1320961109)
Example #18
0
 def test_add_tracks_wrong_position(self):
     playlist = mock_playlist('foo', [], self.owner)
     playlist.add_tracks(99, self.pure_tracks)
Example #19
0
 def test_name(self):
     playlist = mock_playlist("playlist", [], self.owner)
     self.assertEqual(playlist.name(), "playlist")
Example #20
0
 def test_add_tracks_wrong_position(self):
     p1 = self._mock_track("foo")
     p2 = self._mock_track("bar")
     pl = mock_playlist("foobar", [p1])
     pl.add_tracks(99, [p2])
Example #21
0
 def test_len(self):
     playlist = mock_playlist(u"foo", self.tracks, self.owner)
     self.assertEqual(len(playlist), 3)
Example #22
0
 def test_add_tracks_wrong_types(self):
     p1 = self._mock_track("foo")
     pl = mock_playlist("foobar", [p1])
     self.assertRaises(TypeError, pl.add_tracks, 0, True)
     self.assertRaises(TypeError, pl.add_tracks, [False])
Example #23
0
 def test_len(self):
     p1 = _mockspotify.mock_playlist("foo", [])
     p2 = _mockspotify.mock_playlist("bar", [])
     pc = _mockspotify.mock_playlistcontainer([p1, p2])
     self.assertEqual(len(pc), 2)
Example #24
0
 def test_track_create_time(self):
     p1 = self._mock_track("foo")
     pl = mock_playlist("foobar", [p1])
     self.assertEqual(pl.track_create_time(0), 1320961109)
Example #25
0
 def test_sq_item(self):
     p1 = _mockspotify.mock_playlist("foo", [])
     p2 = _mockspotify.mock_playlist("bar", [])
     pc = _mockspotify.mock_playlistcontainer([p1, p2])
     self.assertEqual(pc[0].name(), "foo")
     self.assertEqual(pc[1].name(), "bar")
Example #26
0
 def test_sq_item(self):
     p1 = _mockspotify.mock_playlist("foo", [])
     p2 = _mockspotify.mock_playlist("bar", [])
     pc = _mockspotify.mock_playlistcontainer([p1, p2])
     self.assertEqual(pc[0].name(), "foo")
     self.assertEqual(pc[1].name(), "bar")
Example #27
0
 def test_len(self):
     p1 = self._mock_track("foo")
     p2 = self._mock_track("bar")
     pc = _mockspotify.mock_playlist("foobar", [p1, p2])
     self.assertEqual(len(pc), 2)
Example #28
0
 def test_name(self):
     p1 = _mockspotify.mock_playlist("foo", [])
     self.assertEqual(p1.name(), "foo")
Example #29
0
class TestLink(unittest.TestCase):

    user = mock_user('user')
    artist = mock_artist('artist')
    album = mock_album('album', artist)
    playlist = mock_playlist('playlist', [], user)
    search = mock_search('query', [], [], [])
    track = mock_track('track', [artist], album)

    def setUp(self):
        registry_add('spotify:artist:test_artist', self.artist)
        registry_add('spotify:album:test_album', self.album)
        registry_add('spotify:playlist:test_playlist', self.playlist)
        registry_add('spotify:track:test_track', self.track)

    def tearDown(self):
        registry_clean()

    def test_from_string(self):
        s = "spotify:artist:test"
        l = Link.from_string(s)
        self.assertEqual(str(l), "spotify:artist:test")

    def test_from_track(self):
        l2 = Link.from_track(self.track, 42 * 1000)
        self.assertEqual(str(l2), "spotify:track:test_track#00:42")

    def test_from_album(self):
        l2 = Link.from_album(self.album)
        self.assertEqual(str(l2), "spotify:album:test_album")

    def test_from_artist(self):
        l = Link.from_artist(self.artist)
        self.assertEqual(str(l), "spotify:artist:test_artist")

    def test_from_search(self):
        l2 = Link.from_search(self.search)
        self.assertEqual(str(l2), "spotify:search:query")

    def test_from_playlist(self):
        l = Link.from_playlist(self.playlist)
        self.assertEqual(str(l), "spotify:playlist:test_playlist")

    def test_type(self):
        l = Link.from_track(self.track, 0)
        self.assertEqual(l.type(), Link.LINK_TRACK)

    def test_badlink(self):
        self.assertRaises(SpotifyError, Link.from_string, "BADLINK");

    def test_as_track(self):
        l = Link.from_string("spotify:track:test_track")
        t = l.as_track()
        self.assertEqual(str(t), "track")

    def test_as_album(self):
        l = Link.from_string("spotify:album:test_album")
        t = l.as_album()
        self.assertEqual(str(t), "album")

    def test_as_artist(self):
        l = Link.from_string("spotify:artist:test_artist")
        a = l.as_artist()
        self.assertEqual(str(a), "artist")

    def test_as_string(self):
        s = "spotify:track:str_test"
        l = Link.from_string(s)
        self.assertEqual(str(l), "spotify:track:str_test")
Example #30
0
 def test_name_unicode(self):
     p1 = _mockspotify.mock_playlist(u"æâ€êþÿ", [])
     self.assertEqual(p1.name(), u"æâ€êþÿ")
Example #31
0
 def test_add_tracks_ok(self):
     playlist = mock_playlist(u"foo", [], self.owner)
     playlist.add_tracks(0, self.pure_tracks)
Example #32
0
 def test_rename_unicode(self):
     p1 = _mockspotify.mock_playlist(u"foo", [])
     p1.rename(u"bąr")
     self.assertEqual(p1.name(), u"bąr")
Example #33
0
 def test_add_tracks_wrong_types(self):
     playlist = mock_playlist("foo", [], self.owner)
     self.assertRaises(TypeError, playlist.add_tracks, 0, True)
     self.assertRaises(TypeError, playlist.add_tracks, [False])
Example #34
0
 def test_rename_too_long(self):
     p1 = _mockspotify.mock_playlist(u"foo", [])
     p1.rename(u"bar" * 100)
Example #35
0
 def test_owner(self):
     playlist = mock_playlist("foo", [], self.owner)
     self.assertEqual(playlist.owner().canonical_name(), self.owner.canonical_name())
Example #36
0
 def test_len(self):
     p1 = self._mock_track("foo")
     p2 = self._mock_track("bar")
     pc = _mockspotify.mock_playlist("foobar", [p1, p2])
     self.assertEqual(len(pc), 2)
Example #37
0
 def test_name_unicode(self):
     playlist = mock_playlist(u"plåylïst", [], self.owner)
     self.assertEqual(playlist.name(), u"plåylïst")
Example #38
0
 def test_sq_item(self):
     p1 = self._mock_track("foo")
     p2 = self._mock_track("bar")
     pc = _mockspotify.mock_playlist("foobar", [p1, p2])
     self.assertEqual(pc[0].name(), "foo")
     self.assertEqual(pc[1].name(), "bar")
Example #39
0
 def test_rename_too_long(self):
     playlist = mock_playlist(u"foo", [], self.owner)
     playlist.rename(u"bar" * 100)
Example #40
0
 def test_from_playlist(self):
     p = mock_playlist("foo", [])
     l = Link.from_playlist(p)
     self.assertEqual(str(l), "link:playlist:foo")
Example #41
0
 def test_sq_item(self):
     playlist = mock_playlist(u"foo", self.tracks, self.owner)
     self.assertEqual(playlist[0].name(), "track1")
     self.assertEqual(playlist[1].name(), "track2")
     self.assertEqual(playlist[2].name(), "track3")
Example #42
0
 def test_from_playlist(self):
     p = mock_playlist("foo", [])
     l = Link.from_playlist(p)
     self.assertEqual(str(l), "link:playlist:foo")
Example #43
0
 def test_add_tracks_ok(self):
     p1 = self._mock_track("foo")
     p2 = self._mock_track("bar")
     pl = mock_playlist("foobar", [p1])
     pl.add_tracks(0, [p2])
Example #44
0
 def test_sq_item(self):
     playlist = mock_playlist(u'foo', self.tracks, self.owner)
     self.assertEqual(playlist[0].name(), 'track1')
     self.assertEqual(playlist[1].name(), 'track2')
     self.assertEqual(playlist[2].name(), 'track3')
Example #45
0
 def test_add_tracks_wrong_position(self):
     p1 = self._mock_track("foo")
     p2 = self._mock_track("bar")
     pl = mock_playlist("foobar", [p1])
     pl.add_tracks(99, [p2])
Example #46
0
 def test_name(self):
     p1 = _mockspotify.mock_playlist("foo", [])
     self.assertEqual(p1.name(), "foo")
Example #47
0
 def test_track_create_time(self):
     p1 = self._mock_track("foo")
     pl = mock_playlist("foobar", [p1])
     self.assertEqual(pl.track_create_time(0), 1320961109)
Example #48
0
 def test_rename_unicode(self):
     p1 = _mockspotify.mock_playlist(u'foo', [])
     p1.rename(u'bąr')
     self.assertEqual(p1.name(), u'bąr')
Example #49
0
 def test_subscribers(self):
     playlist = mock_playlist(u'foo', [], self.owner,
                              subscribers=['foo', 'bar', 'baz'])
     self.assertEqual(playlist.subscribers(), [u'foo', u'bar', u'baz'])
Example #50
0
 def test_add_tracks_wrong_types(self):
     playlist = mock_playlist('foo', [], self.owner)
     self.assertRaises(TypeError, playlist.add_tracks, 0, True)
     self.assertRaises(TypeError, playlist.add_tracks, [False])
Example #51
0
 def test_name_unicode(self):
     p1 = _mockspotify.mock_playlist(u'æâ€êþÿ', [])
     self.assertEqual(p1.name(), u'æâ€êþÿ')
Example #52
0
 def test_name(self):
     playlist = mock_playlist('playlist', [], self.owner)
     self.assertEqual(playlist.name(), 'playlist')
Example #53
0
 def test_rename_too_long(self):
     p1 = _mockspotify.mock_playlist(u'foo', [])
     p1.rename(u'bar' * 100)
Example #54
0
 def test_rename_unicode(self):
     playlist = mock_playlist(u'foo', [], self.owner)
     playlist.rename(u'bąr')
     self.assertEqual(playlist.name(), u'bąr')
Example #55
0
 def test_sq_item(self):
     p1 = self._mock_track("foo")
     p2 = self._mock_track("bar")
     pc = _mockspotify.mock_playlist("foobar", [p1, p2])
     self.assertEqual(pc[0].name(), "foo")
     self.assertEqual(pc[1].name(), "bar")
Example #56
0
 def test_rename_too_long(self):
     playlist = mock_playlist(u'foo', [], self.owner)
     playlist.rename(u'bar' * 100)
 def setUp(self):
     global callback_called
     self.manager = MyPlaylistManager()
     self.playlist = mock_playlist('foo_', [])
     callback_called = None
Example #58
0
 def test_num_subscribers(self):
     playlist = mock_playlist("foo", [], self.owner, num_subscribers=42)
     self.assertEqual(playlist.num_subscribers(), 42)
Example #59
0
class TestPlaylistManager(unittest.TestCase):

    artist = mock_artist('artist')
    album = mock_album('album', artist)
    owner = mock_user('owner')
    tracks = [
        (mock_track('track1', [artist], album), owner, 1320961109),
        (mock_track('track2', [artist], album), owner, 1320961109),
        (mock_track('track3', [artist], album), owner, 1320961109),
    ]
    pure_tracks = [t[0] for t in tracks]
    description = 'description'
    num_subscribers = 42
    subscribers = ['sub1', 'sub2', 'sub3']
    image = '01234567890123456789'
    playlist = mock_playlist('foo_', [], owner, subscribers, num_subscribers,
                             description, image)
    def setUp(self):
        global callback_called
        self.manager = MyPlaylistManager()
        callback_called = None

    def test_tracks_added(self):
        global callback_called
        callback = self.manager.tracks_added
        self.playlist.add_tracks_added_callback(callback, self.manager)
        mock_event_trigger(20, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name,"tracks_added")
        self.assertEqual(len(args), 5)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), list)
        self.assertEqual(len(args[2]), 3)
        self.assertEqual(map(lambda x: x.name(), args[2]), ['foo', 'bar', 'baz'])
        self.assertEqual(type(args[3]), int)

    def test_tracks_moved(self):
        global callback_called
        callback = self.manager.tracks_moved
        self.playlist.add_tracks_moved_callback(callback, self.manager)
        mock_event_trigger(21, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "tracks_moved")
        self.assertEqual(len(args), 5)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), list)
        self.assertEqual(len(args[2]), 3)
        self.assertEqual(args[2], [0, 1, 2])
        self.assertEqual(type(args[3]), int)

    def test_tracks_removed(self):
        global callback_called
        callback = self.manager.tracks_removed
        self.playlist.add_tracks_removed_callback(callback, self.manager)
        mock_event_trigger(22, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "tracks_removed")
        self.assertEqual(len(args), 4)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), list)
        self.assertEqual(len(args[2]), 3)
        self.assertEqual(args[2], [0, 1, 2])

    def test_playlist_renamed(self):
        global callback_called
        callback = self.manager.playlist_renamed
        self.playlist.add_playlist_renamed_callback(callback, self.manager)
        mock_event_trigger(23, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "playlist_renamed")
        self.assertEqual(len(args), 3)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())

    def test_playlist_state_changed(self):
        global callback_called
        callback = self.manager.playlist_state_changed
        self.playlist.add_playlist_state_changed_callback(callback, self.manager)
        mock_event_trigger(24, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "playlist_state_changed")
        self.assertEqual(len(args), 3)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())

    def test_playlist_update_in_progress(self):
        global callback_called
        callback = self.manager.playlist_update_in_progress
        self.playlist.add_playlist_update_in_progress_callback(callback, self.manager)
        mock_event_trigger(25, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "playlist_update_in_progress")
        self.assertEqual(len(args), 4)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), bool)
        self.assertEqual(args[2], True)

    def test_playlist_metadata_updated(self):
        global callback_called
        callback = self.manager.playlist_metadata_updated
        self.playlist.add_playlist_metadata_updated_callback(callback, self.manager)
        mock_event_trigger(26, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "playlist_metadata_updated")
        self.assertEqual(len(args), 3)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())

    def test_track_created_changed(self):
        global callback_called
        callback = self.manager.track_created_changed
        self.playlist.add_track_created_changed_callback(callback, self.manager)
        mock_event_trigger(27, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "track_created_changed")
        self.assertEqual(len(args), 6)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), int)
        self.assertEqual(args[2], 1)
        self.assertEqual(type(args[3]), User)
        self.assertEqual(args[3].canonical_name(), u'foo')
        self.assertEqual(type(args[4]), int)
        self.assertEqual(args[4], 123)

    def test_track_message_changed(self):
        global callback_called
        callback = self.manager.track_message_changed
        self.playlist.add_track_message_changed_callback(callback, self.manager)
        mock_event_trigger(28, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "track_message_changed")
        self.assertEqual(len(args), 5)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), int)
        self.assertEqual(args[2], 1)
        self.assertEqual(type(args[3]), unicode)
        self.assertEqual(args[3], u'foo')

    def test_track_seen_changed(self):
        global callback_called
        callback = self.manager.track_seen_changed
        self.playlist.add_track_seen_changed_callback(callback, self.manager)
        mock_event_trigger(29, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "track_seen_changed")
        self.assertEqual(len(args), 5)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), int)
        self.assertEqual(args[2], 1)
        self.assertEqual(type(args[3]), bool)
        self.assertEqual(args[3], False)

    def test_description_changed(self):
        global callback_called
        callback = self.manager.description_changed
        self.playlist.add_description_changed_callback(callback, self.manager)
        mock_event_trigger(30, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "description_changed")
        self.assertEqual(len(args), 4)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), unicode)
        self.assertEqual(args[2], u'foo')

    def test_subscribers_changed(self):
        global callback_called
        callback = self.manager.subscribers_changed
        self.playlist.add_subscribers_changed_callback(callback, self.manager)
        mock_event_trigger(31, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "subscribers_changed")
        self.assertEqual(len(args), 3)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())

    def test_image_changed(self):
        global callback_called
        callback = self.manager.image_changed
        self.playlist.add_image_changed_callback(callback, self.manager)
        mock_event_trigger(32, self.playlist)

        self.assertNotEqual(callback_called, None)
        name, args = callback_called
        self.assertEqual(name, "image_changed")
        self.assertEqual(len(args), 4)
        self.assertEqual(args[0], self.manager)
        self.assertEqual(type(args[1]), Playlist)
        self.assertEqual(args[1].name(), self.playlist.name())
        self.assertEqual(type(args[2]), bytes)
        self.assertEqual(args[2], '01234567890123456789')
Example #60
0
 def test_subscribers(self):
     playlist = mock_playlist(u"foo", [], self.owner, subscribers=["foo", "bar", "baz"])
     self.assertEqual(playlist.subscribers(), [u"foo", u"bar", u"baz"])