def test_get_feedback_for_user(self):
count = self.insert_test_data(self.user["id"])
result = db_feedback.get_feedback_for_user(user_id=self.user["id"], limit=25, offset=0)
self.assertEqual(len(result), count)
self.assertEqual(result[0].user_id, self.user["id"])
self.assertEqual(result[0].user_name, self.user["musicbrainz_id"])
self.assertEqual(result[0].recording_msid, self.sample_feedback[1]["recording_msid"])
self.assertEqual(result[0].score, self.sample_feedback[1]["score"])
self.assertEqual(result[1].user_id, self.user["id"])
self.assertEqual(result[1].user_name, self.user["musicbrainz_id"])
self.assertEqual(result[1].recording_msid, self.sample_feedback[0]["recording_msid"])
self.assertEqual(result[1].score, self.sample_feedback[0]["score"])
# test the score argument
result = db_feedback.get_feedback_for_user(user_id=self.user["id"], limit=25, offset=0, score=1)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].score, 1)
result = db_feedback.get_feedback_for_user(user_id=self.user["id"], limit=25, offset=0, score=-1)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].score, -1)
# test the limit argument
result = db_feedback.get_feedback_for_user(user_id=self.user["id"], limit=1, offset=0)
self.assertEqual(len(result), 1)
# test the offset argument
result = db_feedback.get_feedback_for_user(user_id=self.user["id"], limit=25, offset=1)
self.assertEqual(len(result), 1)
def test_update_score_when_feedback_already_exits(self):
update_fb = self.sample_feedback[0]
count = self.insert_test_data(self.user["id"])
result = db_feedback.get_feedback_for_user(user_id=self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), count)
self.assertEqual(result[1].recording_msid, update_fb["recording_msid"])
self.assertEqual(result[1].score, 1)
update_fb["score"] = -1 # change the score to -1
# update a record by inserting a record with updated score value
db_feedback.insert(
Feedback(user_id=self.user["id"],
recording_msid=update_fb["recording_msid"],
score=update_fb["score"]))
result = db_feedback.get_feedback_for_user(user_id=self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), count)
self.assertEqual(result[0].recording_msid, update_fb["recording_msid"])
self.assertEqual(result[0].score, -1)
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 test_recording_feedback_update_score(self):
"""
Test to check that score gets updated when a user changes feedback score for a recording_msid
i.e love to hate or vice-versa
"""
# submit a feedback with score = 1
feedback = {
"recording_msid": "7babc9be-ca2b-4544-b932-7c9ab38770d6",
"score": 1
}
response = self.client.post(
url_for("feedback_api_v1.recording_feedback"),
data=json.dumps(feedback),
headers={
"Authorization": "Token {}".format(self.user["auth_token"])
},
content_type="application/json")
self.assert200(response)
self.assertEqual(response.json["status"], "ok")
result = db_feedback.get_feedback_for_user(self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].user_id, self.user["id"])
self.assertEqual(result[0].recording_msid, feedback["recording_msid"])
self.assertEqual(result[0].score, feedback["score"])
# submit an updated feedback for the same recording_msid with new score = -1
updated_feedback = {
"recording_msid": "7babc9be-ca2b-4544-b932-7c9ab38770d6",
"score": -1
}
response = self.client.post(
url_for("feedback_api_v1.recording_feedback"),
data=json.dumps(updated_feedback),
headers={
"Authorization": "Token {}".format(self.user["auth_token"])
},
content_type="application/json")
self.assert200(response)
self.assertEqual(response.json["status"], "ok")
# check that the record gets updated
result = db_feedback.get_feedback_for_user(self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].user_id, self.user["id"])
self.assertEqual(result[0].recording_msid,
updated_feedback["recording_msid"])
self.assertEqual(result[0].score, updated_feedback["score"])
def test_get_feedback_for_user_with_metadata(self):
count = self.insert_test_data_with_metadata(self.user["id"])
result = db_feedback.get_feedback_for_user(user_id=self.user["id"],
limit=25,
offset=0,
score=1,
metadata=True)
self.assertEqual(len(result), 1)
self.assertEqual(result[0].user_id, self.user["id"])
self.assertEqual(result[0].user_name, self.user["musicbrainz_id"])
self.assertEqual(
result[0].recording_msid,
self.sample_feedback_with_metadata[0]["recording_msid"])
self.assertEqual(result[0].score,
self.sample_feedback_with_metadata[0]["score"])
self.assertEqual(result[0].track_metadata["artist_name"], "Portishead")
self.assertEqual(result[0].track_metadata["track_name"], "Strangers")
self.assertEqual(
result[0].track_metadata["additional_info"]["recording_mbid"],
"076255b4-1575-11ec-ac84-135bf6a670e3")
self.assertEqual(
result[0].track_metadata["additional_info"]["release_mbid"],
"1fd178b4-1575-11ec-b98a-d72392cd8c97")
self.assertEqual(
result[0].track_metadata["additional_info"]["artist_msid"],
self.saved_artist_msid)
def test_delete(self):
del_fb = self.sample_feedback[0]
count = self.insert_test_data(self.user["id"])
result = db_feedback.get_feedback_for_user(user_id=self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), count)
self.assertEqual(result[3].recording_msid, del_fb["recording_msid"])
# delete one record for the user using msid
db_feedback.delete(
Feedback(user_id=self.user["id"],
recording_msid=del_fb["recording_msid"],
score=del_fb["score"]))
result = db_feedback.get_feedback_for_user(user_id=self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), 3)
self.assertNotIn(del_fb["recording_msid"],
[x.recording_msid for x in result])
# delete using mbid
db_feedback.delete(
Feedback(user_id=self.user["id"],
recording_mbid=self.sample_feedback[2]["recording_mbid"],
score=self.sample_feedback[2]["score"]))
result = db_feedback.get_feedback_for_user(user_id=self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), 2)
self.assertNotIn(self.sample_feedback[2]["recording_mbid"],
[x.recording_mbid for x in result])
# delete using mbid and msid both
db_feedback.delete(
Feedback(user_id=self.user["id"],
recording_mbid=self.sample_feedback[3]["recording_mbid"],
recording_msid=self.sample_feedback[3]["recording_msid"],
score=self.sample_feedback[2]["score"]))
result = db_feedback.get_feedback_for_user(user_id=self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), 1)
self.assertNotIn(self.sample_feedback[3]["recording_mbid"],
[x.recording_mbid for x in result])
def test_delete(self):
del_fb = self.sample_feedback[0]
count = self.insert_test_data(self.user["id"])
result = db_feedback.get_feedback_for_user(user_id=self.user["id"], limit=25, offset=0)
self.assertEqual(len(result), count)
self.assertEqual(result[1].recording_msid, del_fb["recording_msid"])
# delete one record for the user
db_feedback.delete(
Feedback(
user_id=self.user["id"],
recording_msid=del_fb["recording_msid"],
score=del_fb["score"]
)
)
result = db_feedback.get_feedback_for_user(user_id=self.user["id"], limit=25, offset=0)
self.assertEqual(len(result), 1)
self.assertNotEqual(result[0].recording_msid, del_fb["recording_msid"])
def get_feedback_for_user(user_name):
"""
Get feedback given by user ``user_name``. The format for the JSON returned is defined in our :ref:`feedback-json-doc`.
If the optional argument ``score`` is not given, this endpoint will return all the feedback submitted by the user.
Otherwise filters the feedback to be returned by score.
:param score: Optional, If 1 then returns the loved recordings, if -1 returns hated recordings.
:type score: ``int``
:param count: Optional, number of feedback items to return, Default: :data:`~webserver.views.api.DEFAULT_ITEMS_PER_GET`
Max: :data:`~webserver.views.api.MAX_ITEMS_PER_GET`.
:type count: ``int``
:param offset: Optional, number of feedback items to skip from the beginning, for pagination.
Ex. An offset of 5 means the top 5 feedback will be skipped, defaults to 0.
:type offset: ``int``
:param metadata: Optional, 'true' or 'false' if this call should return the metadata for the feedback.
:type metadata: ``str``
:statuscode 200: Yay, you have data!
:resheader Content-Type: *application/json*
"""
score = _parse_int_arg('score')
metadata = parse_boolean_arg('metadata')
offset = get_non_negative_param('offset', default=0)
count = get_non_negative_param('count', default=DEFAULT_ITEMS_PER_GET)
count = min(count, MAX_ITEMS_PER_GET)
user = db_user.get_by_mb_id(user_name)
if user is None:
raise APINotFound("Cannot find user: %s" % user_name)
if score:
if score not in [-1, 1]:
log_raise_400("Score can have a value of 1 or -1.", request.args)
feedback = db_feedback.get_feedback_for_user(user_id=user["id"],
limit=count,
offset=offset,
score=score,
metadata=metadata)
total_count = db_feedback.get_feedback_count_for_user(user["id"])
feedback = [fb.to_api() for fb in feedback]
return jsonify({
"feedback": feedback,
"count": len(feedback),
"total_count": total_count,
"offset": offset
})
def feedback(user_name: str):
""" Show user feedback, with filter on score (love/hate).
Args:
musicbrainz_id (str): the MusicBrainz ID of the user
Raises:
NotFound if user isn't present in the database
"""
score = request.args.get('score', 1)
try:
score = int(score)
except ValueError:
raise BadRequest("Incorrect int argument score: %s" %
request.args.get("score"))
offset = request.args.get('offset', 0)
try:
offset = int(offset)
except ValueError:
raise BadRequest("Incorrect int argument offset: %s" %
request.args.get("offset"))
count = request.args.get("count",
DEFAULT_NUMBER_OF_FEEDBACK_ITEMS_PER_CALL)
try:
count = int(count)
except ValueError:
raise BadRequest("Incorrect int argument count: %s" %
request.args.get("count"))
user = _get_user(user_name)
user_data = {
"name": user.musicbrainz_id,
"id": user.id,
}
feedback_count = get_feedback_count_for_user(user.id, score)
feedback = get_feedback_for_user(user.id, count, offset, score, True)
props = {
"feedback": [f.to_api() for f in feedback],
"feedback_count": feedback_count,
"user": user_data,
"active_section": "feedback",
"logged_in_user_follows_user": logged_in_user_follows_user(user),
}
return render_template("user/feedback.html",
active_section="feedback",
props=ujson.dumps(props),
user=user)
def fetch_feedback(user_id):
"""
Fetch feedback by making repeated queries to DB until we get all the data.
Returns a generator that streams the results.
"""
batch = []
offset = 0
while True:
batch = db_feedback.get_feedback_for_user(user_id=current_user.id, limit=EXPORT_FETCH_COUNT, offset=offset)
if not batch:
break
yield from batch
offset += len(batch)
def test_insert(self):
count = self.insert_test_data(self.user["id"])
result = db_feedback.get_feedback_for_user(user_id=self.user["id"],
limit=25,
offset=0)
self.assertEqual(len(result), count)
