def test_has_submissions_in_round(self): r0 = Round.create(num=0) r1 = Round.create(num=1) cs = ChallengeSet.create(name="foo") cbn = ChallengeBinaryNode.create(name="foo1", cs=cs, blob="aaa") our_team = Team.create(name=Team.OUR_NAME) other_team = Team.create(name="enemy") ChallengeSetFielding.create(cs=cs, cbns=[cbn], team=our_team, submission_round=r1) assert_false(cs.has_submissions_in_round(r0)) assert_true(cs.has_submissions_in_round(r1)) ChallengeSetFielding.create(cs=cs, cbns=[cbn], team=other_team, submission_round=r0) assert_false(cs.has_submissions_in_round(r0)) ChallengeSetFielding.create(cs=cs, cbns=[cbn], team=our_team, submission_round=r0) assert_true(cs.has_submissions_in_round(r0))
def test_prev_round_on_new_game(self): Round.create(num=99) assert_equals(Round.prev_round(), None) r0 = Round.create(num=0) assert_equals(Round.prev_round(), None) Round.create(num=1) assert_equals(Round.prev_round(), r0)
def test_prev_round(self): assert_equals(Round.prev_round(), None) Round.create(num=0) assert_equals(Round.prev_round(), None) r1 = Round.create(num=1) Round.create(num=2) assert_equals(Round.prev_round(), r1)
def test_at_timestamp(self): round0 = Round.create(num=0, created_at=(NOW + timedelta(seconds=10))) round1 = Round.create(num=1, created_at=(NOW + timedelta(seconds=20))) round2 = Round.create(num=2, created_at=(NOW + timedelta(seconds=30))) assert_is_none(Round.at_timestamp(NOW + timedelta(seconds=5))) assert_equals(Round.at_timestamp(NOW + timedelta(seconds=15)).num, 0) assert_equals(Round.at_timestamp(NOW + timedelta(seconds=25)).num, 1) assert_equals(Round.at_timestamp(NOW + timedelta(seconds=35)).num, 2)
def test_fielded_in_round(self): now = datetime.now() r1 = Round.create(num=0) r2 = Round.create(num=1) cs1 = ChallengeSet.create(name="foo") cs1.rounds = [r1, r2] cs2 = ChallengeSet.create(name="bar") cs2.rounds = [r1] assert_equals(len(ChallengeSet.fielded_in_round(r1)), 2) assert_in(cs1, ChallengeSet.fielded_in_round(r1)) assert_in(cs2, ChallengeSet.fielded_in_round(r1))
def test_seen_in_round(self): r0 = Round.create(num=0) r1 = Round.create(num=1) cs = ChallengeSet.create(name="foo") cs.seen_in_round(r0) assert_equals(len(cs.rounds), 1) cs.seen_in_round(r0) assert_equals(len(cs.rounds), 1) cs.seen_in_round(r1) assert_equals(len(cs.rounds), 2)
def test_unsubmitted_exploits(self): r1 = Round.create(num=0) team = Team.create(name=Team.OUR_NAME) cs = ChallengeSet.create(name="foo") cs.rounds = [r1] job = RexJob.create(cs=cs) pov1 = Exploit.create(cs=cs, job=job, pov_type='type1', exploitation_method='rop', blob="exploit", c_code="exploit it") pov2 = Exploit.create(cs=cs, job=job, pov_type='type2', exploitation_method='rop', blob="exploit", c_code="exploit it") assert_equals(len(cs.unsubmitted_exploits), 2) assert_in(pov1, cs.unsubmitted_exploits) assert_in(pov2, cs.unsubmitted_exploits) pov1.submit_to(team, 10) assert_equals(len(cs.unsubmitted_exploits), 1) assert_not_in(pov1, cs.unsubmitted_exploits) assert_in(pov2, cs.unsubmitted_exploits) pov2.submit_to(team, 10) assert_equals(len(cs.unsubmitted_exploits), 0) assert_not_in(pov1, cs.unsubmitted_exploits) assert_not_in(pov2, cs.unsubmitted_exploits)
def test_is_multi_cbn(self): r0 = Round.create(num=0) our_team = Team.create(name=Team.OUR_NAME) # CS single binary cs = ChallengeSet.create(name="single") cs.rounds = [r0] cbn = ChallengeBinaryNode.create(name="foo", cs=cs, blob="aaa1") # CS multi binary cs_multi = ChallengeSet.create(name="multi") cs_multi.rounds = [r0] cbn1 = ChallengeBinaryNode.create(name="foo1", cs=cs_multi, blob="aaa2") cbn2 = ChallengeBinaryNode.create(name="foo2", cs=cs_multi, blob="aaa3") # create fielding entries ChallengeSetFielding.create(cs=cs, cbns=[cbn], team=our_team, available_round=r0) ChallengeSetFielding.create(cs=cs_multi, cbns=[cbn1, cbn2], team=our_team, available_round=r0) assert_false(cs.is_multi_cbn) assert_true(cs_multi.is_multi_cbn)
def test_submitted_and_unsubmitted_patches(self): r0 = Round.create(num=0) team = Team.create(name=Team.OUR_NAME) cs = ChallengeSet.create(name="foo") cs.rounds = [r0] cbn = ChallengeBinaryNode.create(name="cbn", cs=cs, blob="aaa1") patchtype1 = PatchType.create(name="PatchType1", functionality_risk=0, exploitability=0) patchtype2 = PatchType.create(name="PatchType2", functionality_risk=0, exploitability=0) patch1 = ChallengeBinaryNode.create(name="patch1", patch_type=patchtype1, cs=cs, root=cbn, blob="aaa2") patch2 = ChallengeBinaryNode.create(name="patch2", patch_type=patchtype2, cs=cs, root=cbn, blob="aaa3") assert_equals(len(cbn.unsubmitted_patches), 2) assert_in(patch1, cbn.unsubmitted_patches) assert_in(patch2, cbn.unsubmitted_patches) assert_equals(len(cbn.submitted_patches), 0) ChallengeSetFielding.create_or_update_submission(team=team, cbns=[patch1, patch2], round=r0) assert_equals(len(cbn.submitted_patches), 2) assert_equals(len(cbn.unsubmitted_patches), 0)
def test_get_or_create(self): r = Round.create(num=0) cs = ChallengeSet.create(name="foo") cbn1 = ChallengeBinaryNode.create(name="foo1", cs=cs, blob="aaa1") cbn2 = ChallengeBinaryNode.create(name="foo1", cs=cs, blob="aaa2") ids = IDSRule.create(cs=cs, rules="aaa", sha256="sum") cbl1, crtd1 = CSSubmissionCable.get_or_create(cs=cs, ids=ids, cbns=[cbn1], round=r) assert_true(crtd1) cbl2, crtd2 = CSSubmissionCable.get_or_create(cs=cs, ids=ids, cbns=[cbn1], round=r) assert_false(crtd2) assert_equals(cbl1.id, cbl2.id) cbl3, crtd3 = CSSubmissionCable.get_or_create(cs=cs, ids=ids, cbns=[cbn1, cbn2], round=r) assert_true(crtd3) cbl4, crtd4 = CSSubmissionCable.get_or_create(cs=cs, ids=ids, cbns=[cbn1, cbn2], round=r) assert_false(crtd4) assert_equals(cbl3.id, cbl4.id)
def test_most_recent(self): cs = ChallengeSet.create(name="foo") cs2 = ChallengeSet.create(name="bar") team = Team.create(name="opponent") exploit = Exploit.create(cs=cs, job=RexJob.create(), pov_type="type1", blob="abc", c_code="exploit it") exploit2 = Exploit.create(cs=cs2, job=RexJob.create(), pov_type="type1", blob="def", c_code="delfino") Round.create(num=0) cable = ExploitSubmissionCable.create(team=team, cs=cs, exploit=exploit, throws=10, round=Round.current_round()) cable2 = ExploitSubmissionCable.create(team=team, cs=cs2, exploit=exploit2, throws=10, round=Round.current_round()) assert_equals(len(ExploitSubmissionCable.most_recent()), 2) assert_items_equal(ExploitSubmissionCable.most_recent(), [cable, cable2]) # assert we get back only the most recent exploit r1 = Round.create(num=1) new_exploit = Exploit.create(cs=cs, job=RexJob.create(), pov_type="type2", blob="def", c_code="don't exploit it") new_cable = ExploitSubmissionCable.create(team=team, cs=cs, exploit=new_exploit, throws=10, round=r1) assert_equals(len(ExploitSubmissionCable.most_recent()), 2) assert_items_equal(ExploitSubmissionCable.most_recent(), [new_cable, cable2])
def test_submit_to(self): r0 = Round.create(num=0) r1 = Round.create(num=1) cs = ChallengeSet.create(name="foo") cs.rounds = [r1.id] job = AFLJob.create(cs=cs) exploit = Exploit.create(job=job, cs=cs, pov_type="type1", blob=BLOB, c_code="exploit it") team = Team.create(name="opponent") assert_equals(len(exploit.fieldings), 0) ef = exploit.submit_to(team=team, throws=10) assert_equals(len(exploit.fieldings), 1) assert_equals(ef.submission_round, Round.current_round()) ef = exploit.submit_to(team=team, throws=5, round=r0) assert_equals(len(exploit.fieldings), 2) assert_equals(ef.submission_round, r0)
def test_all(self): r1 = Round.create(num=0) cs = ChallengeSet.create(name="foo") cs.rounds = [r1] cbn1 = ChallengeBinaryNode.create(name="foo", cs=cs, blob="blob1") cbn2 = ChallengeBinaryNode.create(name="bar", cs=cs, blob="blob2") assert_equals(len(ChallengeBinaryNode.all()), 2) assert_equals(ChallengeBinaryNode.all()[0], cbn1) assert_equals(ChallengeBinaryNode.all()[1], cbn2)
def test_process_and_unprocessed(self): cs = ChallengeSet.create(name="foo") team = Team.create(name="opponent") exploit = Exploit.create(cs=cs, job=RexJob.create(), pov_type="type1", blob="abc", c_code="exploit it") Round.create(num=0) cable = ExploitSubmissionCable.create(team=team, cs=cs, exploit=exploit, throws=10, round=Round.current_round()) assert_equals(len(ExploitSubmissionCable.unprocessed()), 1) cable.process() assert_equals(len(ExploitSubmissionCable.unprocessed()), 0)
def test_save(self): r1 = Round.create(num=0) cs = ChallengeSet.create(name="foo") cs.rounds = [r1] cbn = ChallengeBinaryNode.create(name="foo", cs=cs, blob="asdf") job = Job(cbn=cbn, worker='basemodel') updated_at = job.updated_at job.worker = '#aftersave' job.save() assert_greater(job.updated_at, updated_at)
def create_round(args): if not len(args.challenge_sets): fielded = [cs.name for cs in CS.fielded_in_round()] else: fielded = args.challenge_sets new_round = Round.create( num=args.number if args.number is not None else Round.current_round() + 1) for f in fielded: cs = CS.select().where(CS.name == f).get() CSF.create(cs=cs, team=Team.get_our(), available_round=new_round)
def test_unprocessed_submission_cables(self): r = Round.create(num=0) cs = ChallengeSet.create(name="foo") cbn = ChallengeBinaryNode.create(name="foo1", cs=cs, blob="aaa") ids = IDSRule.create(cs=cs, rules="aaa", blob="aaa") cable1 = CSSubmissionCable.create(cs=cs, ids=ids, cbns=[cbn], round=r) cable2 = CSSubmissionCable.create(cs=cs, ids=ids, cbns=[], round=r) assert_equals(len(cs.unprocessed_submission_cables()), 2) assert_equals(cable1, cs.unprocessed_submission_cables()[0]) assert_equals(cable2, cs.unprocessed_submission_cables()[1]) cable1.process() assert_equals(len(cs.unprocessed_submission_cables()), 1)
def test_cbns_original(self): r0 = Round.create(num=0) r1 = Round.create(num=1) our_team = Team.create(name=Team.OUR_NAME) other_team = Team.create(name="opponent") cs = ChallengeSet.create(name="foo") cs.rounds = [r0, r1] cbn = ChallengeBinaryNode.create(name="foo", cs=cs, blob="aaa1") cbn_patched = ChallengeBinaryNode.create(name="foo", cs=cs, patch_type=PatchType.create( name="patch1", functionality_risk=0, exploitability=1, ), blob="aaa2") cbn_other_team = ChallengeBinaryNode.create(name="foo", cs=cs, blob="aaa3") ChallengeSetFielding.create(cs=cs, cbns=[cbn], team=our_team, available_round=r0) ChallengeSetFielding.create(cs=cs, cbns=[cbn_patched], team=our_team, submission_round=r0).save() ChallengeSetFielding.create(cs=cs, cbns=[cbn_other_team], team=other_team, available_round=r0).save() assert_equals(len(cs.cbns_original), 1) assert_in(cbn, cs.cbns_original) assert_not_in(cbn_patched, cs.cbns_original) assert_not_in(cbn_other_team, cs.cbns_original)
def test_most_reliable_exploit(self): r1 = Round.create(num=0) team = Team.create(name=Team.OUR_NAME) cs = ChallengeSet.create(name="foo") cs.rounds = [r1] job1 = RexJob.create(cs=cs) job2 = RexJob.create(cs=cs) job3 = RexJob.create(cs=cs) job4 = RexJob.create(cs=cs) pov1 = Exploit.create(cs=cs, job=job1, pov_type='type1', exploitation_method='rop', blob="exploit1", c_code="exploit it", reliability=0.9) assert_equals(pov1, cs.most_reliable_exploit) pov2 = Exploit.create(cs=cs, job=job2, pov_type='type2', exploitation_method='rop', blob="exploit2", c_code="exploit it", reliability=0.5) assert_equals(pov1, cs.most_reliable_exploit) pov3 = Exploit.create(cs=cs, job=job3, pov_type='type2', exploitation_method='rop', blob="exploit3", c_code="exploit it", reliability=0.9) assert_equals(pov1, cs.most_reliable_exploit) pov4 = Exploit.create(cs=cs, job=job4, pov_type='type2', exploitation_method='rop', blob="exploit4", c_code="exploit it", reliability=1.0) assert_equals(pov4, cs.most_reliable_exploit)
def test_has_type1(self): from farnsworth.models.pov_test_result import PovTestResult pov_type = 'type1' cs = ChallengeSet.create(name="foo") job = AFLJob.create(cs=cs) Exploit.create(cs=cs, job=job, pov_type=pov_type, blob=BLOB, c_code="code", reliability=0) assert_false(cs.has_type1) Exploit.create(cs=cs, job=job, pov_type=pov_type, blob=BLOB, c_code="code", reliability=1) assert_true(cs.has_type1) # if not first condition is not met r2 = Round.create(num=2) cs2 = ChallengeSet.create(name="bar") job2 = AFLJob.create(cs=cs2) cbn2 = ChallengeBinaryNode.create(name="bar", cs=cs2, blob="aaa") team2 = Team.create(name=Team.OUR_NAME) exploit2 = Exploit.create(cs=cs2, job=job2, pov_type=pov_type, blob=BLOB, c_code="code", reliability=0) csf2 = ChallengeSetFielding.create_or_update_available(team=team2, cbn=cbn2, round=r2) pov_result2 = PovTestResult.create(exploit=exploit2, cs_fielding=csf2, num_success=0) assert_false(cs2.has_type1) pov_result2.num_success = 10 pov_result2.save() assert_true(cs2.has_type1)
def test_get_or_create(self): assert_equals(len(ChallengeSet.select()), 0) r1 = Round.create(num=0) cs1, _ = ChallengeSet.get_or_create(name="foo") cs2, _ = ChallengeSet.get_or_create(name="foo") cs3, _ = ChallengeSet.get_or_create(name="bar") for cs in [cs1, cs2, cs3]: cs.rounds = [r1.id] assert_equals(len(ChallengeSet.select()), 2) assert_equals(cs2.id, cs1.id) assert_not_equals(cs3.id, cs1.id) cs3.delete_instance(recursive=True) cs2.delete_instance(recursive=True) cs1.delete_instance(recursive=True) r1.delete_instance(recursive=True) ChallengeSet._meta.database.commit()
def test_unsubmitted_ids_rules(self): r1 = Round.create(num=0) team = Team.create(name=Team.OUR_NAME) cs = ChallengeSet.create(name="foo") ids1 = IDSRule.create(cs=cs, rules="aaa") ids2 = IDSRule.create(cs=cs, rules="bbb") assert_equals(len(cs.unsubmitted_ids_rules), 2) assert_in(ids1, cs.unsubmitted_ids_rules) assert_in(ids2, cs.unsubmitted_ids_rules) IDSRuleFielding.create(ids_rule=ids1, team=team, submission_round=r1) assert_equals(len(cs.unsubmitted_ids_rules), 1) assert_not_in(ids1, cs.unsubmitted_ids_rules) assert_in(ids2, cs.unsubmitted_ids_rules) IDSRuleFielding.create(ids_rule=ids2, team=team, submission_round=r1) assert_equals(len(cs.unsubmitted_ids_rules), 0) assert_not_in(ids1, cs.unsubmitted_ids_rules) assert_not_in(ids2, cs.unsubmitted_ids_rules)
def test_variable_submitter(self): t = Team.create(name=Team.OUR_NAME) r0 = Round.create(num=0) # set up several CSes cses = [CS.create(name='CS_%s' % i) for i in range(10)] # Set up the patches for cs in cses: for pt in PT.select(): ids = IDSRule.create(cs=cs, rules="HAHAHA") cbn = CBN.create(cs=cs, name=cs.name + "_" + pt.name, blob="XXXX", patch_type=pt, ids_rule=ids) patch_names = scriba.submitters.cb.ORIG_PATCH_ORDER try: cur_cssc_id = CSSC.select().order_by(CSSC.id.desc()).get().id except CSSC.DoesNotExist: cur_cssc_id = 0 # run the scheduler for _ in scriba.submitters.cb.ORIG_PATCH_ORDER: for c in cses: scriba.submitters.cb.CBSubmitter.rotator_submission(c) # make sure they got rotated correctly for n, cs in enumerate(cses): cables = list( CSSC.select().where((CSSC.cs == cs) & (CSSC.id > cur_cssc_id)).order_by( CSSC.id.asc())) assert len(cables) > 0 assert all(c.cbns[0].patch_type.name == pn for c, pn in zip(cables, (patch_names * 10)[n:]))
def test_current_round(self): assert_equals(Round.current_round(), None) Round.create(num=0) Round.create(num=1) Round.create(num=2) assert_equals(Round.current_round().num, 2)
def test_ready(self): round0 = Round.create(num=0) assert_false(round0.is_ready()) round0.ready() assert_true(round0.is_ready())
def test_simple_selector(self): try: t = Team.get_our() except Team.DoesNotExist: t = Team.create(name=Team.OUR_NAME) cs = CS.create(name='x') # Set up a CBN for it, with some feedback cbn_orig = CBN.create(cs=cs, name="unpatched", blob="XXXX") # Field the default CBN r0 = Round.create(num=0) pf_r0 = PF.create(cs=cs, round=r0, success=1.0, timeout=0, connect=0, function=0, time_overhead=0.0, memory_overhead=0.0) cs.seen_in_round(r0) CSF.create(cs=cs, cbns=[cbn_orig], team=t, available_round=r0, poll_feedback=pf_r0) # make sure we don't submit on round 0 assert_is_none( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r0)) # tick the round r1 = Round.create(num=1) pf_r1 = PF.create(cs=cs, round=r1, success=1.0, timeout=0, connect=0, function=0, time_overhead=0.0, memory_overhead=0.0) cs.seen_in_round(r1) CSF.create(cs=cs, cbns=[cbn_orig], team=t, available_round=r1, poll_feedback=pf_r1) # make sure we don't submit on round 0 assert_is_none( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r1)) # tick the round r2 = Round.create(num=2) pf_r2 = PF.create(cs=cs, round=r2, success=1.0, timeout=0, connect=0, function=0, time_overhead=0.0, memory_overhead=0.0) cs.seen_in_round(r2) CSF.create(cs=cs, cbns=[cbn_orig], team=t, available_round=r2, poll_feedback=pf_r2) # Make sure we properly handle the case when there are no patches assert_is_none( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r0)) # And patch it, without feedback pt1 = PT.create(name="a_patch", functionality_risk=0., exploitability=0.4) cbn_p1 = CBN.create(cs=cs, name="patch1", blob="XXXYZ", patch_type=pt1) pt2 = PT.create(name="b_patch", functionality_risk=0., exploitability=0.3) cbn_p2 = CBN.create(cs=cs, name="patch2", blob="XXXZZ", patch_type=pt2) # Make sure we grab the "best" patch assert_items_equal( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r2), [cbn_p2]) # emulate the ambassador submitting this f****r csf0s = CSF.create(cs=cs, cbns=[cbn_p2], team=t, submission_round=r2) # add a new, better patch pt3 = PT.create(name="c_patch", functionality_risk=0., exploitability=0.2) cbn_p3 = CBN.create(cs=cs, name="patch3", blob="XXXXZ", patch_type=pt3) # make sure we select the new patch, because it's still the right round assert_items_equal( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r2), [cbn_p3]) csf0s.cbns = [cbn_p3] csf0s.save() # make sure we are now happy assert_is_none( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r2)) # down a round r3 = Round.create(num=3) pf_r3 = PF.create(cs=cs, round=r3, success=0, timeout=0, connect=0, function=0, time_overhead=0.0, memory_overhead=0.0) cs.seen_in_round(r3) CSF.create(cs=cs, cbns=[cbn_p3], team=t, available_round=r3, poll_feedback=pf_r3) # tick the round r4 = Round.create(num=4) pf_r4 = PF.create(cs=cs, round=r4, success=1.0, timeout=0, connect=0, function=0, time_overhead=0.05, memory_overhead=0.05) cs.seen_in_round(r4) CSF.create(cs=cs, cbns=[cbn_p3], team=t, available_round=r4, poll_feedback=pf_r4) # make sure we don't choose to change the selection assert_is_none( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r4)) # now find a better patch pt4 = PT.create(name="d_patch", functionality_risk=0., exploitability=0.1) cbn_p4 = CBN.create(cs=cs, name="patch4", blob="XXXYX", patch_type=pt4) # too late, man assert_is_none( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r4)) # now we get the baaaad news r5 = Round.create(num=5) pf_r5 = PF.create(cs=cs, round=r5, success=0.8, timeout=0, connect=0, function=0.2, time_overhead=0.05, memory_overhead=0.05) cs.seen_in_round(r5) CSF.create(cs=cs, cbns=[cbn_p3], team=t, available_round=r5, poll_feedback=pf_r5) # Make sure we properly roll back assert_items_equal( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r5), cs.cbns_original) CSF.create(cs=cs, cbns=cs.cbns_original, team=t, submission_round=r5) # down a round r6 = Round.create(num=6) pf_r6 = PF.create(cs=cs, round=r4, success=0, timeout=0, connect=0, function=0, time_overhead=0.0, memory_overhead=0.0) cs.seen_in_round(r6) CSF.create(cs=cs, cbns=[cbn_orig], team=t, available_round=r6, poll_feedback=pf_r6) # that worked r7 = Round.create(num=7) pf_r7 = PF.create(cs=cs, round=r7, success=1.0, timeout=0, connect=0, function=0, time_overhead=0.0, memory_overhead=0.0) cs.seen_in_round(r7) CSF.create(cs=cs, cbns=[cbn_orig], team=t, available_round=r7, poll_feedback=pf_r7) # make sure we're happy staying unpatched assert_is_none( scriba.submitters.cb.CBSubmitter.patch_decision_simple(cs, r7))
def test_patch_selection(self): t = Team.create(name=Team.OUR_NAME) r0 = Round.create(num=0) cs = CS.create(name='x') # Set up a CBN for it, with some feedback cbn_orig = CBN.create(cs=cs, name="unpatched", blob="XXXX") pf_orig = PF.create(cs=cs, round=r0, success=1.0, timeout=0, connect=0, function=0, time_overhead=0.0, memory_overhead=0.0) # Field the default CBN CSF.create(cs=cs, cbns=[cbn_orig], team=t, available_round=r0, poll_feedback=pf_orig) # Make sure we properly handle the case when there are no patches assert_is_none(scriba.submitters.cb.CBSubmitter.patch_decision(cs)) # And patch it pt = PT.create(name="a_patch", functionality_risk=0., exploitability=0.) cbn_p1 = CBN.create(cs=cs, name="patch1", blob="XXXYZ", patch_type=pt) PS.create(cs=cs, patch_type=pt, num_polls=10, has_failed_polls=False, failed_polls=0, round=r0, perf_score={ 'score': { 'ref': { 'task_clock': 1.0, 'rss': 1.0, 'flt': 1.0, 'file_size': 1.0 }, 'rep': { 'task_clock': 1.1, 'file_size': 1.1, 'rss': 1.1, 'flt': 1.1, } } }) # Make sure we choose this patch assert_equals(scriba.submitters.cb.CBSubmitter.patch_decision(cs), [cbn_p1]) # Field the patch - we're down the first round r1 = Round.create(num=1) pf1 = PF.create(cs=cs, round=r1, success=0.0, timeout=0, connect=0, function=0, time_overhead=0.0, memory_overhead=0.0) CSF.create(cs=cs, cbns=[cbn_p1], team=t, available_round=r1, poll_feedback=pf1) r2 = Round.create(num=2) pf2 = PF.create(cs=cs, round=r1, success=1.0, timeout=0, connect=0, function=0, time_overhead=1.3, memory_overhead=1.3) CSF.create(cs=cs, cbns=[cbn_p1], team=t, available_round=r2, poll_feedback=pf2) # Make sure we revert assert_equals(scriba.submitters.cb.CBSubmitter.patch_decision(cs), [cbn_orig])