def should_return_played_tracs_from_selected_date(self):
most_played = TrackFactory()
second_most_played = TrackFactory()
entries = [
PlaylistHistoryFactory(track=most_played),
PlaylistHistoryFactory(track=most_played),
PlaylistHistoryFactory(track=second_most_played),
PlaylistHistoryFactory(track=second_most_played,
created=datetime.datetime(2014,
1,
1,
tzinfo=tzutc())),
PlaylistHistoryFactory(
created=datetime.datetime(2014, 1, 1, tzinfo=tzutc())),
]
db.session.add_all(entries)
db.session.commit()
url = url_for('player.stats', **{'from': '2015-06-01'})
response = self.client.get(url)
assert response.status_code == 200
assert response.json['most_played_tracks'] == [
{
'track': TrackSerializer().serialize(most_played),
'total': 2
},
{
'track': TrackSerializer().serialize(second_most_played),
'total': 1
},
]
def should_return_played_tracs_from_the_beginning_of_the_age(self):
most_played = TrackFactory()
second_most_played = TrackFactory()
entries = [
PlaylistHistoryFactory(track=most_played),
PlaylistHistoryFactory(track=most_played),
PlaylistHistoryFactory(track=second_most_played),
]
db.session.add_all(entries)
db.session.commit()
url = url_for('player.stats')
response = self.client.get(url)
assert response.status_code == 200
assert response.json['most_played_tracks'] == [
{
'track': TrackSerializer().serialize(most_played),
'total': 2
},
{
'track': TrackSerializer().serialize(second_most_played),
'total': 1
},
]
def get(self, *args, **kwargs):
""" Returns a paginated list of tracks currently in the playlist.
"""
offset = kwargs.pop('offset')
limit = kwargs.pop('limit')
queue = redis.lrange(config.PLAYLIST_REDIS_KEY, offset,
(offset + limit - 1))
total = redis.llen(config.PLAYLIST_REDIS_KEY)
response = []
if total > 0:
for item in queue:
item = json.loads(item)
track = Track.query.filter(
Track.spotify_uri == item['uri']).first()
user = User.query.filter(User.id == item['user']).first()
if track is not None and user is not None:
response.append({
'track': TrackSerializer().serialize(track),
'user': UserSerializer().serialize(user),
'uuid': item.get('uuid', None),
})
return http.OK(response,
page=kwargs.get('page'),
total=total,
limit=limit)
def get(self):
""" Returns the currently playing track.
Returns
-------
http.Response
A http response instance, 204 or 200
"""
track, user = self.get_current_track()
if track is None or user is None:
return http.NoContent()
# Get Pause State
try:
paused = int(redis.get('fm:player:paused'))
except (ValueError, TypeError):
paused = 0
elapsed = self.elapsed(paused=bool(paused))
headers = {'Paused': paused}
response = {
'track': TrackSerializer().serialize(track),
'user': UserSerializer().serialize(user),
'player': {
'elapsed_time': elapsed, # ms
'elapsed_percentage': (elapsed / track.duration) * 100, # %
'elapsed_seconds': elapsed / 1000 # seconds
}
}
return http.OK(response, headers=headers)
def get(self, pk_or_uri):
""" Returns a single track object by primary key, if the track does
not exist a 404 will be returned.
Arguments
---------
pk : str
The track primary key
"""
try:
uuid.UUID(pk_or_uri, version=4)
except ValueError:
field = Track.spotify_uri
else:
field = Track.id
track = Track.query.filter(field == pk_or_uri).first()
if track is None:
return http.NotFound()
data = TrackSerializer().serialize(track)
data['audio_summary'] = track.audio_summary
return http.OK(data)
def should_return_zero_when_elapsed_time_cant_be_pulled(self):
track = TrackFactory()
user = UserFactory()
db.session.add_all([track, user])
db.session.commit()
mock_redis_values = {
'fm:player:current':
json.dumps({
'uri': track.spotify_uri,
'user': user.id
}),
'fm:player:elapsed_time':
None
}
self.redis.get.side_effect = lambda x: mock_redis_values.get(x)
url = url_for('player.current')
response = self.client.get(url)
assert response.status_code == 200
assert response.json['track'] == TrackSerializer().serialize(track)
assert response.json['user'] == UserSerializer().serialize(user)
assert response.json['player']['elapsed_time'] == 0
assert response.json['player']['elapsed_percentage'] == 0
assert response.json['player']['elapsed_seconds'] == 0
def should_return_track_data(self):
track = TrackFactory(duration=10000)
user = UserFactory()
db.session.add_all([track, user])
db.session.commit()
now = datetime.datetime.utcnow()
start = now - datetime.timedelta(seconds=5)
start = start.replace(tzinfo=dateutil.tz.tzutc())
mock_redis_values = {
'fm:player:current':
json.dumps({
'uri': track.spotify_uri,
'user': user.id
}),
'fm:player:start_time':
start.isoformat()
}
self.redis.get.side_effect = lambda x: mock_redis_values.get(x)
url = url_for('player.current')
# We have to mock utcnow so we don't get drift in the test
with mock.patch('fm.views.player.datetime') as _dt:
_dt.utcnow.return_value = now
response = self.client.get(url)
assert response.status_code == 200, response.json
assert response.json['track'] == TrackSerializer().serialize(track)
assert response.json['user'] == UserSerializer().serialize(user)
assert response.json['player']['elapsed_time'] == 5000
assert response.json['player']['elapsed_percentage'] == 50
assert response.json['player']['elapsed_seconds'] == 5
def post(self):
response = []
for track in Random.get_tracks(request.json['tracks']):
response.append({
'track': TrackSerializer().serialize(track),
'user': UserSerializer().serialize(current_user)
})
Queue.add(track.spotify_uri, current_user.id)
return http.Created(response)
def get(self, *args, **kwargs):
""" Returns a paginated list of tracks stored in our DB.
"""
total = Track.query.count()
rows = Track.query \
.limit(kwargs.get('limit')) \
.offset(kwargs.get('offset')) \
.all()
return http.OK(TrackSerializer().serialize(rows, many=True),
limit=kwargs.get('limit'),
page=kwargs.get('page'),
total=total)
def get(self, *args, **kwargs):
since = request.args.get('from', None)
if since:
since = pytz.utc.localize(datetime.strptime(since, '%Y-%m-%d'))
until = request.args.get('to', None)
if until:
until = pytz.utc.localize(datetime.strptime(until, '%Y-%m-%d'))
payload = {
'most_active_djs': [{
'user': UserSerializer().serialize(u),
'total': t
} for u, t in stats.most_active_djs(since, until).limit(10)],
'most_played_tracks': [{
'track': TrackSerializer().serialize(u),
'total': t
} for u, t in stats.most_played_tracks(since, until).limit(10)],
'most_played_artists': [{
'artist': ArtistSerializer().serialize(u),
'total': t
} for u, t in stats.most_played_artists(since, until).limit(10)],
'most_played_genres': [{
'name': u.name,
'total': t
} for u, t in stats.most_played_genres(since, until).limit(10)],
'total_play_time_per_user':
[{
'user': UserSerializer().serialize(u),
'total': t
}
for u, t in stats.total_play_time_per_user(since, until).limit(10)
],
'total_play_time':
stats.total_play_time(since, until).first()[0],
'total_plays':
stats.total_plays(since, until).count(),
}
return http.OK(payload)
def should_populate_artists_name(self):
track = TrackFactory()
serialized = TrackSerializer().serialize(track)
assert serialized['artists'][0]['name'], 'artist name is empty'