def test_new_chosen_and_previous_player_can_restart_index(self): """ test to check that set_new_chosen_and_previous_player returns to index 0 when and only when the final player in the list has a turn value of True """ should_not_be_index_0_turn = [{"username": "******", "turn": False, "previous": True}, {"username": "******", "turn": True, "previous": False}, {"username": "******", "turn": False, "previous": False}, {"username": "******", "turn": False, "previous": False}] json_functions.dump_data(should_not_be_index_0_turn) json_functions.set_new_chosen_and_previous_player() result = json_functions.get_json_data() self.assertFalse(result[0]["turn"]) should_be_index_0_turn = [{"username": "******", "turn": False, "previous": False}, {"username": "******", "turn": False, "previous": False}, {"username": "******", "turn": False, "previous": True}, {"username": "******", "turn": True, "previous": False}] json_functions.dump_data(should_be_index_0_turn) json_functions.set_new_chosen_and_previous_player() result = json_functions.get_json_data() self.assertTrue(result[0]["turn"])
def test_check_previous_answer_correctly_grades_answer(self): """ test to check that check_previous_player_answer adds 'Correct!' to correct.txt if the players answer contains the questions keyword. If it does not, it should write 'incorrect' """ game_text_functions.wipe_game_text() should_write_incorrect = [{"question": ["What starts with a 'P', ends with an 'E'and has thousands of letters?", "The Post Office", "post"], "answer": ["wrong", "answer"], "previous": True, "incorrect guesses": "", "no": 1}] json_functions.dump_data(should_write_incorrect) gameplay_loop.check_previous_player_answer() with open("active-game-files/correct.txt", "r") as f: result = f.readlines() result_should_be = "<span class='incorrect'>Incorrect</span>" self.assertEqual("".join(result), result_should_be) game_text_functions.wipe_game_text() should_write_incorrect = [{"question": ["What starts with a 'P', ends with an 'E'and has thousands of letters?", "The Post Office", "post"], "answer": ["test", "post"], "previous": True, "incorrect guesses": "", "no": 1}] json_functions.dump_data(should_write_incorrect) gameplay_loop.check_previous_player_answer() with open("active-game-files/correct.txt", "r") as f: result = f.readlines() result_should_be = "<span class='correct'>Correct!</span>" self.assertEqual("".join(result), result_should_be)
def test_ask_question_writes_current_player_question(self): """ test to check that ask_question writes the appropriate question tuple entry for the player with a turn value of True """ game_text_functions.wipe_game_text() test_player_data = [ {"previous": False, "last question correct": True, "no": 1, "incorrect guesses": "", "username": "******", "turn": False, "lives": 2, "question": ["This kind of coat can you put on only when it is wet. What is it?", "A coat of paint", "paint"], "answer": ["a", "paint", "of", "coat"], "score": 5}, {"previous": True, "last question correct": False, "no": 2, "incorrect guesses": "<br>the dictionary", "username": "******", "turn": False, "lives": 1, "question": [ "I am a word. If you pronounce me rightly, it will be wrong. If you pronounce me wrong it is right? What word am I?", "Wrong", "wrong"], "answer": ["the", "dictionary"], "score": 4}, {"previous": False, "last question correct": True, "no": 3, "incorrect guesses": "", "username": "******", "turn": True, "lives": 2, "question": ["It has Eighty-eight keys but can't open a single door? What is it?", "A piano", "piano"], "answer": "", "score": 4}] json_functions.dump_data(test_player_data) gameplay_loop.ask_question() result_should_be = "It has Eighty-eight keys but can't open a single door? What is it?<br>" with open("active-game-files/question.txt", "r") as f: result = f.readlines() self.assertEqual("".join(result), result_should_be)
def test_return_player_to_game_replaces_previous_value(self): """ test to check that return_player_to_game_data replaces the player entered as an argument. The player should be replaced in the dictionary, not appended """ test_game_data = [ { "no": 10, "test": "original value", }, {"no": 5, "test": "original value" } ] json_functions.dump_data(test_game_data) original_data = json_functions.get_json_data() replacement_player = { "no": 5, "test": "success!", "additional key": True } json_functions.return_player_to_game_data(replacement_player) new_data = json_functions.get_json_data() self.assertEqual(len(original_data), len(new_data)) self.assertNotEqual(original_data, new_data) self.assertEqual(new_data[1]["test"], "success!") self.assertTrue(new_data[1]["additional key"])
def render_game(): """ main game loop """ wipe_game_text() game_data = get_json_data() if request.method == "POST": # only runs after form has been submitted once. Won't run first time page is loaded set_new_chosen_and_previous_player() set_previous_answer() was_correct = check_previous_player_answer() update_lives_and_score(was_correct) eliminated_player = eliminate_dead_players() if eliminated_player: get_correct_answer(eliminated_player) if not all_players_gone(): set_player_question() ask_question() game_data = get_json_data() else: # runs the first time the page is loaded, before the users submit any answers. Doesn't run again initialize_used_question() game_data[0]["turn"] = True dump_data(game_data) set_player_question() ask_question() if all_players_gone( ): # adds game over and correct answer text and renders leaderboard template wipe_game_text(True) add_game_over_text() leaderboard_data = get_sorted_scores() round_text = get_round_text() return render_template("leaderboard.html", leaderboard_data=leaderboard_data, answer_text="".join(round_text["answer text"]), game_over_text="".join( round_text["game over text"])) col_size = get_col_size(game_data) col_sm_size = get_col_sm_size(game_data) round_text = get_round_text() game_data = get_json_data() return render_template( "game.html", correct_text="".join(round_text["correct text"]), eliminated_text="".join(round_text["eliminated text"]), answer_text="".join(round_text["answer text"]), host_text="".join(round_text["host text"]), question_text="".join(round_text["question text"]), incorrect_guesses_text="".join(round_text["incorrect guesses text"]), col_size=col_size, col_sm_size=col_sm_size, game_data=game_data)
def test_get_current_player_does_not_return_players_with_turn_false(self): """ test to check that get_current_player won't return players with a turn of false """ one_true = [{"turn": False}, {"turn": False}, {"turn": True}, {"turn": False}] json_functions.dump_data(one_true) one_true_result = json_functions.get_current_player() self.assertNotEqual(one_true_result["turn"], False) self.assertTrue(one_true_result["turn"]) all_false = [{"turn": False}, {"turn": False}] json_functions.dump_data(all_false) all_false_result = json_functions.get_current_player() self.assertEqual(all_false_result, {})
def test_all_players_gone_returns_accurate_boolean(self): """ test to check that all_players_gone returns a boolean. Should be False if players.json is not empty. Otherwise should be True """ result = json_functions.all_players_gone() self.assertEqual(type(result), bool) empty_list = [] json_functions.dump_data(empty_list) self.assertTrue(json_functions.all_players_gone()) not_empty_list = [1, 2, 3] json_functions.dump_data(not_empty_list) self.assertFalse(json_functions.all_players_gone())
def test_elimination_text_correctly_identifies_player(self): """ test to check that add_eliminated_text correctly identifies the username of the player that was eliminated """ game_text_functions.wipe_game_text() test_game_data = [{"no": 1, "lives": 2, "username": "******"}, {"no": 2, "question": ("", "", "", ""), "score": 2, "lives": 0, "username": "******"}, {"no": 3, "lives": 6, "username": "******"}] json_functions.dump_data(test_game_data) json_functions.eliminate_dead_players() with open("active-game-files/eliminated.txt", "r") as f: result = f.readlines() result_should_be = "success has been eliminated" self.assertEqual("".join(result), result_should_be)
def test_get_previous_player_returns_empty_dictionary_if_no_previous_player(self): """ test to check that get_previous_player returns an empty dictionary if json file contains no previous player. Otherwise should return the player with a previous value of True """ no_previous_player = [{"username": "******", "turn": False, "previous": False}, {"username": "******", "turn": True, "previous": False}, {"username": "******", "turn": False, "previous": False}, {"username": "******", "turn": False, "previous": False}] json_functions.dump_data(no_previous_player) previous_player = json_functions.get_previous_player() self.assertEqual(previous_player, {}) a_previous_player = [{"username": "******", "turn": False, "previous": True}, {"username": "******", "turn": True, "previous": False}, {"username": "******", "turn": False, "previous": False}, {"username": "******", "turn": False, "previous": False}] json_functions.dump_data(a_previous_player) previous_player = json_functions.get_previous_player() self.assertEqual(previous_player["username"], "p1")
def test_chosen_player_changes_to_previous_player(self): """ test to check that set_new_chosen_and_previous_player() the player with turn: True has turn changed to False and previous turned to true """ test_players = [{"username": "******", "turn": False, "previous": True}, {"username": "******", "turn": True, "previous": False}, {"username": "******", "turn": False, "previous": False}] json_functions.dump_data(test_players) test_players = json_functions.get_json_data() self.assertTrue(test_players[1]["turn"]) self.assertFalse(test_players[1]["previous"]) json_functions.set_new_chosen_and_previous_player() test_players = json_functions.get_json_data() self.assertFalse(test_players[1]["turn"]) self.assertTrue(test_players[1]["previous"])
def test_dump_data_and_get_data_return_equal_values(self): """ test to check that the data entered into dump data will be the same as the value returned by get_json_data """ data_to_dump = [{ "should be 1": 1, "should be false": False, "should be 'test'": "test" }, { "another": "dictionary" }] json_functions.dump_data(data_to_dump) retrieved_data = json_functions.get_json_data() retrieved_dictionary = retrieved_data[0] self.assertEqual(len(retrieved_data), 2) self.assertEqual(retrieved_dictionary["should be 1"], 1) self.assertEqual(retrieved_dictionary["should be false"], False) self.assertEqual(retrieved_dictionary["should be 'test'"], "test")
def test_players_with_0_lives_are_eliminated(self): """ test to check that eliminate_dead_players will remove a player with 0 lives """ no_dead_players = [{"no": 1, "lives": 2, "username": "******"}, {"no": 2, "lives": 1, "username": "******"}, {"no": 3, "lives": 6, "username": "******"}] json_functions.dump_data(no_dead_players) json_functions.eliminate_dead_players() result = json_functions.get_json_data() self.assertEqual(len(no_dead_players), len(result)) one_dead_player = [{"no": 1, "lives": 2, "username": "******"}, {"no": 2, "question": ("", "", "", ""), "score": 2, "lives": 0, "username": "******"}, {"no": 3, "lives": 6, "username": "******"}] json_functions.dump_data(one_dead_player) json_functions.eliminate_dead_players() result = json_functions.get_json_data() self.assertEqual(len(result), len(one_dead_player) - 1) for player in result: self.assertNotEqual(player["no"], 2)
def test_correctly_add_or_sum_score_and_lives(self): """ test to check that update_lives_and_score adds 1 to the previous player's score if True is entered as an argument. If false is entered, it should subtract 1 from the previous player's life """ test_data = [{"previous": True, "lives": 0, "score": 0, "no": 1}] json_functions.dump_data(test_data) to_add_to_score = 5 to_subtract_from_lives = 3 for x in range(to_add_to_score): gameplay_loop.update_lives_and_score(True) for y in range(to_subtract_from_lives): gameplay_loop.update_lives_and_score(False) result = json_functions.get_json_data() self.assertEqual(result[0]["score"], to_add_to_score) self.assertEqual(result[0]["lives"], (- to_subtract_from_lives))