def fetch_tracks(*args): kwargs = dict(provider=Provider.lastfm) if args: kwargs["id"] = lambda x: x in args # So wrong, but yaspin doesn't support nested spinners LastService.get_tags() with spinner("Fetching track lists") as sp: for playlist in PlaylistManager.find(**kwargs): tracklist = LastService.get_tracks( type=playlist.type, **playlist.arguments ) track_ids: List[str] = [] for entry in tracklist: id = TrackManager.set( dict(artist=entry.artist.name, name=entry.name) ).id if id not in track_ids: track_ids.append(id) sp.write( "Playlist: {} - {} tracks".format(playlist.id, len(track_ids)) ) PlaylistManager.update(playlist, dict(tracks=track_ids))
def test_assert_config(self, configure): with self.assertRaises(NotFound): LastService.assert_config() ConfigManager.set( dict(provider=Provider.lastfm, data=dict(api_key="aaa")) ) LastService.assert_config() configure.assert_called_once_with(api_key="aaa")
def test_get_tags(self, get_top_tags, time, assert_config): time.return_value = 1 get_top_tags.side_effect = [ [Tag(name=i) for i in range(0, 250)], [Tag(name=i) for i in range(250, 500)], [Tag(name=i) for i in range(500, 750)], [Tag(name=i) for i in range(750, 1000)], ] names = [t.name for t in LastService.get_tags()] self.assertEqual(list(range(0, 1000)), names) get_top_tags.assert_has_calls( [ mock.call(limit=250, page=1), mock.call(limit=250, page=2), mock.call(limit=250, page=3), mock.call(limit=250, page=4), ] ) tags, ttl = Registry.get("last.fm_tag_list") self.assertEqual(1000, len(tags)) self.assertEqual({"name": 0}, tags[0]) self.assertEqual(timedelta(days=30, seconds=1).total_seconds(), ttl) assert_config.assert_called_once()
def test_sync_with_chart(self, top_tracks_chart, *args): top_tracks_chart.return_value = ListModel(["a", "b", "c"]) actual = LastService.get_tracks( type=PlaylistType.CHART.value, limit=10 ) self.assertEqual(["a", "b", "c"], actual) top_tracks_chart.assert_called_once_with(limit=10)
def test_sync_with_artist_chart(self, get_artist, get_top_tracks, *args): get_artist.return_value = Artist(name="queen") get_top_tracks.return_value = ListModel(["a", "b", "c"]) actual = LastService.get_tracks( type=PlaylistType.ARTIST.value, limit=10, artist="queeen" ) self.assertEqual(["a", "b", "c"], actual) get_artist.assert_called_once_with("queeen") get_top_tracks.assert_called_once_with(limit=10)
def test_sync_with_tag_chart(self, get_tag, get_top_tracks, *args): get_tag.return_value = Tag(name="rock") get_top_tracks.return_value = ListModel(["a", "b", "c"]) actual = LastService.get_tracks( type=PlaylistType.TAG.value, limit=10, tag="rock" ) self.assertEqual(["a", "b", "c"], actual) get_tag.assert_called_once_with("rock") get_top_tracks.assert_called_once_with(limit=10)
def test_sync_with_country_chart(self, top_tracks_by_country, *args): top_tracks_by_country.return_value = ListModel(["a", "b", "c"]) actual = LastService.get_tracks( type=PlaylistType.COUNTRY.value, limit=10, country="greece" ) self.assertEqual(["a", "b", "c"], actual) top_tracks_by_country.assert_called_once_with( limit=10, country="greece" )
def test_sync_with_user_loved_tracks(self, get_user, loved_tracks, *args): get_user.return_value = self.get_user() loved_tracks.return_value = ListModel(["a", "b", "c"]) actual = LastService.get_tracks( type=PlaylistType.USER_LOVED_TRACKS.value, limit=10, username="******" ) self.assertEqual(["a", "b", "c"], actual) get_user.assert_called_once_with("foo") loved_tracks.assert_called_once_with(limit=10)
def test_sync_with_user_top_tracks(self, get_user, top_tracks, *args): get_user.return_value = self.get_user() top_tracks.return_value = ListModel(["a", "b", "c"]) actual = LastService.get_tracks( type=PlaylistType.USER_TOP_TRACKS.value, limit=10, username="******" ) self.assertEqual(["a", "b", "c"], actual) get_user.assert_called_once_with("foo") top_tracks.assert_called_once_with( period=constants.Period.overall, limit=10 )
def fetch_tags(): values = [ (tag.name, tag.count, tag.reach) for tag in LastService.get_tags() ] click.echo_via_pager( tabulate( values, showindex="always", headers=("No", "Name", "Count", "Reach"), ) )
def test_get_user(self, find, time, assert_config): time.return_value = 1 my_user = self.get_user() find.return_value = my_user self.assertEqual(my_user, LastService.get_user("rj")) find.assert_called_once_with("rj") user, ttl = Registry.get("last.fm_user_rj") self.assertEqual(self.get_user().to_dict(), user) self.assertEqual(timedelta(hours=24, seconds=1).total_seconds(), ttl) assert_config.assert_called_once()
def test_get_artist(self, find, time, assert_config): time.return_value = 1 find.return_value = Artist(name="Queen") artist = LastService.get_artist("quueee") self.assertEqual(Artist(name="Queen"), artist) find.assert_called_once_with("quueee") artist, ttl = Registry.get("last.fm_artist_quueee") self.assertEqual({"name": "Queen"}, artist) self.assertEqual(timedelta(days=30, seconds=1).total_seconds(), ttl) assert_config.assert_called_once()
def test_sync_with_user_friends_tracks(self, get_user, friends, *args): get_user.return_value = self.get_user() friend = namedtuple("Friend", ["recent_track"]) friends.return_value = [ friend(recent_track=1), friend(recent_track=2), friend(recent_track=3), ] actual = LastService.get_tracks( type=PlaylistType.USER_FRIENDS_RECENT_TRACKS.value, limit=10, username="******", ) self.assertEqual([1, 2, 3], actual) get_user.assert_called_once_with("foo") friends.assert_called_once_with(limit=10, recent_tracks=True)
def convert(self, value, param, ctx): try: return LastService.get_user(value).name except Exception: self.fail("Unknown user: %s" % value, param, ctx)
def convert(self, value, param, ctx): try: return LastService.get_tag(value).name except IndexError: self.fail("Unknown tag: %s" % value, param, ctx)