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.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)