def test_get_active_users_to_process(self): db_user.create(2, 'newspotifyuser') db_spotify.create_spotify( user_id=2, user_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), ) users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 2) self.assertEqual(users[0]['user_id'], 1) self.assertEqual(users[1]['user_id'], 2) # check order, the users should be sorted by latest_listened_at timestamp db_user.create(3, 'newnewspotifyuser') db_spotify.create_spotify( user_id=3, user_token='tokentoken', refresh_token='newrefresh_token', token_expires_ts=int(time.time()), ) t = int(time.time()) db_spotify.update_latest_listened_at(2, t + 20) db_spotify.update_latest_listened_at(1, t + 10) users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 3) self.assertEqual(users[0]['user_id'], 2) self.assertEqual(users[1]['user_id'], 1) self.assertEqual(users[2]['user_id'], 3) db_spotify.add_update_error(2, 'something broke') db_spotify.add_update_error(3, 'oops.') users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 1) self.assertEqual(users[0]['user_id'], 1)
def test_get_active_users_to_process(self): db_user.create(2, 'newspotifyuser') db_spotify.create_spotify( user_id=2, user_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), ) users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 2) self.assertEqual(users[0]['user_id'], 1) self.assertEqual(users[1]['user_id'], 2) # check order, the users should be sorted by latest_listened_at timestamp db_user.create(3, 'newnewspotifyuser') db_spotify.create_spotify( user_id=3, user_token='tokentoken', refresh_token='newrefresh_token', token_expires_ts=int(time.time()), ) t = int(time.time()) db_spotify.update_latest_listened_at(2, t + 20) db_spotify.update_latest_listened_at(1, t + 10) users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 3) self.assertEqual(users[0]['user_id'], 2) self.assertEqual(users[1]['user_id'], 1) self.assertEqual(users[2]['user_id'], 3) db_spotify.add_update_error(2, 'something broke') db_spotify.add_update_error(3, 'oops.') users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 1) self.assertEqual(users[0]['user_id'], 1)
def test_import_postgres_db(self): # create a user with self.app.app_context(): one_id = db_user.create(1, 'test_user') user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # do a db dump and reset the db private_dump, private_ts_dump, public_dump, public_ts_dump = db_dump.dump_postgres_db( self.tempdir) self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) # import the dump db_dump.import_postgres_dump(private_dump, None, public_dump, None) user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # reset again, and use more threads to import self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) db_dump.import_postgres_dump(private_dump, None, public_dump, None, threads=2) user_count = db_user.get_user_count() self.assertEqual(user_count, 1) two_id = db_user.create(2, 'vnskprk') self.assertGreater(two_id, one_id)
def test_dump_postgres_db_table_entries(self): db_user.create('test_user') timestamp = datetime.today() location = db_dump.dump_postgres_db(self.tempdir, dump_time=timestamp) dump_entries = db_dump.get_dump_entries() self.assertEqual(len(dump_entries), 1) self.assertEqual(dump_entries[0]['created'].strftime('%s'), timestamp.strftime('%s'))
def test_import_postgres_db(self): # create a user db_user.create(1, 'test_user') user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # do a db dump and reset the db private_dump, public_dump = db_dump.dump_postgres_db(self.tempdir) self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) # import the dump db_dump.import_postgres_dump(private_dump, public_dump) user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # reset again, and use more threads to import self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) db_dump.import_postgres_dump(private_dump, public_dump, threads=2) user_count = db_user.get_user_count() self.assertEqual(user_count, 1)
def test_import_postgres_db(self): # create a user with self.app.app_context(): one_id = db_user.create(1, 'test_user') user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # do a db dump and reset the db private_dump, public_dump = db_dump.dump_postgres_db(self.tempdir) self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) # import the dump db_dump.import_postgres_dump(private_dump, public_dump) user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # reset again, and use more threads to import self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) db_dump.import_postgres_dump(private_dump, public_dump, threads=2) user_count = db_user.get_user_count() self.assertEqual(user_count, 1) two_id = db_user.create(2, 'vnskprk') self.assertGreater(two_id, one_id)
def test_import_postgres_db(self): # create a user db_user.create('test_user') user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # do a db dump and reset the db location = db_dump.dump_postgres_db(self.tempdir) self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) # import the dump db_dump.import_postgres_dump(location) user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # reset again, and use more threads to import self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) db_dump.import_postgres_dump(location, threads=2) user_count = db_user.get_user_count() self.assertEqual(user_count, 1)
def test_get_similar_users(self): user_id_21 = db_user.create(21, "twenty_one") user_id_22 = db_user.create(22, "twenty_two") user_id_23 = db_user.create(23, "twenty_three") similar_users_21 = { str(user_id_22): [0.4, .01], str(user_id_23): [0.7, 0.001] } similar_users_22 = {str(user_id_21): [0.4, .01]} similar_users_23 = {str(user_id_21): [0.7, .02]} similar_users = { str(user_id_21): similar_users_21, str(user_id_22): similar_users_22, str(user_id_23): similar_users_23, } import_user_similarities(similar_users) self.assertDictEqual( { "twenty_two": 0.4, "twenty_three": 0.7 }, db_user.get_similar_users(user_id_21).similar_users) self.assertDictEqual( {"twenty_one": 0.4}, db_user.get_similar_users(user_id_22).similar_users) self.assertDictEqual( {"twenty_one": 0.7}, db_user.get_similar_users(user_id_23).similar_users)
def generate_data(from_date, num_records, user_name): test_data = [] current_date = to_epoch(from_date) artist_msid = str(uuid.uuid4()) user = db_user.get_by_mb_id(user_name) if not user: db_user.create(user_name) user = db_user.get_by_mb_id(user_name) for i in range(num_records): current_date += 1 # Add one second item = Listen( user_id=user['id'], user_name=user_name, timestamp=datetime.utcfromtimestamp(current_date), artist_msid=artist_msid, recording_msid=str(uuid.uuid4()), release_msid=str(uuid.uuid4()), data={ 'artist_name': 'Test Artist Pls ignore', 'track_name': 'Hello Goodbye', 'additional_info': {}, }, ) test_data.append(item) return test_data
def test_get_similar_users(self): user_id_21 = db_user.create(21, "twenty_one") user_id_22 = db_user.create(22, "twenty_two") user_id_23 = db_user.create(23, "twenty_three") similar_users_21 = {"twenty_two": 0.4, "twenty_three": 0.7} similar_users_22 = {"twenty_one": 0.4} similar_users_23 = {"twenty_one": 0.7} similar_users = { "twenty_one": similar_users_21, "twenty_two": similar_users_22, "twenty_three": similar_users_23, } import_user_similarities(similar_users) self.assertDictEqual( similar_users_21, db_user.get_similar_users(user_id_21).similar_users) self.assertDictEqual( similar_users_22, db_user.get_similar_users(user_id_22).similar_users) self.assertDictEqual( similar_users_23, db_user.get_similar_users(user_id_23).similar_users)
def test_get_user_by_id(self): user_id_24 = db_user.create(24, "twenty_four") user_id_25 = db_user.create(25, "twenty_five") users = {user_id_24: "twenty_four", user_id_25: "twenty_five"} self.assertDictEqual(users, db_user.get_users_by_id([user_id_24, user_id_25]))
def test_dump_postgres_db_table_entries(self): with self.app.app_context(): db_user.create(1, 'test_user') timestamp = datetime.today() location = db_dump.dump_postgres_db(self.tempdir, dump_time=timestamp) dump_entries = db_dump.get_dump_entries() self.assertEqual(len(dump_entries), 1) self.assertEqual(dump_entries[0]['created'].strftime('%s'), timestamp.strftime('%s'))
def setUp(self): super(SpotifyDatabaseTestCase, self).setUp() db_user.create(1, 'testspotifyuser') self.user = db_user.get(1) db_spotify.create_spotify( user_id=self.user['id'], user_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), )
def test_create_spotify(self): db_user.create(2, 'spotify') db_spotify.create_spotify( user_id=2, user_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), ) token = db_spotify.get_token_for_user(2) self.assertEqual(token, 'token')
def test_create_spotify(self): db_user.create(2, 'spotify') db_spotify.create_spotify( user_id=2, user_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), ) token = db_spotify.get_token_for_user(2) self.assertEqual(token, 'token')
def setUp(self): super(SpotifyDatabaseTestCase, self).setUp() db_user.create(1, 'testspotifyuser') self.user = db_user.get(1) db_spotify.create_spotify( user_id=self.user['id'], user_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), )
def test_create_oauth(self): db_user.create(2, 'spotify') db_oauth.save_token(user_id=2, service=ExternalServiceType.SPOTIFY, access_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), record_listens=True, scopes=['user-read-recently-played']) user = db_oauth.get_token(2, ExternalServiceType.SPOTIFY) self.assertEqual('token', user['access_token'])
def test_get_all_users(self): """ Tests that get_all_users returns ALL users in the db """ users = db_user.get_all_users() self.assertEqual(len(users), 0) db_user.create(8, 'user1') users = db_user.get_all_users() self.assertEqual(len(users), 1) db_user.create(9, 'user2') users = db_user.get_all_users() self.assertEqual(len(users), 2)
def setUp(self): super(OAuthDatabaseTestCase, self).setUp() db_user.create(1, 'testspotifyuser') self.user = db_user.get(1) db_oauth.save_token(user_id=self.user['id'], service=ExternalServiceType.SPOTIFY, access_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), record_listens=True, scopes=['user-read-recently-played'])
def test_import_dump_many_users(self): for i in range(50): db_user.create('user%d' % i) 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() done = self.logstore.import_listens_dump(dump_location) sleep(1) self.assertEqual(done, len(db_user.get_all_users()))
def test_import_dump_many_users(self): for i in range(2, 52): db_user.create(i, 'user%d' % i) 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() done = self.logstore.import_listens_dump(dump_location) sleep(1) self.assertEqual(done, len(db_user.get_all_users()))
def test_fetch_top_similar_users(self): user_id = db_user.create(1, "tom") user_id2 = db_user.create(2, "jerry") with db.engine.connect() as connection: connection.execute(sqlalchemy.text("""INSERT INTO recommendation.similar_user (user_id, similar_users) VALUES (1, '{ "jerry" : 0.42 }')""")) connection.execute(sqlalchemy.text("""INSERT INTO recommendation.similar_user (user_id, similar_users) VALUES (2, '{ "tom" : 0.42 }')""")) similar_users = get_top_similar_users() assert len(similar_users) == 1 assert similar_users[0][0] == 'jerry' assert similar_users[0][1] == 'tom' assert similar_users[0][2] == "0.420"
def setUp(self): super(TestAPICompatUserClass, self).setUp() self.log = logging.getLogger(__name__) self.logstore = init_influx_connection(self.log, { 'INFLUX_HOST': config.INFLUX_HOST, 'INFLUX_PORT': config.INFLUX_PORT, 'INFLUX_DB_NAME': config.INFLUX_DB_NAME, 'REDIS_HOST': config.REDIS_HOST, 'REDIS_PORT': config.REDIS_PORT, 'REDIS_NAMESPACE': config.REDIS_NAMESPACE, }) # Create a user uid = db_user.create(1, "test_api_compat_user") self.assertIsNotNone(db_user.get(uid)) with db.engine.connect() as connection: result = connection.execute(text(""" SELECT * FROM "user" WHERE id = :id """), { "id": uid, }) row = result.fetchone() self.user = User(row['id'], row['created'], row['musicbrainz_id'], row['auth_token'])
def test_session_create(self): user = User.load_by_id(db_user.create(1, "test")) token = Token.generate(user.api_key) token.approve(user.name) session = Session.create(token) self.assertIsInstance(session, Session) self.assertDictEqual(user.__dict__, session.user.__dict__)
def setUp(self): super(TestAPICompatUserClass, self).setUp() self.log = logging.getLogger(__name__) self.logstore = init_influx_connection( self.log, { 'INFLUX_HOST': config.INFLUX_HOST, 'INFLUX_PORT': config.INFLUX_PORT, 'INFLUX_DB_NAME': config.INFLUX_DB_NAME, 'REDIS_HOST': config.REDIS_HOST, 'REDIS_PORT': config.REDIS_PORT, }) # Create a user uid = db_user.create("test_api_compat_user") self.assertIsNotNone(db_user.get(uid)) with db.engine.connect() as connection: result = connection.execute( text(""" SELECT * FROM "user" WHERE id = :id """), { "id": uid, }) row = result.fetchone() self.user = User(row['id'], row['created'], row['musicbrainz_id'], row['auth_token']) # Insert some listens date = datetime(2015, 9, 3, 0, 0, 0) self.log.info("Inserting test data...") test_data = generate_data(date, 100, self.user.name) self.logstore.insert(test_data) self.log.info("Test data inserted")
def test_session_create(self): user = User.load_by_id(db_user.create("test")) token = Token.generate(user.api_key) token.approve(user.name) session = Session.create(token) self.assertIsInstance(session, Session) self.assertDictEqual(user.__dict__, session.user.__dict__)
def test_dump_recording_feedback(self): # create a user with self.app.app_context(): one_id = db_user.create(1, 'test_user') user_count = db_user.get_user_count() self.assertEqual(user_count, 1) # insert a feedback record feedback = Feedback( user_id=one_id, recording_msid="d23f4719-9212-49f0-ad08-ddbfbfc50d6f", score=1) db_feedback.insert(feedback) # do a db dump and reset the db private_dump, private_ts_dump, public_dump, public_ts_dump = db_dump.dump_postgres_db( self.tempdir) self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) self.assertEqual( db_feedback.get_feedback_count_for_user(user_id=one_id), 0) # import the dump and check the records are inserted db_dump.import_postgres_dump(private_dump, None, public_dump, None) user_count = db_user.get_user_count() self.assertEqual(user_count, 1) dumped_feedback = db_feedback.get_feedback_for_user(user_id=one_id, limit=1, offset=0) self.assertEqual(len(dumped_feedback), 1) self.assertEqual(dumped_feedback[0].user_id, feedback.user_id) self.assertEqual(dumped_feedback[0].recording_msid, feedback.recording_msid) self.assertEqual(dumped_feedback[0].score, feedback.score) # reset again, and use more threads to import self.reset_db() user_count = db_user.get_user_count() self.assertEqual(user_count, 0) dumped_feedback = [] db_dump.import_postgres_dump(private_dump, None, public_dump, None, threads=2) user_count = db_user.get_user_count() self.assertEqual(user_count, 1) dumped_feedback = db_feedback.get_feedback_for_user(user_id=one_id, limit=1, offset=0) self.assertEqual(len(dumped_feedback), 1) self.assertEqual(dumped_feedback[0].user_id, feedback.user_id) self.assertEqual(dumped_feedback[0].recording_msid, feedback.recording_msid) self.assertEqual(dumped_feedback[0].score, feedback.score)
def setUp(self): super(TestAPICompatUserClass, self).setUp() self.log = logging.getLogger(__name__) self.logstore = init_influx_connection( self.log, { 'INFLUX_HOST': config.INFLUX_HOST, 'INFLUX_PORT': config.INFLUX_PORT, 'INFLUX_DB_NAME': config.INFLUX_DB_NAME, 'REDIS_HOST': config.REDIS_HOST, 'REDIS_PORT': config.REDIS_PORT, 'REDIS_NAMESPACE': config.REDIS_NAMESPACE, }) # Create a user uid = db_user.create("test_api_compat_user") self.assertIsNotNone(db_user.get(uid)) with db.engine.connect() as connection: result = connection.execute( text(""" SELECT * FROM "user" WHERE id = :id """), { "id": uid, }) row = result.fetchone() self.user = User(row['id'], row['created'], row['musicbrainz_id'], row['auth_token'])
def setUp(self): super(TestRedisListenStore, self).setUp() self.log = logging.getLogger(__name__) self._redis = init_redis_connection(self.log, self.config.REDIS_HOST, self.config.REDIS_PORT) self.testuser_id = db_user.create(1, "test") self._create_test_data()
def test_update_user_details(self): user_id = db_user.create(17, "barbazfoo", "*****@*****.**") db_user.update_user_details(user_id, "hello-world", "*****@*****.**") user = db_user.get(user_id, fetch_email=True) self.assertEqual(user["id"], user_id) self.assertEqual(user["musicbrainz_id"], "hello-world") self.assertEqual(user["email"], "*****@*****.**")
def setUp(self): super().setUp() self.app = create_app() self.tempdir = tempfile.mkdtemp() self.runner = CliRunner() self.listenstore = timescale_connection._ts self.user_id = db_user.create(1, 'iliekcomputers') self.user_name = db_user.get(self.user_id)['musicbrainz_id']
def test_search(self): searcher_id = db_user.create(0, "Cécile") db_user.create(1, "Cecile") db_user.create(2, "lucifer") db_user.create(3, "rob") with db.engine.connect() as connection: connection.execute( sqlalchemy.text( """INSERT INTO recommendation.similar_user (user_id, similar_users) VALUES (:user_id, :similar_users)""" ), { "user_id": searcher_id, "similar_users": json.dumps({ "Cecile": [0.42, 0.20], "lucifer": [0.61, 0.25], "rob": [0.87, 0.43] }) }) results = db_user.search("cif", 10, searcher_id) self.assertEqual(results, [("Cécile", 0.1, None), ("Cecile", 0.1, 0.42), ("lucifer", 0.0909091, 0.61)])
def test_import_dump_many_users(self): for i in range(2, 52): db_user.create(i, 'user%d' % i) temp_dir = tempfile.mkdtemp() dump_location = self.logstore.dump_listens( location=temp_dir, dump_id=1, end_time=datetime.now(), ) sleep(1) self.assertTrue(os.path.isfile(dump_location)) self.reset_influx_db() done = self.logstore.import_listens_dump(dump_location) sleep(1) self.assertEqual(done, len(db_user.get_all_users())) shutil.rmtree(temp_dir)
def setUp(self): super(TestPostgresListenStore, self).setUp() self.log = logging.getLogger(__name__) self.logstore = init_postgres_connection(self.config.SQLALCHEMY_DATABASE_URI) # TODO: Does this use the normal or test DB?? self.testuser_id = db_user.create("test") user = db_user.get(self.testuser_id) print(user) self.testuser_name = db_user.get(self.testuser_id)['musicbrainz_id']
def test_mb_user_deleter_valid_account(self, mock_delete_user, mock_authorize_mb_user_deleter): user1 = db_user.create(1, 'iliekcomputers') r = self.client.get( url_for('index.mb_user_deleter', musicbrainz_row_id=1, access_token='132')) self.assert200(r) mock_authorize_mb_user_deleter.assert_called_once_with('132') mock_delete_user.assert_called_once_with('iliekcomputers')
def test_get_active_users_to_process(self): db_user.create(2, 'newspotifyuser') db_oauth.save_token( user_id=2, service=ExternalServiceType.SPOTIFY, access_token='token', refresh_token='refresh_token', token_expires_ts=int(time.time()), record_listens=True, scopes=['user-read-recently-played'] ) users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 2) self.assertEqual(users[0]['user_id'], 1) self.assertEqual(users[0]['musicbrainz_row_id'], 1) self.assertEqual(users[1]['user_id'], 2) self.assertEqual(users[1]['musicbrainz_row_id'], 2) # check order, the users should be sorted by latest_listened_at timestamp db_user.create(3, 'newnewspotifyuser') db_oauth.save_token( user_id=3, service=ExternalServiceType.SPOTIFY, access_token='tokentoken', refresh_token='newrefresh_token', token_expires_ts=int(time.time()), record_listens=True, scopes=['user-read-recently-played'] ) t = int(time.time()) db_import.update_latest_listened_at(2, ExternalServiceType.SPOTIFY, t + 20) db_import.update_latest_listened_at(1, ExternalServiceType.SPOTIFY, t + 10) users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 3) self.assertEqual(users[0]['user_id'], 2) self.assertEqual(users[1]['user_id'], 1) self.assertEqual(users[2]['user_id'], 3) db_import.update_import_status(2, ExternalServiceType.SPOTIFY, 'something broke') db_import.update_import_status(3, ExternalServiceType.SPOTIFY, 'oops.') users = db_spotify.get_active_users_to_process() self.assertEqual(len(users), 1) self.assertEqual(users[0]['user_id'], 1)
def test_delete_when_spotify_import_activated(self): user_id = db_user.create(11, 'kishore') user = db_user.get(user_id) self.assertIsNotNone(user) db_spotify.create_spotify(user_id, 'user token', 'refresh token', 0) db_user.delete(user_id) user = db_user.get(user_id) self.assertIsNone(user) token = db_spotify.get_token_for_user(user_id) self.assertIsNone(token)
def setUp(self): super(TestAPICompatTokenClass, self).setUp() self.log = logging.getLogger(__name__) # Create a user uid = db_user.create(1, "test") self.assertIsNotNone(db_user.get(uid)) with db.engine.connect() as connection: result = connection.execute(text('SELECT * FROM "user" WHERE id = :id'), {"id": uid}) row = result.fetchone() self.user = User(row['id'], row['created'], row['musicbrainz_id'], row['auth_token'])
def test_get_users_in_order(self): id1 = db_user.create(11, 'eleven') id2 = db_user.create(12, 'twelve') users = db_user.get_users_in_order([]) self.assertListEqual(users, []) users = db_user.get_users_in_order([id1, id2]) self.assertEqual(len(users), 2) self.assertEqual(users[0]['id'], id1) self.assertEqual(users[1]['id'], id2) users = db_user.get_users_in_order([id2, id1]) self.assertEqual(len(users), 2) self.assertEqual(users[0]['id'], id2) self.assertEqual(users[1]['id'], id1) users = db_user.get_users_in_order([id2, id1, 213213132]) self.assertEqual(len(users), 2) self.assertEqual(users[0]['id'], id2) self.assertEqual(users[1]['id'], id1)
def test_session_load(self): user = User.load_by_id(db_user.create(1, "test")) token = Token.generate(user.api_key) token.approve(user.name) session = Session.create(token) self.assertIsInstance(session, Session) self.assertDictEqual(user.__dict__, session.user.__dict__) session.user = None # Load with session_key + api_key session2 = Session.load(session.sid) self.assertDictEqual(user.__dict__, session2.__dict__['user'].__dict__) session2.user = None self.assertDictEqual(session.__dict__, session2.__dict__)
def setUp(self): super(TestInfluxListenStore, self).setUp() self.log = logging.getLogger(__name__) # In order to do counting correctly, we need a clean DB to start with self.reset_influx_db() self.logstore = init_influx_connection(self.log, { '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.testuser_id = db_user.create(1, "test") self.testuser_name = db_user.get(self.testuser_id)['musicbrainz_id']
def setUp(self): super(TestRedisListenStore, self).setUp() self.log = logging.getLogger(__name__) self._redis = init_redis_connection(self.log, self.config.REDIS_HOST, self.config.REDIS_PORT) self.testuser_id = db_user.create(1, "test") self._create_test_data()