def test_reviewer_votes(self):
submission_keys = self.common_data_setup()
votes_cast = []
self.assertEquals(len(dedupvotes.reviewer_votes("Anton", votes_cast)),
0)
self.assertEquals(len(dedupvotes.reviewer_votes("Allan", votes_cast)),
0)
self.assertEquals(len(dedupvotes.reviewer_votes("Grisha", votes_cast)),
0)
votes_cast.append(
voterecord.cast_new_vote(submission_keys[0], "Allan", 1, "One", 1))
votes_cast.append(
voterecord.cast_new_vote(submission_keys[0], "Grisha", 2, "Two",
1))
self.assertEquals(len(dedupvotes.reviewer_votes("Anton", votes_cast)),
0)
self.assertEquals(len(dedupvotes.reviewer_votes("Allan", votes_cast)),
1)
self.assertEquals(len(dedupvotes.reviewer_votes("Grisha", votes_cast)),
1)
votes_cast.append(
voterecord.cast_new_vote(submission_keys[0], "Grisha", 2, "Again!",
1))
self.assertEquals(len(dedupvotes.reviewer_votes("Anton", votes_cast)),
0)
self.assertEquals(len(dedupvotes.reviewer_votes("Allan", votes_cast)),
1)
self.assertEquals(len(dedupvotes.reviewer_votes("Grisha", votes_cast)),
2)
def test_get_scores(self):
self.create_conference()
t1 = talk.Talk()
t1.title = "Talk T1"
t1.put()
sub_key1 = submissionrecord.make_submission(t1.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key1, "Fred", -2, "I hate this talk", 1)
voterecord.cast_new_vote(sub_key1, "Jill", -2, "I hate this talk too",
1)
scores1 = sub_key1.get().get_scores(1)
self.assertEquals(scores1.mean_score, -2)
self.assertEquals(scores1.median_score, -2)
self.assertEquals(scores1.total_score, -4)
self.assertEquals(scores1.votes, 2)
scores2 = sub_key1.get().get_scores(2)
self.assertEquals(scores2.mean_score, 0)
self.assertEquals(scores2.median_score, 0)
self.assertEquals(scores2.total_score, 0)
self.assertEquals(scores2.votes, 0)
voterecord.cast_new_vote(sub_key1, "Fred", 1, "One", 2)
voterecord.cast_new_vote(sub_key1, "Jim", 2, "Two", 2)
voterecord.cast_new_vote(sub_key1, "Shiela", 2, "Two two", 2)
scores2 = sub_key1.get().get_scores(2)
self.assertEquals(scores2.total_score, 5)
self.assertEquals(scores2.mean_score, 1.67)
self.assertEquals(scores2.median_score, 2)
self.assertEquals(scores2.votes, 3)
def test_delete_vote_comments(self):
c, t = self.data_setup()
report = reports.commentreport.get_commented_votes(c.key)
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
vote1 = voterecord.cast_new_vote(subs_key, "New reviewer", 1,
"Comment", 1)
vote2 = voterecord.cast_new_vote(subs_key, "Another reviewer", 1,
"Good", 1)
vote3 = voterecord.cast_new_vote(subs_key, "3rd reviewer", 1, "Bad",
-1)
vote4 = voterecord.cast_new_vote(subs_key, "4th", 1, "", 3)
self.assertEquals("Comment", vote1.comment)
self.assertEquals("Good", vote2.comment)
self.assertEquals("Bad", vote3.comment)
self.assertEquals("", vote4.comment)
reports.commentreport.delete_vote_comments(
[vote1.key, vote2.key, vote3.key, vote4.key])
self.assertEquals("", vote1.comment)
self.assertEquals("", vote2.comment)
self.assertEquals("", vote3.comment)
self.assertEquals("", vote4.comment)
# check they are in the db correctly
# Todo: this test always works... even when put removed... need to fix
votes = voterecord.find_existing_votes(subs_key, 1)
for v in votes:
self.assertEquals("", v.comment)
def mk_test_data(self, name):
new_conf = conference.Conference()
new_conf.name = name
new_conf.put()
subm_key = submissionrecord.make_submission(None, new_conf.key,
"Track", "Format")
confoptions.make_conference_track(new_conf.key, "Track")
voterecord.cast_new_vote(subm_key, "Harry", 2, "No comment", 1)
cospeaker.make_cospeaker(subm_key, "Ron", "ron2hogwarts.com")
return new_conf.key, subm_key
def test_get_commented_votes(self):
c, t = self.data_setup()
report = reports.commentreport.get_commented_votes(c.key)
self.assertEquals(report.comments, {})
self.assertFalse(report.has_comments)
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
vote1 = voterecord.cast_new_vote(subs_key, "New reviewer", 1, "", 1)
report = reports.commentreport.get_commented_votes(c.key)
self.assertEquals(report.comments, {})
self.assertFalse(report.has_comments)
vote2 = voterecord.cast_new_vote(subs_key, "Another reviewer", 1,
"Good", 1)
report = reports.commentreport.get_commented_votes(c.key)
self.assertTrue(report.has_comments)
self.assertEquals(report.comments, {subs_key: [vote2.key]})
vote3 = voterecord.cast_new_vote(subs_key, "3rd reviewer", 1, "Bad",
-1)
self.assertEquals(
reports.commentreport.get_commented_votes(c.key).comments,
{subs_key: [vote2.key, vote3.key]})
t2 = talk.Talk()
t2.title = "A testing talk"
t2.put()
subs_key2 = submissionrecord.make_submission(t2.key, c.key, "track",
"format")
self.assertEquals(
reports.commentreport.get_commented_votes(c.key).comments,
{subs_key: [vote2.key, vote3.key]})
vote4 = voterecord.cast_new_vote(subs_key2, "New reviewer", 1, "", 2)
self.assertEquals(
reports.commentreport.get_commented_votes(c.key).comments,
{subs_key: [vote2.key, vote3.key]})
subs_key3 = submissionrecord.make_submission(t2.key, c.key, "track",
"format")
self.assertEquals(
reports.commentreport.get_commented_votes(c.key).comments,
{subs_key: [vote2.key, vote3.key]})
vote5 = voterecord.cast_new_vote(subs_key3, "New reviewer", 1, "Yes!",
2)
self.assertEquals(
reports.commentreport.get_commented_votes(c.key).comments, {
subs_key: [vote2.key, vote3.key],
subs_key3: [vote5.key]
})
def test_extract_reviewers(self):
votes = [
voterecord.cast_new_vote(None, "Allan", 0, "None", 1),
voterecord.cast_new_vote(None, "Grisha", 0, "None", 1),
voterecord.cast_new_vote(None, "Anton", 0, "None", 1),
voterecord.cast_new_vote(None, "Allan", 0, "None", 1)
]
reviewers = dedupvotes.extract_reviewers(votes)
self.assertEqual(len(reviewers), 3)
reviewers.sort()
self.assertEqual(reviewers[0], "Allan")
self.assertEqual(reviewers[1], "Anton")
self.assertEqual(reviewers[2], "Grisha")
def test_find_existing_vote_by_reviewer(self):
c, t = self.data_setup()
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
self.assertEquals(
len(submission_queries.retrieve_conference_submissions(c.key)), 1)
existing_vote = voterecord.find_existing_vote_by_reviewer(
subs_key, "Reviewer", 1)
self.assertTrue(existing_vote is None)
vote = voterecord.VoteRecord(parent=subs_key)
vote.cast_vote("Reviewer", 2, "Vote early, vote often", 1)
existing_vote = voterecord.find_existing_vote_by_reviewer(
subs_key, "Reviewer", 1)
self.assertTrue(existing_vote is not None)
existing_vote = voterecord.find_existing_vote_by_reviewer(
subs_key, "Never voted reviewer", 1)
self.assertTrue(existing_vote is None)
# test cast_vote wrapper
vote = voterecord.cast_new_vote(subs_key, "New reviewer", 1, "OK", 1)
new_vote = voterecord.find_existing_vote_by_reviewer(
subs_key, "New reviewer", 1)
self.assertTrue(new_vote is not None)
self.assertEquals(new_vote.comment, "OK")
def new_vote(self, review_round):
vote = voterecord.cast_new_vote(
ndb.Key(urlsafe=self.request.get("submissionrecord_key")),
self.get_crrt_user().email(),
int(self.request.get("vote")),
self.request.get("review_comment"),
round=review_round)
self.store_private_comment(vote.key)
return vote
def test_submission_scores(self):
self.create_conference()
sub_key = submissionrecord.make_submission(self.t.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key, "Fred", -2, "I hate this talk", 1)
voterecord.cast_new_vote(sub_key, "Jim", 1, "I sort of like this talk",
1)
voterecord.cast_new_vote(sub_key, "Sheila", 1, "I like this talk", 1)
submissions = submissionrecord.retrieve_submissions_records(self.c.key)
self.assertEquals(len(submissions), 1)
scores = submissions[0].get_scores(1)
self.assertEquals(scores.total_score, 0)
self.assertEquals(scores.mean_score, 0)
self.assertEquals(scores.median_score, 1.0)
self.assertEquals(scores.votes, 3)
t2 = talk.Talk()
t2.title = "Unreviewed"
t2.put()
sub_key = submissionrecord.make_submission(t2.key, self.c.key, "track",
"format")
scores2 = sub_key.get().get_scores(1)
self.assertEquals(scores2.total_score, 0)
self.assertEquals(scores2.mean_score, 0)
self.assertEquals(scores2.median_score, 0)
self.assertEquals(scores2.votes, 0)
def test_count_votes_for_submissions(self):
c, t = self.data_setup()
round = 1
sub_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
self.assertEquals(
0, voterecord.count_votes_for_submission(sub_key, round))
t2 = talk.Talk()
t2.title = "Another talk"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, c.key, "track",
"format")
self.assertEquals(
0, voterecord.count_votes_for_submission(sub_key2, round))
self.assertItemsEqual({
sub_key: 0,
sub_key2: 0
}, voterecord.count_votes_for_submissions([sub_key, sub_key2], 1))
voterecord.cast_new_vote(sub_key, "Reviewer1", 2, "No comment", 1)
self.assertEquals(
1, voterecord.count_votes_for_submission(sub_key, round))
self.assertItemsEqual({
sub_key: 1,
sub_key2: 0
}, voterecord.count_votes_for_submissions([sub_key, sub_key2], 1))
voterecord.cast_new_vote(sub_key, "Reviewer2", 2, "No comment", 1)
self.assertItemsEqual({
sub_key: 2,
sub_key2: 0
}, voterecord.count_votes_for_submissions([sub_key, sub_key2], 1))
voterecord.cast_new_vote(sub_key2, "Reviewer1", 2, "Comments", 1)
self.assertItemsEqual({
sub_key: 2,
sub_key2: 1
}, voterecord.count_votes_for_submissions([sub_key, sub_key2], 1))
self.assertItemsEqual({
sub_key: 0,
sub_key2: 0
}, voterecord.count_votes_for_submissions([sub_key, sub_key2], 2))
voterecord.cast_new_vote(sub_key, "Reviewer1", 2, "No comment", 2)
self.assertItemsEqual({
sub_key: 1,
sub_key2: 0
}, voterecord.count_votes_for_submissions([sub_key, sub_key2], 2))
def test_add_comment(self):
c, t = self.data_setup()
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
vote = voterecord.cast_new_vote(subs_key, "Reviewer", 2, "No comment",
1)
comment = votecomment.mk_new_comment(vote.key, "Private",
"I say old chap")
self.assertTrue(comment.is_private())
self.assertEquals(comment.comment_text(), "I say old chap")
self.assertEquals(comment.key.parent(), vote.key)
def test_reviewer_voting_score(self):
self.create_conference()
sub_key = submissionrecord.make_submission(self.t.key, self.c.key,
"track", "format")
self.assertEquals(sub_key.get().reviewer_voting_score("Fred", 1), 0)
self.assertEquals(sub_key.get().reviewer_voting_msg("Fred", 1),
"No vote")
self.assertEquals(sub_key.get().reviewer_voting_comment("Fred", 1), "")
voterecord.cast_new_vote(sub_key, "Fred", -2, "I hate this talk", 1)
voterecord.cast_new_vote(sub_key, "Jim", 1, "I sort of like this talk",
1)
self.assertEquals(sub_key.get().reviewer_voting_score("Fred", 1), -2)
self.assertEquals(sub_key.get().reviewer_voting_msg("Fred", 1), -2)
self.assertEquals(sub_key.get().reviewer_voting_comment("Fred", 1),
"I hate this talk")
self.assertEquals(sub_key.get().reviewer_voting_score("Jim", 1), 1)
self.assertEquals(sub_key.get().reviewer_voting_comment("Jim", 1),
"I sort of like this talk")
def test_find_existing_vote(self):
c, t = self.data_setup()
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
self.assertEquals(
len(submission_queries.retrieve_conference_submissions(c.key)), 1)
existing_vote = voterecord.find_existing_votes(subs_key, 1)
self.assertTrue(existing_vote is None)
voterecord.cast_new_vote(subs_key, "Reviewer", 2, "No comment", 1)
reviews = voterecord.find_existing_votes(subs_key, 1)
self.assertEquals(len(reviews), 1)
self.assertEquals(reviews[0].reviewer, "Reviewer")
voterecord.cast_new_vote(subs_key, "Another Reviewer", 2,
"yes comment", 1)
reviews = voterecord.find_existing_votes(subs_key, 1)
self.assertEquals(len(reviews), 2)
self.assertEquals(reviews[0].reviewer, "Reviewer")
self.assertEquals(reviews[1].reviewer, "Another Reviewer")
def test_retrieve_all_reviews(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
t = talk.Talk()
t.title = "A testing talk"
t.put()
sub_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
self.assertEquals(
len(submissionrecord.retrieve_conference_submissions(c.key)), 1)
self.assertEquals(
len(roundreviews.retrieve_all_reviews(sub_key.get())), 0)
voterecord.cast_new_vote(sub_key, "Fred", -2, "I hate this talk", 1)
reviews = roundreviews.retrieve_all_reviews(sub_key.get())
self.assertEquals(
len(roundreviews.retrieve_all_reviews(sub_key.get())), 1)
voterecord.cast_new_vote(sub_key, "Jim", 1, "I sort of like this talk",
1)
t2 = talk.Talk()
t2.title = "Another talk"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, c.key, "track",
"format")
voterecord.cast_new_vote(sub_key2, "Barney", 1, "Yo ho ho", 1)
reviews = roundreviews.retrieve_all_reviews(sub_key.get())
self.assertEquals(len(reviews), 2)
self.assertEquals(reviews[0].reviewer, "Fred")
self.assertEquals(reviews[1].reviewer, "Jim")
sub_key.get().set_review_decision(1, "Round2")
sub_key2.get().set_review_decision(1, "Decline")
confstate.close_round1_and_open_round2(c)
voterecord.cast_new_vote(sub_key, "Sheila", 1, "Yes please", 2)
reviews = roundreviews.retrieve_all_reviews(sub_key.get())
self.assertEquals(len(reviews), 3)
self.assertEquals(reviews[0].reviewer, "Fred")
self.assertEquals(reviews[1].reviewer, "Jim")
self.assertEquals(reviews[2].reviewer, "Sheila")
def test_update_comment(self):
c, t = self.data_setup()
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
vote = voterecord.cast_new_vote(subs_key, "Reviewer", 2, "No comment",
1)
private_comment = votecomment.retrieve_vote_comment(vote.key)
comment = votecomment.update_comment(vote.key, "Private",
"I say old chap")
self.assertEquals(comment.comment_text(), "I say old chap")
comment = votecomment.update_comment(vote.key, "Private",
"Just like any picnic")
self.assertEquals(comment.comment_text(), "Just like any picnic")
def test_sort_submissions_low__to_high(self):
self.create_conference()
t3 = talk.Talk()
t3.title = "A round talk"
t3.put()
sub_key3 = submissionrecord.make_submission(t3.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key3, "Fred", 1, "I like this talk", 1)
t1 = talk.Talk()
t1.title = "A testing talk"
t1.put()
sub_key1 = submissionrecord.make_submission(t1.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key1, "Fred", -2, "I hate this talk", 1)
t4 = talk.Talk()
t4.title = "Another round talk"
t4.put()
sub_key4 = submissionrecord.make_submission(t4.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key4, "Fred", 2,
"I really like this talk", 1)
t2 = talk.Talk()
t2.title = "Another testing talk"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key2, "Fred", -1, "I dislike this talk",
1)
submissions = submissionrecord.retrieve_submissions_records(self.c.key)
sorted_submissions = submissionrecord.sort_low_to_high(
submissions, "Fred", 1)
self.assertEquals(len(sorted_submissions), 4)
self.assertEquals(sorted_submissions[0].title(), t1.title)
self.assertEquals(sorted_submissions[1].title(), t2.title)
self.assertEquals(sorted_submissions[2].title(), t3.title)
self.assertEquals(sorted_submissions[3].title(), t4.title)
def test_report_has_duplicates(self):
VotingRound = 1
submission_keys = self.common_data_setup()
self.assertEquals(dedupvotes.retrieve_duplicate_report(self.c.key),
None)
report = dedupvotes.generate_duplicate_vote_report(self.c.key, 1)
self.assertFalse(report.has_duplicates())
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Anton", -1, "Minus 1",
VotingRound)
self.assertFalse(report.has_duplicates())
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
report = dedupvotes.generate_duplicate_vote_report(self.c.key, 1)
self.assertTrue(report.has_duplicates())
def test_retreive_comments(self):
c, t = self.data_setup()
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
vote = voterecord.cast_new_vote(subs_key, "Reviewer", 2, "No comment",
1)
private_comment = votecomment.retrieve_vote_comment(vote.key)
self.assertIsNone(private_comment)
self.assertEquals(votecomment.retrieve_comment_text(vote.key), "")
comment = votecomment.mk_new_comment(vote.key, "Private",
"I say old chap")
retrieved_comment = votecomment.retrieve_vote_comment(vote.key)
self.assertIsNotNone(retrieved_comment)
self.assertEquals(comment, retrieved_comment)
self.assertEquals(votecomment.retrieve_comment_text(vote.key),
"I say old chap")
def test_count_reviewer_votes_cast(self):
c, t = self.data_setup()
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
self.assertEquals(0,
voterecord.count_reviewer_votes(c.key, "lister", 1))
# single reviewer, single round, single vote
voterecord.cast_new_vote(subs_key, "lister", 99, "Nowt", round=1)
self.assertEquals(1,
voterecord.count_reviewer_votes(c.key, "lister", 1))
# count is by round; single reviewer, second round
self.assertEquals(0,
voterecord.count_reviewer_votes(c.key, "lister", 2))
voterecord.cast_new_vote(subs_key, "lister", 10, "No comment", round=2)
self.assertEquals(1,
voterecord.count_reviewer_votes(c.key, "lister", 2))
self.assertEquals(1,
voterecord.count_reviewer_votes(c.key, "lister", 1))
# second submission in another track
subs_key2 = submissionrecord.make_submission(t.key, c.key, "track2",
"format")
voterecord.cast_new_vote(subs_key, "lister", 10, "2 comment", round=1)
self.assertEquals(2,
voterecord.count_reviewer_votes(c.key, "lister", 1))
# second reviewer
voterecord.cast_new_vote(subs_key, "rimmer", 99, "Nowt", round=1)
self.assertEquals(1,
voterecord.count_reviewer_votes(c.key, "rimmer", 1))
self.assertEquals(2,
voterecord.count_reviewer_votes(c.key, "lister", 1))
self.assertEquals(1,
voterecord.count_reviewer_votes(c.key, "lister", 2))
def test_summary(self):
c, t = self.data_setup()
round = 1
sub_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
self.assertEquals(
len(submissionrecord.retrieve_conference_submissions(c.key)), 1)
summary = votesummary.retrieve_vote_summary("Reviewer1", round)
self.assertEquals(len(summary), 0)
voterecord.cast_new_vote(sub_key, "Reviewer1", 2, "No comment", 1)
summary = votesummary.retrieve_vote_summary("Reviewer1", round)
self.assertEquals(len(summary), 1)
self.assertTrue(summary.has_key(sub_key.urlsafe()))
self.assertTrue(summary[sub_key.urlsafe()].score, 2)
self.assertTrue(summary[sub_key.urlsafe()].shared_comment,
"Yes comment")
self.assertTrue(summary[sub_key.urlsafe()].shared_comment, "")
t2 = talk.Talk()
t2.title = "Another talk"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, c.key, "track",
"format")
voterecord.cast_new_vote(sub_key2, "Reviewer1", 2, "Comments", 1)
summary = votesummary.retrieve_vote_summary("Reviewer1", round)
self.assertEquals(len(summary), 2)
self.assertTrue(summary.has_key(sub_key2.urlsafe()))
self.assertTrue(summary[sub_key2.urlsafe()].score, 1)
self.assertTrue(summary[sub_key2.urlsafe()].shared_comment, "Comment2")
self.assertTrue(summary[sub_key2.urlsafe()].shared_comment, "PRIVATE")
voterecord.cast_new_vote(sub_key2, "Reviewer2", 2, "Comments", 1)
self.assertEquals(
len(votesummary.retrieve_vote_summary("Reviewer1", round)), 2)
self.assertEquals(
len(votesummary.retrieve_vote_summary("Reviewer2", round)), 1)
self.assertEquals(
len(votesummary.retrieve_vote_summary("Reviewer3", round)), 0)
def test_mutiple_submissions_without_duplicate_votes(self):
VotingRound = 1
submission_keys = self.common_data_setup()
existing_vote = voterecord.find_existing_vote_by_reviewer(
submission_keys[0], "Allan", VotingRound)
self.assertTrue(existing_vote is None)
voterecord.cast_new_vote(submission_keys[0], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[0], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[0], "Anton", -1, "Minus 1",
VotingRound)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[0], 1)), 3)
existing_vote = voterecord.find_existing_vote_by_reviewer(
submission_keys[1], "Allan", VotingRound)
self.assertTrue(existing_vote is None)
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Anton", -1, "Minus 1",
VotingRound)
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound).total_score, 2)
duplicates_list = dedupvotes.find_duplicate_votes(
self.c.key, VotingRound)
self.assertEquals(len(duplicates_list), 0)
dedupvotes.remove_duplicates(duplicates_list)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[0],
VotingRound)), 3)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[1],
VotingRound)), 3)
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound).total_score, 2)
def test_sort_submissions_by_total(self):
self.create_conference()
t1 = talk.Talk()
t1.title = "Talk T1"
t1.put()
sub_key1 = submissionrecord.make_submission(t1.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key1, "Fred", -2, "I hate this talk", 1)
voterecord.cast_new_vote(sub_key1, "Jill", -2, "I hate this talk too",
1)
t2 = talk.Talk()
t2.title = "Talk T2"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key2, "Fred", -1, "I dislike this talk",
1)
voterecord.cast_new_vote(sub_key2, "Jill", 2, "Like", 1)
t3 = talk.Talk()
t3.title = "Talk T3...."
t3.put()
sub_key3 = submissionrecord.make_submission(t3.key, self.c.key,
"track", "format")
voterecord.cast_new_vote(sub_key3, "Fred", 1, "I like this talk", 1)
voterecord.cast_new_vote(sub_key3, "Jill", 2, "Like too", 1)
submissions = submissionrecord.retrieve_submissions_records(self.c.key)
sorted_submissions = submissionrecord.sort_submissions_by_total_low_to_high(
submissions, 1)
self.assertEquals(len(sorted_submissions), 3)
self.assertEquals(sorted_submissions[0].title(), t1.title)
self.assertEquals(sorted_submissions[0].get_scores(1).total_score, -4)
self.assertEquals(sorted_submissions[1].title(), t2.title)
self.assertEquals(sorted_submissions[1].get_scores(1).total_score, 1)
self.assertEquals(sorted_submissions[2].title(), t3.title)
self.assertEquals(sorted_submissions[2].get_scores(1).total_score, 3)
rev_sorted_submissions = submissionrecord.sort_submissions_by_total_high_to_low(
submissions, 1)
self.assertEquals(len(rev_sorted_submissions), 3)
self.assertEquals(rev_sorted_submissions[0].title(), t3.title)
self.assertEquals(rev_sorted_submissions[0].get_scores(1).total_score,
3)
self.assertEquals(rev_sorted_submissions[1].title(), t2.title)
self.assertEquals(rev_sorted_submissions[1].get_scores(1).total_score,
1)
self.assertEquals(rev_sorted_submissions[2].title(), t1.title)
self.assertEquals(rev_sorted_submissions[2].get_scores(1).total_score,
-4)
voterecord.cast_new_vote(sub_key2, "Jim", +3, "Brill", 1)
voterecord.cast_new_vote(sub_key2, "Shiela", +3, "Super", 1)
mean_sorted = submissionrecord.sort_submissions_by_mean_low_to_high(
submissions, 1)
self.assertEquals(len(mean_sorted), 3)
self.assertEquals(mean_sorted[0].title(), t1.title)
self.assertEquals(mean_sorted[0].get_scores(1).mean_score, -2)
self.assertEquals(mean_sorted[1].title(), t3.title)
self.assertEquals(mean_sorted[1].get_scores(1).mean_score, 1.5)
self.assertEquals(mean_sorted[2].title(), t2.title)
self.assertEquals(mean_sorted[2].get_scores(1).mean_score, 1.75)
mean_sorted = submissionrecord.sort_submissions_by_mean_high_to_low(
submissions, 1)
self.assertEquals(len(mean_sorted), 3)
self.assertEquals(mean_sorted[2].title(), t1.title)
self.assertEquals(mean_sorted[2].get_scores(1).mean_score, -2)
self.assertEquals(mean_sorted[1].title(), t3.title)
self.assertEquals(mean_sorted[1].get_scores(1).mean_score, 1.5)
self.assertEquals(mean_sorted[0].title(), t2.title)
self.assertEquals(mean_sorted[0].get_scores(1).mean_score, 1.75)
voterecord.cast_new_vote(sub_key3, "Jim", +3, "Brill", 1)
voterecord.cast_new_vote(sub_key3, "Shiela", +2, "Super", 1)
median_sorted = submissionrecord.sort_submissions_by_median_low_to_high(
submissions, 1)
self.assertEquals(len(median_sorted), 3)
self.assertEquals(median_sorted[0].title(), t1.title)
self.assertEquals(median_sorted[0].get_scores(1).median_score, -2)
self.assertEquals(median_sorted[1].title(), t3.title)
self.assertEquals(median_sorted[1].get_scores(1).median_score, 2)
self.assertEquals(median_sorted[2].title(), t2.title)
self.assertEquals(median_sorted[2].get_scores(1).median_score, 2.5)
def test_delete_conference(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
ur = userrights.UserRights(c.key)
ur.add_track_reviewer("harry", "technology track")
self.assertEquals(
1, self.count_db_entries(userrights.RightsRecord, c.key))
track1 = confoptions.make_conference_track(c.key, "New Track")
track2 = confoptions.make_conference_track(c.key, "Another track")
self.assertEquals(
2, self.count_db_entries(confoptions.TrackOption, c.key))
duration1 = confoptions.make_conference_option(
confoptions.DurationOption, c.key, "30 minutes")
self.assertEquals(
1, self.count_db_entries(confoptions.DurationOption, c.key))
confoptions.make_conference_option(confoptions.TalkFormatOption, c.key,
"Lecture")
self.assertEquals(
1, self.count_db_entries(confoptions.TalkFormatOption, c.key))
confoptions.make_conference_option(confoptions.ExpenseOptions, c.key,
"Local")
self.assertEquals(
1, self.count_db_entries(confoptions.ExpenseOptions, c.key))
review_config = confreviewconfig.get_conference_review_factory(c.key)
self.assertIsNotNone(review_config)
self.assertEquals(
1,
self.count_db_entries(confreviewconfig.ConferenceReviewFactory,
c.key))
self.assertEquals(
0, self.count_db_entries(confreviewconfig.ClassicReview, c.key))
self.assertEquals(
1, self.count_db_entries(confreviewconfig.NewScoringReview, c.key))
self.assertEquals(
1, self.count_db_entries(confreviewconfig.RankReview, c.key))
s = speaker.make_new_speaker("mail@email")
s.name = "Arnold Rimmer"
s.put()
t = talk.Talk(parent=s.key)
t.title = "A testing talk"
t.put()
sub_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
self.assertEquals(
1, self.count_db_entries(submissionrecord.SubmissionRecord, c.key))
vote = voterecord.cast_new_vote(sub_key, "Reviewer1", 2, "No comment",
1)
self.assertEquals(1, self.count_db_entries(voterecord.VoteRecord,
c.key))
rev = reviewer.make_new_reviewer(c.key, "rimmer@email")
self.assertEquals(1, self.count_db_entries(reviewer.Reviewer, c.key))
rev.assign_submission("track", [sub_key], review_round=1)
self.assertEquals(
1, self.count_db_entries(reviewer.ReviewAssignment, c.key))
confdelete.cascade_delete_conference(c.key)
self.assertEquals(
0, self.count_db_entries(userrights.RightsRecord, c.key))
self.assertEquals(
0, self.count_db_entries(submissionrecord.SubmissionRecord, c.key))
self.assertEquals(0, self.count_db_entries(voterecord.VoteRecord,
c.key))
self.assertEquals(
0, self.count_db_entries(confoptions.TrackOption, c.key))
self.assertEquals(
0, self.count_db_entries(confoptions.DurationOption, c.key))
self.assertEquals(
0, self.count_db_entries(confoptions.TalkFormatOption, c.key))
self.assertEquals(
0, self.count_db_entries(confoptions.ExpenseOptions, c.key))
self.assertEquals(
0,
self.count_db_entries(confoptions.AcknowledgementEmailCCAddresses,
c.key))
self.assertEquals(
0,
self.count_db_entries(confoptions.AcknowledgementEmailBCCAddresses,
c.key))
self.assertEquals(
0, self.count_db_entries(confoptions.AcceptEmailCCAddress, c.key))
self.assertEquals(
0,
self.count_db_entries(confreviewconfig.ConferenceReviewFactory,
c.key))
self.assertEquals(
0, self.count_db_entries(confreviewconfig.ClassicReview, c.key))
self.assertEquals(
0, self.count_db_entries(confreviewconfig.NewScoringReview, c.key))
self.assertEquals(
0, self.count_db_entries(confreviewconfig.RankReview, c.key))
self.assertEquals(
0, self.count_db_entries(dedupvotes.DuplicateVoteReport, c.key))
self.assertEquals(
0, self.count_db_entries(reviewer.ReviewAssignment, c.key))
self.assertEquals(0, self.count_db_entries(reviewer.Reviewer, c.key))
def test_find_reviewer_votes_for_round(self):
c, t = self.data_setup()
round = 1
# no votes at the start
self.assertEquals(
0,
len(
reports.commentreport.find_reviewer_votes_for_round(
"Reviewer1", round)))
# first vote
subs_key = submissionrecord.make_submission(t.key, c.key, "track",
"format")
vote1 = voterecord.cast_new_vote(subs_key, "Reviewer1", 1, "Comment",
round)
self.assertEquals(
1,
len(
reports.commentreport.find_reviewer_votes_for_round(
"Reviewer1", round)))
# another vote for another submission
subs_key2 = submissionrecord.make_submission(t.key, c.key, "track",
"format1")
vote2 = voterecord.cast_new_vote(subs_key2, "Reviewer1", 1, "", round)
self.assertEquals(
2,
len(
reports.commentreport.find_reviewer_votes_for_round(
"Reviewer1", round)))
# vote for another track
subs_key3 = submissionrecord.make_submission(t.key, c.key,
"anotherTrack", "format")
vote3 = voterecord.cast_new_vote(subs_key2, "Reviewer1", 1, "", round)
self.assertEquals(
3,
len(
reports.commentreport.find_reviewer_votes_for_round(
"Reviewer1", round)))
# vote for another round
vote4 = voterecord.cast_new_vote(subs_key, "Reviewer1", 1, "Round2",
round + 1)
self.assertEquals(
0,
len(
reports.commentreport.find_reviewer_votes_for_round(
"Reviewer", round + 1)))
self.assertEquals(
3,
len(
reports.commentreport.find_reviewer_votes_for_round(
"Reviewer1", round)))
# somelse votes
vote5 = voterecord.cast_new_vote(subs_key, "Reviewer2", 1, "some else",
round)
self.assertEquals(
0,
len(
reports.commentreport.find_reviewer_votes_for_round(
"Reviewer", round)))
self.assertEquals(
3,
len(
reports.commentreport.find_reviewer_votes_for_round(
"Reviewer1", round)))
def test_find_and_remove_duplicate_votes(self):
VotingRound = 1
submission_keys = self.common_data_setup()
existing_vote = voterecord.find_existing_vote_by_reviewer(
submission_keys[0], "Allan", VotingRound)
self.assertTrue(existing_vote is None)
voterecord.cast_new_vote(submission_keys[0], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[0], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[0], "Anton", -1, "Minus 1",
VotingRound)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[0],
VotingRound)), 3)
existing_vote = voterecord.find_existing_vote_by_reviewer(
submission_keys[1], "Allan", VotingRound)
self.assertTrue(existing_vote is None)
# Set up the bug
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Anton", -1, "Minus 1",
VotingRound)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[1],
VotingRound)), 5)
# This is the bug
# Because of extra vote the total is wrong
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound).total_score, 4)
duplicates_list = dedupvotes.find_duplicate_votes(
self.c.key, VotingRound)
self.assertEquals(len(duplicates_list), 1)
self.assertEquals(len(duplicates_list[duplicates_list.keys()[0]]), 3)
self.assertEquals(len(duplicates_list["Allan"]), 3)
dedupvotes.remove_duplicates(duplicates_list)
# Check it was all done
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[0],
VotingRound)), 3)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[1],
VotingRound)), 3)
# And the total score is now correct
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound).total_score, 2)
def test_dedup_leave_other_rounds(self):
VotingRound = 1
submission_keys = self.common_data_setup()
existing_vote = voterecord.find_existing_vote_by_reviewer(
submission_keys[0], "Allan", VotingRound)
self.assertTrue(existing_vote is None)
voterecord.cast_new_vote(submission_keys[0], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[0], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[0], "Anton", -1, "Minus 1",
VotingRound)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[0],
VotingRound)), 3)
existing_vote = voterecord.find_existing_vote_by_reviewer(
submission_keys[1], "Allan", VotingRound)
self.assertTrue(existing_vote is None)
# Set up the bug
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Anton", -1, "Minus 1",
VotingRound)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[1],
VotingRound)), 5)
# This is the bug
# Because of extra vote the total is wrong
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound).total_score, 4)
# Add votes for another round, also with duplicates
voterecord.cast_new_vote(submission_keys[0], "Harry", 1, "One",
VotingRound + 1)
voterecord.cast_new_vote(submission_keys[0], "Ron", 2, "Two",
VotingRound + 1)
voterecord.cast_new_vote(submission_keys[0], "Percy", -1, "Minus 1",
VotingRound + 1)
self.assertEquals(
len(
voterecord.find_existing_votes(submission_keys[0],
VotingRound + 1)), 3)
voterecord.cast_new_vote(submission_keys[1], "Harry", 1, "One",
VotingRound + 1)
voterecord.cast_new_vote(submission_keys[1], "Harry", 1, "One",
VotingRound + 1)
voterecord.cast_new_vote(submission_keys[1], "Harry", 1, "One",
VotingRound + 1)
voterecord.cast_new_vote(submission_keys[1], "Ron", 2, "Two",
VotingRound + 1)
voterecord.cast_new_vote(submission_keys[1], "Percy", -1, "Minus 1",
VotingRound + 1)
self.assertEquals(
len(
voterecord.find_existing_votes(submission_keys[1],
VotingRound + 1)), 5)
duplicates_list = dedupvotes.find_duplicate_votes(
self.c.key, VotingRound)
self.assertEquals(len(duplicates_list), 1)
self.assertEquals(len(duplicates_list[duplicates_list.keys()[0]]), 3)
self.assertEquals(len(duplicates_list["Allan"]), 3)
dedupvotes.remove_duplicates(duplicates_list)
# Check it was all done
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[0],
VotingRound)), 3)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[1],
VotingRound)), 3)
# And the total score is now correct
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound).total_score, 2)
# Check second round wasn't touched
self.assertEquals(
len(
voterecord.find_existing_votes(submission_keys[0],
VotingRound + 1)), 3)
self.assertEquals(
len(
voterecord.find_existing_votes(submission_keys[1],
VotingRound + 1)), 5)
# Fix it
second_duplicates_list = dedupvotes.find_duplicate_votes(
self.c.key, VotingRound + 1)
dedupvotes.remove_duplicates(second_duplicates_list)
self.assertEquals(
len(
voterecord.find_existing_votes(submission_keys[0],
VotingRound + 1)), 3)
self.assertEquals(
len(
voterecord.find_existing_votes(submission_keys[1],
VotingRound + 1)), 3)
self.assertEqual(
submission_keys[0].get().get_scores(VotingRound + 1).total_score,
2)
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound + 1).total_score,
2)
def test_multiple_submissions_with_duplicate_votes(self):
VotingRound = 1
submission_keys = self.common_data_setup()
existing_vote = voterecord.find_existing_vote_by_reviewer(
submission_keys[0], "Allan", VotingRound)
self.assertTrue(existing_vote is None)
voterecord.cast_new_vote(submission_keys[0], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[0], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[0], "Anton", -1, "Minus 1",
VotingRound)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[0], 1)), 3)
existing_vote = voterecord.find_existing_vote_by_reviewer(
submission_keys[1], "Allan", VotingRound)
self.assertTrue(existing_vote is None)
# Set up the bug
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Allan", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Grisha", 2, "Two",
VotingRound)
voterecord.cast_new_vote(submission_keys[1], "Anton", -1, "Minus 1",
VotingRound)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[1],
VotingRound)), 5)
# This is the bug
# Because of extra vote the total is wrong
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound).total_score, 4)
# Another submission with duplicae votes
t3 = talk.Talk()
t3.title = "Talk3 - Another submission with duplicates"
t3.put()
subs_key3 = submissionrecord.make_submission(t3.key, self.c.key,
"track", "format")
submission_keys.append(subs_key3)
self.assertEquals(
len(submissionrecord.retrieve_conference_submissions(self.c.key)),
3)
voterecord.cast_new_vote(submission_keys[2], "Harry", 2, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[2], "Ron", 2, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[2], "Draco", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[2], "Draco", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[2], "Draco", 1, "One",
VotingRound)
voterecord.cast_new_vote(submission_keys[2], "Percy", 3, "Three",
VotingRound)
# check the bug is in place
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[2],
VotingRound)), 6)
self.assertEqual(
submission_keys[2].get().get_scores(VotingRound).total_score, 10)
duplicates_list = dedupvotes.find_duplicate_votes(
self.c.key, VotingRound)
self.assertEquals(len(duplicates_list), 2)
dedupvotes.remove_duplicates(duplicates_list)
# Check it was all done
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[0],
VotingRound)), 3)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[1],
VotingRound)), 3)
self.assertEquals(
len(voterecord.find_existing_votes(submission_keys[2],
VotingRound)), 4)
# And the total score is now correct
self.assertEqual(
submission_keys[0].get().get_scores(VotingRound).total_score, 2)
self.assertEqual(
submission_keys[1].get().get_scores(VotingRound).total_score, 2)
self.assertEqual(
submission_keys[2].get().get_scores(VotingRound).total_score, 8)
def new_vote(self, submission_key, ranking, comment, review_round):
return voterecord.cast_new_vote(submission_key,
self.get_crrt_user().email(),
ranking,
comment,
round=review_round)
