Add tests for completion block.

problem_builder/tests/integration/base_test.py

@@ -86,6 +86,25 @@ class ProblemBuilderBaseTest(SeleniumXBlockTest, PopupCheckMixin):
         self.browser.execute_script('document.querySelectorAll("header.banner")[0].style.display="none";')
         return element
 
+    def wait_for_init(self):
+        """ Wait for the scenario to initialize """
+        self.wait_until_hidden(self.browser.find_element_by_css_selector('.messages'))
+
+    def reload_page(self):
+        """
+        Reload current page.
+        """
+        self.browser.execute_script("$(document).html(' ');")
+        return self.go_to_view("student_view")
+
+    @property
+    def checkmark(self):
+        return self.browser.find_element_by_css_selector('.submit-result')
+
+    @property
+    def submit_button(self):
+        return self.browser.find_element_by_css_selector('.submit input.input-main')
+
     def click_submit(self, mentoring):
         """ Click the submit button and wait for the response """
         submit = mentoring.find_element_by_css_selector('.submit input.input-main')
@@ -101,6 +120,12 @@ class ProblemBuilderBaseTest(SeleniumXBlockTest, PopupCheckMixin):
                 label.click()
                 break
 
+    def expect_checkmark_visible(self, visible):
+        self.assertEqual(self.checkmark.is_displayed(), visible)
+
+    def expect_submit_enabled(self, enabled):
+        self.assertEqual(self.submit_button.is_enabled(), enabled)
+
 
 class MentoringBaseTest(SeleniumBaseTest, PopupCheckMixin):
     module_name = __name__
@@ -164,6 +189,10 @@ class MentoringAssessmentBaseTest(ProblemBuilderBaseTest):
 
         return mentoring, controls
 
+    def wait_for_init(self):
+        """ Wait for the scenario to initialize """
+        self.wait_until_visible(self.browser.find_elements_by_css_selector('.sb-step')[0])
+
     def assert_hidden(self, elem):
         self.assertFalse(elem.is_displayed())
 

problem_builder/tests/integration/test_completion.py

