bots: port trivia_quiz to game_handler

Author: fremiller

zulip_bots/zulip_bots/bots/trivia_quiz/controller.py

@@ -0,0 +1,105 @@
+from zulip_bots.game_handler import BadMoveException
+import html
+import json
+import requests
+import random
+from copy import deepcopy
+from zulip_bots.lib import Any
+
+from typing import Optional, Any, Dict, Tuple
+
+class NotAvailableException(Exception):
+    def __init__(self, message: str) -> None:
+        self.message = message
+
+    def __str__(self) -> str:
+        return self.message
+
+class TriviaQuizModel(object):
+    def __init__(self):
+        # This could throw an exception. It will be picked up by
+        # game_handler and the game will end
+        self.current_board = self.get_trivia_quiz()
+        self.scores = {} # type: Dict[int, int]
+
+    def validate_move(self, answer):
+        return answer in "ABCD"
+
+    def make_move(self, move, player_number, is_computer=False):
+        if player_number not in self.scores:
+            self.scores[player_number] = 0
+        if not self.validate_move(move):
+            raise BadMoveException("Move not valid")
+        if move == self.current_board['correct_letter']:
+            self.scores[player_number] += 1
+        else:
+            self.scores[player_number] -= 1
+            if self.scores[player_number] < 0:
+                self.scores[player_number] = 0
+        self.current_board = self.get_trivia_quiz()
+        return {
+            'correct': move == self.current_board['correct_letter'],
+            'correct_letter': self.current_board['correct_letter'],
+            'score': self.scores[player_number]
+        }
+
+    def determine_game_over(self, players):
+        for player_number, score in self.scores.items():
+            if score >= 5:
+                # Game over
+                return players[player_number]
+        return
+
+    def get_trivia_quiz(self) -> Dict[str, Any]:
+        payload = self.get_trivia_payload()
+        quiz = self.get_quiz_from_payload(payload)
+        return quiz
+
+    def get_trivia_payload(self) -> Dict[str, Any]:
+
+        url = 'https://opentdb.com/api.php?amount=1&type=multiple'
+
+        try:
+            data = requests.get(url)
+
+        except requests.exceptions.RequestException:
+            raise NotAvailableException("Uh-Oh! Trivia service is down.")
+
+        if data.status_code != 200:
+            raise NotAvailableException("Uh-Oh! Trivia service is down.")
+
+        payload = data.json()
+        return payload
+
+    def get_quiz_from_payload(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        result = payload['results'][0]
+        question = result['question']
+        letters = ['A', 'B', 'C', 'D']
+        random.shuffle(letters)
+        correct_letter = letters[0]
+        answers = dict()
+        answers[correct_letter] = result['correct_answer']
+        for i in range(3):
+            answers[letters[i+1]] = result['incorrect_answers'][i]
+
+        def fix_quotes(s: str) -> Optional[str]:
+            # opentdb is nice enough to escape HTML for us, but
+            # we are sending this to code that does that already :)
+            #
+            # Meanwhile Python took until version 3.4 to have a
+            # simple html.unescape function.
+            try:
+                return html.unescape(s)
+            except Exception:
+                raise Exception('Please use python3.4 or later for this bot.')
+        answers = {
+            letter: fix_quotes(answer)
+            for letter, answer
+            in answers.items()
+        }
+        quiz = dict(
+            question=fix_quotes(question),
+            answers=answers,
+            correct_letter=correct_letter,
+        )
+        return quiz

zulip_bots/zulip_bots/bots/trivia_quiz/fixtures/test_new_question_dict.json

@@ -0,0 +1,10 @@
+{
+    "question": "Which class of animals are newts members of?",
+    "answers": {
+        "A": "Amphibian",
+        "B": "Fish",
+        "C": "Reptiles",
+        "D": "Mammals"
+    },
+    "correct_letter": "A"
+}

zulip_bots/zulip_bots/bots/trivia_quiz/test_trivia_quiz.py

@@ -12,146 +12,145 @@
 )
 
 from zulip_bots.request_test_lib import (
-    mock_request_exception,
+    mock_request_exception
+)
+
+from zulip_bots.bots.trivia_quiz.controller import (
+    TriviaQuizModel,
+    NotAvailableException
 )
 
 from zulip_bots.bots.trivia_quiz.trivia_quiz import (
-    get_quiz_from_payload,
-    fix_quotes,
-    get_quiz_from_id,
-    update_quiz,
-    handle_answer,
+    TriviaQuizMessageHandler
 )
 
