Fixed showing feedback for all MRQ options on page reload and marking answer…

Fixed showing feedback for all MRQ options on page reload and marking answer blocks as incomplete on first load (+tests)

problem_builder/answer.py

@@ -190,7 +190,7 @@ class AnswerBlock(AnswerMixin, StepMixin, StudioEditableXBlockMixin, XBlock):
         }
 
     def get_last_result(self):
-        return self.get_results(None)
+        return self.get_results(None) if self.student_input else {}
 
     def submit(self, submission):
         """

problem_builder/mrq.py

@@ -81,16 +81,19 @@ class MRQBlock(QuestionnaireAbstractBlock):
             return self._(u"Ignored")
         return self._(u"Not Acceptable")
 
-    def get_results(self, previous_result):
+    def get_results(self, previous_result, only_selected=False):
         """
         Get the results a student has already submitted.
         """
-        result = self.calculate_results(previous_result['submissions'])
+        result = self.calculate_results(previous_result['submissions'], only_selected)
         result['completed'] = True
         return result
 
     def get_last_result(self):
-        return self.get_results({'submissions': self.student_choices}) if self.student_choices else {}
+        if self.student_choices:
+            return self.get_results({'submissions': self.student_choices}, only_selected=True)
+        else:
+            return {}
 
     def submit(self, submissions):
         log.debug(u'Received MRQ submissions: "%s"', submissions)
@@ -101,13 +104,17 @@ class MRQBlock(QuestionnaireAbstractBlock):
         log.debug(u'MRQ submissions result: %s', result)
         return result
 
-    def calculate_results(self, submissions):
+    def calculate_results(self, submissions, only_selected=False):
         score = 0
         results = []
+
         for choice in self.custom_choices:
             choice_completed = True
             choice_tips_html = []
             choice_selected = choice.value in submissions
+            if not choice_selected and only_selected:
+                continue
+
             if choice.value in self.required_choices:
                 if not choice_selected:
                     choice_completed = False

problem_builder/public/js/answer.js

@@ -31,13 +31,14 @@ function AnswerBlock(runtime, element) {
                 // Display of checkmark would be redundant.
                 return
             }
-
+            if (result.status) {
                 if (result.status === "correct") {
                     checkmark.addClass('checkmark-correct icon-ok fa-check');
                 }
                 else {
                     checkmark.addClass('checkmark-incorrect icon-exclamation fa-exclamation');
                 }
+            }
         },
 
         clearResult: function() {

problem_builder/tests/integration/test_mentoring.py

@@ -93,19 +93,15 @@ class ProblemBuilderQuestionnaireBlockTest(ProblemBuilderBaseTest):
 
         return answer, mcq, mrq, rating
 
-    def _assert_feedback_hidden(self, questionnaire, choice_index):
-        choice = self._get_choice(questionnaire, choice_index)
-        choice_result = choice.find_element_by_css_selector('.choice-result')
-        feedback_popup = choice.find_element_by_css_selector(".choice-tips")
-
-        choice_result_classes = choice_result.get_attribute('class').split()
-
-        self.assertTrue(choice_result.is_displayed())
-        self.assertFalse(feedback_popup.is_displayed())
-        self.assertNotIn('checkmark-correct', choice_result_classes)
-        self.assertNotIn('checkmark-incorrect', choice_result_classes)
-
-    def _assert_feedback_visible(self, questionnaire, choice_index, expected_text,
+    def _assert_checkmark(self, checkmark, shown=True, checkmark_class=None):
+        choice_result_classes = checkmark.get_attribute('class').split()
+        if shown:
+            self.assertTrue(checkmark.is_displayed())
+            self.assertIn(checkmark_class, choice_result_classes)
+        else:
+            self.assertFalse(checkmark.is_displayed())
+
+    def _assert_feedback_showed(self, questionnaire, choice_index, expected_text,
                                 click_choice_result=False, success=True):
         """
         Asserts that feedback for given element contains particular text
@@ -118,11 +114,21 @@ class ProblemBuilderQuestionnaireBlockTest(ProblemBuilderBaseTest):
             choice_result.click()
 
         feedback_popup = choice.find_element_by_css_selector(".choice-tips")
-        self.assertTrue(choice_result.is_displayed())
+        checkmark_class = 'checkmark-correct' if success else 'checkmark-incorrect'
+        self._assert_checkmark(choice_result, shown=True, checkmark_class=checkmark_class)
         self.assertTrue(feedback_popup.is_displayed())
         self.assertEqual(feedback_popup.text, expected_text)
+
+    def _assert_feedback_hidden(self, questionnaire, choice_index):
+        choice = self._get_choice(questionnaire, choice_index)
+        choice_result = choice.find_element_by_css_selector('.choice-result')
+        feedback_popup = choice.find_element_by_css_selector(".choice-tips")
         choice_result_classes = choice_result.get_attribute('class').split()
-        self.assertIn('checkmark-correct' if success else 'checkmark-incorrect', choice_result_classes)
+
+        self.assertTrue(choice_result.is_displayed())
+        self.assertFalse(feedback_popup.is_displayed())
+        self.assertNotIn('checkmark-correct', choice_result_classes)
+        self.assertNotIn('checkmark-incorrect', choice_result_classes)
 
     def _standard_filling(self, answer, mcq, mrq, rating):
         answer.send_keys('This is the answer')
