def setUp(self):
super(UserTestCase, self).setUp()
self.user1 = User(db_users.get_or_create(1, 'tester_1', new_user_data={
"display_name": "test",
}))
self.user2 = User(db_users.get_or_create(2, "тестер", new_user_data={
"display_name": "test1",
}))
self.author = User(db_users.get_or_create(3, "author1", new_user_data={
"display_name": "Author1",
}))
license = db_license.create(
id='Test',
full_name='Test License',
)
self.review = db_review.create(
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing!",
user_id=self.author.id,
is_draft=False,
license_id=license["id"],
)
db_vote.submit(self.user1.id, self.review["last_revision"]["id"], True)
self.review_created = self.review["last_revision"]["timestamp"]
self.review_id = self.review["id"]
self.revision_id = self.review["last_revision"]["id"]
self.report = db_spam_report.create(self.revision_id, self.user1.id, "Testing Reason Report")
def vote_submit(review_id):
review_id = str(review_id)
if 'yes' in request.form:
vote = True
elif 'no' in request.form:
vote = False
else:
vote = None
review = Review.query.get_or_404(review_id)
if review.is_hidden and not current_user.is_admin():
raise NotFound(gettext("Review has been hidden."))
if review.user == current_user:
flash.error(gettext("You cannot rate your own review."))
return redirect(url_for('.entity', id=review_id))
if current_user.is_vote_limit_exceeded is True and current_user.has_voted(
review) is False:
flash.error(gettext("You have exceeded your limit of votes per day."))
return redirect(url_for('.entity', id=review_id))
if current_user.is_blocked:
flash.error(
gettext("You are not allowed to rate this review because "
"your account has been blocked by a moderator."))
return redirect(url_for('.entity', id=review_id))
db_vote.submit(
user_id=current_user.id,
revision_id=review.last_revision.id,
vote=vote, # overwrites an existing vote, if needed
)
flash.success(gettext("You have rated this review!"))
return redirect(url_for('.entity', id=review_id))
def test_get_top_users_overall(self, cache_set, cache_get):
# user_1 added a review
review_1 = self.create_dummy_review(user_id=self.user_1.id)
# user_2 added a review
review_2 = self.create_dummy_review(user_id=self.user_2.id)
# user_2 commented on review by user_1
db_comment.create(
user_id=self.user_2.id,
review_id=review_1["id"],
text="Test comment",
)
# user_1 upvoted review by user_2
db_vote.submit(
user_id=self.user_1.id,
revision_id=review_2["last_revision"]["id"],
vote=True,
)
# get list of top users
top_users = db_statistics.get_top_users_overall()
expected_key = b"top_users_overall_cb_statistics"
cache_get.assert_called_once_with(expected_key,
db_statistics._CACHE_NAMESPACE)
cache_set.assert_called_once_with(key=expected_key, val={"users": top_users},
namespace=db_statistics._CACHE_NAMESPACE,
time=db_statistics._DEFAULT_CACHE_EXPIRATION)
self.assertEqual(len(top_users), 2)
self.assertEqual(top_users[0]["id"], self.user_2.id)
self.assertEqual(top_users[0]["score"], 7)
self.assertEqual(top_users[1]["id"], self.user_1.id)
self.assertEqual(top_users[1]["score"], 6)
def test_get(self):
vote.submit(self.user_1.id, self.review["last_revision"]["id"], True)
vote_1_data = vote.get(self.user_1.id,
self.review["last_revision"]["id"])
rated_at = vote_1_data.pop("rated_at")
self.assertDictEqual(
vote_1_data, {
"user_id": UUID(self.user_1.id),
"revision_id": self.review["last_revision"]["id"],
"vote": True,
})
self.assertEqual(type(vote_1_data["user_id"]), UUID)
self.assertEqual(type(vote_1_data["revision_id"]), int)
self.assertEqual(type(rated_at), datetime)
vote.submit(self.user_2.id, self.review["last_revision"]["id"], False)
vote_2_data = vote.get(self.user_2.id,
self.review["last_revision"]["id"])
vote_2_data.pop("rated_at")
self.assertDictEqual(
vote_2_data, {
"user_id": UUID(self.user_2.id),
"revision_id": self.review["last_revision"]["id"],
"vote": False,
})
def test_get_top_users_overall(self):
# user_1 added a review
review_1 = self.create_dummy_review(user_id=self.user_1.id)
# user_2 added a review
review_2 = self.create_dummy_review(user_id=self.user_2.id)
# user_2 commented on review by user_1
db_comment.create(
user_id=self.user_2.id,
review_id=review_1["id"],
text="Test comment",
)
# user_1 upvoted review by user_2
db_vote.submit(
user_id=self.user_1.id,
revision_id=review_2["last_revision"]["id"],
vote=True,
)
# get list of top users
top_users = db_statistics.get_top_users_overall()
self.assertEqual(len(top_users), 2)
self.assertEqual(top_users[0]["id"], self.user_2.id)
self.assertEqual(top_users[0]["score"], 7)
self.assertEqual(top_users[1]["id"], self.user_1.id)
self.assertEqual(top_users[1]["score"], 6)
def setUp(self):
super(UserTestCase, self).setUp()
self.user1 = User(
db_users.get_or_create('tester_1',
new_user_data={
"display_name": "test",
}))
self.user2 = User(
db_users.get_or_create("тестер",
new_user_data={
"display_name": "test1",
}))
self.author = User(
db_users.get_or_create("author1",
new_user_data={
"display_name": "Author1",
}))
license = db_license.create(
id='Test',
full_name='Test License',
)
self.review = db_review.create(
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing!",
user_id=self.author.id,
is_draft=False,
license_id=license["id"],
)
db_vote.submit(self.user1.id, self.review["last_revision"]["id"], True)
self.review_created = self.review["last_revision"]["timestamp"]
self.review_id = self.review["id"]
self.revision_id = self.review["last_revision"]["id"]
self.report = db_spam_report.create(self.revision_id, self.user1.id,
"Testing Reason Report")
def review_vote_put_handler(review_id, user):
"""Set your vote for a specified review.
**OAuth scope:** vote
**Request Example:**
.. code-block:: bash
$ curl "https://critiquebrainz.org/ws/1/review/9cb11424-d070-4ac1-8771-a8703ae5cccd/vote" \\
-X PUT \\
-H "Content-type: application/json" \\
-H "Authorization: Bearer <access token>" \\
-d '{"vote":true}'
**Response Example:**
.. code-block:: json
{
"message": "Request processed successfully"
}
:json boolean vote: ``true`` if upvote, ``false`` if downvote
**NOTE:** Voting on reviews without text is not allowed.
:statuscode 200: success
:statuscode 400: invalid request (see source)
:statuscode 403: daily vote limit exceeded
:statuscode 404: review not found
:resheader Content-Type: *application/json*
"""
def fetch_params():
vote = Parser.bool('json', 'vote')
return vote
review = get_review_or_404(review_id)
if review["is_hidden"]:
raise NotFound("Review has been hidden.")
vote = fetch_params()
if str(review["user_id"]) == user.id:
raise InvalidRequest(desc='You cannot rate your own review.')
if review["text"] is None:
raise InvalidRequest(
desc='Voting on reviews without text is not allowed.')
if user.is_vote_limit_exceeded and not db_users.has_voted(
user.id, review_id):
raise LimitExceeded('You have exceeded your limit of votes per day.')
db_vote.submit(
user_id=user.id,
revision_id=review["last_revision"]["id"],
vote=vote, # overwrites an existing vote, if needed
)
return jsonify(message='Request processed successfully')
def review_vote_put_handler(review_id, user):
"""Set your vote for a specified review.
**OAuth scope:** vote
**Request Example:**
.. code-block:: bash
$ curl "https://critiquebrainz.org/ws/1/review/9cb11424-d070-4ac1-8771-a8703ae5cccd/vote" \\
-X PUT \\
-H "Content-type: application/json" \\
-H "Authorization: Bearer <access token>" \\
-d '{"vote":true}'
**Response Example:**
.. code-block:: json
{
"message": "Request processed successfully"
}
:json boolean vote: ``true`` if upvote, ``false`` if downvote
**NOTE:** Voting on reviews without text is not allowed.
:statuscode 200: success
:statuscode 400: invalid request (see source)
:statuscode 403: daily vote limit exceeded
:statuscode 404: review not found
:resheader Content-Type: *application/json*
"""
def fetch_params():
vote = Parser.bool('json', 'vote')
return vote
review = get_review_or_404(review_id)
if review["is_hidden"]:
raise NotFound("Review has been hidden.")
vote = fetch_params()
if str(review["user_id"]) == user.id:
raise InvalidRequest(desc='You cannot rate your own review.')
if review["text"] is None:
raise InvalidRequest(desc='Voting on reviews without text is not allowed.')
if user.is_vote_limit_exceeded and not db_users.has_voted(user.id, review_id):
raise LimitExceeded('You have exceeded your limit of votes per day.')
db_vote.submit(
user_id=user.id,
revision_id=review["last_revision"]["id"],
vote=vote, # overwrites an existing vote, if needed
)
return jsonify(message='Request processed successfully')
def test_get_all_votes(self):
"""Test to get the number of votes on revisions of a review"""
review_id = self.review["id"]
revision.get_count(review_id)
first_revision = revision.get(review_id)[0]
vote.submit(self.user_1.id, first_revision['id'], True)
vote.submit(self.user_2.id, first_revision['id'], False)
votes = revision.get_all_votes(review_id)
votes_first_revision = votes[first_revision['id']]
self.assertDictEqual(votes_first_revision, {
"positive": 1,
"negative": 1
})
def test_get_all_votes(self):
"""Test to get the number of votes on revisions of a review"""
review_id = self.review["id"]
revision.get_count(review_id)
first_revision = revision.get(review_id)[0]
vote.submit(self.user_1.id, first_revision['id'], True)
vote.submit(self.user_2.id, first_revision['id'], False)
votes = revision.get_all_votes(review_id)
votes_first_revision = votes[first_revision['id']]
self.assertDictEqual(votes_first_revision, {
"positive": 1,
"negative": 1
})
def setUp(self):
super(UserTestCase, self).setUp()
self.user1 = User(
db_users.get_or_create('tester_1',
new_user_data={
"display_name": "test",
}))
self.user2 = User(
db_users.get_or_create("тестер",
new_user_data={
"display_name": "test1",
}))
self.author = User(
db_users.get_or_create("author1",
new_user_data={
"display_name": "Author1",
}))
license = License(id='Test', full_name='Test License')
db.session.add(license)
db.session.commit()
self.review = Review.create(
release_group='e7aad618-fa86-3983-9e77-405e21796eca',
text="Testing!",
user_id=self.author.id,
is_draft=False,
license_id=license.id,
)
vote = db_vote.submit(self.user1.id, self.review.last_revision.id,
True)
self.review_created = self.review.last_revision.timestamp
self.review_id = self.review.id
self.revision_id = self.review.last_revision.id
self.report = SpamReport.create(self.revision_id, self.user1.id,
"Testing Reason Report")
def test_get_users_with_vote_count(self):
# user_2 added a review
review_2 = self.create_dummy_review(user_id=self.user_2.id)
# user_1 upvoted review by user_2
db_vote.submit(
user_id=self.user_1.id,
revision_id=review_2["last_revision"]["id"],
vote=True,
)
# get list of users with comment_count
users_vote_count = db_statistics.get_users_with_vote_count()
print("User Votes: ", users_vote_count)
for user in users_vote_count:
if str(user["id"]) == self.user_1.id:
self.assertEqual(user["vote_count"], 1)
else:
self.assertEqual(user["vote_count"], 0)
def test_get(self):
vote.submit(self.user_1.id, self.review["last_revision"]["id"], True)
vote_1_data = vote.get(self.user_1.id, self.review["last_revision"]["id"])
rated_at = vote_1_data.pop("rated_at")
self.assertDictEqual(vote_1_data, {
"user_id": UUID(self.user_1.id),
"revision_id": self.review["last_revision"]["id"],
"vote": True,
})
self.assertEqual(type(vote_1_data["user_id"]), UUID)
self.assertEqual(type(vote_1_data["revision_id"]), int)
self.assertEqual(type(rated_at), datetime)
vote.submit(self.user_2.id, self.review["last_revision"]["id"], False)
vote_2_data = vote.get(self.user_2.id, self.review["last_revision"]["id"])
vote_2_data.pop("rated_at")
self.assertDictEqual(vote_2_data, {
"user_id": UUID(self.user_2.id),
"revision_id": self.review["last_revision"]["id"],
"vote": False,
})
def test_importer(self):
user_1 = User(db_users.get_or_create(1, "Tester_1", new_user_data={
"display_name": "test user_1",
}))
user_2 = User(db_users.get_or_create(2, "Tester_2", new_user_data={
"display_name": "test user_2",
}))
# user_1 adds a review
review = db_review.create(
user_id=user_1.id,
entity_id="e7aad618-fa86-3983-9e77-405e21796eca",
entity_type="release_group",
text="Testing",
rating=5,
is_draft=False,
license_id=self.license["id"],
)
# user_2 votes on review by user_1
db_vote.submit(user_2.id, review["last_revision"]["id"], True)
# Make dumps and delete entities
self.runner.invoke(dump_manager.public, ['--location', self.tempdir])
archives = get_archives(self.tempdir)
db_review.delete(review['id'])
db_users.delete(user_1.id)
db_users.delete(user_2.id)
self.assertEqual(db_users.total_count(), 0)
self.assertEqual(db_review.get_count(), 0)
self.assertEqual(db_vote.get_count(), 0)
# Import dumps - cbdump.tar.bz2 and cbdump-reviews-all.tar.bz2 and check if data imported properly
self.runner.invoke(dump_manager.importer, [archives['cbdump.tar.bz2']])
self.assertEqual(db_users.total_count(), 2)
self.runner.invoke(dump_manager.importer, [archives['cbdump-reviews-all.tar.bz2']])
self.assertEqual(db_review.get_count(), 1)
self.assertEqual(db_vote.get_count(), 1)
def test_delete(self):
vote.submit(self.user_1.id, self.review["last_revision"]["id"], True)
self.assertEqual(vote.get_count(), 1)
vote.delete(self.user_1.id, self.review["last_revision"]["id"])
self.assertEqual(vote.get_count(), 0)
