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 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_speakers_who_have_submitted(self):
c = conference.Conference()
c.name = "TestConf"
c.put()
blank_speaker = speaker.make_new_speaker("rimmer@email")
blank_speaker.name = "Arnold Rimmer"
blank_speaker.put()
t1 = talk.mk_talk(blank_speaker.key, "Talk T1")
sub_key1 = submissionrecord.make_submission(t1, c.key, "track",
"format")
bioed = speaker.make_new_speaker("cat@email")
bioed.name = "Arnold Rimmer"
bioed.bio = "The Cat"
bioed.put()
t2 = talk.mk_talk(bioed.key, "Cat Talks")
sub_key2 = submissionrecord.make_submission(t2, c.key, "track",
"format")
spk_list = speaker_checks.find_blank_bio_submissions(c.key)
self.assertEquals(1, len(spk_list))
self.assertEquals("rimmer@email", spk_list[0].email)
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_speaker_key(self):
usr = mimasuser.mk_MimasUser("allan", "*****@*****.**", "unique")
s = speaker.make_new_speaker("mail@email")
usr.set_speaker_key(s.key)
self.assertEquals(s.key, usr.speaker_key())
def test_zero_out_speaker(self):
s = speaker.make_new_speaker("mail@email")
s.telephone = "+44 123"
s.address = "Yellow Brick Road"
s.bio = "Once upon a time"
s.set_field("Twitter", "@Tweetypy")
s.set_field(s.FIELD_JOBTITLE, "Superman")
s.put()
speakerdir.SpeakerDir().add_speaker(s.key)
image.store_only_image(s.key, "Just some binary data")
tags.TagList(s.key).add_tag("Test", "Speaker")
self.assertTrue(image.image_exists(s.key))
self.assertFalse(s.is_zero_deleted())
s.zero_out_speaker()
self.assertTrue(s.is_zero_deleted())
self.assertFalse(speaker.speaker_exists("mail@email"))
self.assertEquals("*****@*****.**", s.email)
self.assertEquals("", s.telephone)
self.assertEquals("", s.address)
self.assertEquals("", s.bio)
self.assertEquals("", s.field("Twitter"))
self.assertFalse(speakerdir.SpeakerDir().is_speaker_listed(s.key))
self.assertEquals([], tags.TagList(s.key).get_all_tags([]))
self.assertFalse(image.image_exists(s.key))
def test_make_new_speaker(self):
self.assertFalse(speaker.speaker_exists("mail@email"))
s = speaker.make_new_speaker("mail@email")
self.assertFalse(s.is_zero_deleted())
self.assertEquals(s.name, "")
self.assertEquals(s.telephone, "")
self.assertEquals(s.email, "mail@email")
self.assertFalse(speaker.speaker_exists("mail@email"))
def test_speaker_image_url(self):
s = speaker.make_new_speaker("mail@email")
s.put()
self.assertFalse(s.has_full_size_image())
img_key = image.store_only_image(s.key, "Some value")
self.assertTrue(s.has_full_size_image())
expected = "/speakerfullimg?spk_id=" + s.key.urlsafe()
self.assertEquals(s.full_image_url(), expected)
def test_double_entry(self):
s = speaker.make_new_speaker("mail@email")
s.put()
speakerdir.SpeakerDir().add_speaker(s.key)
self.assertTrue(speakerdir.SpeakerDir().is_speaker_listed(s.key))
self.assertEquals(1, len(speakerdir.SpeakerDir().get_speaker_list()))
speakerdir.SpeakerDir().add_speaker(s.key)
self.assertEquals(1, len(speakerdir.SpeakerDir().get_speaker_list()))
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_directory_listing(self):
spk1 = speaker.make_new_speaker("who@email")
spk1.put()
t1_key = talk.mk_talk(spk1.key, "Wonderful")
t1 = t1_key.get()
self.assertTrue(t1.is_listed())
t1.hide_listing()
self.assertFalse(t1.is_listed())
t1.show_listing()
self.assertTrue(t1.is_listed())
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()
def test_speakers_retrievable(self):
email = "allan@allan"
self.assertFalse(speaker.speaker_exists(email))
s = speaker.make_new_speaker("mail@email")
s.email = email
s.put()
self.assertTrue(speaker.speaker_exists(email))
retrieved = speaker.retreive_speaker(email)
self.assertTrue(retrieved.email, email)
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
self.c = conference.Conference()
self.c.name = "TestConf"
self.c.put()
self.spk1 = speaker.make_new_speaker("who@email")
self.spk1.name = "Dr Who"
self.spk1.put()
def test_retrieve_full_directory(self):
d = speakerdir.SpeakerDir()
self.assertEquals(0, len(d.get_speaker_list()))
s = speaker.make_new_speaker("mail@email")
s.put()
self.assertFalse(d.is_speaker_listed(s.key))
d.add_speaker(s.key)
self.assertTrue(d.is_speaker_listed(s.key))
speaker_list = d.get_speaker_list()
self.assertEquals(1, len(speaker_list))
self.assertEquals("mail@email", speaker_list[0].get().email)
s2 = speaker.make_new_speaker("harry@email")
s2.put()
d.add_speaker(s2.key)
s3 = speaker.make_new_speaker("ron@email")
s3.put()
d.add_speaker(s3.key)
self.assertEquals(3, len(d.get_speaker_list()))
def test_remove_speaker(self):
d = speakerdir.SpeakerDir()
self.assertEquals(0, len(d.get_speaker_list()))
s = speaker.make_new_speaker("mail@email")
s.put()
d.add_speaker(s.key)
s2 = speaker.make_new_speaker("harry@email")
s2.put()
d.add_speaker(s2.key)
self.assertEquals(2, len(d.get_speaker_list()))
self.assertTrue(d.is_speaker_listed(s.key))
self.assertTrue(d.is_speaker_listed(s2.key))
d.remove_speaker(s.key)
self.assertEquals(1, len(d.get_speaker_list()))
self.assertEquals("harry@email", d.get_speaker_list()[0].get().email)
self.assertFalse(d.is_speaker_listed(s.key))
self.assertTrue(d.is_speaker_listed(s2.key))
def create_conference(self):
self.c = conference.Conference()
self.c.name = "Wizard Con 2018"
self.c.put()
self.s = speaker.make_new_speaker("*****@*****.**")
self.s.name = "Harry Potter"
self.s.bio = "Harry is an amazing wizard"
self.s.put()
self.t = talk.Talk(parent=self.s.key)
self.t.title = "Fighting Voldermort"
self.t.put()
self.sub_key = submissionrecord.make_submission(self.t.key, self.c.key, "track", "format")
def test_find_duplicate_speakers(self):
self.assertEquals([], speaker.find_duplicate_speakers())
s1 = speaker.make_new_speaker("*****@*****.**")
s1.put()
self.assertEquals([], speaker.find_duplicate_speakers())
s2 = speaker.make_new_speaker("*****@*****.**")
s2.put()
self.assertEquals([], speaker.find_duplicate_speakers())
s3 = speaker.make_new_speaker("*****@*****.**")
s3.put()
self.assertEquals([], speaker.find_duplicate_speakers())
s4 = speaker.make_new_speaker("*****@*****.**")
s4.put()
duplicates = speaker.find_duplicate_speakers()
self.assertEquals(1, len(duplicates))
self.assertEquals("*****@*****.**", duplicates[0].speaker_email)
s5 = speaker.make_new_speaker("*****@*****.**")
s5.put()
duplicates = speaker.find_duplicate_speakers()
self.assertEquals(1, len(duplicates))
self.assertEquals("*****@*****.**", duplicates[0].speaker_email)
speaker.make_new_speaker("*****@*****.**").put()
duplicates = speaker.find_duplicate_speakers()
self.assertEquals(1, len(duplicates))
self.assertEquals("*****@*****.**", duplicates[0].speaker_email)
speaker.make_new_speaker("*****@*****.**").put()
duplicates = speaker.find_duplicate_speakers()
self.assertEquals(2, len(duplicates))
self.assertEquals("*****@*****.**", duplicates[0].speaker_email)
self.assertEquals("*****@*****.**", duplicates[1].speaker_email)
def test_profile_exists(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")
self.assertEquals(len(cospeaker.get_cospeakers(sub_key1)), 0)
cospeak = cospeaker.make_cospeaker(sub_key1, "Harry", "*****@*****.**")
r = cospeaker.get_cospeakers(sub_key1)
self.assertEquals(len(r), 1)
self.assertEquals(r[0], cospeak)
self.assertFalse(r[0].profile_exists())
self.assertFalse(speaker.speaker_exists("*****@*****.**"))
harry = speaker.make_new_speaker("*****@*****.**")
harry.put()
self.assertTrue(speaker.speaker_exists("*****@*****.**"))
self.assertTrue(r[0].profile_exists())
def test_getset(self):
s = speaker.make_new_speaker("mail@email")
self.assertEquals(s.telephone, "")
s.telephone = "+44 123"
self.assertEquals(s.telephone, "+44 123")
s.address = "Yellow Brick Road"
self.assertEquals(s.address, "Yellow Brick Road")
self.assertEquals(s.bio, "")
s.bio = "Once upon a time"
self.assertEquals(s.bio, "Once upon a time")
self.assertEquals(s.field("Twitter"), "")
s.set_field("Twitter", "@Tweetypy")
self.assertEquals(s.field("Twitter"), "@Tweetypy")
self.assertEquals("", s.field(s.FIELD_JOBTITLE))
s.set_field(s.FIELD_JOBTITLE, "Superman")
self.assertEquals("Superman", s.field(s.FIELD_JOBTITLE))
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 common_setup(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, "Money")
s = speaker.make_new_speaker("arnold@email")
s.name = "Arnold Rimmer"
s.put()
t1 = talk.Talk(parent=s.key)
t1.title = "Talk T1"
t1.put()
sub_key1 = submissionrecord.make_submission_plus(
t1.key, c.key, track1.shortname(), format1.shortname(),
duration1.shortname(), expenses1.shortname())
return c, sub_key1
def test_new_name_parts(self):
s = speaker.Speaker()
s.set_empty_profile("*****@*****.**")
self.assertEquals(s.first_name(), "")
self.assertEquals(s.later_names(), "")
s.set_first_name("Harry")
self.assertEquals(s.first_name(), "Harry")
self.assertEquals(s.later_names(), "")
self.assertEquals(s.name, "Harry")
s.set_later_names("Potter")
self.assertEquals(s.first_name(), "Harry")
self.assertEquals(s.later_names(), "Potter")
self.assertEquals(s.name, "Harry Potter")
s.set_later_names("S. Potter")
self.assertEquals(s.first_name(), "Harry")
self.assertEquals(s.later_names(), "S. Potter")
self.assertEquals(s.name, "Harry S. Potter")
s2 = speaker.Speaker()
s2.set_empty_profile("*****@*****.**")
self.assertEquals(s2.first_name(), "")
self.assertEquals(s2.later_names(), "")
s2.set_later_names("Weasley")
self.assertEquals(s2.first_name(), "")
self.assertEquals(s2.later_names(), "Weasley")
self.assertEquals(s2.name, "Weasley")
s3 = speaker.make_new_speaker("*****@*****.**")
s3.set_names("Hermione", "Granger")
self.assertEquals(s3.first_name(), "Hermione")
self.assertEquals(s3.later_names(), "Granger")
self.assertEquals(s3.name, "Hermione Granger")
def test_ctor(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", "*****@*****.**")
self.assertFalse(speaker.speaker_exists("*****@*****.**"))
self.assertEquals(cospeak.name, "Harry")
self.assertFalse(speaker.speaker_exists("*****@*****.**"))
self.assertEquals(cospeak.email, "*****@*****.**")
self.assertFalse(speaker.speaker_exists("*****@*****.**"))
self.assertEquals(cospeak.profile().bio, "No bio supplied")
self.assertFalse(speaker.speaker_exists("*****@*****.**"))
self.assertFalse(cospeak.profile_exists())
spk2 = speaker.make_new_speaker("*****@*****.**")
spk2.name="Harry"
spk2.bio="The child who lived"
spk2.put()
# add a speaker profile on that email address
self.assertTrue(cospeak.profile_exists())
self.assertEquals(cospeak.profile().bio, "The child who lived")
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 add_test_speaker(self, name, email):
s = speaker.make_new_speaker(email)
s.name = name
return s.put()
def make_empty_profile(self):
profile = make_new_speaker(self.cospeaker_email)
profile.name = self.cospeaker_name
profile.bio = "No bio supplied"
return profile
def standard_test_data(self):
conf_key = self.get_crrt_conference_key()
conference = conf_key.get()
track1 = confoptions.make_conference_track(conf_key,
"Software delivery")
track2 = confoptions.make_conference_track(conf_key,
"Product Management")
track3 = confoptions.make_conference_track(conf_key, "Team working")
duration1 = confoptions.make_conference_option(
confoptions.DurationOption, conf_key,
"Single session (45 minutes)")
confoptions.make_conference_option(confoptions.DurationOption,
conf_key,
"Double session (90 minutes+)")
format1 = confoptions.make_conference_option(
confoptions.TalkFormatOption, conf_key, "Lecture style")
confoptions.make_conference_option(
confoptions.TalkFormatOption, conf_key,
"Interactive with exercises (no computers)")
expenses1 = confoptions.make_conference_option(
confoptions.ExpenseOptions, conf_key, "Local")
confoptions.make_conference_option(confoptions.ExpenseOptions,
conf_key, "UK")
s = speaker.make_new_speaker("*****@*****.**")
s.name = "Speaker Test"
speaker_key = s.put()
t = talk.Talk(parent=s.key)
t.title = "All talk"
t_key = t.put()
sub_key = submissionrecord.make_submission_plus(
t_key, conf_key, track1.shortname(), format1.shortname(),
duration1.shortname(), expenses1.shortname())
t2 = talk.Talk(parent=s.key)
t2.title = "Talk2"
t2_key = t.put()
sub_key2 = submissionrecord.make_submission_plus(
t2_key, conf_key, track1.shortname(), format1.shortname(),
duration1.shortname(), expenses1.shortname())
conference.user_rights().add_permission("*****@*****.**",
userrightsnames.CONF_CREATOR)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.CHANGE_CONF_STATE)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.APPOINT_REVIEWERS)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.ROUND1_REVIEWER)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.ROUND1_DECISION)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.ROUND2_REVIEWER)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.ROUND2_DECISION)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.ROUND2_DECISION)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.SPEAK_COMMS_COMMS)
conference.user_rights().add_permission(
"*****@*****.**", userrightsnames.CONF_DATA_DUMPS)
conference.user_rights().add_track_reviewer("*****@*****.**",
track1.shortname())
conference.user_rights().add_track_reviewer("*****@*****.**",
track2.shortname())
conference.user_rights().add_track_reviewer("*****@*****.**",
track3.shortname())
reportrecord.mk_report_record(conf_key, "Export", "none.such")
return '/confoptionspage?conf=' + conf_key.urlsafe()
def test_count_submissions(self):
self.create_conference()
spk1 = speaker.make_new_speaker("who@email")
spk1.put()
t1 = talk.Talk(parent=spk1.key)
t1.title = "Talk T1"
t1.put()
sub_key = submissionrecord.make_submission(t1.key, self.c.key, "track",
"format")
self.assertEquals(
submission_queries.count_submissions(self.c.key, spk1.key), 1)
t2 = talk.Talk(parent=spk1.key)
t2.title = "Talk T2"
t2.put()
sub_key2 = submissionrecord.make_submission(t2.key, self.c.key,
"track", "format")
self.assertEquals(
submission_queries.count_submissions(self.c.key, spk1.key), 2)
spk2 = speaker.make_new_speaker("you@email")
spk2.put()
t3 = talk.Talk(parent=spk2.key)
t3.title = "Talk T3 speaker 2"
t3.put()
sub_key3 = submissionrecord.make_submission(t3.key, self.c.key,
"track", "format")
self.assertEquals(
submission_queries.count_submissions(self.c.key, spk1.key), 2)
self.assertEquals(
submission_queries.count_submissions(self.c.key, spk2.key), 1)
c2 = conference.Conference()
c2.name = "TestConf2"
c2.put()
self.assertEquals(
submission_queries.count_submissions(c2.key, spk1.key), 0)
self.assertEquals(
submission_queries.count_submissions(c2.key, spk2.key), 0)
t4 = talk.Talk(parent=spk1.key)
t4.title = "Talk T4"
t4.put()
sub_key4 = submissionrecord.make_submission(t4.key, c2.key, "track",
"format")
self.assertEquals(
submission_queries.count_submissions(c2.key, spk1.key), 1)
self.assertEquals(
submission_queries.count_submissions(c2.key, spk2.key), 0)
self.assertEquals(
submission_queries.count_submissions(self.c.key, spk1.key), 2)
self.assertEquals(
submission_queries.count_submissions(self.c.key, spk2.key), 1)
sub_key2.get().withdraw()
self.assertEquals(
submission_queries.count_submissions(c2.key, spk1.key), 1)
self.assertEquals(
submission_queries.count_submissions(c2.key, spk2.key), 0)
self.assertEquals(
submission_queries.count_submissions(self.c.key, spk1.key), 1)
self.assertEquals(
submission_queries.count_submissions(self.c.key, spk2.key), 1)
def test_assign_more_reviews(self):
# basic test
sub_key1, sub_key2, sub_key3 = self.setup_test_data()
reviewer1 = reviewer.make_new_reviewer(self.conference.key,
"lister@email")
reviewer1.assign_more_reviews("track", 2, 1)
self.assertEqual(
2,
len(reviewer1.retrieve_review_assignments("track",
review_round=1)))
reviewer2 = reviewer.make_new_reviewer(self.conference.key,
"cat@email")
self.assertEqual(
2,
len(reviewer1.retrieve_review_assignments("track",
review_round=1)))
reviewer2.assign_more_reviews("track", 2, 1)
self.assertEqual(
2,
len(reviewer2.retrieve_review_assignments("track",
review_round=1)))
# three possible success scenarios - don't care which was chosen
# on suubmission should be assigned to both reviewers
# other submissions should both be assigned to one reviewer
# less assigned submissions shoul be assigned first
# then semi-random assignment up to totoal
if (reviewer.count_submission_assignments(self.conference.key,
sub_key1, 1) == 2):
print "*** First assignment case"
self.assertEqual(
1,
reviewer.count_submission_assignments(self.conference.key,
sub_key3, 1))
self.assertEqual(
1,
reviewer.count_submission_assignments(self.conference.key,
sub_key2, 1))
elif (reviewer.count_submission_assignments(self.conference.key,
sub_key2, 1) == 2):
print "*** Second assignment case"
self.assertEqual(
1,
reviewer.count_submission_assignments(self.conference.key,
sub_key1, 1))
self.assertEqual(
1,
reviewer.count_submission_assignments(self.conference.key,
sub_key3, 1))
elif (reviewer.count_submission_assignments(self.conference.key,
sub_key3, 1) == 2):
print "*** Third assignment case"
self.assertEqual(
1,
reviewer.count_submission_assignments(self.conference.key,
sub_key1, 1))
self.assertEqual(
1,
reviewer.count_submission_assignments(self.conference.key,
sub_key2, 1))
else:
self.assertFalse(True, "Unexpected assignment pattern")
reviewer3 = reviewer.make_new_reviewer(self.conference.key,
"kyton@email")
reviewer3.assign_more_reviews("track", 2, 1)
self.assertEqual(
2,
reviewer.count_submission_assignments(self.conference.key,
sub_key1, 1))
self.assertEqual(
2,
reviewer.count_submission_assignments(self.conference.key,
sub_key2, 1))
self.assertEqual(
2,
reviewer.count_submission_assignments(self.conference.key,
sub_key3, 1))
# check no repeated assignment
reviewer1.assign_more_reviews("track", 2, 1)
self.assertEqual(
3,
len(reviewer1.retrieve_review_assignments("track",
review_round=1)))
reviewer1.assign_more_reviews("track", 2, 1)
self.assertEqual(
3,
len(reviewer1.retrieve_review_assignments("track",
review_round=1)))
# check no self-assignment
rogue = "holy@email"
s = speaker.make_new_speaker(rogue)
s.name = "Holy"
s.put()
t4 = talk.Talk(parent=s.key)
t4.title = "Lets see if the new speaker can review themselves"
t4.put()
sub_key4 = submissionrecord.make_submission(t4.key,
self.conference.key,
"track", "format")
reviewer4 = reviewer.make_new_reviewer(self.conference.key, rogue)
reviewer4.assign_more_reviews("track", 99, 1)
self.assertItemsEqual([sub_key1, sub_key2, sub_key3],
reviewer4.retrieve_review_assignments(
"track", review_round=1))
self.assertEqual(
0,
reviewer.count_submission_assignments(self.conference.key,
sub_key4, 1))