@@ -140,28 +146,34 @@ class ProblemBuilderQuestionnaireBlockTest(ProblemBuilderBaseTest):
             if checkbox.is_selected():
                 checkbox.click()
 
-    def _standard_checks(self, answer, mcq, mrq, rating, messages):
+    def _standard_checks(self, answer, mcq, mrq, rating, messages, only_selected=False):
         self.assertEqual(answer.get_attribute('value'), 'This is the answer')
-        self._assert_feedback_visible(mcq, 0, "Great!")
-        self._assert_feedback_visible(
+        self._assert_feedback_showed(mcq, 0, "Great!")
+        self._assert_feedback_showed(
             mrq, 0, "This is something everyone has to like about this MRQ",
             click_choice_result=True
         )
-        self._assert_feedback_visible(
+        if not only_selected:
+            self._assert_feedback_showed(
                 mrq, 1, "This is something everyone has to like about beauty",
                 click_choice_result=True, success=False
             )
-        self._assert_feedback_visible(mrq, 2, "This MRQ is indeed very graceful", click_choice_result=True)
-        self._assert_feedback_visible(mrq, 3, "Nah, there aren't any!", click_choice_result=True, success=False)
-        self._assert_feedback_visible(rating, 3, "I love good grades.", click_choice_result=True)
+        else:
+            self._assert_feedback_hidden(mrq, 1)
+        self._assert_feedback_showed(mrq, 2, "This MRQ is indeed very graceful", click_choice_result=True)
+        self._assert_feedback_showed(mrq, 3, "Nah, there aren't any!", click_choice_result=True, success=False)
+        self._assert_feedback_showed(rating, 3, "I love good grades.", click_choice_result=True)
         self.assertTrue(messages.is_displayed())
         self.assertEqual(messages.text, "FEEDBACK\nNot done yet")
 
     def test_feedbacks_and_messages_is_not_shown_on_first_load(self):
         mentoring = self.load_scenario("feedback_persistence.xml")
-        _, mcq, mrq, rating = self._get_controls(mentoring)
+        answer, mcq, mrq, rating = self._get_controls(mentoring)
         messages = self._get_messages_element(mentoring)
 
+        answer_checkmark = answer.find_element_by_xpath("parent::*").find_element_by_css_selector(".answer-checkmark")
+
+        self._assert_checkmark(answer_checkmark, shown=False)
         for i in range(3):
             self._assert_feedback_hidden(mcq, i)
         for i in range(4):
@@ -183,7 +195,7 @@ class ProblemBuilderQuestionnaireBlockTest(ProblemBuilderBaseTest):
         mentoring = self.go_to_view("student_view")
         answer, mcq, mrq, rating = self._get_controls(mentoring)
         messages = self._get_messages_element(mentoring)
-        self._standard_checks(answer, mcq, mrq, rating, messages)
+        self._standard_checks(answer, mcq, mrq, rating, messages, only_selected=True)
 
     def test_given_perfect_score_in_past_loads_current_result(self):
         mentoring = self.load_scenario("feedback_persistence.xml")
@@ -201,18 +213,18 @@ class ProblemBuilderQuestionnaireBlockTest(ProblemBuilderBaseTest):
 
         # precondition - verifying 100% score achieved
         self.assertEqual(answer.get_attribute('value'), 'This is the answer')
-        self._assert_feedback_visible(mcq, 0, "Great!")
-        self._assert_feedback_visible(
+        self._assert_feedback_showed(mcq, 0, "Great!")
+        self._assert_feedback_showed(
             mrq, 0, "This is something everyone has to like about this MRQ",
             click_choice_result=True
         )
-        self._assert_feedback_visible(
+        self._assert_feedback_showed(
             mrq, 1, "This is something everyone has to like about beauty",
             click_choice_result=True
         )
-        self._assert_feedback_visible(mrq, 2, "This MRQ is indeed very graceful", click_choice_result=True)
-        self._assert_feedback_visible(mrq, 3, "Nah, there aren't any!", click_choice_result=True)
-        self._assert_feedback_visible(rating, 3, "I love good grades.", click_choice_result=True)
+        self._assert_feedback_showed(mrq, 2, "This MRQ is indeed very graceful", click_choice_result=True)
+        self._assert_feedback_showed(mrq, 3, "Nah, there aren't any!", click_choice_result=True)
+        self._assert_feedback_showed(rating, 3, "I love good grades.", click_choice_result=True)
         self.assertTrue(messages.is_displayed())
         self.assertEqual(messages.text, "FEEDBACK\nAll Good")
 
@@ -225,4 +237,4 @@ class ProblemBuilderQuestionnaireBlockTest(ProblemBuilderBaseTest):
         mentoring = self.go_to_view("student_view")
         answer, mcq, mrq, rating = self._get_controls(mentoring)
         messages = self._get_messages_element(mentoring)
-        self._standard_checks(answer, mcq, mrq, rating, messages)
+        self._standard_checks(answer, mcq, mrq, rating, messages, only_selected=True)