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