+from zulip_bots.game_handler import BadMoveException
+
 class TestTriviaQuizBot(BotTestCase, DefaultTests):
-    bot_name = "trivia_quiz"  # type: str
+    bot_name = 'trivia_quiz'  # type: str
 
     new_question_response = '\nQ: Which class of animals are newts members of?\n\n' + \
         '* **A** Amphibian\n' + \
         '* **B** Fish\n' + \
         '* **C** Reptiles\n' + \
         '* **D** Mammals\n' + \
-        '**reply**: answer Q001 <letter>'
-
-    def get_test_quiz(self) -> Tuple[Dict[str, Any], Any]:
-        bot_handler = StubBotHandler()
-        quiz_payload = read_bot_fixture_data('trivia_quiz', 'test_new_question')['response']
-        with patch('random.shuffle'):
-            quiz = get_quiz_from_payload(quiz_payload)
-        return quiz, bot_handler
-
-    def _test(self, message: str, response: str, fixture: Optional[str]=None) -> None:
-        if fixture:
-            with self.mock_http_conversation(fixture):
-                self.verify_reply(message, response)
-        else:
-            self.verify_reply(message, response)
-
-    def test_bot_responds_to_empty_message(self) -> None:
-        self._test('', 'type "new" for a new question')
-
-    def test_bot_new_question(self) -> None:
-        with patch('random.shuffle'):
-            self._test('new', self.new_question_response, 'test_new_question')
+        '**reply**: <letter>'
+    
+    test_question = {
+        'question': 'Question 1?',
+        'answers': {
+            'A': 'Correct',
+            'B': 'Incorrect 1',
+            'C': 'Incorrect 2',
+            'D': 'Incorrect 3'
+        },
+        'correct_letter': 'A'
+    }
+
+    test_question_message_content = '''
+Q: Question 1?
+
+* **A** Correct
+* **B** Incorrect 1
+* **C** Incorrect 2
+* **D** Incorrect 3
+**reply**: <letter>'''
+
+    test_question_message_widget = '{"widget_type": "zform", "extra_data": {"type": "choices", "heading": "Question 1?", "choices": [{"type": "multiple_choice", "short_name": "A", "long_name": "Correct", "reply": "A"}, {"type": "multiple_choice", "short_name": "B", "long_name": "Incorrect 1", "reply": "B"}, {"type": "multiple_choice", "short_name": "C", "long_name": "Incorrect 2", "reply": "C"}, {"type": "multiple_choice", "short_name": "D", "long_name": "Incorrect 3", "reply": "D"}]}}'
 
     def test_question_not_available(self) -> None:
