def test_can_close_conference(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
# No submissions so no outstanding decisions
self.assertTrue(confstate.can_close_conference(c.key, 1))
t1 = talk.Talk()
t1.title = "Talk T1"
t1.put()
sub_key1 = submissionrecord.make_submission(t1.key, c.key, "track",
"format")
# can't close while submission is undecided
self.assertFalse(confstate.can_close_conference(c.key, 1))
sub = sub_key1.get()
sub.set_review_decision(1, "Accept")
sub.put()
self.assertTrue(confstate.can_close_conference(c.key, 1))
t2 = talk.Talk()
t2.title = "Talk T2"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, c.key, "track",
"format")
self.assertFalse(confstate.can_close_conference(c.key, 1))
def test_post_many(self, mock_deferred_func):
c, sub_key1 = self.common_setup()
t2 = talk.Talk()
t2.title = "Talk T2"
t2.put()
sub_key2 = submissionrecord.make_submission_plus(
t2.key, c.key, "track", "format", "time", "exp")
t3 = talk.Talk()
t3.title = "Talk T3"
t3.put()
sub_key3 = submissionrecord.make_submission_plus(
t3.key, c.key, "track", "format", "time", "exp")
accept = msgtemplate.retrieveTemplate(msgtemplate.AcceptMsg, c.key)
try:
postmail.Postman().post_many(
c,
accept, [sub_key1.get(),
sub_key2.get(),
sub_key3.get()],
send_gap_seconds=10)
except:
self.assertTrue(False, "Exception rasied unexpectedly")
else:
self.assertTrue(True, "Exception not rasied as expected")
def setup_test_data(self):
s = speaker.make_new_speaker("rimmer@email")
s.name = "Arnold Rimmer"
s.put()
t1 = talk.Talk(parent=s.key)
t1.title = "A testing talk"
t1.put()
sub_key1 = submissionrecord.make_submission(t1.key,
self.conference.key,
"track", "format")
t2 = talk.Talk(parent=s.key)
t2.title = "Another testing talk"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key,
self.conference.key,
"track", "format")
s2 = speaker.make_new_speaker("cat@email")
s2.name = "Cat"
s2.put()
t3 = talk.Talk(parent=s2.key)
t3.title = "Cool for cats"
t3.put()
sub_key3 = submissionrecord.make_submission(t3.key,
self.conference.key,
"track", "format")
return sub_key1, sub_key2, sub_key3
def common_data_setup(self):
self.c = conference.Conference()
self.c.name = "TestConf"
self.c.put()
# Set up the scenario
t1 = talk.Talk()
t1.title = "Talk1 - No duplicate votes"
t1.put()
subs_key1 = submissionrecord.make_submission(t1.key, self.c.key,
"track", "format")
self.assertEquals(
len(submissionrecord.retrieve_conference_submissions(self.c.key)),
1)
t2 = talk.Talk()
t2.title = "Talk2 - Allan duplicate votes"
t2.put()
subs_key2 = submissionrecord.make_submission(t2.key, self.c.key,
"track", "format")
self.assertEquals(
len(submissionrecord.retrieve_conference_submissions(self.c.key)),
2)
return [subs_key1, subs_key2]
def test_retrieve_conference_submission_keys_by_track_and_round(self):
self.create_conference()
sub_key1 = submissionrecord.make_submission(self.t.key, self.c.key, "Track1", "format")
sub = sub_key1.get()
sub.last_review_round = 2
sub.put()
t2 = talk.Talk()
t2.title = "Talk 2"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, self.c.key, "Track1", "format")
t3 = talk.Talk()
t3.title = "Talk 3"
t3.put()
sub_key2 = submissionrecord.make_submission(t2.key, self.c.key, "Track3", "format")
subs_round2track1 = submissions_aux.retrieve_conference_submission_keys_by_track_and_round(
self.c.key, "Track1", 2)
self.assertEquals(len(subs_round2track1), 1)
self.assertItemsEqual([sub_key1], subs_round2track1)
self.assertEquals(len(
submissions_aux.retrieve_conference_submission_keys_by_track(self.c.key, "Track2")), 0)
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track1")), 2)
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track2")), 0)
def test_get_submission_by_talk_and_conf(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")
t2 = talk.Talk()
t2.title = "Unsubmitted"
t2.put()
self.assertEquals(
sub_key1,
submissionrecord.get_submission_by_talk_and_conf(
t1.key, "TestConf"))
self.assertEquals(
None,
submissionrecord.get_submission_by_talk_and_conf(
t2.key, "TestConf"))
# does not get listed for other conferences
c2 = conference.Conference()
c2.name = "OtherConf"
c2.put()
self.assertEquals(
None,
submissionrecord.get_submission_by_talk_and_conf(
t1.key, "OtherConf"))
self.assertEquals(
None,
submissionrecord.get_submission_by_talk_and_conf(
t2.key, "OtherConf"))
def test_export_submissions_list(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
track1 = confoptions.make_conference_track(c.key, "track")
track2 = confoptions.make_conference_track(c.key, "another track")
format1 = confoptions.make_conference_option(confoptions.TalkFormatOption, c.key, "lecture")
duration1 = confoptions.make_conference_option(confoptions.DurationOption, c.key, "10mins")
expenses1 = confoptions.make_conference_option(confoptions.ExpenseOptions, c.key, "Money")
s = speaker.make_new_speaker("*****@*****.**")
s.put()
t = talk.Talk(parent=s.key)
t.title = "A testing talk"
t.put()
sub_key = submissionrecord.make_submission_plus(t.key, c.key, track1.shortname(),
format1.shortname(), duration1.shortname(),
expenses1.shortname())
s2 = speaker.make_new_speaker("*****@*****.**")
s2.put()
t2 = talk.Talk(parent=s2.key)
t2.title = "Knowing Rimmer"
t2.put()
sub_key2 = submissionrecord.make_submission_plus(t2.key, c.key, track2.shortname(),
format1.shortname(), duration1.shortname(),
expenses1.shortname())
output = MockOutStream()
exportcsv.write_sub_list(output, [sub_key, sub_key2])
self.assertEquals(output.number_of_writes(), 38)
def test_filter_for_cospeakers(self):
t = talk.Talk(parent=self.spk1.key)
t.title = "Talk talk"
t.put()
sub_key1 = submissionrecord.make_submission(t.key, self.c.key, "TrackB", "format")
t2 = talk.Talk(parent=self.spk1.key)
t2.title = "More talk"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, self.c.key, "TrackB", "format")
cospeak = cospeaker.make_cospeaker(sub_key2, "Harry", "*****@*****.**")
submissions = [ sub_key1, sub_key2 ]
sub_speakers_map = cospeaker.filter_for_cospeakers(submissions)
self.assertFalse(sub_speakers_map.has_key(sub_key1))
self.assertTrue(sub_speakers_map.has_key(sub_key2))
self.assertEqual(sub_speakers_map[sub_key2][0].name, "Harry")
cospeak = cospeaker.make_cospeaker(sub_key2, "Ron", "*****@*****.**")
sub_speakers_map = cospeaker.filter_for_cospeakers(submissions)
self.assertFalse(sub_speakers_map.has_key(sub_key1))
self.assertTrue(sub_speakers_map.has_key(sub_key2))
cospeakers = sub_speakers_map[sub_key2]
cospeakers.sort(key=lambda speaker: speaker.name)
self.assertEqual(sub_speakers_map[sub_key2][0].name, "Harry")
self.assertEqual(sub_speakers_map[sub_key2][1].name, "Ron")
def test_count_all_speakers(self):
self.assertEqual(cospeaker.count_all_speakers([]).total_number_of_speakers(), 0)
t = talk.Talk(parent=self.spk1.key)
t.title = "Talk talk"
t.put()
sub_key1 = submissionrecord.make_submission(t.key, self.c.key, "TrackB", "format")
submissions = [sub_key1]
self.assertEqual(cospeaker.count_all_speakers(submissions).total_number_of_speakers(), 1)
t2 = talk.Talk(parent=self.spk1.key)
t2.title = "More talk"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, self.c.key, "TrackB", "format")
submissions = [sub_key1, sub_key2]
self.assertEqual(cospeaker.count_all_speakers(submissions).total_number_of_speakers(), 1)
cospeak = cospeaker.make_cospeaker(sub_key2, "Harry", "*****@*****.**")
self.assertEqual(cospeaker.count_all_speakers(submissions).total_number_of_speakers(), 2)
cospeak = cospeaker.make_cospeaker(sub_key2, "Ron", "*****@*****.**")
self.assertEqual(cospeaker.count_all_speakers(submissions).total_number_of_speakers(), 3)
cospeak = cospeaker.make_cospeaker(sub_key1, "Ron", "*****@*****.**")
self.assertEqual(cospeaker.count_all_speakers(submissions).total_number_of_speakers(), 3)
def test_store_retrieve_by_key(self):
spk1 = speaker.make_new_speaker("who@email")
spk1.put()
t1 = talk.Talk(parent=spk1.key)
t1.title = "Wonderful"
t1.put()
t2 = talk.Talk(parent=spk1.key)
t2.title = "Great"
t2.put()
user1_talks = talk.speaker_talks_by_key(spk1.key)
self.assertEquals(len(user1_talks), 2)
spk2 = speaker.make_new_speaker("nobody@email")
spk2.put()
t3 = talk.Talk(parent=spk2.key)
t3.title = "Smashing"
t3.put()
user2_talks = talk.speaker_talks_by_key(spk2.key)
self.assertEquals(len(user2_talks), 1)
t2.key.delete()
user1_talks = talk.all_user_talks_by_email(spk1.email)
self.assertEquals(len(user1_talks), 1)
def test_decision_summary(self):
self.create_conference()
t = talk.Talk()
t.title = "A testing talk"
t.put()
submission = submissionrecord.make_submission(t.key, self.c.key,
"track", "format").get()
decision_summary = submissionrecord.get_decision_summary(
self.c.key, "track", 1)
self.assertEquals(len(decision_summary), 1)
self.assertEquals(decision_summary["No decision"], 1)
submission.set_review_decision(1, "Accept")
submission.put()
decision_summary = submissionrecord.get_decision_summary(
self.c.key, "track", 1)
self.assertEquals(len(decision_summary), 2)
self.assertEquals(decision_summary["Accept"], 1)
self.assertEquals(decision_summary["No decision"], 0)
t2 = talk.Talk()
t2.title = "A bad test"
t2.put()
sub2 = submissionrecord.make_submission(t2.key, self.c.key, "track",
"format").get()
sub2.set_review_decision(1, "Reject")
sub2.put()
decision_summary = submissionrecord.get_decision_summary(
self.c.key, "track", 1)
self.assertEquals(len(decision_summary), 3)
self.assertEquals(decision_summary["Reject"], 1)
self.assertEquals(decision_summary["No decision"], 0)
t3 = talk.Talk()
t3.title = "A good test"
t3.put()
sub3 = submissionrecord.make_submission(t3.key, self.c.key, "track",
"format").get()
sub3.set_review_decision(1, "Accept")
sub3.put()
decision_summary = submissionrecord.get_decision_summary(
self.c.key, "track", 1)
self.assertEquals(len(decision_summary), 3)
self.assertEquals(decision_summary["Accept"], 2)
self.assertEquals(decision_summary["Reject"], 1)
self.assertEquals(decision_summary["No decision"], 0)
decision_summary = submissionrecord.get_decision_summary(
self.c.key, "another track", 1)
self.assertEquals(len(decision_summary), 1)
def show_single_submit_page(self):
if self.submissions_exceeded():
sorrypage.redirect_sorry(self, "SubsLimitReached")
return
conf_questions = confquestion.retrieve_questions(self.crrt_conf.key)
conf_answers = submission_ans.retrieve_answer_map(
None, map(lambda q: q.key, conf_questions))
template_values = {
"crrt_conf": self.crrt_conf,
# Speaker fields
'new_speaker': True,
'speaker': self.submitter,
"emaillocked": "readonly",
'speakerKey': "",
'readonly': "",
# Talk fields
"talk_details": talk.Talk(parent=None),
"is_new": True,
"talk_key": None,
# Conference submission fields
"selected_track": self.crrt_conf.track_options().keys()[0],
"selected_duration": self.crrt_conf.duration_options().keys()[0],
"selected_format":
self.crrt_conf.delivery_format_options().keys()[0],
"selected_expenses": self.crrt_conf.expenses_options().keys()[0],
"conf_questions": conf_questions,
"conf_answers": conf_answers,
}
self.write_page('submission_lib/singlesubmitpage.html',
template_values)
def test_retrieve_conference_submissions_keys(self):
self.create_conference()
self.assertEquals(
len(
submissionrecord.retrieve_conference_submissions_keys(
self.c.key)), 0)
t1 = talk.Talk()
t1.title = "Talk T1"
t1.put()
sub_key = submissionrecord.make_submission(t1.key, self.c.key, "track",
"format")
self.assertEquals(
len(
submissionrecord.retrieve_conference_submissions_keys(
self.c.key)), 1)
subs_list = submissionrecord.retrieve_conference_submissions_keys(
self.c.key)
self.assertEquals(sub_key, subs_list[0])
sub_key2 = submissionrecord.make_submission(t1.key, self.c.key,
"track2", "format")
self.assertEquals(
len(
submissionrecord.retrieve_conference_submissions_keys(
self.c.key)), 2)
subs_list = submissionrecord.retrieve_conference_submissions_keys(
self.c.key)
self.assertListEqual([sub_key, sub_key2], subs_list)
def test_speaker_comms_state(self):
self.create_conference()
t1 = talk.Talk()
t1.title = "Talk T1"
t1.put()
sub_key = submissionrecord.make_submission(t1.key, self.c.key, "track",
"format")
sub = sub_key.get()
self.assertEquals(sub.communication, "None")
sub.acknowledge_receipt()
self.assertEquals(sub.communication, "Receipt acknowledged")
sub.mark_decline_pending()
self.assertEquals(sub.communication, "Decline pending")
sub.mark_declined()
self.assertEquals(sub.communication, "Decline sent")
sub.mark_acccept_pending()
self.assertEquals(sub.communication, "Accept pending")
sub.mark_acccept()
self.assertEquals(sub.communication, "Accept sent")
sub.mark_accept_acknowledged()
self.assertEquals(sub.communication, "Acceptance acknowledged")
sub.mark_accept_declined()
self.assertEquals(sub.communication, "Acceptance declined")
sub.mark_accept_problem()
self.assertEquals(sub.communication, "Acceptance problem")
sub.mark_comms(submissionnotifynames.SUBMISSION_ACCEPTED)
self.assertEquals(sub.communication, "Accept sent")
sub.mark_comms(
submissionnotifynames.SUBMISSION_FAILED_ACCEPT_NOTIFICATON)
self.assertEquals(sub.communication, "Accept notification failed")
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_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_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_submission_by_conf_and_talk(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")
t2 = talk.Talk()
t2.title = "Talk T2"
t2.put()
self.assertEquals(
submissionrecord.get_submission_key(self.c.key, t1.key), sub_key1)
self.assertEquals(
submissionrecord.get_submission_key(self.c.key, t2.key), None)
def test_mass_track_change(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
ReviewRound = 1
t1 = talk.Talk()
t1.title = "Talk T1 - No decsion"
t1.put()
sub_key1 = submissionrecord.make_submission(t1.key, c.key, "track 1",
"format")
self.assertEqual(sub_key1.get().review_decision(ReviewRound),
"No decision")
t2 = talk.Talk()
t2.title = "Talk T2 - Accept"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, c.key, "track 1",
"format")
sub_key2.get().set_review_decision(ReviewRound, "Accept")
t3 = talk.Talk()
t3.title = "Talk T3 - No decsion"
t3.put()
sub_key3 = submissionrecord.make_submission(t1.key, c.key, "track 1",
"format")
self.assertEqual(sub_key3.get().review_decision(ReviewRound),
"No decision")
t4 = talk.Talk()
t4.title = "Talk T4 - Shortlist"
t4.put()
sub_key4 = submissionrecord.make_submission(t4.key, c.key, "track 1",
"format")
sub_key4.get().set_review_decision(ReviewRound, "Shortlist")
roundreviews.mass_track_change(c.key, "track 1", ReviewRound,
"No decision", "Decline")
self.assertEqual(sub_key1.get().review_decision(ReviewRound),
"Decline")
self.assertEqual(sub_key2.get().review_decision(ReviewRound), "Accept")
self.assertEqual(sub_key3.get().review_decision(ReviewRound),
"Decline")
self.assertEqual(sub_key4.get().review_decision(ReviewRound),
"Shortlist")
def test_current_review_assisgments(self):
sub_key1, sub_key2, sub_key3 = self.setup_test_data()
reviewer1 = reviewer.make_new_reviewer(self.conference.key,
"rimmer@email")
self.assertItemsEqual([],
reviewer1.retrieve_review_assignments(
"track", review_round=1))
self.assertItemsEqual(
[],
reviewer1.retrieve_review_assignments_for_round(review_round=1))
reviewer2 = reviewer.make_new_reviewer(self.conference.key,
"cat@email")
self.assertItemsEqual([],
reviewer1.retrieve_review_assignments(
"track", review_round=1))
reviewer1.assign_submission("track", [sub_key3], review_round=1)
self.assertItemsEqual([sub_key3],
reviewer1.retrieve_review_assignments(
"track", review_round=1))
self.assertItemsEqual(
[sub_key3],
reviewer1.retrieve_review_assignments_for_round(review_round=1))
reviewer1.assign_submission("track", [sub_key2], review_round=1)
self.assertItemsEqual([sub_key2, sub_key3],
reviewer1.retrieve_review_assignments(
"track", review_round=1))
self.assertItemsEqual(
[sub_key2, sub_key3],
reviewer1.retrieve_review_assignments_for_round(review_round=1))
reviewer2.assign_submission("track", [sub_key1, sub_key2],
review_round=1)
self.assertItemsEqual([sub_key2, sub_key1],
reviewer2.retrieve_review_assignments(
"track", review_round=1))
t4 = talk.Talk(parent=None)
t4.title = "Nobody on another track"
t4.put()
sub_key4 = submissionrecord.make_submission(t4.key,
self.conference.key,
"another_track", "format")
reviewer1.assign_submission("another_track", [sub_key4],
review_round=1)
self.assertItemsEqual([sub_key2, sub_key3],
reviewer1.retrieve_review_assignments(
"track", review_round=1))
self.assertItemsEqual([sub_key4],
reviewer1.retrieve_review_assignments(
"another_track", review_round=1))
self.assertItemsEqual(
[sub_key2, sub_key3, sub_key4],
reviewer1.retrieve_review_assignments_for_round(review_round=1))
def data_setup(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
t = talk.Talk()
t.title = "A testing talk"
t.put()
return c, t
def test_export_submission(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
track1 = confoptions.make_conference_track(c.key, "track")
format1 = confoptions.make_conference_option(confoptions.TalkFormatOption, c.key, "lecture")
duration1 = confoptions.make_conference_option(confoptions.DurationOption, c.key, "10mins")
expenses1 = confoptions.make_conference_option(confoptions.ExpenseOptions, c.key, "Long haul")
s = speaker.make_new_speaker("*****@*****.**")
s.name = 'Arnold "J" Rimmer'
s.telephone = "051 652 0538"
s.address = "Cabin 42, Deck 3, Red Dwarf"
s.set_field("affiliation", "Mining Corp")
s.set_field("twitter", "@arnold")
s.bio = "Arnold 'J' Rimmer joined Mining Corp (Space Division) at, what now seems, a very young age."
s.put()
t = talk.Talk(parent=s.key)
t.title = "A testing talk"
t.set_field(talk.SHORT_SYNOPSIS, "A few words about the tests you need")
t.set_field(talk.LONG_SYNOPSIS, "Many more words about testing.... 1, 2, 3")
t.put()
sub_key = submissionrecord.make_submission_plus(t.key, c.key,
track1.shortname(), format1.shortname(),
duration1.shortname(), expenses1.shortname())
cospeak = cospeaker.make_cospeaker(sub_key, "Harry Potter", "*****@*****.**")
output = MockOutStream()
exportcsv.write_sub(output, sub_key.get())
self.assertEquals(output.sequence[0], 'No decision, ')
self.assertEquals(output.sequence[1], "Arnold 'J' Rimmer, ")
self.assertEquals(output.sequence[2], '[email protected], ')
self.assertEquals(output.sequence[3], '051 652 0538, ')
self.assertEquals(output.sequence[4], '"Cabin 42, Deck 3, Red Dwarf", ')
self.assertEquals(output.sequence[5], 'Harry Potter, ')
self.assertEquals(output.sequence[6], ', ')
self.assertEquals(output.sequence[7], 'Mining Corp, ')
self.assertEquals(output.sequence[8], '@arnold, ')
self.assertEquals(output.sequence[9], """"Arnold 'J' Rimmer joined Mining Corp (Space Division) at, what now seems, a very young age.", """)
self.assertEquals(output.sequence[10], 'None, ')
self.assertEquals(output.sequence[11], 'A testing talk, ')
self.assertEquals(output.sequence[12], "A few words about the tests you need, ")
self.assertEquals(output.sequence[13], '"Many more words about testing.... 1, 2, 3", ')
self.assertEquals(output.sequence[14], 'track, ')
self.assertEquals(output.sequence[15], 'lecture, ')
self.assertEquals(output.sequence[16], '10mins, ')
self.assertEquals(output.sequence[17], 'Long haul, ')
self.assertEquals(output.number_of_writes(), 18)
def test_submit_decision(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
t1 = talk.Talk()
t1.title = "Talk T1 - Accept"
t1.put()
sub_key1 = submissionrecord.make_submission(t1.key, c.key, "track 1",
"format")
t2 = talk.Talk()
t2.title = "Talk T2 - Reject"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, c.key, "track 1",
"format")
decisions_map = {
sub_key1.urlsafe(): "Accept",
sub_key2.urlsafe(): "Decline"
}
t3 = talk.Talk()
t3.title = "Talk T3 - No decision, different track"
t3.put()
sub_key3 = submissionrecord.make_submission(t3.key, c.key, "track 2",
"format")
c.start_round1_reviews()
roundreviews.submit_decisions(c.key, "track 1", 1, decisions_map)
self.assertEquals(sub_key1.get().review_decision(1), "Accept")
self.assertEquals(sub_key2.get().review_decision(1), "Decline")
self.assertEquals(sub_key3.get().review_decision(1), "No decision")
decisions_map = {sub_key3.urlsafe(): "Accept"}
roundreviews.submit_decisions(c.key, "track 2", 1, decisions_map)
self.assertEquals(sub_key1.get().review_decision(1), "Accept")
self.assertEquals(sub_key2.get().review_decision(1), "Decline")
self.assertEquals(sub_key3.get().review_decision(1), "Accept")
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_retrieve_conference_submissions_by_track(self):
self.create_conference()
submissionrecord.make_submission(self.t.key, self.c.key, "Track1", "format")
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track1")), 1)
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track2")), 0)
self.assertEquals(len(
submissions_aux.retrieve_conference_submission_keys_by_track(self.c.key, "Track1")), 1)
self.assertEquals(len(
submissions_aux.retrieve_conference_submission_keys_by_track(self.c.key, "Track2")), 0)
t2 = talk.Talk()
t2.title = "Talk 2"
t2.put()
submissionrecord.make_submission(t2.key, self.c.key, "Track1", "format")
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track1")), 2)
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track2")), 0)
t3 = talk.Talk()
t3.title = "Talk 3 Track 2"
t3.put()
sub_key3 = submissionrecord.make_submission(t3.key, self.c.key, "Track2", "format")
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track1")), 2)
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track2")), 1)
self.assertEquals(len(
submissions_aux.retrieve_conference_submission_keys_by_track(self.c.key, "Track1")), 2)
self.assertEquals(len(
submissions_aux.retrieve_conference_submission_keys_by_track(self.c.key, "Track2")), 1)
sub_key3.get().withdraw()
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track1")), 2)
self.assertEquals(len(
submissions_aux.retrieve_conference_submissions_by_track(self.c.key, "Track2")), 0)
def test_delete_cospeakers(self):
t = talk.Talk(parent=self.spk1.key)
t.title = "Talk talk"
t.put()
sub_key1 = submissionrecord.make_submission(t.key, self.c.key, "TrackB", "format")
cospeak = cospeaker.make_cospeaker(sub_key1, "Harry", "*****@*****.**")
cospeak2 = cospeaker.make_cospeaker(sub_key1, "Ron", "*****@*****.**")
self.assertEquals(len(cospeaker.get_cospeakers(sub_key1)), 2)
cospeaker.delete_cospeakers(sub_key1)
self.assertEquals(len(cospeaker.get_cospeakers(sub_key1)), 0)
def test_track_and_format(self):
self.create_conference()
t = talk.Talk()
t.title = "A testing talk"
t.put()
subs_key = submissionrecord.make_submission(t.key, self.c.key,
"Track1", "WithComputers")
self.assertEquals(subs_key.get().track, "Track1")
self.assertEquals(subs_key.get().delivery_format, "WithComputers")
def create_talks(self):
self.s = speaker.make_new_speaker("mail@email")
self.s.name = "Arnold Rimmer"
self.s.put()
self.t1 = talk.Talk(parent=self.s.key)
self.t1.title = "Talk 1"
self.t1.put()
self.t2 = talk.Talk(parent=self.s.key)
self.t2.title = "Talk 2"
self.t2.put()
self.t3 = talk.Talk(parent=self.s.key)
self.t3.title = "Talk 3"
self.t3.put()
self.t4 = talk.Talk(parent=self.s.key)
self.t4.title = "Talk 4"
self.t4.put()
def test_listed_cospeaker(self):
self.assertFalse(cospeaker.is_listed_cospeaker("*****@*****.**"))
t = talk.Talk(parent=self.spk1.key)
t.title = "Talk talk"
t.put()
sub_key1 = submissionrecord.make_submission(t.key, self.c.key, "TrackB", "format")
cospeak = cospeaker.make_cospeaker(sub_key1, "Harry", "*****@*****.**")
self.assertFalse(speaker.speaker_exists("*****@*****.**"))
self.assertFalse(cospeaker.is_listed_cospeaker("*****@*****.**"))
def create_conference(self):
self.c = conference.Conference()
self.c.name = "TestConf"
self.c.put()
self.s = speaker.make_new_speaker("mail@email")
self.s.name = "Arnold Rimmer"
self.s.put()
self.t = talk.Talk(parent=self.s.key)
self.t.title = "A testing talk"
self.t.put()
