Python Question.add_alternative方法代码示例

# 需要导入模块: from question import Question [as 别名]
# 或者: from question.Question import add_alternative [as 别名]
 def get_default_questions_json():
     question_list = list()
     question1 = Question(0, 'Choose A, B or C', True)
     question1.add_alternative(0, 'A', False)
     question1.add_alternative(1, 'B', True)
     question1.add_alternative(2, 'C', False)
     question_list.append(question1.to_json())
     question2 = Question(1, 'Choose D, E or F', False)
     question2.add_alternative(0, 'D', False)
     question2.add_alternative(1, 'E', False)
     question2.add_alternative(2, 'F', True)
     question_list.append(question2.to_json())
     return question_list

# 需要导入模块: from question import Question [as 别名]
# 或者: from question.Question import add_alternative [as 别名]
    def save_question(self, data, suffix=''):
        """
        Adds question to question collection stored in ``QuestionController`` class.
        :param data: JSON object that contains question in a format:
                data = {
                        'id': 1,
                        'text': 'Text',
                        'alternatives': [
                            {
                                'id': '1',
                                'text': 'Text',
                                'isCorrect': 'false'
                            },
                            {
                                'id': '2',
                                'text': 'Text2',
                                'isCorrect': 'false'
                            },
                            ...
                        ],
                        'hasDifficultyLevel': 'false'
                }
        :param suffix:
        :return: JSON object with the size of questions collection and last added question
        """
        try:
            q_id = int(data['id'])
            q_text = data['text']
            if data['hasDifficultyLevel']:
                q_has_diff_lvl = True
            else:
                q_has_diff_lvl = False

            new_question = Question(q_id, q_text, q_has_diff_lvl)

            for i in range(0, len(data['alternatives'])):
                # TODO: Note that the called function in CreatedAnswers throws error
                # TODO: See comment in Question::add_alternative
                if not new_question.add_alternative(i, data['alternatives'][i]['text'], data['alternatives'][i]['isCorrect']):
                    return {'status': 'Not saved', 'message': 'Alternative is not valid'}

            if new_question.is_valid:
                if q_id < 0:
                    new_question.set_question_id(len(self.questions_json_list))
                    self.questions_json_list.append(new_question.to_json())
                else:
                    for i in range(0, len(self.questions_json_list)):
                        if self.questions_json_list[i]['id'] == q_id:
                            del self.questions_json_list[i]
                            self.questions_json_list.insert(i, new_question.to_json())

                num_questions = len(self.questions_json_list)
                question = self.questions_json_list[num_questions - 1]
                return {'status': 'successful', 'numQuestions': num_questions, 'question': question}
            else:
                return{'status': 'unsuccessful', 'message': 'Question data is not valid'}
        except Exception as ex:
            return {'status': 'unsuccessful', 'message': str(ex)}

# 需要导入模块: from question import Question [as 别名]
# 或者: from question.Question import add_alternative [as 别名]
    def create_object_from_json(self):
        """
        Creates a list of Question objects from the JSON dictionary questions_json_list

        Returns:
            list: List containing objects of the class Questions

        """
        question_list = list()
        # loop through all the json questions and add them to the list
        for json_question in self.questions_json_list:
            q_id = json_question['id']
            q_text = json_question['question']
            q_diff_lvl = json_question['has_difficulty_level']
            question = Question(q_id, q_text, q_diff_lvl)
            # loop through all the alternatives for this question and add them
            for alt in json_question['alternatives']:
                a_id = alt['id']
                a_text = alt['text']
                a_is_correct = alt['isCorrect']
                question.add_alternative(a_id, a_text, a_is_correct)
            # add the question object to the list
            question_list.append(question)
        return question_list

# 需要导入模块: from question import Question [as 别名]
# 或者: from question.Question import add_alternative [as 别名]
    def get_default_question_objects():
        """
        Creates a list which is returned, this is to be used as default option in
        the list ```question_objects_list```

        Returns:
            list: A list with default question objects
        """
        question_list = list()
        question1 = Question(0, 'Choose A, B or C', False)
        question1.add_alternative(0, 'A', True)
        question1.add_alternative(1, 'B', False)
        question1.add_alternative(2, 'C', False)
        question_list.append(question1)
        question2 = Question(1, 'Choose D, E or F', False)
        question2.add_alternative(0, 'D', False)
        question2.add_alternative(1, 'E', False)
        question2.add_alternative(2, 'F', True)
        question_list.append(question2)
        return question_list

# 需要导入模块: from question import Question [as 别名]
# 或者: from question.Question import add_alternative [as 别名]
class test_question(unittest.TestCase):

    def setUp(self):
        self.q = Question(1, "some text", True)


    def test_get_question_id(self):
        id = self.q.get_question_id()
        assert id == 1

    def test_set_question_text(self):
        self.q.set_question_text("test is best")
        assert self.q.get_question_text() == "test is best"

    def test_set_has_difficulty_level(self):
        self.q.set_has_difficulty_level(True)
        assert self.q.get_has_difficulty_level() == True

    def test_add_alternative(self):
        self.q.add_alternative(0, "An alternative", True)
        self.q.add_alternative(1, "An alternative 2", False)
        alternatives = self.q.get_alternatives();
        assert len(alternatives) == 2

    def test_add_alternative_negative(self):
        self.q.add_alternative("A", "An alternative", True)
        alternatives = self.q.get_alternatives()
        assert len(alternatives) == 0

    def test_is_valid(self):
        self.q.set_question_text("test is best")
        self.q.add_alternative(0, "An alternative", True)
        self.q.add_alternative(1, "An alternative 2", False)
        valid = self.q.is_valid()
        assert valid == True

    def test_is_valid_id_negative(self):
        self.q.set_question_id(0)
        valid = self.q.is_valid()
        assert valid == False

    def test_is_valid_text_negative(self):
        self.q.set_question_id(1)
        self.q.set_question_text("")
        valid = self.q.is_valid()
        assert valid == False

    def test_is_valid_difficulty_level_negative(self):
        self.q.set_question_id(1)
        self.q.set_question_text("Test question")
        self.q.set_has_difficulty_level(None)
        valid = self.q.is_valid()
        assert valid == False

    def test_is_valid_alternatives_negative(self):
        self.q.set_question_id(1)
        self.q.set_question_text("Test question")
        self.q.set_has_difficulty_level(True)
        valid = self.q.is_valid()
        assert valid == False

    def test_to_json(self):
        self.q.set_question_text("test is best")
        self.q.add_alternative(0, "An alternative", True)
        json = self.q.to_json()
        assert "id" in json
        assert "question" in json
        assert "alternatives" in json
        assert "has_difficulty_level" in json
        assert "id" in json["alternatives"][0]
        assert "text" in json["alternatives"][0]
        assert "isCorrect" in json["alternatives"][0]

        assert json["id"] == 1
        assert json["question"] == "test is best"
        assert json["has_difficulty_level"] == True
        assert json["alternatives"][0]["id"] == 0
        assert json["alternatives"][0]["text"] == "An alternative"
        assert json["alternatives"][0]["isCorrect"] == True