-        self._test('new', 'Uh-Oh! Trivia service is down.', 'test_status_code')
-
-        with mock_request_exception():
-            self.verify_reply('new', 'Uh-Oh! Trivia service is down.')
-
-    def test_fix_quotes(self) -> None:
-        self.assertEqual(fix_quotes('test &amp; test'), html.unescape('test &amp; test'))
-        print('f')
-        with patch('html.unescape') as mock_html_unescape:
-            mock_html_unescape.side_effect = Exception
-            with self.assertRaises(Exception) as exception:
-                fix_quotes('test')
-            self.assertEqual(str(exception.exception), "Please use python3.4 or later for this bot.")
-
-    def test_invalid_answer(self) -> None:
-        invalid_replies = ['answer A',
-                           'answer A Q10',
-                           'answer Q001 K',
-                           'answer 001 A']
-        for reply in invalid_replies:
-            self._test(reply, 'Invalid answer format')
-
-    def test_invalid_quiz_id(self) -> None:
-        self._test('answer Q100 A', 'Invalid quiz id')
-
-    def test_answers(self) -> None:
-        quiz_payload = read_bot_fixture_data('trivia_quiz', 'test_new_question')['response']
-        with patch('random.shuffle'):
-            quiz = get_quiz_from_payload(quiz_payload)
-
-        # Test initial storage
-        self.assertEqual(quiz['question'], 'Which class of animals are newts members of?')
-        self.assertEqual(quiz['correct_letter'], 'A')
-        self.assertEqual(quiz['answers']['D'], 'Mammals')
-        self.assertEqual(quiz['answered_options'], [])
-        self.assertEqual(quiz['pending'], True)
-
-        # test incorrect answer
-        with patch('zulip_bots.bots.trivia_quiz.trivia_quiz.get_quiz_from_id',
-                   return_value=json.dumps(quiz)):
-            self._test('answer Q001 B', ':disappointed: WRONG, Foo Test User! B is not correct.')
-
-        # test correct answer
-        with patch('zulip_bots.bots.trivia_quiz.trivia_quiz.get_quiz_from_id',
-                   return_value=json.dumps(quiz)):
-            with patch('zulip_bots.bots.trivia_quiz.trivia_quiz.start_new_quiz') as mock_new_quiz:
-                self._test('answer Q001 A', ':tada: **Amphibian** is correct, Foo Test User!')
-
-    def test_update_quiz(self) -> None:
-        quiz, bot_handler = self.get_test_quiz()
-        update_quiz(quiz, 'Q001', bot_handler)
-        test_quiz = json.loads(bot_handler.storage.get('Q001'))
-        self.assertEqual(test_quiz, quiz)
-
-    def test_get_quiz_from_id(self) -> None:
-        quiz, bot_handler = self.get_test_quiz()
-        bot_handler.storage.put('Q001', quiz)
-        self.assertEqual(get_quiz_from_id('Q001', bot_handler), quiz)
-
-    def test_handle_answer(self) -> None:
-        quiz, bot_handler = self.get_test_quiz()
-        # create test initial storage
-        update_quiz(quiz, 'Q001', bot_handler)
-
-        # test for a correct answer
-        start_new_question, response = handle_answer(quiz, 'A', 'Q001', bot_handler, 'Test user')
-        self.assertTrue(start_new_question)
-        self.assertEqual(response, ':tada: **Amphibian** is correct, Test user!')
-
-        # test for an incorrect answer
-        start_new_question, response = handle_answer(quiz, 'D', 'Q001', bot_handler, 'Test User')
-        self.assertFalse(start_new_question)
-        self.assertEqual(response, ':disappointed: WRONG, Test User! D is not correct.')
-
-    def test_handle_answer_three_failed_attempts(self) -> None:
-        quiz, bot_handler = self.get_test_quiz()
-        # create test storage for a question which has been incorrectly answered twice
-        quiz['answered_options'] = ['C', 'B']
-        update_quiz(quiz, 'Q001', bot_handler)
-
-        # test response  and storage after three failed attempts
-        start_new_question, response = handle_answer(quiz, 'D', 'Q001', bot_handler, 'Test User')
-        self.assertEqual(response, ':disappointed: WRONG, Test User! The correct answer is **Amphibian**.')
-        self.assertTrue(start_new_question)
-        quiz_reset = json.loads(bot_handler.storage.get('Q001'))
-        self.assertEqual(quiz_reset['pending'], False)
-
-        # test response after question has ended
-        incorrect_answers = ['B', 'C', 'D']
-        for ans in incorrect_answers:
-            start_new_question, response = handle_answer(quiz, ans, 'Q001', bot_handler, 'Test User')
-            self.assertEqual(response, ':disappointed: WRONG, Test User! The correct answer is **Amphibian**.')
-            self.assertFalse(start_new_question)
-        start_new_question, response = handle_answer(quiz, 'A', 'Q001', bot_handler, 'Test User')
-        self.assertEqual(response, ':tada: **Amphibian** is correct, Test User!')
-        self.assertFalse(start_new_question)
-
-        # test storage after question has ended
-        quiz_reset = json.loads(bot_handler.storage.get('Q001'))
-        self.assertEqual(quiz_reset['pending'], False)
+        with self.mock_http_conversation('test_new_question'):
+            model = TriviaQuizModel()
+        # Exception
+        with self.assertRaises(NotAvailableException):
+            with mock_request_exception():
+                model.get_trivia_quiz()
+        # non-ok status code
+        with self.assertRaises(NotAvailableException):
+            with self.mock_http_conversation("test_status_code"):
+                model.get_trivia_quiz()
+
+    def test_validate_move(self) -> None:
+        with self.mock_http_conversation('test_new_question'):
+            model = TriviaQuizModel()
+        valid_moves = [
+            'A',
+            'B',
+            'C',
+            'D'
+        ]
+        invalid_moves = [
+            'AA',
+            '1'
+        ]
+        for valid_move in valid_moves:
+            self.assertTrue(model.validate_move(valid_move))
+        for invalid_move in invalid_moves:
+            self.assertFalse(model.validate_move(invalid_move))
+
+    def test_make_move(self):
+        with self.mock_http_conversation('test_new_question'):
+            model = TriviaQuizModel()
+        model.current_board = self.test_question
+        model.scores = {
+            0: 0,
+            1: 1
+        }
+        # Invalid move should raise BadMoveException
+        with self.assertRaises(BadMoveException):
+            model.make_move('AA', 0)
+        # Correct move should:
+        with self.mock_http_conversation('test_new_question'):
+            with patch('random.shuffle'):
+                move_data = model.make_move('A', 0)
+                # Increment score
+                self.assertEqual(model.scores[0], 1)
+                # Change question
+                self.assertEqual(model.current_board, read_bot_fixture_data("trivia_quiz", "test_new_question_dict"))
+                # Move data correct should be true
+                self.assertTrue(move_data['correct'])
+                # Move data score should be the same as model.scores[player_number]
+                self.assertEqual(move_data['score'], 1)
+        # Incorrect move should:
+        with self.mock_http_conversation('test_new_question'):
+            model.current_board = self.test_question
+            move_data = model.make_move('B', 1)
+            # Decrement score
+            self.assertEqual(model.scores[1], 0)
+            # Move data correct should be false
+            self.assertFalse(move_data['correct'])
+
+    def test_determine_game_over(self):
+        with self.mock_http_conversation('test_new_question'):
+            model = TriviaQuizModel()
+            model.scores = {
+                0: 0,
+                1: 5,
+                2: 1
+            }
+            self.assertEqual(model.determine_game_over(["Test 0", "Test 1", "Test 2"]), "Test 1")
+            model.scores = {
+                0: 0,
+                1: 4,
+                2: 1
+            }
+            self.assertIsNone(model.determine_game_over(["Test 0", "Test 1", "Test 2"]))
+    
+    def test_message_handler_parse_board(self):
+        message_handler = TriviaQuizMessageHandler()
+        board_message_content, board_message_widget = message_handler.parse_board(self.test_question)
+        self.assertEqual(board_message_content, self.test_question_message_content)
+        self.assertEqual(board_message_widget, self.test_question_message_widget)
+
+    def test_message_handler_alert_move_message(self):
+        message_handler = TriviaQuizMessageHandler()
+        correct_responses = [
+            (("Test User", "A", {'correct': True, 'score': 5}), ":tada: Correct Test User (5 points)!"),
+            (("Test User", "B", {'correct': False, 'score': 1, 'correct_letter': "B"}), ":disappointed: Incorrect Test User (1 points). The correct answer was **B**")
+        ]
+        for args, response in correct_responses:
+            self.assertEqual(message_handler.alert_move_message(*args), response)
+
+    def test_message_handler_get_player_color(self):
+        message_handler = TriviaQuizMessageHandler()
+        self.assertIsNone(message_handler.get_player_color(0))