def play_round(self): print("Round #: {}".format(self.round_number)) if self.round_number == 1: yield (SubmissionMustFail(QuizPartOne, {'q1': ['2'], 'q2': ['1']})) yield (SubmissionMustFail(QuizPartOne, {'q1': ['1'], 'q2': ['1']})) yield (QuizPartOne, {'q1': ['2'], 'q2': ['2']}) expect(self.player.q1, "['2']") expect(self.player.q2, "['2']") yield (SubmissionMustFail(QuizPartTwo, {'q3': ['2'], 'q4': ['1']})) yield (QuizPartTwo, {'q3': ['2', '3', '4'], 'q4': ['1', '3']}) yield (InstructionPage) if self.round_number != 1 and ( (self.round_number - 1) % (Constants.rounds_per_lottery + 1)) == 0: yield (NewLotteryReminder) if ((self.round_number - 1) % (Constants.rounds_per_lottery + 1)) == 0: yield (ValuationPage, {'bid': 0}) if ((self.round_number - 1) % (Constants.rounds_per_lottery + 1)) == 1: yield (NewSignalReminder) if ((self.round_number - 1) % (Constants.rounds_per_lottery + 1)) != 0: yield (BidPage, {'bid': 0}) yield (OutcomePage)
def play_round(self): # p = self.participant.id_in_session # file_name = "player{0}.html".format(p) # f = open(file_name, 'w') # f.write(self.html) # f.close() yield (pages.ThanksForWaiting) yield (pages.Payoffs) yield SubmissionMustFail( pages.Payment, { 'first_name_cleartext': 'Scott', 'last_name_cleartext': 'Claessens', 'bank_details_cleartext': '000-000-000' }) yield (pages.Payment, { 'first_name_cleartext': 'Scott', 'last_name_cleartext': 'Claessens', 'bank_details_cleartext': '12-1234-1234567-001' }) correct = random.choice([1, 0]) yield (pages.BankAgain, {'correct_details': correct}) if correct == 0: yield (pages.BankWrong) yield (pages.Feedback, { 'feedback': "No feedback", 'understand': random.randint(1, 7) }) yield (pages.Recruitment, {'recruitment': 1}) yield SubmissionMustFail(pages.ReEnterLabel, {'reenterlabel': '0'}) yield (pages.ReEnterLabel, {'reenterlabel': 'AAA11'}) yield SubmissionMustFail(pages.ReEnterLabel2, {'reenterlabel2': '0'}) yield (pages.ReEnterLabel2, {'reenterlabel2': 'AAA11'}) yield Submission(pages.Final, check_html=False)
def play_round(self): if self.round_number == 1: yield (pages.InstructionsPage) max_value = Participant.get_experiment( self.player).phase_three.auction( self.player.round_number).max_value yield SubmissionMustFail(pages.BidPage, {'bid': -1}) yield SubmissionMustFail(pages.BidPage, {'bid': max_value + 1}) yield SubmissionMustFail(pages.BidPage) yield (pages.BidPage, {'bid': 0}) assert self.player.bid == 0 else: max_value = Participant.get_experiment( self.player).phase_three.auction( self.player.round_number).max_value r_bid = random.randint(0, max_value) yield (pages.BidPage, {'bid': r_bid}) assert self.player.bid == r_bid, "Entered bid {}, Player bid {}".format( r_bid, self.player.bid) signal = Participant.get_experiment( self.player).phase_three.signal(self.player.round_number) bid = Participant.get_experiment(self.player).phase_three.auction( self.player.round_number).get_bid(signal) assert bid == r_bid, "Entered bid {}, Auction bid {}".format( r_bid, bid)
def before_reset_price_hook(self, bot): for value1 in INVALID_PRICE_VALUES: for value2 in INVALID_PRICE_VALUES: for value3 in ("True", "False"): yield SubmissionMustFail( pages.ResetPricePage, { 'cartel_agree': value3, 'cartel_price': value1, 'reset_price': value2, }) for value1 in VALID_PRICE_VALUES: for value2 in INVALID_PRICE_VALUES: for value3 in ("True", "False"): yield SubmissionMustFail( pages.ResetPricePage, { 'cartel_agree': value3, 'cartel_price': value1, 'reset_price': value2, }) for value1 in INVALID_PRICE_VALUES: for value2 in VALID_PRICE_VALUES: for value3 in ("True", "False"): yield SubmissionMustFail( pages.ResetPricePage, { 'cartel_agree': value3, 'cartel_price': value1, 'reset_price': value2, })
def play_round(self): if self.round_number == 1: yield (pages.InstructionsPage) max_value = Participant.get_experiment( self.player).phase_two.get_auction( self.player.round_number).max_value yield SubmissionMustFail(pages.CutoffSelectionPage, { 'cutoff': -1, 'clicked': 1 }) yield SubmissionMustFail(pages.CutoffSelectionPage, { 'cutoff': max_value + 1, 'clicked': 1 }) yield (pages.CutoffSelectionPage, {'cutoff': 0, 'clicked': 1}) assert self.player.cutoff == 0 else: max_value = Participant.get_experiment( self.player).phase_two.get_auction( self.player.round_number).max_value r_cutoff = random.randint(0, max_value) yield (pages.CutoffSelectionPage, { 'cutoff': r_cutoff, 'clicked': 1 }) assert self.player.cutoff == r_cutoff, "Entered cutoff {}, Player cutoff {}".format( r_cutoff, self.player.cutoff) cutoff = Participant.get_experiment( self.player).phase_two.get_auction( self.player.round_number).cutoff assert cutoff == r_cutoff, "Entered cutoff {}, Auction cutoff {}".format( r_cutoff, cutoff)
def test_bots_submission_varieties(self): '''Testing different syntaxes for a submission''' Page1 = tests.bots_cases.views.Page1 for submission in [ Submission(Page1), Submission(Page1, {}), SubmissionMustFail(Page1, check_html=False), Submission(Page1, {'f2': True}, check_html=False), SubmissionMustFail(Page1, {}), Submission(Page1, {'f3': True}), ]: self.assertIsInstance(submission, dict)
def play_round(self): # check role assignment if self.player.id_in_group == 1: assert self.player.role() == 'proposer' if self.player.id_in_group == 2: assert self.player.role() == 'responder' # page 1 yield (views.RoleAssignment) # page 2 if self.player.role() == 'proposer': # proposer page yield SubmissionMustFail(views.Proposal, {'proposer_share': -5}) # negative yield SubmissionMustFail( views.Proposal, {'proposer_share': 120}) # larger than pot yield (views.Proposal, {'proposer_share': 60}) assert self.group.proposer_share == c(60) # page 3 responder_decision = {'accept': True, 'reject': False} payoffs = { 'proposer': { 'accept': 60, 'reject': 0 }, 'responder': { 'accept': 40, 'reject': 0 } } if self.player.role() == 'responder': yield (views.Response, {'accepted': responder_decision[self.case]}) if self.case == 'accept': assert self.group.accepted == True else: assert self.group.accepted == False # check if payoffs are correctly set: assert self.player.payoff == payoffs[self.player.role()][self.case] # page 4 yield (views.Results)
def play_round(self): with open('dictator/test_cases.json', 'r', encoding='utf-8') as json_file: values = simplejson.load(json_file) valid_values = values['values_validation'] yield views.Introduction #Valores fuera del rango [0,100], palabras o caracteres no deberían ser considerados: for value in valid_values['valid_kept']: yield SubmissionMustFail(views.Offer, {"kept": value}) yield views.Offer, dict(kept=55) yield views.Results #Corroborando pagos if self.player.dictator == True: assert self.player.payoff == self.group.group_kept, "dictator: el pago no es el correcto" print(f'Todo salio bien para jugador {self.player.id_in_group}') else: assert self.player.payoff == Constants.endowment - self.group.group_kept, "citizen: el pago no es el correcto" print(f'Todo salio bien para jugador {self.player.id_in_group}') print(self.player.payoff, self.group.group_kept, 'Es dictator:', self.player.dictator == True)
class PlayerBot(Bot): cases = [ {'offer': cu(0), 'return': cu(0), 'p1_payoff': cu(10), 'p2_payoff': cu(0)}, {'offer': cu(5), 'return': cu(10), 'p1_payoff': cu(15), 'p2_payoff': cu(5)}, {'offer': cu(10), 'return': cu(30), 'p1_payoff': cu(30), 'p2_payoff': cu(0)}, ] def play_round(self): case = self.case if self.player.id_in_group == 1: yield Send, dict(sent_amount=case['offer']) else: for invalid_return in [-1, case['offer'] * Constants.multiplier + 1]: yield SubmissionMustFail( SendBack, dict(sent_back_amount=invalid_return) ) yield SendBack, dict(sent_back_amount=case['return']) if self.player.id_in_group == 1: expected_payoff = case['p1_payoff'] else: expected_payoff = case['p2_payoff'] expect(self.player.payoff, expected_payoff)
class PlayerBot(Bot): cases = [ {'offer': c(0), 'return': c(0), 'p1_payoff': c(10), 'p2_payoff': c(0)}, {'offer': c(5), 'return': c(10), 'p1_payoff': c(15), 'p2_payoff': c(5)}, {'offer': c(10), 'return': c(30), 'p1_payoff': c(30), 'p2_payoff': c(0)}, ] def play_round(self): case = self.case if self.player.id_in_group == 1: yield (pages.Send, {"sent_amount": case['offer']}) else: for invalid_return in [-1, case['offer'] * Constants.multiplier + 1]: yield SubmissionMustFail( pages.SendBack, {'sent_back_amount': invalid_return} ) yield (pages.SendBack, {'sent_back_amount': case['return']}) if self.player.id_in_group == 1: expected_payoff = case['p1_payoff'] else: expected_payoff = case['p2_payoff'] assert self.player.payoff == expected_payoff
def play_round(self): yield (views.Instructions) yield (views.Role) yield (views.DecisionA, {"investment_A":"Project 1"}) assert self.player.payoff == c(150) if project_success == "successful": assert self.player.payoff == c(150) else: assert self.player.payoff == c(50) yield(views.Information) if self.player.id_in_group == 3 or self.player.id_in_group == 4: yield(views.Punishment, {"punishment":True}) yield SubmissionMustFail(views.PunishmentDecision, {"punishment_A": 80}) yield (views.PunishmentDecision, {"punishment_A": 20, "punishment_B": 10, "punishment_C": 5}) if punishment_selection == "D": assert p1.payoff == p1.payoff - 20 assert p2.payoff == p2.payoff -10 assert p3.payoff == p3.payoff - 5 yield (views.Results) yield (view.Questions) yield (views.Finish)
def play_round(self): yield views.Introduction # Verificando que valores extremos ni decimales funcionen for extreme_value in [-5.5, -100, -1, Constants.endowment + 1, 5.4]: yield SubmissionMustFail(views.Contribute, {'contribution': extreme_value}) if self.player.id_in_group == 1: yield views.Contribute, {"contribution": self.p1} elif self.player.id_in_group == 2: yield views.Contribute, {"contribution": self.p2} elif self.player.id_in_group == 3: yield views.Contribute, {"contribution": self.p3} else: yield views.Contribute, {"contribution": self.p4} # Corroborando que los pagos sean los correctos pago = (Constants.endowment - self.player.contribution) + self.group.individual_share yield views.Results print(self.player.round_payoff, pago) assert self.player.round_payoff == pago, "El pago no cuadra" print(f'Todo salio bien para jugador {self.player.id_in_group}')
def play_round(self): if self.subsession.round_number == 1: yield (pages.Introduction) if self.case == 'p1_wins': if self.player.id_in_group == 1: for invalid_guess in [-1, 101]: yield SubmissionMustFail(pages.Guess, {"guess": invalid_guess}) yield (pages.Guess, {"guess": 9}) assert self.player.payoff == Constants.jackpot assert 'you win' in self.html else: yield (pages.Guess, {"guess": 10}) assert self.player.payoff == 0 assert 'you did not win' in self.html else: if self.player.id_in_group in [1, 2]: yield (pages.Guess, {"guess": 9}) assert self.player.payoff == Constants.jackpot / 2 assert 'you are one of the 2 winners' in self.html else: yield (pages.Guess, {"guess": 10}) assert self.player.payoff == 0 assert 'you did not win' in self.html yield (pages.Results)
class PlayerBot(Bot): cases = ['basic', 'min', 'max'] def play_round(self): case = self.case yield pages.Introduction if case == 'basic': if self.player.id_in_group == 1: for invalid_contribution in [-1, 101]: yield SubmissionMustFail( pages.Contribute, dict(contribution=invalid_contribution)) contribution = dict(min=0, max=100, basic=50)[case] yield pages.Contribute, dict(contribution=contribution) yield pages.Results if self.player.id_in_group == 1: if case == 'min': expected_payoff = 100 elif case == 'max': expected_payoff = 200 else: expected_payoff = 150 expect(self.player.payoff, expected_payoff)
class PlayerBot(Bot): cases = ['basic', 'min', 'max'] def play_round(self): case = self.case yield (views.Introduction) if case == 'basic': if self.player.id_in_group == 1: for invalid_contribution in [-1, 101]: yield SubmissionMustFail(views.Contribute, { 'contribution': invalid_contribution}) contribution = { 'min': 0, 'max': 100, 'basic': 50, }[case] yield (views.Contribute, {"contribution": contribution}) yield (views.Results) if self.player.id_in_group == 1: if case == 'min': expected_payoff = 100 elif case == 'max': expected_payoff = 200 else: expected_payoff = 150 assert self.player.payoff == expected_payoff
def play_round(self): if self.round_number == 1: yield pages.Introduction if self.case == 'p1_wins': if self.player.id_in_group == 1: for invalid_guess in [-1, 101]: yield SubmissionMustFail(pages.Guess, dict(guess=invalid_guess)) yield pages.Guess, dict(guess=9) expect(self.player.payoff, Constants.jackpot) expect('you win', 'in', self.html) else: yield pages.Guess, dict(guess=10) expect(self.player.payoff, 0) expect('you did not win', 'in', self.html) else: if self.player.id_in_group in [1, 2]: yield pages.Guess, dict(guess=9) expect(self.player.payoff, Constants.jackpot / 2) expect('you are one of the 2 winners', 'in', self.html) else: yield pages.Guess, dict(guess=10) expect(self.player.payoff, 0) expect('you did not win', 'in', self.html) yield pages.Results
def play_round(self): # must reject transcription that is too inaccurate yield SubmissionMustFail(pages.Transcribe, {'transcribed_text': 'foo'}) transcription = Constants.reference_texts[self.subsession.round_number - 1] add_char = Constants.allowed_error_rates[self.subsession.round_number - 1] > 0 if add_char: # add a 1-char error, should still be fine transcription += 'a' yield (pages.Transcribe, {'transcribed_text': transcription}) for value in [ self.player.levenshtein_distance, self.player.transcribed_text, self.player.payoff ]: assert value != None if add_char: assert self.player.levenshtein_distance == 1 else: assert self.player.levenshtein_distance == 0 if self.subsession.round_number == Constants.num_rounds: # final page should print lengths of all reference texts for ref_text in Constants.reference_texts: assert str(len(ref_text)) in self.html # because of add_char, there should be an error in at least 1 round assert any(p.levenshtein_distance > 0 for p in self.player.in_all_rounds())
def play_round(self): yield SubmissionMustFail(views.MyPage, {'invest': -27}) yield (views.MyPage, {'invest': 20}) if self.player.decision == 'win': assert self.player.payoff == 120 else: assert self.player.payoff == 80
def play_round(self): if self.player.id_in_group == 1: yield SubmissionMustFail(views.PasswordPage, {'password': "******"}) yield (views.PasswordPage, {'password': "******"}) else: pass yield (views.Introduction) yield SubmissionMustFail(views.Choice, { 'wtp_remove': 15, 'expected_green_balls': 15 }) yield (views.Choice, {'wtp_remove': 5, 'expected_green_balls': 5}) yield (views.Information) if self.player.id_in_group == 1: yield (views.Input, { 'no_modification_ball': "green", 'one_modified_ball': "green", 'five_modified_balls': "green" }) else: pass yield (views.Results) yield SubmissionMustFail(views.Demographics, { 'age': -3, 'gender': "male", 'risk': 8, 'country': "AT" }) yield SubmissionMustFail( views.Demographics, { 'age': 55, 'gender': "male", 'risk': 4, 'country': "AT", 'no_student': True, 'field_of_study': "spam" }) yield (views.Demographics, { 'age': 55, 'gender': "male", 'risk': 4, 'country': "AT", 'no_student': True, 'field_of_study': "" })
def play_round(self): strings = STRINGS[settings.LANGUAGE_CODE] assert strings.next in self.html assert strings.yes in self.html assert strings.time_left in self.html assert strings.user_defined_string in self.html yield SubmissionMustFail(views.Page1) assert strings.form_has_errors in self.html
def play_round(self): yield (views.Instructions) for number in [-1, -10, 200, 300]: yield SubmissionMustFail(views.BetOnCoin, {'wager': number}) yield (views.BetOnCoin, {'wager': 50}) yield (views.Results)
class PlayerBot(Bot): cases = ['basic', 'min', 'max'] def play_round(self): case = self.case yield (views.Introduction) if case == 'basic' and self.player.id_in_group == 1: for invalid_contribution in [-1, 101]: yield SubmissionMustFail( views.Contribute, {'contribution': invalid_contribution})
def play_round(self): yield SubmissionMustFail(views.ErrorMessage, { 'add100_1': 1, 'add100_2': 98 }) yield (views.ErrorMessage, {'add100_1': 1, 'add100_2': 99}) yield SubmissionMustFail(views.FieldErrorMessage, {'even_int': 1}) yield (views.FieldErrorMessage, {'even_int': 2}) yield SubmissionMustFail(views.DynamicChoices, {'dynamic_choices': 'c'}) yield (views.DynamicChoices, { 'dynamic_choices': random.choice(['a', 'b']) }) yield SubmissionMustFail(views.MinMax, {'min_max': 2}) yield (views.MinMax, {'min_max': 5}) yield SubmissionMustFail(views.DynamicMinMax, {'dynamic_min_max': 4}) yield (views.DynamicMinMax, {'dynamic_min_max': 3}) yield (views.Blank)
def play_round(self): if self.player.round_number == 1: yield (pages.InstructionsPage) yield SubmissionMustFail(pages.SelectAuctionPage, {'preference': 1000000}) yield SubmissionMustFail(pages.SelectAuctionPage) yield (pages.SelectAuctionPage, {'preference': -1}) assert self.player.preference == -1 else: auction_ids = [ Participant.get_experiment(self.player).phase_one.left_auction(self.player.round_number).aid, Participant.get_experiment(self.player).phase_one.right_auction(self.player.round_number).aid, -1] random_auction_id = random.choice(auction_ids) yield (pages.SelectAuctionPage, {'preference': random_auction_id}) assert self.player.preference == random_auction_id, "actual preference was {}".format(self.player.preference) auction_id = Participant.get_experiment(self.player).phase_one.get_preference(self.player.round_number) assert random_auction_id == auction_id, "expected {}, but received {}".format(random_auction_id, auction_id)
def play_round(self): # invalid age data should be rejected invalid_age_data = { 'age': -1, # age is negative 'gender': 'male', 'field_of_studies': 'Economics', 'height': 2.00, 'weight': 90.0 } yield SubmissionMustFail(views.Demographics, invalid_age_data) # invalid gender inputs should also be rejected invalid_gender_data = { 'age': 25, 'gender': 'monkey', # monkey is not an allowed input for the gender field 'field_of_studies': 'Economics', 'height': 2.00, 'weight': 90.0 } yield SubmissionMustFail(views.Demographics, invalid_gender_data) # valid data should pass valid_survey_data = { 'age': 25, 'gender': 'male', 'field_of_studies': 'Economics', 'height': 2.00, 'weight': 90.0 } yield (views.Demographics, valid_survey_data) # bmi should now be calculated for each player # formula: BMI = w / h^2 # in our case: BMI = 90 / 2^2 = 90/4 = 22.5 assert self.player.bmi == 22.5 assert self.player.bmi_classification == 'normal' # finally we should see the Results page. yield (views.BMI_Result)
def play_round(self): '''all args should autocomplete''' yield SubmissionMustFail( views.Page1, {'a': 1}, check_html=True) yield Submission( views.Page1, {'a': 1}, check_html=False, timeout_happened=True)
def play_round(self): yield (views.Instructions) for test_number in [-1, -2, 4, 0.5]: yield SubmissionMustFail( views.Demographics, { 'age': 25, 'field_of_study': "", 'female': 0, 'height': test_number, 'weight': 100, 'likes_experiment': "Yes, of course!" })
def play_round(self): a_revealed = random.choice([True, False]) a_option = random.choice([1, 2]) b_option = random.choice([1, 2]) c_option = random.choice([1, 2]) yield (pages.AInstructions) yield SubmissionMustFail(pages.AComprehension, { "a_comp1": 1, "a_comp2": 2, "a_comp3": 2 }) yield (pages.AComprehension, Constants.a_comp_answers) if a_revealed: yield (pages.AChoice, {'a_revealed': a_revealed}) yield Submission(pages.ARevealed, {'a_option': a_option}) else: yield (pages.AChoice, {'a_option': a_option}) yield (pages.BInstructions) yield SubmissionMustFail(pages.BComprehension, { "b_comp1a": 5, "b_comp1b": 3, "b_comp2a": 2, "b_comp2b": 1 }) yield (pages.BComprehension, Constants.b_comp_answers) yield (pages.BChoice, {'b_option': b_option}) yield (pages.CInstructions) yield SubmissionMustFail(pages.CComprehension, { "c_comp1a": 2, "c_comp1b": 7, "c_comp2a": 1, "c_comp2b": 7 }) yield (pages.CComprehension, Constants.c_comp_answers) yield (pages.CChoice, {'c_option': c_option})
def play_round(self): yield (pages.Introduction) yield SubmissionMustFail(pages.Main, {'request': 80}) if self.case == 'add20': if self.player.id_in_group == 1: yield (pages.Main, {'request': 11}) assert self.player.payoff == c(31) else: yield (pages.Main, {'request': 12}) assert self.player.payoff == c(12) else: yield (pages.Main, {'request': 12}) assert self.player.payoff == c(12) yield (pages.Results)
def play_round(self): yield Submission(pages.Instructions, check_html=False) yield SubmissionMustFail( pages.Comprehension, { 'comp1a': 2, 'comp1b': 2, 'comp1c': 2, 'comp2a': 2, 'comp2b': 2, 'comp2c': 2, 'comp3': False }) yield (pages.Comprehension, Constants.comp_answers) yield (pages.Choice, {'option': random.choice([1, 2])}) yield Submission(pages.Summary, check_html=False)