def setUp(self):
ServerTestCase.setUp(self)
DatabaseTestCase.setUp(self)
self.user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(self.user['musicbrainz_id'])
self.weirduser = db_user.get_or_create(2, 'weird\\user name')
db_user.agree_to_gdpr(self.weirduser['musicbrainz_id'])
def setUp(self):
ServerTestCase.setUp(self)
DatabaseTestCase.setUp(self)
self.authorized_user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(self.authorized_user['musicbrainz_id'])
self.unauthorized_user = db_user.get_or_create(2, 'blahblahblah')
db_user.agree_to_gdpr(self.unauthorized_user['musicbrainz_id'])
def test_dedup_different_users(self):
"""
Test to make sure timescale writer doesn't confuse listens with same timestamps
but different users to be duplicates
"""
user1 = db_user.get_or_create(1, 'testuser1')
user2 = db_user.get_or_create(2, 'testuser2')
r = self.send_listen(user1, 'valid_single.json')
self.assert200(r)
r = self.send_listen(user2, 'valid_single.json')
self.assert200(r)
time.sleep(2) # sleep to allow timescale-writer to do its thing
to_ts = int(time.time())
listens = self.ls.fetch_listens(user1['musicbrainz_id'],
to_ts=to_ts,
time_range=-1)
self.assertEqual(len(listens), 1)
listens = self.ls.fetch_listens(user2['musicbrainz_id'],
to_ts=to_ts,
time_range=-1)
self.assertEqual(len(listens), 1)
def setUp(self):
super(PinnedRecAPITestCase, self).setUp()
self.user = db_user.get_or_create(1, "test_user_1")
self.followed_user_1 = db_user.get_or_create(2, "followed_user_1")
self.followed_user_2 = db_user.get_or_create(3, "followed_user_2")
self.pinned_rec_samples = [
{
"recording_msid": "7f3d82ee-3817-4367-9eec-f33a312247a1",
"recording_mbid": "83b57de1-7f69-43cb-a0df-5f77a882e954",
"blurb_content": "Amazing first recording",
},
{
"recording_msid": "7f3d82ee-3817-4367-9eec-f33a312247a1",
"recording_mbid": "7e4142f4-b01e-4492-ae13-553493bad634",
"blurb_content": "Wonderful second recording",
},
{
"recording_msid": "7f3d82ee-3817-4367-9eec-f33a312247a1",
"recording_mbid": "a67ef149-3550-4547-b1eb-1b7c0b6879fa",
"blurb_content": "Incredible third recording",
},
{
"recording_msid": "67c4697d-d956-4257-8cc9-198e5cb67479",
"recording_mbid": "6867f7eb-b0d8-4c08-89e4-aa9d4b58ffb5",
"blurb_content": "Great fourth recording",
},
]
def setUp(self):
super(CFRecommendationsViewsTestCase, self).setUp()
self.user = db_user.get_or_create(1, 'vansika_1')
self.user2 = db_user.get_or_create(2, 'vansika_2')
self.user3 = db_user.get_or_create(3, 'vansika_3')
# generate test data
data = {"recording_mbid": []}
for score in range(1500, 0, -1):
data["recording_mbid"].append({
"recording_mbid": str(uuid.uuid4()),
"score": score
})
db_recommendations_cf_recording.insert_user_recommendation(
1,
UserRecommendationsJson(**{
'top_artist': data['recording_mbid'],
'similar_artist': []
}))
db_recommendations_cf_recording.insert_user_recommendation(
2,
UserRecommendationsJson(**{
'top_artist': [],
'similar_artist': data['recording_mbid']
}))
# get recommendations
self.user_recommendations = db_recommendations_cf_recording.get_user_recommendation(
1)
self.user2_recommendations = db_recommendations_cf_recording.get_user_recommendation(
2)
def setUp(self):
super(CFRecommendationsViewsTestCase, self).setUp()
self.user = db_user.get_or_create(1, 'vansika_1')
self.user2 = db_user.get_or_create(2, 'vansika_2')
self.user3 = db_user.get_or_create(3, 'vansika_3')
# insert recommendations
with open(self.path_to_data_file('cf_recommendations_db_data_for_api_test_recording.json'), 'r') as f:
self.payload = json.load(f)
db_recommendations_cf_recording.insert_user_recommendation(
1,
UserRecommendationsJson(**{
'top_artist': self.payload['recording_mbid'],
'similar_artist': []
})
)
db_recommendations_cf_recording.insert_user_recommendation(
2,
UserRecommendationsJson(**{
'top_artist': [],
'similar_artist': self.payload['recording_mbid']
})
)
# get recommendations
self.user_recommendations = db_recommendations_cf_recording.get_user_recommendation(1)
self.user2_recommendations = db_recommendations_cf_recording.get_user_recommendation(2)
def setUp(self):
super(ProfileViewsTestCase, self).setUp()
self.user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(self.user['musicbrainz_id'])
self.weirduser = db_user.get_or_create(2, 'weird\\user name')
db_user.agree_to_gdpr(self.weirduser['musicbrainz_id'])
self.service = SpotifyService()
def setUp(self):
ServerTestCase.setUp(self)
DatabaseTestCase.setUp(self)
self.log = logging.getLogger(__name__)
self.influx = InfluxDBClient(
host=current_app.config['INFLUX_HOST'],
port=current_app.config['INFLUX_PORT'],
database=current_app.config['INFLUX_DB_NAME'],
)
self.influx.query('''create database %s''' % current_app.config['INFLUX_DB_NAME'])
self.logstore = init_influx_connection(self.log, {
'REDIS_HOST': current_app.config['REDIS_HOST'],
'REDIS_PORT': current_app.config['REDIS_PORT'],
'REDIS_NAMESPACE': current_app.config['REDIS_NAMESPACE'],
'INFLUX_HOST': current_app.config['INFLUX_HOST'],
'INFLUX_PORT': current_app.config['INFLUX_PORT'],
'INFLUX_DB_NAME': current_app.config['INFLUX_DB_NAME'],
})
user = db_user.get_or_create(1, 'iliekcomputers')
self.user = User.from_dbrow(user)
weirduser = db_user.get_or_create(2, 'weird\\user name')
self.weirduser = User.from_dbrow(weirduser)
def test_menu_logged_in_error_show(self, mock_user_get):
""" If the user is logged in, if we show a 400 or 404 error, show the user menu"""
@self.app.route('/page_that_returns_400')
def view400():
raise BadRequest('bad request')
@self.app.route('/page_that_returns_404')
def view404():
raise NotFound('not found')
user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(user['musicbrainz_id'])
user = db_user.get_or_create(1, 'iliekcomputers')
mock_user_get.return_value = user
self.temporary_login(user['id'])
resp = self.client.get('/page_that_returns_400')
data = resp.data.decode('utf-8')
self.assert400(resp)
# username (menu header)
self.assertIn('iliekcomputers', data)
self.assertIn('Import!', data)
# item in user menu
self.assertIn('Your Listens', data)
mock_user_get.assert_called_with(user['id'])
resp = self.client.get('/page_that_returns_404')
data = resp.data.decode('utf-8')
self.assert404(resp)
# username (menu header)
self.assertIn('iliekcomputers', data)
self.assertIn('Import!', data)
# item in user menu
self.assertIn('Your Listens', data)
mock_user_get.assert_called_with(user['id'])
def setUp(self):
ServerTestCase.setUp(self)
DatabaseTestCase.setUp(self)
self.authorized_user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(self.authorized_user['musicbrainz_id'])
self.unauthorized_user = db_user.get_or_create(2, 'blahblahblah')
db_user.agree_to_gdpr(self.unauthorized_user['musicbrainz_id'])
def setUp(self):
ServerTestCase.setUp(self)
DatabaseTestCase.setUp(self)
self.log = logging.getLogger(__name__)
self.influx = InfluxDBClient(
host=current_app.config['INFLUX_HOST'],
port=current_app.config['INFLUX_PORT'],
database=current_app.config['INFLUX_DB_NAME'],
)
self.influx.query('''create database %s''' %
current_app.config['INFLUX_DB_NAME'])
self.logstore = init_influx_connection(
self.log, {
'REDIS_HOST': current_app.config['REDIS_HOST'],
'REDIS_PORT': current_app.config['REDIS_PORT'],
'REDIS_NAMESPACE': current_app.config['REDIS_NAMESPACE'],
'INFLUX_HOST': current_app.config['INFLUX_HOST'],
'INFLUX_PORT': current_app.config['INFLUX_PORT'],
'INFLUX_DB_NAME': current_app.config['INFLUX_DB_NAME'],
})
user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(user['musicbrainz_id'])
self.user = User.from_dbrow(user)
weirduser = db_user.get_or_create(2, 'weird\\user name')
self.weirduser = User.from_dbrow(weirduser)
def setUp(self):
self.server_url = "https://labs.api.listenbrainz.org/recording-mbid-lookup/json"
super(CFRecommendationsViewsTestCase, self).setUp()
self.user = db_user.get_or_create(1, 'vansika')
db_user.agree_to_gdpr(self.user['musicbrainz_id'])
self.user2 = db_user.get_or_create(2, 'vansika_1')
self.user3 = db_user.get_or_create(3, 'vansika_2')
# generate test data
data = {"recording_mbid": []}
for score in range(1500, 0, -1):
data["recording_mbid"].append(
{
"recording_mbid": str(uuid.uuid4()),
"score": score
}
)
db_recommendations_cf_recording.insert_user_recommendation(
2,
UserRecommendationsJson(**{
'top_artist': data['recording_mbid'],
'similar_artist': []
})
)
db_recommendations_cf_recording.insert_user_recommendation(
3,
UserRecommendationsJson(**{
'top_artist': [],
'similar_artist': data['recording_mbid']
})
)
def setUp(self):
self.server_url = "https://labs.api.listenbrainz.org/recording-mbid-lookup/json"
ServerTestCase.setUp(self)
DatabaseTestCase.setUp(self)
self.user = db_user.get_or_create(1, 'vansika')
db_user.agree_to_gdpr(self.user['musicbrainz_id'])
self.user2 = db_user.get_or_create(2, 'vansika_1')
self.user3 = db_user.get_or_create(3, 'vansika_2')
# insert recommendations
with open(self.path_to_data_file('cf_recommendations_db_data_for_api_test_recording.json'), 'r') as f:
self.payload = json.load(f)
db_recommendations_cf_recording.insert_user_recommendation(
2,
UserRecommendationsJson(**{
'top_artist': self.payload['recording_mbid'],
'similar_artist': []
})
)
db_recommendations_cf_recording.insert_user_recommendation(
3,
UserRecommendationsJson(**{
'top_artist': [],
'similar_artist': self.payload['recording_mbid']
})
)
def test_menu_logged_in_error_dont_show_user_loaded(self, mock_user_get):
""" If the user is logged in, if we show a 500 error, do not show the user menu
If the user has previously been loaded in the view, check that it's not
loaded while rendering the template"""
user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(user['musicbrainz_id'])
user = db_user.get_or_create(1, 'iliekcomputers')
mock_user_get.return_value = user
@self.app.route('/page_that_returns_500')
@login_required
def view500():
# flask-login user is loaded during @login_required, so check that the db has been queried
mock_user_get.assert_called_with(user['login_id'])
raise InternalServerError('error')
self.temporary_login(user['login_id'])
resp = self.client.get('/page_that_returns_500')
data = resp.data.decode('utf-8')
self.assertIn('Import', data)
# item not in user menu
self.assertNotIn('My Listens', data)
self.assertNotIn('Sign in', data)
# Even after rendering the template, the database has only been queried once (before the exception)
mock_user_get.assert_called_once()
self.assertIsInstance(self.get_context_variable('current_user'),
listenbrainz.webserver.login.User)
def setUp(self):
ServerTestCase.setUp(self)
DatabaseTestCase.setUp(self)
self.user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(self.user['musicbrainz_id'])
self.user2 = db_user.get_or_create(2, 'iliekcomputers_2')
db_user.agree_to_gdpr(self.user2['musicbrainz_id'])
self.user3 = db_user.get_or_create(3, 'iliekcomputers_3')
db_user.agree_to_gdpr(self.user3['musicbrainz_id'])
def test_delete_feed_events_token_for_authorization(self):
# Adding notification to the db
metadata_not = {
"message":
'You have a <a href="https://listenbrainz.org/non-existent-playlist">playlist</a>'
}
approved_user = db_user.get_or_create(11, "troi-bot")
self.client.post(url_for(
'user_timeline_event_api_bp.create_user_notification_event',
user_name=self.user['musicbrainz_id']),
data=json.dumps({"metadata": metadata_not}),
headers={
'Authorization':
'Token {}'.format(approved_user['auth_token'])
})
# Attempt to delete notifications by passing no Auth header
r_not = self.client.post(
url_for('user_timeline_event_api_bp.delete_feed_events',
user_name=self.user["musicbrainz_id"]),
data=json.dumps({
'event_type': UserTimelineEventType.NOTIFICATION.value,
'id': 1
}),
)
self.assert401(r_not)
# Adding recording recommendation to db
new_user = db_user.get_or_create(2, "riksucks")
metadata_rec = {
'artist_name': 'Nujabes',
'track_name': 'Aruarian Dance',
'artist_msid': str(uuid.uuid4()),
'recording_msid': str(uuid.uuid4()),
}
self.client.post(
url_for(
'user_timeline_event_api_bp.create_user_recording_recommendation_event',
user_name=new_user['musicbrainz_id']),
data=json.dumps({'metadata': metadata_rec}),
headers={
'Authorization': 'Token {}'.format(new_user['auth_token'])
},
)
# Deleting recommendation event
r_rec = self.client.post(
url_for('user_timeline_event_api_bp.delete_feed_events',
user_name=new_user["musicbrainz_id"]),
data=json.dumps({
'event_type':
UserTimelineEventType.RECORDING_RECOMMENDATION.value,
'id':
2
}),
headers={'Authorization': 'Token l33thaxors'})
self.assert401(r_rec)
def test_create_feedback(self, mock_notify):
self.user = db_user.get_or_create(1, "ernie")
self.user2 = db_user.get_or_create(2, "bert")
sample_feedback = [{
"user_id": self.user['id'],
"recording_msid": "d23f4719-9212-49f0-ad08-ddbfbfc50d6f",
"score": 1
}, {
"user_id": self.user2['id'],
"recording_msid": "222eb00d-9ead-42de-aec9-8f8c1509413d",
"score": -1
}]
for fb in sample_feedback:
db_feedback.insert(
Feedback(user_id=fb["user_id"],
recording_msid=fb["recording_msid"],
score=fb["score"]))
rec_feedback = [{
"recording_mbid": "d23f4719-9212-49f0-ad08-ddbfbfc50d6f",
"rating": 'love',
'user_id': self.user['id']
}, {
"recording_mbid": "222eb00d-9ead-42de-aec9-8f8c1509413d",
"rating": 'bad_recommendation',
"user_id": self.user['id']
}, {
"recording_mbid": "922eb00d-9ead-42de-aec9-8f8c1509413d",
"rating": 'hate',
"user_id": self.user2['id']
}]
for fb in rec_feedback:
db_rec_feedback.insert(
RecommendationFeedbackSubmit(
user_id=fb['user_id'],
recording_mbid=fb["recording_mbid"],
rating=fb["rating"]))
# create a feedback dump
self.runner.invoke(dump_manager.create_feedback,
['--location', self.tempdir])
self.assertEqual(len(os.listdir(self.tempdir)), 1)
dump_name = os.listdir(self.tempdir)[0]
mock_notify.assert_called_with(dump_name, 'feedback')
# make sure that the dump contains a feedback dump
archive_count = 0
for file_name in os.listdir(os.path.join(self.tempdir, dump_name)):
if file_name.endswith('.tar.xz'):
archive_count += 1
self.assertEqual(archive_count, 1)
def setUp(self):
super(UserViewsTestCase, self).setUp()
self.log = logging.getLogger(__name__)
self.logstore = timescale_connection._ts
user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(user['musicbrainz_id'])
self.user = User.from_dbrow(user)
weirduser = db_user.get_or_create(2, 'weird\\user name')
self.weirduser = User.from_dbrow(weirduser)
abuser = db_user.get_or_create(3, 'abuser')
self.abuser = User.from_dbrow(abuser)
def test_get_users_with_uncalculated_stats(self):
# create two users, set one's last_login
# to a very old value and one's last_login
# to now and then call the function
user1 = db_user.get_or_create(5, 'recentuser1')
with db.engine.connect() as connection:
connection.execute(
sqlalchemy.text("""
UPDATE "user"
SET last_login = to_timestamp(0)
WHERE musicbrainz_id = :musicbrainz_id
"""), {'musicbrainz_id': 'recentuser1'})
user2 = db_user.get_or_create(6, 'recentuser2')
with db.engine.connect() as connection:
connection.execute(
sqlalchemy.text("""
UPDATE "user"
SET last_login = NOW()
WHERE musicbrainz_id = :musicbrainz_id
"""), {'musicbrainz_id': 'recentuser2'})
users_with_uncalculated_stats = db_user.get_users_with_uncalculated_stats(
)
self.assertEqual(len(users_with_uncalculated_stats), 1)
self.assertEqual(users_with_uncalculated_stats[0]['musicbrainz_id'],
'recentuser2')
# now if we've calculated the stats for user2 recently (just now)
# then the function shouldn't return user2
# put some data in the stats table for user2
with db.engine.connect() as connection:
connection.execute(
sqlalchemy.text("""
INSERT INTO statistics.user (user_id, artist, release, recording, last_updated)
VALUES (:user_id, :artist, :release, :recording, NOW())
"""), {
'user_id': user2['id'],
'artist': ujson.dumps({}),
'release': ujson.dumps({}),
'recording': ujson.dumps({}),
})
users_with_uncalculated_stats = db_user.get_users_with_uncalculated_stats(
)
self.assertListEqual(users_with_uncalculated_stats, [])
def test_it_returns_follow_events(self):
# make a user you're following follow a new user
new_user_1 = db_user.get_or_create(104, 'new_user_1')
db_user_relationship.insert(self.following_user_1['id'],
new_user_1['id'], 'follow')
# this should show up in the events
r = self.client.get(
url_for('user_timeline_event_api_bp.user_feed',
user_name=self.main_user['musicbrainz_id']),
headers={'Authorization': f"Token {self.main_user['auth_token']}"},
query_string={'max_ts': int(time.time()) + 1})
self.assert200(r)
# should contain 3 events, the main user followed 2 people and then we created a new follow event
self.assertEqual(3, r.json['payload']['count'])
# the first event should be the latest one
self.assertEqual('follow',
r.json['payload']['events'][0]['event_type'])
self.assertEqual('following_1',
r.json['payload']['events'][0]['user_name'])
self.assertEqual(
'following_1',
r.json['payload']['events'][0]['metadata']['user_name_0'])
self.assertEqual(
'new_user_1',
r.json['payload']['events'][0]['metadata']['user_name_1'])
self.assertEqual(
'follow',
r.json['payload']['events'][0]['metadata']['relationship_type'])
# now, check the main user's own following events
self.assertEqual('follow',
r.json['payload']['events'][1]['event_type'])
self.assertEqual(self.main_user['musicbrainz_id'],
r.json['payload']['events'][1]['user_name'])
self.assertEqual(
self.main_user['musicbrainz_id'],
r.json['payload']['events'][1]['metadata']['user_name_0'])
self.assertEqual(
self.following_user_2['musicbrainz_id'],
r.json['payload']['events'][1]['metadata']['user_name_1'])
self.assertEqual(
'follow',
r.json['payload']['events'][1]['metadata']['relationship_type'])
self.assertEqual('follow',
r.json['payload']['events'][2]['event_type'])
self.assertEqual(self.main_user['musicbrainz_id'],
r.json['payload']['events'][2]['user_name'])
self.assertEqual(
self.main_user['musicbrainz_id'],
r.json['payload']['events'][2]['metadata']['user_name_0'])
self.assertEqual(
self.following_user_1['musicbrainz_id'],
r.json['payload']['events'][2]['metadata']['user_name_1'])
self.assertEqual(
'follow',
r.json['payload']['events'][2]['metadata']['relationship_type'])
def setUp(self):
super(FeedAPITestCase, self).setUp()
self.main_user = db_user.get_or_create(100, 'param')
self.following_user_1 = self.create_and_follow_user(
self.main_user['id'], 102, 'following_1')
self.following_user_2 = self.create_and_follow_user(
self.main_user['id'], 103, 'following_2')
def test_dedup_same_timestamp_different_tracks(self):
""" Test to check that if there are two tracks w/ the same timestamp,
they don't get considered as duplicates
"""
user = db_user.get_or_create('difftracksametsuser')
# send four different tracks with the same timestamp
r = self.send_listen(user, 'valid_single.json')
self.assert200(r)
r = self.send_listen(user,
'same_timestamp_diff_track_valid_single.json')
self.assert200(r)
r = self.send_listen(user,
'same_timestamp_diff_track_valid_single_2.json')
self.assert200(r)
r = self.send_listen(user,
'same_timestamp_diff_track_valid_single_3.json')
self.assert200(r)
time.sleep(2)
to_ts = int(time.time())
listens = self.ls.fetch_listens(user['musicbrainz_id'], to_ts=to_ts)
self.assertEqual(len(listens), 4)
def test_delete_feed_events_for_bad_request(self):
# Adding notification to the db
metadata_not = {
"message":
'You have a <a href="https://listenbrainz.org/non-existent-playlist">playlist</a>'
}
approved_user = db_user.get_or_create(11, "troi-bot")
self.client.post(url_for(
'user_timeline_event_api_bp.create_user_notification_event',
user_name=self.user['musicbrainz_id']),
data=json.dumps({"metadata": metadata_not}),
headers={
'Authorization':
'Token {}'.format(approved_user['auth_token'])
})
# Attempt to delete notification with empty JSON, should throw bad request error
r = self.client.post(url_for(
'user_timeline_event_api_bp.delete_feed_events',
user_name=self.user["musicbrainz_id"]),
data=json.dumps({}),
headers={
'Authorization':
'Token {}'.format(self.user['auth_token'])
})
self.assert400(r)
def test_get_events_for_feed_returns_events(self):
db_user_timeline_event.create_user_track_recommendation_event(
user_id=self.user['id'],
metadata=RecordingRecommendationMetadata(
track_name="Sunflower",
artist_name="Swae Lee & Post Malone",
recording_msid=str(uuid.uuid4()),
artist_msid=str(uuid.uuid4()),
))
new_user = db_user.get_or_create(2, 'superman')
db_user_timeline_event.create_user_track_recommendation_event(
user_id=new_user['id'],
metadata=RecordingRecommendationMetadata(
track_name="Sunflower",
artist_name="Swae Lee & Post Malone",
recording_msid=str(uuid.uuid4()),
artist_msid=str(uuid.uuid4()),
))
events = db_user_timeline_event.get_recording_recommendation_events_for_feed(
user_ids=(self.user['id'], new_user['id']),
min_ts=0,
max_ts=int(time.time()) + 10,
count=50,
)
self.assertEqual(2, len(events))
self.assertEqual(new_user['id'], events[0].user_id)
self.assertEqual(self.user['id'], events[1].user_id)
def test_get_follow_events_honors_timestamp_parameters(self):
ts = int(time.time())
db_user_relationship.insert(self.main_user['id'],
self.followed_user_1['id'], 'follow')
db_user_relationship.insert(self.main_user['id'],
self.followed_user_2['id'], 'follow')
time.sleep(3)
new_user = db_user.get_or_create(4, 'new_user')
db_user_relationship.insert(self.followed_user_1['id'], new_user['id'],
'follow')
# max_ts is too low, won't return anything
events = db_user_relationship.get_follow_events(
user_ids=(self.main_user['id'], self.followed_user_1['id']),
min_ts=0,
max_ts=ts,
count=50)
self.assertListEqual([], events)
# check that it honors min_ts as well
events = db_user_relationship.get_follow_events(
user_ids=(self.main_user['id'], self.followed_user_1['id']),
min_ts=ts + 1,
max_ts=ts + 10,
count=50)
self.assertEqual(1, len(events))
def test_get_following_for_user_returns_correct_data(self):
# no relationships yet, should return an empty list
following = db_user_relationship.get_following_for_user(
self.main_user['id'])
self.assertListEqual(following, [])
# make the main_user follow followed_user_1
db_user_relationship.insert(self.main_user['id'],
self.followed_user_1['id'], 'follow')
# the list of users main_user is following should have 1 element now
following = db_user_relationship.get_following_for_user(
self.main_user['id'])
self.assertEqual(1, len(following))
# make it so that the main user follows two users, followed_user_1 and followed_user_2
self.followed_user_2 = db_user.get_or_create(3, 'followed_user_2')
db_user_relationship.insert(self.main_user['id'],
self.followed_user_2['id'], 'follow')
# the list of users main_user is following should have 2 elements now
following = db_user_relationship.get_following_for_user(
self.main_user['id'])
self.assertEqual(2, len(following))
def test_dump_and_import_listens_escaped(self):
user = db_user.get_or_create(3, 'i have a\\weird\\user, na/me"\n')
count = self._create_test_data(user['musicbrainz_id'])
sleep(1)
count = self._create_test_data(self.testuser_name)
sleep(1)
temp_dir = tempfile.mkdtemp()
dump_location = self.logstore.dump_listens(
location=temp_dir,
)
sleep(1)
self.assertTrue(os.path.isfile(dump_location))
self.reset_influx_db()
self.logstore.import_listens_dump(dump_location)
sleep(1)
listens = self.logstore.fetch_listens(user_name=user['musicbrainz_id'], to_ts=1400000300)
self.assertEqual(len(listens), 5)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000050)
self.assertEqual(listens[4].ts_since_epoch, 1400000000)
listens = self.logstore.fetch_listens(user_name=self.testuser_name, to_ts=1400000300)
self.assertEqual(len(listens), 5)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000050)
self.assertEqual(listens[4].ts_since_epoch, 1400000000)
def test_dump_and_import_listens_escaped(self):
user = db_user.get_or_create('i have a\\weird\\user, na/me"\n')
count = self._create_test_data(user['musicbrainz_id'])
sleep(1)
count = self._create_test_data(self.testuser_name)
sleep(1)
temp_dir = tempfile.mkdtemp()
dump_location = self.logstore.dump_listens(location=temp_dir, )
sleep(1)
self.assertTrue(os.path.isfile(dump_location))
self.reset_influx_db()
self.logstore.import_listens_dump(dump_location)
sleep(1)
listens = self.logstore.fetch_listens(user_name=user['musicbrainz_id'],
to_ts=1400000300)
self.assertEqual(len(listens), 5)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000050)
self.assertEqual(listens[4].ts_since_epoch, 1400000000)
listens = self.logstore.fetch_listens(user_name=self.testuser_name,
to_ts=1400000300)
self.assertEqual(len(listens), 5)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000050)
self.assertEqual(listens[4].ts_since_epoch, 1400000000)
def test_delete_feed_events_for_db_exceptions(self, mock_create_event):
# Adding notification to the db
metadata_not = {
"message":
'You have a <a href="https://listenbrainz.org/non-existent-playlist">playlist</a>'
}
approved_user = db_user.get_or_create(11, "troi-bot")
self.client.post(url_for(
'user_timeline_event_api_bp.create_user_notification_event',
user_name=self.user['musicbrainz_id']),
data=json.dumps({"metadata": metadata_not}),
headers={
'Authorization':
'Token {}'.format(self.user['auth_token'])
})
# Attempt to delete notification
r = self.client.post(url_for(
'user_timeline_event_api_bp.delete_feed_events',
user_name=self.user["musicbrainz_id"]),
data=json.dumps({
'event_type':
UserTimelineEventType.NOTIFICATION.value,
'id':
1
}),
headers={
'Authorization':
'Token {}'.format(self.user['auth_token'])
})
self.assert500(r)
data = json.loads(r.data)
self.assertEqual('Something went wrong. Please try again',
data['error'])
def get_user():
"""Function should fetch user data from database, or, if necessary, create it, and return it."""
s = _musicbrainz.get_auth_session(
data={
'code': _fetch_data('code'),
'grant_type': 'authorization_code',
'redirect_uri': url_for('login.musicbrainz_post', _external=True)
},
decoder=lambda b: ujson.loads(b.decode("utf-8")))
data = s.get('oauth2/userinfo').json()
musicbrainz_id = data.get('sub')
musicbrainz_row_id = data.get('metabrainz_user_id')
user = db_user.get_or_create(musicbrainz_row_id, musicbrainz_id)
if user:
if not user['musicbrainz_row_id']:
db_user.update_musicbrainz_row_id(musicbrainz_id,
data['metabrainz_user_id'])
# if the musicbrainz_id of the user from MusicBrainz is different, we need
# to update it here too
if user['musicbrainz_id'] != musicbrainz_id:
db_user.update_musicbrainz_id(user['id'], musicbrainz_id)
return User.from_dbrow(user)
else:
return None
def test_get_notification_event(self):
metadata = {
"message":
'You have a <a href="https://listenbrainz.org/non-existent-playlist">playlist</a>'
}
approved_user = db_user.get_or_create(11, "troi-bot")
self.client.post(url_for(
'user_timeline_event_api_bp.create_user_notification_event',
user_name=self.user['musicbrainz_id']),
data=json.dumps({"metadata": metadata}),
headers={
'Authorization':
'Token {}'.format(approved_user['auth_token'])
})
r = self.client.get(url_for('user_timeline_event_api_bp.user_feed',
user_name=self.user['musicbrainz_id']),
headers={
'Authorization':
'Token {}'.format(self.user['auth_token'])
})
payload = r.json['payload']
self.assertEqual(1, payload['count'])
self.assertEqual(self.user['musicbrainz_id'], payload['user_id'])
event = payload['events'][0]
self.assertEqual('notification', event['event_type'])
self.assertEqual(
'You have a <a href="https://listenbrainz.org/non-existent-playlist">playlist</a>',
event['metadata']['message'])
self.assertEqual(approved_user['musicbrainz_id'], event['user_name'])
def test_dump_and_import_listens_escaped(self):
user = db_user.get_or_create(3, 'i have a\\weird\\user, na/me"\n')
self._create_test_data(user['musicbrainz_id'])
self._create_test_data(self.testuser_name)
temp_dir = tempfile.mkdtemp()
dump_location = self.logstore.dump_listens(
location=temp_dir,
dump_id=1,
end_time=datetime.now(),
)
self.assertTrue(os.path.isfile(dump_location))
self.reset_timescale_db()
self.logstore.import_listens_dump(dump_location)
listens, min_ts, max_ts = self.logstore.fetch_listens(
user_name=user['musicbrainz_id'], to_ts=1400000300)
self.assertEqual(len(listens), 5)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000050)
self.assertEqual(listens[4].ts_since_epoch, 1400000000)
listens, min_ts, max_ts = self.logstore.fetch_listens(
user_name=self.testuser_name, to_ts=1400000300)
self.assertEqual(len(listens), 5)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000050)
self.assertEqual(listens[4].ts_since_epoch, 1400000000)
shutil.rmtree(temp_dir)
def test_delete_single_listen(self):
uid = random.randint(2000, 1 << 31)
testuser = db_user.get_or_create(uid, "user_%d" % uid)
testuser_name = testuser['musicbrainz_id']
self._create_test_data(testuser_name)
listens, min_ts, max_ts = self.logstore.fetch_listens(
user_name=testuser_name, to_ts=1400000300)
self.assertEqual(len(listens), 5)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000050)
self.assertEqual(listens[4].ts_since_epoch, 1400000000)
self.logstore.delete_listen(1400000050, testuser_name,
"c7a41965-9f1e-456c-8b1d-27c0f0dde280")
listens, min_ts, max_ts = self.logstore.fetch_listens(
user_name=testuser_name, to_ts=1400000300)
self.assertEqual(len(listens), 4)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000000)
self.assertEqual(
self.logstore.get_listen_count_for_user(testuser_name), 4)
min_ts, max_ts = self.logstore.get_timestamps_for_user(testuser_name)
self.assertEqual(min_ts, 1400000000)
self.assertEqual(max_ts, 1400000200)
def test_fetch_listens_escaped(self):
user = db_user.get_or_create(2, 'i have a\\weird\\user, name"\n')
user_name = user['musicbrainz_id']
self._create_test_data(user_name)
listens = self.logstore.fetch_listens(user_name=user_name, from_ts=1400000100)
self.assertEqual(len(listens), 2)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
def test_dedup_same_batch(self):
user = db_user.get_or_create(3, 'phifedawg')
r = self.send_listen(user, 'same_batch_duplicates.json')
self.assert200(r)
time.sleep(2)
to_ts = int(time.time())
listens = self.ls.fetch_listens(user['musicbrainz_id'], to_ts=to_ts)
self.assertEqual(len(listens), 1)
def setUp(self):
super(APICompatDeprecatedTestCase, self).setUp()
self.user = db_user.get_or_create(1, 'apicompatoldtestuser')
self.ls = InfluxListenStore({
'REDIS_HOST': config.REDIS_HOST,
'REDIS_PORT': config.REDIS_PORT,
'REDIS_NAMESPACE': config.REDIS_NAMESPACE,
'INFLUX_HOST': config.INFLUX_HOST,
'INFLUX_PORT': config.INFLUX_PORT,
'INFLUX_DB_NAME': config.INFLUX_DB_NAME,
}, self.app.logger)
def test_dedup_different_users(self):
"""
Test to make sure influx writer doesn't confuse listens with same timestamps
but different users to be duplicates
"""
user1 = db_user.get_or_create(1, 'testuser1')
user2 = db_user.get_or_create(2, 'testuser2')
r = self.send_listen(user1, 'valid_single.json')
self.assert200(r)
r = self.send_listen(user2, 'valid_single.json')
self.assert200(r)
time.sleep(2) # sleep to allow influx-writer to do its thing
to_ts = int(time.time())
listens = self.ls.fetch_listens(user1['musicbrainz_id'], to_ts=to_ts)
self.assertEqual(len(listens), 1)
listens = self.ls.fetch_listens(user2['musicbrainz_id'], to_ts=to_ts)
self.assertEqual(len(listens), 1)
def test_delete_listens_escaped(self):
user = db_user.get_or_create(213, 'i have a\\weird\\user, na/me"\n')
count = self._create_test_data(user['musicbrainz_id'])
listens = self.logstore.fetch_listens(user_name=user['musicbrainz_id'], to_ts=1400000300)
self.assertEqual(len(listens), 5)
self.assertEqual(listens[0].ts_since_epoch, 1400000200)
self.assertEqual(listens[1].ts_since_epoch, 1400000150)
self.assertEqual(listens[2].ts_since_epoch, 1400000100)
self.assertEqual(listens[3].ts_since_epoch, 1400000050)
self.assertEqual(listens[4].ts_since_epoch, 1400000000)
self.logstore.delete(user['musicbrainz_id'])
listens = self.logstore.fetch_listens(user_name=user['musicbrainz_id'], to_ts=1400000300)
self.assertEqual(len(listens), 0)
def test_dedup(self):
user = db_user.get_or_create(1, 'testinfluxwriteruser')
# send the same listen twice
r = self.send_listen(user, 'valid_single.json')
self.assert200(r)
time.sleep(2)
r = self.send_listen(user, 'valid_single.json')
self.assert200(r)
time.sleep(2)
to_ts = int(time.time())
listens = self.ls.fetch_listens(user['musicbrainz_id'], to_ts=to_ts)
self.assertEqual(len(listens), 1)
def test_dedup_user_special_characters(self):
user = db_user.get_or_create(2, 'i have a\\weird\\user, name"\n')
# send the same listen twice
r = self.send_listen(user, 'valid_single.json')
self.assert200(r)
time.sleep(2)
r = self.send_listen(user, 'valid_single.json')
self.assert200(r)
time.sleep(2)
to_ts = int(time.time())
listens = self.ls.fetch_listens(user['musicbrainz_id'], to_ts=to_ts)
self.assertEqual(len(listens), 1)
def get_user():
"""Function should fetch user data from database, or, if necessary, create it, and return it."""
s = _musicbrainz.get_auth_session(data={
'code': _fetch_data('code'),
'grant_type': 'authorization_code',
'redirect_uri': url_for('login.musicbrainz_post', _external=True)
}, decoder=lambda b: ujson.loads(b.decode("utf-8")))
data = s.get('oauth2/userinfo').json()
musicbrainz_id = data.get('sub')
musicbrainz_row_id = data.get('metabrainz_user_id')
user = db_user.get_or_create(musicbrainz_row_id, musicbrainz_id)
if user:
if not user['musicbrainz_row_id']:
db_user.update_musicbrainz_row_id(musicbrainz_id, data['metabrainz_user_id'])
return User.from_dbrow(user)
else:
return None
def setUp(self):
super(APICompatTestCase, self).setUp()
self.lb_user = db_user.get_or_create(1, 'apicompattestuser')
self.lfm_user = User(
self.lb_user['id'],
self.lb_user['created'],
self.lb_user['musicbrainz_id'],
self.lb_user['auth_token'],
)
self.ls = InfluxListenStore({
'REDIS_HOST': current_app.config['REDIS_HOST'],
'REDIS_PORT': current_app.config['REDIS_PORT'],
'REDIS_NAMESPACE': current_app.config['REDIS_NAMESPACE'],
'INFLUX_HOST': current_app.config['INFLUX_HOST'],
'INFLUX_PORT': current_app.config['INFLUX_PORT'],
'INFLUX_DB_NAME': current_app.config['INFLUX_DB_NAME'],
}, self.app.logger)
def test_dedup_same_timestamp_different_tracks(self):
""" Test to check that if there are two tracks w/ the same timestamp,
they don't get considered as duplicates
"""
user = db_user.get_or_create(1, 'difftracksametsuser')
# send four different tracks with the same timestamp
r = self.send_listen(user, 'valid_single.json')
self.assert200(r)
r = self.send_listen(user, 'same_timestamp_diff_track_valid_single.json')
self.assert200(r)
r = self.send_listen(user, 'same_timestamp_diff_track_valid_single_2.json')
self.assert200(r)
r = self.send_listen(user, 'same_timestamp_diff_track_valid_single_3.json')
self.assert200(r)
time.sleep(2)
to_ts = int(time.time())
listens = self.ls.fetch_listens(user['musicbrainz_id'], to_ts=to_ts)
self.assertEqual(len(listens), 4)
def setUp(self):
super().setUp()
self.user = db_user.get_or_create(1, 'iliekcomputers')
db_user.agree_to_gdpr(self.user['musicbrainz_id'])
def setUp(self):
super(BigQueryJobRunnerTestCase, self).setUp()
self.app = create_app() # create a flask app for config purposes
self.sc = BigQueryJobRunner()
self.sc.bigquery = MagicMock()
self.user = db_user.get_or_create(21, 'stats_calculator_test_user')
def setUp(self):
super(APITestCase, self).setUp()
self.user = db_user.get_or_create(1, 'testuserpleaseignore')
def setUp(self):
DatabaseTestCase.setUp(self)
self.user = db_user.get_or_create(1, 'stats_user')
def test_delete_listens_no_measurement(self):
user = db_user.get_or_create(12, 'user_with_no_measurement')
self.logstore.delete(user['musicbrainz_id'])
listens = self.logstore.fetch_listens(user_name=user['musicbrainz_id'], to_ts=1400000300)
self.assertEqual(len(listens), 0)
