def refresh(self):
        playlists = []

        for playlist in self.backend.session.get_all_playlist_contents():
            tracks = []
            for track in playlist['tracks']:
                if not track['deleted']:
                    tracks += self.backend.library.lookup('gmusic:track:' +
                                                          track['trackId'])

            playlist = Playlist(uri='gmusic:playlist:' + playlist['id'],
                                name=playlist['name'],
                                tracks=tracks)
            playlists.append(playlist)

        for playlist in self.backend.session.get_all_playlists():
            if playlist.get('type') == 'SHARED':
                tracks = []
                tracklist = self.backend.session.get_shared_playlist_contents(
                    playlist['shareToken'])
                for track in tracklist:
                        tracks += self.backend.library.lookup('gmusic:track:' +
                                                              track['trackId'])
                playlist = Playlist(uri='gmusic:playlist:' + playlist['id'],
                                    name=playlist['name'],
                                    tracks=tracks)
                playlists.append(playlist)

        self.playlists = playlists
        listener.BackendListener.send('playlists_loaded')

 def test_with_new_name(self):
     tracks = [Track()]
     last_modified = datetime.datetime.utcnow()
     playlist = Playlist(uri="an uri", name="a name", tracks=tracks, last_modified=last_modified)
     new_playlist = playlist.copy(name="another name")
     self.assertEqual(new_playlist.uri, "an uri")
     self.assertEqual(new_playlist.name, "another name")
     self.assertEqual(list(new_playlist.tracks), tracks)
     self.assertEqual(new_playlist.last_modified, last_modified)

 def test_with_new_uri(self):
     tracks = [Track()]
     last_modified = dt.datetime.now()
     playlist = Playlist(uri=u"an uri", name=u"a name", tracks=tracks, last_modified=last_modified)
     new_playlist = playlist.copy(uri=u"another uri")
     self.assertEqual(new_playlist.uri, u"another uri")
     self.assertEqual(new_playlist.name, u"a name")
     self.assertEqual(list(new_playlist.tracks), tracks)
     self.assertEqual(new_playlist.last_modified, last_modified)

 def test_with_new_last_modified(self):
     tracks = [Track()]
     last_modified = datetime.datetime.utcnow()
     new_last_modified = last_modified + datetime.timedelta(1)
     playlist = Playlist(uri="an uri", name="a name", tracks=tracks, last_modified=last_modified)
     new_playlist = playlist.copy(last_modified=new_last_modified)
     self.assertEqual(new_playlist.uri, "an uri")
     self.assertEqual(new_playlist.name, "a name")
     self.assertEqual(list(new_playlist.tracks), tracks)
     self.assertEqual(new_playlist.last_modified, new_last_modified)

 def test_with_new_uri(self):
     tracks = [Track()]
     last_modified = datetime.datetime.utcnow()
     playlist = Playlist(
         uri='an uri', name='a name', tracks=tracks,
         last_modified=last_modified)
     new_playlist = playlist.copy(uri='another uri')
     self.assertEqual(new_playlist.uri, 'another uri')
     self.assertEqual(new_playlist.name, 'a name')
     self.assertEqual(list(new_playlist.tracks), tracks)
     self.assertEqual(new_playlist.last_modified, last_modified)

 def test_with_new_name(self):
     tracks = [Track()]
     last_modified = 1390942873000
     playlist = Playlist(
         uri='an uri', name='a name', tracks=tracks,
         last_modified=last_modified)
     new_playlist = playlist.replace(name='another name')
     self.assertEqual(new_playlist.uri, 'an uri')
     self.assertEqual(new_playlist.name, 'another name')
     self.assertEqual(list(new_playlist.tracks), tracks)
     self.assertEqual(new_playlist.last_modified, last_modified)

 def test_with_new_last_modified(self):
     tracks = [Track()]
     last_modified = 1390942873000
     new_last_modified = last_modified + 1000
     playlist = Playlist(
         uri='an uri', name='a name', tracks=tracks,
         last_modified=last_modified)
     new_playlist = playlist.copy(last_modified=new_last_modified)
     self.assertEqual(new_playlist.uri, 'an uri')
     self.assertEqual(new_playlist.name, 'a name')
     self.assertEqual(list(new_playlist.tracks), tracks)
     self.assertEqual(new_playlist.last_modified, new_last_modified)

 def __init__(self, config, backend):
     super(InternetArchivePlaylistsProvider, self).__init__(backend)
     self._bookmarks = []
     self._username = config[Extension.ext_name]['username']
     self._playlist = Playlist(
         uri='%s://%s/bookmarks' % (Extension.ext_name, self._username),
         name='Internet Archive Bookmarks'
     )
     self.playlists = [self._playlist]

class InternetArchivePlaylistsProvider(backend.PlaylistsProvider):

    def __init__(self, config, backend):
        super(InternetArchivePlaylistsProvider, self).__init__(backend)
        self._bookmarks = []
        self._username = config[Extension.ext_name]['username']
        self._playlist = Playlist(
            uri='%s://%s/bookmarks' % (Extension.ext_name, self._username),
            name='Internet Archive Bookmarks'
        )
        self.playlists = [self._playlist]

    def create(self, name):
        pass  # TODO

    def delete(self, uri):
        pass  # TODO

    def lookup(self, uri):
        for playlist in self.playlists:
            if playlist.uri == uri:
                return playlist
        return None

    def refresh(self):
        try:
            bookmarks = self.backend.client.bookmarks(self._username)
            logger.info('Loaded %d Internet Archive bookmarks', len(bookmarks))
            if bookmarks == self._bookmarks:
                return  # unchanged
            # FIXME: this can probably be removed when playlists return refs...
            tracks = self._tracks(bookmarks)
            logger.info('Loaded %d Internet Archive tracks', len(tracks))
            self.playlists = [self._playlist.copy(tracks=tracks)]
            backend.BackendListener.send('playlists_loaded')
            self._bookmarks = bookmarks
        except Exception as e:
            logger.error('Error loading Internet Archive bookmarks: %s', e)

    def save(self, playlist):
        pass  # TODO

    def _tracks(self, bookmarks):
        tracks = []
        for doc in bookmarks:
            tracks.extend(self.backend.library._lookup(doc['identifier']))
        return tracks

 def test_copying_playlist(self):
     playlist = Playlist()
     self.compare(playlist, playlist.copy())

 def test_last_modified(self):
     last_modified = 1390942873000
     playlist = Playlist(last_modified=last_modified)
     self.assertEqual(playlist.last_modified, last_modified)
     with self.assertRaises(AttributeError):
         playlist.last_modified = None

 def test_tracks(self):
     tracks = [Track(), Track(), Track()]
     playlist = Playlist(tracks=tracks)
     self.assertEqual(list(playlist.tracks), tracks)
     with self.assertRaises(AttributeError):
         playlist.tracks = None

 def test_name(self):
     name = 'a name'
     playlist = Playlist(name=name)
     self.assertEqual(playlist.name, name)
     with self.assertRaises(AttributeError):
         playlist.name = None

 def test_uri(self):
     uri = 'an_uri'
     playlist = Playlist(uri=uri)
     self.assertEqual(playlist.uri, uri)
     with self.assertRaises(AttributeError):
         playlist.uri = None

 def test_replace_playlist(self):
     playlist = Playlist()
     self.compare(playlist, playlist.replace())