def test_cannot_assign_score_without_code(self):
_, _, ballot = self.add_one_matchup_w_judge()
result = schema.execute(f"""
mutation openingScore {{
assignSpeechScore(ballot: {ballot}, side: PL, speech: OPENING, score: 10)
}}
""")
self.assertIsNotNone(result.errors)
result = schema.execute(f"""
mutation examinationScore {{
assignExamScore(ballot: {ballot}, side: PL, exam: 1, witness: true, cross: true, score: 10)
}}
""")
self.assertIsNotNone(result.errors)
def assertSchoolContainsTeam(self, school, team_num, team_name):
result = schema.execute(
f"""
query numTeams {{
tournament(id: {self.tourn_id}) {{
school(name: "{school}") {{
teams {{
num
name
}}
}}
}}
}}
"""
)
teams = result.data["tournament"]["school"]["teams"]
has_team = any(
team["name"] == team_name and team["num"] == team_num for team in teams
)
team_ids = ", ".join(str(team["num"]) for team in teams)
self.assertTrue(
has_team,
f"Team {team_num} not found. Team numbers: {team_ids} (also check the names)",
)
def assertStudentHasRole(self, student_id, role, matchup, side):
result = schema.execute(
f"""
query getRole {{
tournament(id: {self.tourn_id}) {{
matchup(id: {matchup}) {{
team(side: {side}) {{
attorney(role: {role}) {{
student {{
id
}}
}}
}}
}}
}}
}}
"""
)
role = result.data["tournament"]["matchup"]["team"]["attorney"]
if student_id is None:
self.assertIsNone(role)
else:
student_in_role = role["student"]
self.assertIsNotNone(student_in_role, f"No student assigned to {role}")
self.assertEqual(
student_in_role["id"],
student_id,
f"Student {student_id} does not have role {role}",
)
def assertHasMatchup(self, matchup_id, pl_num, def_num):
result = schema.execute(
f"""
query matchupTest {{
tournament(id: {self.tourn_id}) {{
matchup(id: {matchup_id}) {{
pl {{
team {{
num
}}
}}
def {{
team {{
num
}}
}}
}}
}}
}}
"""
)
matchup = result.data["tournament"]["matchup"]
self.assertEqual(matchup["pl"]["team"]["num"], pl_num, "π num does not match")
self.assertEqual(matchup["def"]["team"]["num"], def_num, "∆ num does not match")
def test_matchup_teams_are_fully_explorable(self):
matchup = self.add_one_matchup_setup()
result = schema.execute(
f"""
query teamMatchups {{
tournament(id: {self.tourn_id}) {{
matchup(id: {matchup}) {{
pl {{
team {{
num
name
}}
}}
def {{
team {{
num
name
}}
}}
}}
}}
}}
"""
)
match = result.data['tournament']['matchup']
pl = match['pl']['team']
self.assertEqual(pl['num'], 1001)
self.assertEqual(pl['name'], "Midlands University A")
de = match['def']['team']
self.assertEqual(de['num'], 1101)
self.assertEqual(de['name'], "Midlands State University A")
def add_judge_conflict(self, judge_id, school):
result = schema.execute(f"""
mutation addConflict {{
addJudgeConflict(tournamentId: {self.tourn_id}, judgeId: {judge_id}, school: "{school}") {{
id
}}
}}
""")
def assign_exam_score(self, ballot, side, exam, witness, cross, score):
result = schema.execute(
f"""
mutation addWitnessScore {{
{self._exam_assignment(ballot, side, exam, witness, cross, score)}
}}
""", None, FakeInfo)
return result.data['assignExamScore']
def assign_speech_notes(self, ballot, side, speech, notes):
result = schema.execute(f"""
mutation assignNotes($notes: String!) {{
assignSpeechNotes(ballot: {ballot}, side: {side}, speech: {speech}, notes: $notes)
}}
""",
variable_values={"notes": notes})
return result.data['assignSpeechNotes']
def assign_exam_notes(self, ballot, side, exam, witness, cross, notes):
result = schema.execute(f"""
mutation assignExamNotes($notes: String!) {{
assignExamNotes(ballot: {ballot}, side: {side}, exam: {exam}, witness: {self._to_GQL_bool(witness)}, cross: {self._to_GQL_bool(cross)}, notes: $notes)
}}
""",
variable_values={"notes": notes})
return result.data['assignExamNotes']
def set_matchup_notes(self, matchup, notes):
result = schema.execute(f"""
mutation assignNotes($notes: String!) {{
assignMatchupNotes(tournament: {self.tourn_id}, matchup: {matchup}, notes: $notes) {{
notes
}}
}}
""",
variable_values={"notes": notes})
def complete_ballot(self, ballot):
result = schema.execute(f"""
mutation completeBallot {{
completeBallot(tournament: {self.tourn_id}, ballot: {ballot}) {{
complete
}}
}}
""")
return result.data['completeBallot']
def assign_full_round(self, ballot, pd):
pl_scores = chain(repeat(10, pd), repeat(9))
def_scores = repeat(9)
side_scores = {"PL": pl_scores, "DEF": def_scores}
def speech_assignment(side, speech):
return self._speech_assignment(ballot, side, speech,
next(side_scores[side]))
def exam_assignment(side, exam, witness, cross):
return self._exam_assignment(ballot, side, exam, witness, cross,
next(side_scores[side]))
def pl_full_exam(exam):
return f"""
wDir{exam}: {exam_assignment("PL", exam, True, False)}
aDir{exam}: {exam_assignment("PL", exam, False, False)}
wCr{exam}: {exam_assignment("PL", exam, True, True,)}
aCr{exam}: {exam_assignment("DEF", exam, False, True)}
"""
def def_full_exam(exam):
return f"""
dWDir{exam}: {exam_assignment("DEF", exam, True, False,)}
dADir{exam}: {exam_assignment("DEF", exam, False, False)}
dWCr{exam}: {exam_assignment("DEF", exam, True, True)}
dACr{exam}: {exam_assignment("PL", exam, False, True)}
"""
new_line = "\n"
schema.execute(
f"""
mutation fullRound {{
pOpen: {speech_assignment("PL", "OPENING")}
dOpen: {speech_assignment("DEF", "OPENING")}
{new_line.join(pl_full_exam(exam) for exam in range(1, 4))}
{new_line.join(def_full_exam(exam) for exam in range(1, 4))}
pClose: {speech_assignment("PL", "CLOSING")}
dClose: {speech_assignment("DEF", "CLOSING")}
}}
""", None, FakeInfo)
def assign_speech_score(self, ballot, side, speech, score):
result = schema.execute(
f"""
mutation openingScore {{
{self._speech_assignment(ballot, side, speech, score)}
}}
""", None, FakeInfo)
score = result.data['assignSpeechScore']
return score
def add_school_to_tournament(self, name):
result = schema.execute(f"""
mutation addSchool {{
addSchool(tournament: {self.tourn_id}, name: "{name}") {{
name
}}
}}
""")
new_school_data = result.data["addSchool"]
return new_school_data
def get_matchup_notes(self, matchup):
result = schema.execute(f"""
query getMatchupNotes {{
tournament(id: {self.tourn_id}) {{
matchup(id: {matchup}) {{
notes
}}
}}
}}
""")
return result.data['tournament']['matchup']['notes']
def get_all_tournaments(self):
result = schema.execute(
f"""
query getTournaments {{
tournaments {{
id
name
}}
}}
"""
)
return result.data["tournaments"]
def add_judge_to_tournament(self, name):
result = schema.execute(f"""
mutation addJudge {{
addJudge(tournamentId: {self.tourn_id}, name: "{name}") {{
id
name
}}
}}
""")
new_judge = result.data["addJudge"]
return new_judge
def create_tournament(self):
result = schema.execute("""
mutation makeTournament {
addTournament(name: "Test Tournament") {
id
name
}
}
""")
new_tourn_data = result.data["addTournament"]
self.tourn_id = new_tourn_data["id"]
return new_tourn_data
def assertSpeechHasNotes(self, ballot, side, speech, notes):
result = schema.execute(f"""
query getOpeningNote {{
tournament(id: {self.tourn_id}) {{
ballot(id: {ballot}) {{
side(side: {side}) {{
speechNotes(speech: {speech})
}}
}}
}}
}}
""")
self.assertEqual(result.data['tournament']['ballot']['side']['speechNotes'], notes)
def assign_witness_name(self, matchup, side, order, name):
result = schema.execute(f"""
mutation assignWitnessName {{
assignWitnessName(tournament: {self.tourn_id}, matchup: {matchup}, side: {side}, order: {order}, witness: "{name}") {{
matchup {{
id
}}
witnessName
}}
}}
""")
assignment = result.data['assignWitnessName']
return assignment
def test_can_delete_ballot(self):
matchup, judge, ballot = self.add_one_matchup_w_judge()
result = schema.execute(
f"""
mutation deleteBallot {{
deleteBallot(id: {ballot})
}}
"""
)
self.assertIsNone(result.errors)
self.assertJudgeHasBallot(judge, ballot, should_have_ballot=False)
self.assertMatchupHasBallot(matchup, ballot, should_have_ballot=False)
def test_can_assign_presiding_ballots(self):
match = self.add_one_matchup_setup()
judge = self.add_judge_to_tournament("John G. Roberts, Jr.")['id']
result = schema.execute(
f"""
mutation assignBallot {{
assignJudgeToMatchup(tournament: {self.tourn_id}, judge: {judge}, matchup: {match}, presiding: true) {{
presiding
}}
}}
"""
)
self.assertEqual(result.data['assignJudgeToMatchup']['presiding'], True)
def get_judge_info(self, judge_id):
result = schema.execute(f"""
query getJudge {{
tournament(id: {self.tourn_id}) {{
judge(id: {judge_id}) {{
id
name
email
}}
}}
}}
""")
judge = result.data["tournament"]["judge"]
return judge
def add_team_to_tournament(self, team_num, school, team_name):
result = schema.execute(f"""
mutation addTeam {{
addTeam(tournament: {self.tourn_id}, school: "{school}", num: {team_num}, name: "{team_name}") {{
num
name
schoolName
tournamentId
}}
}}
""")
new_team = result.data["addTeam"]
return new_team
def assertBallotHasPD(self, ballot, side, pd):
result = schema.execute(
f"""
query getPD {{
tournament(id: {self.tourn_id}) {{
ballot(id: {ballot}) {{
pd(side: {side})
}}
}}
}}
"""
)
true_pd = result.data['tournament']['ballot']['pd']
self.assertEqual(pd, true_pd)
def assertHasRound(self, round_num):
result = schema.execute(
f"""
query roundInTournament {{
tournament(id: {self.tourn_id}) {{
round(num: {round_num}) {{
roundNum
}}
}}
}}
"""
)
found_round = result.data['tournament']['round']
self.assertEqual(found_round['roundNum'], round_num)
def assertBallotIsDone(self, ballot, done=True):
result = schema.execute(
f"""
query ballotIsDone {{
tournament(id: {self.tourn_id}) {{
ballot(id: {ballot}) {{
complete
}}
}}
}}
"""
)
is_complete = result.data['tournament']['ballot']['complete']
self.assertEqual(done, is_complete)
def test_can_toggle_note_only(self):
matchup, judge, ballot = self.add_one_matchup_w_judge()
result = schema.execute(
f"""
mutation noteOnly {{
noteOnlyBallot(id: {ballot}, noteOnly: true) {{
id
noteOnly
}}
}}
"""
)
ballot_info = result.data['noteOnlyBallot']
self.assertEqual(ballot_info['noteOnly'], True)
def test_matchup_gives_round_num(self):
[matchup, _] = self.add_default_r1_setup()
result = schema.execute(
f"""
query teamMatchups {{
tournament(id: {self.tourn_id}) {{
matchup(id: {matchup}) {{
roundNum
}}
}}
}}
"""
)
round_num = result.data['tournament']['matchup']['roundNum']
self.assertEqual(round_num, 1)
def assign_notes(self, matchup, notes):
result = schema.execute(
f"""
mutation setMatchupNotes {{
assignMatchupNotes(tournament: {self.tourn_id}, matchup: {matchup}, notes: "{notes}") {{
matchup {{
id
}}
notes
}}
}}
"""
)
result = result.data['assignMatchupNotes']
return result