+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2014-2015 Harvard, edX & OpenCraft
+#
+# This software's license gives you freedom; you can copy, convey,
+# propagate, redistribute and/or modify this program under the terms of
+# the GNU Affero General Public License (AGPL) as published by the Free
+# Software Foundation (FSF), either version 3 of the License, or (at your
+# option) any later version of the AGPL published by the FSF.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero
+# General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program in a file in the toplevel directory called
+# "AGPLv3".  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# Imports ###########################################################
+
+from .base_test import ProblemBuilderBaseTest, MentoringAssessmentBaseTest, GetChoices
+
+
+# Classes ###########################################################
+
+class CompletionBlockTestMixin(object):
+    """
+    Mixin for testing completion blocks.
+    """
+
+    @property
+    def completion_checkbox(self):
+        return self.browser.find_element_by_css_selector('.pb-completion-value')
+
+    def expect_checkbox_checked(self, checked):
+        self.assertEqual(bool(self.completion_checkbox.get_attribute('checked')), checked)
+
+
+class CompletionBlockTest(CompletionBlockTestMixin, ProblemBuilderBaseTest):
+    """
+    Tests for CompletionBlock inside a normal Problem Builder block.
+    """
+
+    def test_simple_flow(self):
+        """
+        Test a regular Problem Builder block containing one completion block.
+        """
+        self.pb_wrapper = self.load_scenario('completion_problem.xml', {'include_mcq': False})
+        self.wait_for_init()
+
+        # Checkbox of completion block should not have "checked" attribute set initially,
+        # and "Submit" should be enabled since leaving checkbox unchecked produces a valid value:
+        self.assertIsNone(self.completion_checkbox.get_attribute('checked'))
+        self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(True)
+
+        # Confirm completion by checking checkbox, and click "Submit":
+        self.completion_checkbox.click()
+        self.click_submit(self.pb_wrapper)
+        # Now, we expect "Submit" to be disabled and the checkmark to be visible:
+        self.expect_checkbox_checked(True)
+        self.expect_checkmark_visible(True)
+        self.expect_submit_enabled(False)
+
+        # Uncheck checkbox
+        self.completion_checkbox.click()
+        # It should be possible to click "Submit" again, and the checkmark should be hidden:
+        self.expect_checkbox_checked(False)
+        self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(True)
+
+        # Now reload the page:
+        self.pb_wrapper = self.reload_page()
+        self.wait_for_init()
+        # The checkbox should be checked (since that's the value we submitted earlier),
+        # and "Submit" should be disabled (to discourage submitting the same answer):
+        self.expect_checkbox_checked(True)
+        self.expect_checkmark_visible(True)
+        self.expect_submit_enabled(False)
+
+    def test_simple_flow_with_peer(self):
+        """
+        Test a regular Problem Builder block containing one completion block and an MCQ.
+        """
+        self.pb_wrapper = self.load_scenario("completion_problem.xml", {"include_mcq": True})
+        self.wait_for_init()
+
+        # Checkbox of completion block should not have "checked" attribute set initially,
+        # and "Submit" should be disabled until an MCQ choice is selected
+        self.assertIsNone(self.completion_checkbox.get_attribute('checked'))
+        self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(False)
+
+        # Confirm completion by checking checkbox:
+        self.completion_checkbox.click()
+        # Checkmark should be hidden, and "Submit" should be disabled (did not select an MCQ choice yet):
+        self.expect_checkbox_checked(True)
+        self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(False)
+
+        # Select an MCQ choice:
+        GetChoices(self.pb_wrapper).select('Yes')
+        # "Submit" button should now be enabled:
+        self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(True)
+
+        # Submit answers
+        self.click_submit(self.pb_wrapper)
+        # Now, we expect submit to be disabled and the checkmark to be visible:
+        self.expect_checkmark_visible(True)
+        self.expect_submit_enabled(False)
+
+        # Uncheck checkbox
+        self.completion_checkbox.click()
+        # It should be possible to click "Submit" again, and the checkmark should be hidden:
+        self.expect_checkbox_checked(False)
+        self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(True)
+
+
+class CompletionStepBlockTest(CompletionBlockTestMixin, MentoringAssessmentBaseTest):
+    """
+    Tests for CompletionBlock inside a Step Builder block.
+    """
+
+    def test_step_with_completion_block(self):
+        """
+        Test a regular Step Builder block containing one completion block and an MCQ.
+        """
+        step_builder, controls = self.load_assessment_scenario("completion_step.xml")
+        self.wait_for_init()
+        self.assertIsNone(self.completion_checkbox.get_attribute('checked'))
+
+        # Submit step 1 (the completion block step), and advance to next step:
+        question = self.expect_question_visible(1, step_builder, question_text="Attendance Check")
+        self.assertIn("Did you attend the meeting?", question.text)  # Question
+        self.assertIn("Yes, I did.", question.text)  # Answer
+        self.assertTrue(controls.submit.is_enabled())
+        self.assert_hidden(controls.try_again)
+
+        self.completion_checkbox.click()
+        self.expect_checkbox_checked(True)
+        controls.submit.click()
+        self.do_submit_wait(controls, last=False)
+        self.wait_until_clickable(controls.next_question)
+        controls.next_question.click()
+
+        # Submit step 2 (the MCQ step), and advance to review step:
+        question = self.expect_question_visible(2, step_builder)
+        GetChoices(question).select("Yes")
+        controls.submit.click()
+        self.do_submit_wait(controls, last=True)
+        self.wait_until_clickable(controls.review)
+        controls.review.click()
+
+        self.wait_until_visible(controls.try_again)
+        # You can't get a completion block question wrong, but it does count as one correct point by default:
+        self.assertIn("You answered 2 questions correctly", step_builder.text)

problem_builder/tests/integration/test_slider.py

@@ -45,28 +45,27 @@ class SliderBlockTest(SliderBlockTestMixins, ProblemBuilderBaseTest):
         pb_wrapper = self.load_scenario("slider_problem.xml", {"include_mcq": False})
         self.wait_for_init()
         # The initial value should be 50 and submit should be enabled since 50 is a valid value:
-        self.assertTrue(self.submit_button.is_enabled())
         self.assertEqual(self.get_slider_value(), 50)
         self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(True)
         # Set the value to 75:
         self.set_slider_value(75)
         self.assertEqual(self.get_slider_value(), 75)
         self.click_submit(pb_wrapper)
         # Now, we expect submit to be disabled and the checkmark to be visible:
         self.expect_checkmark_visible(True)
-        self.assertFalse(self.submit_button.is_enabled())
+        self.expect_submit_enabled(False)
         # Now change the value, and the button/checkmark should reset:
         self.set_slider_value(45)
-        self.assertTrue(self.submit_button.is_enabled())
         self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(True)
         # Now reload the page:
-        self.browser.execute_script("$(document).html(' ');")
-        pb_wrapper = self.go_to_view("student_view")
+        pb_wrapper = self.reload_page()
         self.wait_for_init()
         # Now the initial value should be 75 and submit should be disabled (to discourage submitting the same answer):
         self.assertEqual(self.get_slider_value(), 75)
-        self.assertFalse(self.submit_button.is_enabled())
         self.expect_checkmark_visible(True)
+        self.expect_submit_enabled(False)
 
     def test_simple_flow_with_peer(self):
         """ Test a regular Problem Builder block containing one slider and an MCQ """
@@ -74,35 +73,23 @@ class SliderBlockTest(SliderBlockTestMixins, ProblemBuilderBaseTest):
         self.wait_for_init()
         # The initial value should be 50 and submit should be disabled until an MCQ choice is selected
         self.assertEqual(self.get_slider_value(), 50)
-        self.assertFalse(self.submit_button.is_enabled())
         self.expect_checkmark_visible(False)
+        self.expect_submit_enabled(False)
         # Set the value to 15:
         self.set_slider_value(15)
         self.assertEqual(self.get_slider_value(), 15)
-        self.assertFalse(self.submit_button.is_enabled())
+        self.expect_submit_enabled(False)
         # Choose a choice:
         GetChoices(pb_wrapper).select('Yes')
-        self.assertTrue(self.submit_button.is_enabled())
+        self.expect_submit_enabled(True)
         self.click_submit(pb_wrapper)
         # Now, we expect submit to be disabled and the checkmark to be visible:
         self.expect_checkmark_visible(True)
-        self.assertFalse(self.submit_button.is_enabled())
+        self.expect_submit_enabled(False)
         # Now change the value, and the button/checkmark should reset:
         self.set_slider_value(20)
-        self.assertTrue(self.submit_button.is_enabled())
         self.expect_checkmark_visible(False)
-
-    def wait_for_init(self):
-        """ Wait for the scenario to initialize """
-        self.wait_until_hidden(self.browser.find_element_by_css_selector('.messages'))
-
-    @property
-    def submit_button(self):
-        return self.browser.find_element_by_css_selector('.submit input.input-main')
-
-    def expect_checkmark_visible(self, visible):
-        checkmark = self.browser.find_element_by_css_selector('.xblock-pb-slider .submit-result')
-        self.assertEqual(checkmark.is_displayed(), visible)
+        self.expect_submit_enabled(True)
 
 
 class SliderStepBlockTest(SliderBlockTestMixins, MentoringAssessmentBaseTest):
@@ -140,7 +127,3 @@ class SliderStepBlockTest(SliderBlockTestMixins, MentoringAssessmentBaseTest):
         self.wait_until_visible(controls.try_again)
         # You can't get a slider question wrong, but it does count as one correct point by default:
         self.assertIn("You answered 2 questions correctly", step_builder.text)
-
-    def wait_for_init(self):
-        """ Wait for the scenario to initialize """
-        self.wait_until_visible(self.browser.find_elements_by_css_selector('.sb-step')[0])

problem_builder/tests/integration/xml_templates/completion_problem.xml

+<problem-builder url_name="pb_with_completion">
+    <pb-completion name="completion_1" question="Did you attend the meeting?" answer="Yes, I did." />
+
+    {% if include_mcq %}
+    <pb-mcq name="mcq_2" question="Do you like this MCQ?" correct_choices='["yes"]'>
+        <pb-choice value="yes">Yes</pb-choice>
+        <pb-choice value="maybenot">Maybe not</pb-choice>
+        <pb-choice value="understand">I don't understand</pb-choice>
+    </pb-mcq>
+    {% endif %}
+
+</problem-builder>

problem_builder/tests/integration/xml_templates/completion_step.xml

+<step-builder display_name="Step Builder">
+
+  <sb-step display_name="Completion step">
+    <pb-completion name="completion_1" display_name="Attendance Check" question="Did you attend the meeting?" answer="Yes, I did."/>
+  </sb-step>
+
+  <sb-step display_name="MCQ step">
+    <pb-mcq name="mcq" display_name="Question 2" question="Do you like this MCQ?" correct_choices='["yes"]'>
+        <pb-choice value="yes">Yes</pb-choice>
+        <pb-choice value="no">No</pb-choice>
+    </pb-mcq>
+  </sb-step>
+
+  <sb-review-step>
+    <sb-review-score/>
+  </sb-review-step>
+
+</step-builder>

problem_builder/tests/unit/test_problem_builder.py

@@ -9,9 +9,11 @@ from xblock.field_data import DictFieldData
 from problem_builder.mcq import MCQBlock
 from problem_builder.mentoring import MentoringBlock, MentoringMessageBlock, _default_options_config
 
+from .utils import BlockWithChildrenTestMixin
+
 
 @ddt.ddt
-class TestMentoringBlock(unittest.TestCase):
+class TestMentoringBlock(BlockWithChildrenTestMixin, unittest.TestCase):
     def test_sends_progress_event_when_rendered_student_view_with_display_submit_false(self):
         block = MentoringBlock(MagicMock(), DictFieldData({
             'display_submit': False
@@ -87,6 +89,26 @@ class TestMentoringBlock(unittest.TestCase):
             _, _, show_message = block._get_standard_results()
             self.assertEqual(show_message, expected_show_message)
 
+    def test_allowed_nested_blocks(self):
+        block = MentoringBlock(Mock(), DictFieldData({}), Mock())
+        self.assert_allowed_nested_blocks(block, message_blocks=[
+                'pb-message',  # Message type: "completed"
+                'pb-message',  # Message type: "incomplete"
+                'pb-message',  # Message type: "max_attempts_reached"
+            ] +
+            (['pb-message'] if block.is_assessment else [])  # Message type: "on-assessment-review"
+        )
+
+    def test_allowed_nested_blocks_assessment(self):
+        block = MentoringBlock(Mock(), DictFieldData({'mode': 'assessment'}), Mock())
+        self.assert_allowed_nested_blocks(block, message_blocks=[
+                'pb-message',  # Message type: "completed"
+                'pb-message',  # Message type: "incomplete"
+                'pb-message',  # Message type: "max_attempts_reached"
+            ] +
+            (['pb-message'] if block.is_assessment else [])  # Message type: "on-assessment-review"
+        )
+
 
 @ddt.ddt
 class TestMentoringBlockTheming(unittest.TestCase):

problem_builder/tests/unit/test_step.py

 import unittest
+
+from mock import Mock
 from xblock.field_data import DictFieldData
-from problem_builder.step import MentoringStepBlock
 
 from problem_builder.mixins import QuestionMixin, StepParentMixin
-from mock import Mock, patch
+from problem_builder.step import MentoringStepBlock
+
+from .utils import BlockWithChildrenTestMixin
 
 
 class Parent(StepParentMixin):
@@ -96,53 +99,8 @@ class TestQuestionMixin(unittest.TestCase):
         self.assertFalse(step2.lonely_child)
 
 
-class TestMentoringStep(unittest.TestCase):
-
-    def get_allowed_blocks(self, block):
-        return [
-            getattr(allowed_block, 'category', getattr(allowed_block, 'CATEGORY', None))
-            for allowed_block in block.allowed_nested_blocks
-        ]
+class TestMentoringStep(BlockWithChildrenTestMixin, unittest.TestCase):
 
     def test_allowed_nested_blocks(self):
         block = MentoringStepBlock(Mock(), DictFieldData({}), Mock())
-        self.assertEqual(
-            self.get_allowed_blocks(block),
-            [
-                'pb-answer',
-                'pb-mcq',
-                'pb-rating',
-                'pb-mrq',
-                'pb-completion',
-                'html',
-                'pb-answer-recap',
-                'pb-table',
-                'sb-plot',
-                'pb-slider',
-            ]
-        )
-        from sys import modules
-        xmodule_mock = Mock()
-        fake_modules = {
-            'xmodule': xmodule_mock,
-            'xmodule.video_module': xmodule_mock.video_module,
-            'xmodule.video_module.video_module': xmodule_mock.video_module.video_module,
-            'imagemodal': Mock()
-        }
-        with patch.dict(modules, fake_modules):
-            self.assertEqual(
-                self.get_allowed_blocks(block), [
-                    'pb-answer',
-                    'pb-mcq',
-                    'pb-rating',
-                    'pb-mrq',
-                    'pb-completion',
-                    'html',
-                    'pb-answer-recap',
-                    'pb-table',
-                    'sb-plot',
-                    'pb-slider',
-                    'video',
-                    'imagemodal',
-                ]
-            )
+        self.assert_allowed_nested_blocks(block)

problem_builder/tests/unit/utils.py

 """
 Helper methods for testing Problem Builder / Step Builder blocks
 """
-from mock import MagicMock, Mock
+from mock import MagicMock, Mock, patch
 from xblock.field_data import DictFieldData
 
 
@@ -20,6 +20,58 @@ class ScoresTestMixin(object):
         self.assertIsInstance(block.max_score(), (int, float))
 
 
+class BlockWithChildrenTestMixin(object):
+    """
+    Mixin for tests targeting blocks that contain nested child blocks.
+    """
+
+    ALLOWED_NESTED_BLOCKS = [
+        'pb-answer',
+        'pb-mcq',
+        'pb-rating',
+        'pb-mrq',
+        'pb-completion',
+        'html',
+        'pb-answer-recap',
+        'pb-table',
+        'sb-plot',
+        'pb-slider',
+    ]
+
+    ADDITIONAL_BLOCKS = [
+        'video',
+        'imagemodal',
+    ]
+
+    def get_allowed_blocks(self, block):
+        """
+        Return list of categories corresponding to child blocks allowed for `block`.
+        """
+        return [
+            getattr(allowed_block, 'category', getattr(allowed_block, 'CATEGORY', None))
+            for allowed_block in block.allowed_nested_blocks
+        ]
+
+    def assert_allowed_nested_blocks(self, block, message_blocks=[]):
+        self.assertEqual(
+            self.get_allowed_blocks(block),
+            self.ALLOWED_NESTED_BLOCKS + message_blocks
+        )
+        from sys import modules
+        xmodule_mock = Mock()
+        fake_modules = {
+            'xmodule': xmodule_mock,
+            'xmodule.video_module': xmodule_mock.video_module,
+            'xmodule.video_module.video_module': xmodule_mock.video_module.video_module,
+            'imagemodal': Mock()
+        }
+        with patch.dict(modules, fake_modules):
+            self.assertEqual(
+                self.get_allowed_blocks(block),
+                self.ALLOWED_NESTED_BLOCKS + self.ADDITIONAL_BLOCKS + message_blocks
+            )
+
+
 def instantiate_block(cls, fields=None):
     """
     Instantiate the given XBlock in a mock runtime.