{% trans "Submissions by others" %}
+Please enter your response here
" + context = { + "prompt": studio_settings_prompt, + } + fragment = self.xblock.build_fragment( + template="view.html", + context=context, + js_init="FreeTextResponseView", + css=[], + js=[], + ) + self.assertIn(studio_settings_prompt, fragment.content) + + def test_max_score(self): + """ + Tests max_score function + Should return the weight + """ + self.xblock.weight = 4 + self.assertEqual(self.xblock.weight, self.xblock.max_score()) + + def test_studio_view(self): + """ + Checks studio view for instance variables specified by the instructor. + """ + studio_view_html = self.xblock.studio_view(context=None).content + self.assertIn(self.xblock.display_name, studio_view_html) + self.assertIn(self.xblock.prompt, studio_view_html) + self.assertIn(str(self.xblock.weight), studio_view_html) + self.assertIn(str(self.xblock.max_attempts), studio_view_html) + self.assertIn(str(self.xblock.display_correctness), studio_view_html) + self.assertIn(str(self.xblock.min_word_count), studio_view_html) + self.assertIn(str(self.xblock.max_word_count), studio_view_html) + self.assertIn( + ", ".join( + self.xblock.fullcredit_keyphrases, + ), + studio_view_html, + ) + self.assertIn( + ", ".join( + self.xblock.halfcredit_keyphrases, + ), + studio_view_html, + ) + self.assertIn(str(self.xblock.submitted_message), studio_view_html) + + # Scoring + @ddt.file_data(path.join(tests_dir, "determine_credit.json")) + def test_determine_credit(self, **test_data): + # pylint: disable=protected-access + """ + Tests determine_credit + After a student response this function will + return the Credit enum full, half, or zero + """ + self.xblock._word_count_valid = MagicMock(return_value=test_data["word_count_valid"]) + self.xblock.fullcredit_keyphrases = test_data["fullcredit"] + self.xblock.halfcredit_keyphrases = test_data["halfcredit"] + self.xblock.student_answer = test_data["student_answer"] + credit = Credit[test_data["credit"]] + self.assertEqual(credit, self.xblock._determine_credit()) + + @ddt.data(Credit.zero, Credit.half, Credit.full) + def test_compute_score(self, credit): + # pylint: disable=protected-access + """ + Tests _compute_score + After a student response this function will + set the xblock score and publish the grade + """ + self.xblock.runtime.publish = MagicMock(return_value=None) + self.xblock._determine_credit = MagicMock(return_value=credit) + self.xblock._compute_score() + self.xblock.runtime.publish.assert_called_with( + self.xblock, + "grade", + {"value": credit.value, "max_value": Credit.full.value}, + ) + + def test_compute_score_integrity_error(self): + # pylint: disable=protected-access, invalid-name + """ + Tests that _compute_score gracefully handles IntegrityError exception. + + Tests to ensure that if an IntegrityError exception + is thrown by any of the methods/functions called in the + process of saving the score, the program handles it gracefully. + We force runtime.publish to throw an IntegrityError exception, + and expect _compute_score to be graceful about it. + """ + self.xblock.runtime.publish = MagicMock(return_value=None) + self.xblock.runtime.publish.side_effect = IntegrityError("Unique Key Violation") + self.xblock._determine_credit = MagicMock(return_value=Credit.zero) + self.xblock._compute_score() + + def test_is_at_least_one_phrase_present(self): + # pylint: disable=invalid-name, protected-access + """ + Tests _is_at_least_one_phrase_present + Helper method to match student response + with given phrase list + """ + keyphrases_list = ["do dict phrase", "re dict phrase", "mi dict phrase", "fa dict phrase"] + answer = keyphrases_list[1] + answer = "ajhsdfhjaefhaf " + answer + "jkfbaufebn; fuqv" + self.assertTrue( + _is_at_least_one_phrase_present( + keyphrases_list, + answer, + ), + ) + + def test_not_is_at_least_one_phrase_present(self): + # pylint: disable=invalid-name, protected-access + """ + Tests _is_at_least_one_phrase_present + Helper method to match student response + with given phrase list + """ + keyphrases_list = ["do dict phrase", "re dict phrase", "mi dict phrase", "fa dict phrase"] + answer = "so dict phrase" + answer = "ajhsdfhjaefhaf " + answer + "jkfbaufebn; fuqv" + self.assertFalse( + _is_at_least_one_phrase_present( + keyphrases_list, + answer, + ), + ) + + @ddt.file_data(path.join(tests_dir, "word_count_valid.json")) + def test_word_count_valid(self, **test_data): + # pylint: disable=protected-access + """ + Tests _word_count_valid + After a student response this will + determine if the response meets word + count criteria + """ + self.xblock.min_word_count = test_data["min_word_count"] + self.xblock.max_word_count = test_data["max_word_count"] + self.xblock.student_answer = test_data["student_answer"] + self.assertEqual(test_data["result"], self.xblock._word_count_valid()) + + # Messages + @ddt.data( + # max_attempts, count_attempts, result + (None, 4, ""), + (0, 4, ""), + (1, 0, "You have used 0 of 1 submission"), + (3, 2, "You have used 2 of 3 submissions"), + ) + @ddt.unpack + def test_used_attempts_feedback_normal(self, max_attempts, count_attempts, result): + # pylint: disable=invalid-name, protected-access + """ + Tests get_used_attempts_feedback + Returns the used attempts feedback message + after a student response + """ + self.xblock.max_attempts = max_attempts + self.xblock.count_attempts = count_attempts + self.assertEqual( + result, + self.xblock._get_used_attempts_feedback(), + ) + + @ddt.data( + # min_word_count, max_word_count, result + (0, 1, "Your response must be between 0 and 1 word."), + (2, 3, "Your response must be between 2 and 3 words."), + ) + @ddt.unpack + def test_get_word_count_message( + self, + min_word_count, + max_word_count, + result, + ): + # pylint: disable=protected-access + """ + Tests _get_word_count_message + Returns the word count message + based on instructor set word count + min and max + """ + self.xblock.min_word_count = min_word_count + self.xblock.max_word_count = max_word_count + self.assertEqual( + result, + self.xblock._get_word_count_message(), + ) + + # Tested from get_user_alert + @ddt.file_data(path.join(tests_dir, "invalid_word_count_message.json")) + def test_get_user_alert(self, **test_data): + # pylint: disable=protected-access + """ + Tests _get_user_alert + if the word count is invalid this will + return the invalid word count message + """ + self.xblock._word_count_valid = MagicMock(return_value=test_data["word_count_valid"]) + self.xblock.count_attempts = test_data["count_attempts"] + self.xblock.min_word_count = test_data["min_word_count"] + self.xblock.max_word_count = test_data["max_word_count"] + self.assertEqual( + str(test_data["result"]), + self.xblock._get_user_alert(ignore_attempts=test_data["ignore_attempts"]), + ) + + @ddt.data( + # word_count_valid, result + (False, ""), + (True, "test submission received message"), + ) + @ddt.unpack + def test_get_submitted_message(self, word_count_valid, result): + # pylint: disable=protected-access + """ + Tests _get_submitted_message + Returns a message to display to + the user after they submit a + response + """ + self.xblock._word_count_valid = MagicMock(return_value=word_count_valid) + self.xblock.submitted_message = "test submission received message" + self.assertEqual( + result, + self.xblock._get_submitted_message(), + ) + + @ddt.file_data(path.join(tests_dir, "problem_progress.json")) + def test_get_problem_progress(self, **test_data): + # pylint: disable=protected-access + """ + Tests _get_problem_progress + Score can be 0, 0.5, or 1 + Return a message for current + problem progress + """ + self.xblock.weight = test_data["weight"] + self.xblock.score = test_data["score"] + self.assertEqual( + test_data["result"], + self.xblock._get_problem_progress(), + ) + + # CSS Classes + @ddt.file_data(path.join(tests_dir, "indicator_class.json")) + def test_get_indicator_class(self, **test_data): + # pylint: disable=protected-access + """ + Test _get_indicator_class + Returns the correctness CCS class + to show correct/incorrect/unanswered + UI + """ + credit = None + if test_data["credit"]: + credit = Credit[test_data["credit"]] + self.xblock.display_correctness = test_data["display_correctness"] + self.xblock._word_count_valid = MagicMock(return_value=test_data["word_count_valid"]) + self.xblock._determine_credit = MagicMock(return_value=credit) + self.assertEqual(test_data["result"], self.xblock._get_indicator_class()) + + @ddt.data( + # display_correctness, result + (True, ""), + (False, "hidden"), + ) + @ddt.unpack + def test_get_indicator_visibility_class(self, display_correctness, result): + # pylint: disable=invalid-name, protected-access + """ + Tests _get_indicator_visibility_class + Return hidden or blank CCS class to + hide correctness UI + """ + self.xblock.display_correctness = display_correctness + self.assertEqual( + result, + self.xblock._get_indicator_visibility_class(), + ) + + @ddt.file_data(path.join(tests_dir, "submitdisplay_class.json")) + def test_get_submitdisplay_class(self, **test_data): + # pylint: disable=protected-access + """ + Tests _get_submitdisplay_class + Return blank or nodisplay CCS class + that hide the submit buttons after + a user has reached max_attempts + """ + self.xblock.max_attempts = test_data["max_attempts"] + self.xblock.count_attempts = test_data["count_attempts"] + self.assertEqual(test_data["result"], self.xblock._get_nodisplay_class()) + + @ddt.data( + ({"max_attempts": None, "count_attempts": 1}, True), + ({"max_attempts": None, "count_attempts": 3}, True), + ({"max_attempts": 0, "count_attempts": 3}, True), + ({"max_attempts": 3, "count_attempts": 2}, True), + ({"max_attempts": 3, "count_attempts": 3}, False), + ({"due": None, "graceperiod": None}, True), + ({"due": None, "graceperiod": timedelta(hours=1)}, True), + ( + { + "due": dt.now(UTC).replace(tzinfo=None) + timedelta(hours=1), + "graceperiod": None, + }, + True, + ), + ( + { + "due": dt.now(UTC).replace(tzinfo=None) - timedelta(hours=1), + "graceperiod": None, + }, + False, + ), + ( + { + "due": dt.now(UTC).replace(tzinfo=None) - timedelta(hours=1), + "graceperiod": timedelta(hours=2), + }, + True, + ), + ( + { + "due": dt.now(UTC).replace(tzinfo=None) - timedelta(hours=5), + "graceperiod": timedelta(hours=2), + }, + False, + ), + ) + @ddt.unpack + def test_submit(self, xblock_config, can_submit): + # pylint: disable=protected-access + """ + Tests save_response results + """ + student_answer = "asdf" + for key, value in xblock_config.items(): + setattr(self.xblock, key, value) + data = json.dumps({"student_answer": student_answer}) + request = TestRequest() + request.method = "POST" + request.body = data.encode("utf-8") + response = self.xblock.submit(request) + # Added for response json_body + # pylint: disable=no-member + self.assertEqual(response.json_body["status"], "success") + self.assertEqual(response.json_body["problem_progress"], self.xblock._get_problem_progress()) + self.assertEqual(response.json_body["indicator_class"], self.xblock._get_indicator_class()) + self.assertEqual(response.json_body["used_attempts_feedback"], self.xblock._get_used_attempts_feedback()) + self.assertEqual(response.json_body["nodisplay_class"], self.xblock._get_nodisplay_class()) + self.assertEqual(response.json_body["submitted_message"], self.xblock._get_submitted_message()) + self.assertEqual( + response.json_body["user_alert"], + self.xblock._get_user_alert( + ignore_attempts=True, + ), + ) + self.assertEqual(response.json_body["visibility_class"], self.xblock._get_indicator_visibility_class()) + self.assertEqual(self.xblock.student_answer, student_answer if can_submit else "") + + @ddt.data( + ({"max_attempts": None, "count_attempts": 1}, True), + ({"max_attempts": None, "count_attempts": 3}, True), + ({"max_attempts": 0, "count_attempts": 3}, True), + ({"max_attempts": 3, "count_attempts": 3}, False), + ) + @ddt.unpack + def test_save_response(self, xblock_config, can_save): + # pylint: disable=protected-access + """ + Tests save_response results + """ + student_answer = "asdf" + for key, value in xblock_config.items(): + setattr(self.xblock, key, value) + data = json.dumps({"student_answer": student_answer}) + request = TestRequest() + request.method = "POST" + request.body = data.encode("utf-8") + response = self.xblock.save_response(request) + # Added for response json_body + # pylint: disable=no-member + self.assertEqual(response.json_body["status"], "success") + self.assertEqual(response.json_body["problem_progress"], self.xblock._get_problem_progress()) + self.assertIsNone( + response.json_body.get("indicator_class", None), + ) + self.assertEqual(response.json_body["used_attempts_feedback"], self.xblock._get_used_attempts_feedback()) + self.assertEqual(response.json_body["nodisplay_class"], self.xblock._get_nodisplay_class()) + self.assertEqual(response.json_body["submitted_message"], "") + self.assertEqual(response.json_body["user_alert"], self.xblock.saved_message) + self.assertEqual(response.json_body["visibility_class"], self.xblock._get_indicator_visibility_class()) + self.assertEqual(self.xblock.student_answer, student_answer if can_save else "") diff --git a/src/freetextresponse/tests/test_i18n_resources.py b/src/freetextresponse/tests/test_i18n_resources.py new file mode 100644 index 0000000..4627ef9 --- /dev/null +++ b/src/freetextresponse/tests/test_i18n_resources.py @@ -0,0 +1,54 @@ +""" +Tests for gettext translations and XBlock i18n. +""" + +from unittest.mock import patch + +import django.utils.translation +from django.test import TestCase +from django.utils.translation.trans_real import get_language, translation + +from freetextresponse.xblocks import FreeTextResponse + +from .tests_utils import make_xblock + + +def mock_gettext(source, *_args): + """ + Mock gettext to avoid loading the .mo file. + """ + return { + "Submit": "Süßmït", + "Your response must be between {min} and {max} word.": "Ýöür réspönsé müst ßé ßétwéén {min} änd {max} wörd.", + "Your response must be between {min} and {max} words.": "Ýöür réspönsé müst ßé ßétwéén {min} änd {max} wörds.", + }.get(source, source) + + +class TestFreeTextResponseI18N(TestCase): + """ + Ensure the i18n is setup correctly for the XBlock. + """ + + def test_esperanto_translations_in_student_view(self): + """ + Checks if the template and its context are both correctly translated. + """ + xblock = make_xblock("freetextresponse", FreeTextResponse, {}) + current_translation = translation(get_language()) + + with ( + django.utils.translation.override("eo"), + patch.object(current_translation, "gettext") as gettext, + patch.object(current_translation, "ngettext") as ngettext, + ): + gettext.side_effect = mock_gettext + ngettext.side_effect = mock_gettext + student_view = xblock.student_view() + student_view_html = student_view.content + + self.assertIn("Süßmït", student_view_html) + + english_text = "Your response must be between" + translated_text = "Ýöür réspönsé müst ßé ßétwéén" + self.assertNotIn(english_text, student_view_html) + self.assertIn(translated_text, student_view_html) diff --git a/src/freetextresponse/tests/tests_utils.py b/src/freetextresponse/tests/tests_utils.py new file mode 100644 index 0000000..17b0782 --- /dev/null +++ b/src/freetextresponse/tests/tests_utils.py @@ -0,0 +1,38 @@ +""" +Test utilities for the FreeTextResponse XBlock tests. +""" + +from unittest.mock import Mock + +from workbench.runtime import WorkbenchRuntime # pylint: disable=all +from xblock.fields import ScopeIds +from xblock.runtime import DictKeyValueStore, KvsFieldData + + +def make_xblock(xblock_name, xblock_cls, attributes): + """ + Helper to construct XBlock objects + """ + runtime = WorkbenchRuntime() + key_store = DictKeyValueStore() + db_model = KvsFieldData(key_store) + ids = generate_scope_ids(runtime, xblock_name) + xblock = xblock_cls(runtime, db_model, scope_ids=ids) + xblock.category = Mock() + xblock.location = Mock( + html_id=Mock(return_value="sample_element_id"), + ) + xblock.runtime = runtime + xblock.course_id = "course-v1:foo+bar+baz" + for key, value in attributes.items(): + setattr(xblock, key, value) + return xblock + + +def generate_scope_ids(runtime, block_type): + """ + Helper to generate scope IDs for an XBlock + """ + def_id = runtime.id_generator.create_definition(block_type) + usage_id = runtime.id_generator.create_usage(def_id) + return ScopeIds("user", block_type, def_id, usage_id) diff --git a/src/freetextresponse/tests/validate_field_data.json b/src/freetextresponse/tests/validate_field_data.json new file mode 100644 index 0000000..f689954 --- /dev/null +++ b/src/freetextresponse/tests/validate_field_data.json @@ -0,0 +1,51 @@ +{ + "weight_attempts_negative": { + "weight": -1, + "max_attempts": 1, + "max_word_count": 1, + "min_word_count": 1, + "submitted_message": "s", + "result": "Weight cannot be negative" + }, + "max_attempts_negative": { + "weight": 0, + "max_attempts": -1, + "max_word_count": 1, + "min_word_count": 1, + "submitted_message": "s", + "result": "Maximum Attempts cannot be negative" + }, + "min_word_count_less_than_one": { + "weight": 0, + "max_attempts": 1, + "max_word_count": 1, + "min_word_count": 0, + "submitted_message": "s", + "result": "Minimum Word Count cannot be less than 1" + }, + "min_not_greater_than_max": { + "weight": 0, + "max_attempts": 1, + "max_word_count": 1, + "min_word_count": 2, + "submitted_message": "s", + "result": "Minimum Word Count cannot be greater than Max Word Count" + }, + "submission_message_blank": { + "weight": 0, + "max_attempts": 1, + "max_word_count": 3, + "min_word_count": 2, + "submitted_message": "", + "result": "Submission Received Message cannot be blank" + }, + "submission_message_blank_null_max_attempts": { + "weight": 0, + "max_attempts": null, + "max_word_count": 3, + "min_word_count": 2, + "submitted_message": "", + "result": "Submission Received Message cannot be blank" + } +} + diff --git a/src/freetextresponse/tests/word_count_valid.json b/src/freetextresponse/tests/word_count_valid.json new file mode 100644 index 0000000..3d376e6 --- /dev/null +++ b/src/freetextresponse/tests/word_count_valid.json @@ -0,0 +1,38 @@ +{ + "blank_answer": { + "min_word_count": 1, + "max_word_count": 2, + "student_answer": "", + "result": false + }, + "min_answer": { + "min_word_count": 1, + "max_word_count": 2, + "student_answer": "One", + "result": true + }, + "max_answer": { + "min_word_count": 1, + "max_word_count": 2, + "student_answer": "One Two", + "result": true + }, + "too_long_answer": { + "min_word_count": 2, + "max_word_count": 4, + "student_answer": "One Two Three Four Five", + "result": false + }, + "too_short_answer": { + "min_word_count": 2, + "max_word_count": 4, + "student_answer": "One", + "result": false + }, + "in_range_answer": { + "min_word_count": 3, + "max_word_count": 6, + "student_answer": "One Two Three Four Five", + "result": true + } +} diff --git a/src/freetextresponse/views.py b/src/freetextresponse/views.py new file mode 100644 index 0000000..a87c1a0 --- /dev/null +++ b/src/freetextresponse/views.py @@ -0,0 +1,328 @@ +""" +Handle view logic for the XBlock +""" + +from xblock.core import XBlock +from xblock.validation import ValidationMessage + +try: + from xblock.utils.resources import ResourceLoader + from xblock.utils.studio_editable import StudioEditableXBlockMixin +except ModuleNotFoundError: # pragma: no cover + # For backward compatibility with releases older than Quince. + from xblockutils.resources import ResourceLoader + from xblockutils.studio_editable import StudioEditableXBlockMixin + +from .mixins.dates import EnforceDueDates +from .mixins.fragment import XBlockFragmentBuilderMixin +from .mixins.i18n import I18nXBlockMixin +from .models import MAX_RESPONSES, Credit + + +# pylint: disable=no-member +class FreeTextResponseViewMixin( + I18nXBlockMixin, + EnforceDueDates, + XBlockFragmentBuilderMixin, + StudioEditableXBlockMixin, +): + """ + Handle view logic for FreeTextResponse XBlock instances + """ + + loader = ResourceLoader(__name__) + static_js_init = "FreeTextResponseView" + + def provide_context(self, context=None): + """ + Build a context dictionary to render the student view + """ + context = context or {} + context = dict(context) + context.update( + { + "display_name": self.display_name, + "usage_id": str(self.scope_ids.usage_id) + .replace(":", "_") + .replace("@", "_") + .replace("/", "_") + .replace("+", "_") + .replace(".", "_"), + "indicator_class": self._get_indicator_class(), + "nodisplay_class": self._get_nodisplay_class(), + "problem_progress": self._get_problem_progress(), + "prompt": self.prompt, + "student_answer": self.student_answer, + "is_past_due": self.is_past_due(), + "used_attempts_feedback": self._get_used_attempts_feedback(), + "visibility_class": self._get_indicator_visibility_class(), + "word_count_message": self._get_word_count_message(), + "display_other_responses": self.display_other_student_responses, + "other_responses": self.get_other_answers(), + "user_alert": "", + "submitted_message": "", + } + ) + return context + + def _get_indicator_class(self): + """ + Returns the class of the correctness indicator element + """ + result = "unanswered" + if self.display_correctness and self._word_count_valid(): + if self._determine_credit() == Credit.zero: + result = "incorrect" + else: + result = "correct" + return result + + def _get_nodisplay_class(self): + """ + Returns the css class for the submit button + """ + result = "" + if self.max_attempts and 0 < self.max_attempts <= self.count_attempts: + result = "nodisplay" + return result + + def _word_count_valid(self): + """ + Returns a boolean value indicating whether the current + word count of the user's answer is valid + """ + word_count = len(self.student_answer.split()) + result = self.max_word_count >= word_count >= self.min_word_count + return result + + def _determine_credit(self): + # Not a standard xblock pylint disable. + # This is a problem with pylint 'enums and R0204 in general' + """ + Helper Method that determines the level of credit that + the user should earn based on their answer + """ + result = None + if self.student_answer == "" or not self._word_count_valid(): + result = Credit.zero + elif not self.fullcredit_keyphrases and not self.halfcredit_keyphrases: + result = Credit.full + elif _is_at_least_one_phrase_present(self.fullcredit_keyphrases, self.student_answer): + result = Credit.full + elif _is_at_least_one_phrase_present(self.halfcredit_keyphrases, self.student_answer): + result = Credit.half + else: + result = Credit.zero + return result + + def _get_problem_progress(self): + """ + Returns a statement of progress for the XBlock, which depends + on the user's current score + """ + if self.weight == 0: + result = "" + elif self.score == 0.0: + weight = self.weight + temp = self.ngettext(f"{weight} point possible", f"{weight} points possible", weight) + result = f"({temp})" + else: + scaled_score = self.score * self.weight + # No trailing zero and no scientific notation + score_string = f"{scaled_score:.15f}".rstrip("0").rstrip(".") + weight = self.weight + temp = self.ngettext(f"{score_string}/{weight} point", f"{score_string}/{weight} points", weight) + result = f"({temp})" + return result + + def _get_used_attempts_feedback(self): + """ + Returns the text with feedback to the user about the number of attempts + they have used if applicable + """ + result = "" + if self.max_attempts and self.max_attempts > 0: + result = self.ngettext( + "You have used {count_attempts} of {max_attempts} submission", + "You have used {count_attempts} of {max_attempts} submissions", + self.max_attempts, + ).format( + count_attempts=self.count_attempts, + max_attempts=self.max_attempts, + ) + return result + + def _get_indicator_visibility_class(self): + """ + Returns the visibility class for the correctness indicator html element + """ + if self.display_correctness: + result = "" + else: + result = "hidden" + return result + + def _get_word_count_message(self): + """ + Returns the word count message + """ + result = self.ngettext( + "Your response must be between {min} and {max} word.", + "Your response must be between {min} and {max} words.", + self.max_word_count, + ).format( + min=self.min_word_count, + max=self.max_word_count, + ) + return result + + def get_other_answers(self): + """ + Returns at most MAX_RESPONSES answers from the pool. + + Does not return answers the student had submitted. + """ + student_id = self.get_student_id() + display_other_responses = self.display_other_student_responses + shouldnt_show_other_responses = not display_other_responses + student_answer_incorrect = self._determine_credit() == Credit.zero + if student_answer_incorrect or shouldnt_show_other_responses: + return [] + return_list = [response for response in self.displayable_answers if response["student_id"] != student_id] + return_list = return_list[-(MAX_RESPONSES):] + return return_list + + @XBlock.json_handler + def submit(self, data, suffix=""): + # pylint: disable=unused-argument + """ + Processes the user's submission + """ + # Fails if the UI submit/save buttons were shut + # down on the previous submission + if self._can_submit(): + self.student_answer = data["student_answer"] + # Counting the attempts and publishing a score + # even if word count is invalid. + self.count_attempts += 1 + self._compute_score() + display_other_responses = self.display_other_student_responses + if display_other_responses and data.get("can_record_response"): + self.store_student_response() + result = { + "status": "success", + "problem_progress": self._get_problem_progress(), + "indicator_class": self._get_indicator_class(), + "used_attempts_feedback": self._get_used_attempts_feedback(), + "nodisplay_class": self._get_nodisplay_class(), + "submitted_message": self._get_submitted_message(), + "user_alert": self._get_user_alert( + ignore_attempts=True, + ), + "other_responses": self.get_other_answers(), + "display_other_responses": self.display_other_student_responses, + "visibility_class": self._get_indicator_visibility_class(), + } + return result + + @XBlock.json_handler + def save_response(self, data, suffix=""): + # pylint: disable=unused-argument + """ + Processes the user's save + """ + # Fails if the UI submit/save buttons were shut + # down on the previous submission + if not self.max_attempts or self.count_attempts < self.max_attempts: + self.student_answer = data["student_answer"] + result = { + "status": "success", + "problem_progress": self._get_problem_progress(), + "used_attempts_feedback": self._get_used_attempts_feedback(), + "nodisplay_class": self._get_nodisplay_class(), + "submitted_message": "", + "user_alert": self.saved_message, + "visibility_class": self._get_indicator_visibility_class(), + } + return result + + def _get_invalid_word_count_message(self, ignore_attempts=False): + """ + Returns the invalid word count message + """ + result = "" + if (ignore_attempts or self.count_attempts > 0) and (not self._word_count_valid()): + word_count_message = self._get_word_count_message() + result = self.gettext("Invalid Word Count. {word_count_message}").format( + word_count_message=word_count_message, + ) + return result + + def _get_submitted_message(self): + """ + Returns the message to display in the submission-received div + """ + result = "" + if self._word_count_valid(): + result = self.submitted_message + return result + + def _get_user_alert(self, ignore_attempts=False): + """ + Returns the message to display in the user_alert div + depending on the student answer + """ + result = "" + if not self._word_count_valid(): + result = self._get_invalid_word_count_message(ignore_attempts) + return result + + def _can_submit(self): + """ + Determine if a user may submit a response + """ + if self.is_past_due(): + return False + if not self.max_attempts: + return True + if self.count_attempts < self.max_attempts: + return True + return False + + def _generate_validation_message(self, text): + """ + Helper method to generate a ValidationMessage from + the supplied string + """ + result = ValidationMessage(ValidationMessage.ERROR, self.gettext(str(text))) + return result + + def validate_field_data(self, validation, data): + """ + Validates settings entered by the instructor. + """ + if data.weight < 0: + msg = self._generate_validation_message("Weight cannot be negative") + validation.add(msg) + if data.max_attempts and data.max_attempts < 0: + msg = self._generate_validation_message("Maximum Attempts cannot be negative") + validation.add(msg) + if data.min_word_count < 1: + msg = self._generate_validation_message("Minimum Word Count cannot be less than 1") + validation.add(msg) + if data.min_word_count > data.max_word_count: + msg = self._generate_validation_message("Minimum Word Count cannot be greater than Max Word Count") + validation.add(msg) + if not data.submitted_message: + msg = self._generate_validation_message("Submission Received Message cannot be blank") + validation.add(msg) + + +def _is_at_least_one_phrase_present(phrases, answer): + """ + Determines if at least one of the supplied phrases is + present in the given answer + """ + answer = answer.lower() + matches = [phrase.lower() in answer for phrase in phrases] + return any(matches) diff --git a/src/freetextresponse/xblocks.py b/src/freetextresponse/xblocks.py new file mode 100644 index 0000000..bdfc577 --- /dev/null +++ b/src/freetextresponse/xblocks.py @@ -0,0 +1,23 @@ +""" +This is the core logic for the XBlock +""" + +from xblock.core import XBlock + +from .mixins.scenario import XBlockWorkbenchMixin +from .mixins.user import MissingDataFetcherMixin +from .models import FreeTextResponseModelMixin +from .views import FreeTextResponseViewMixin + + +@XBlock.needs("i18n") +class FreeTextResponse( + FreeTextResponseModelMixin, + FreeTextResponseViewMixin, + MissingDataFetcherMixin, + XBlockWorkbenchMixin, + XBlock, +): + """ + XBlock to capture a free-text response. + """ diff --git a/uv.lock b/uv.lock index 4ac4c23..83e028a 100644 --- a/uv.lock +++ b/uv.lock @@ -374,6 +374,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" }, ] +[[package]] +name = "ddt" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/51/d4/bdea45c5c1f1f0ae55844d841101b00905c9863ee1004da37d911253abb2/ddt-1.7.2.tar.gz", hash = "sha256:d215d6b083963013c4a19b1e4dcd6a96e80e43ab77519597a6acfcf2e9a3e04b", size = 13673, upload-time = "2024-02-26T01:36:33.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/7c/38d1aec205833096eddefcbb3492fbb2c886e74174c72bc160da9522b2f0/ddt-1.7.2-py2.py3-none-any.whl", hash = "sha256:6adcfaf9785f0a36f9e73a89b91e412de9ef8649e289b750e3683bc79d5e2354", size = 7065, upload-time = "2024-02-26T01:36:32.45Z" }, +] + [[package]] name = "dill" version = "0.4.1" @@ -1541,8 +1550,10 @@ docs = [ ] test = [ { name = "coverage" }, + { name = "ddt" }, { name = "edx-lint" }, { name = "edx-opaque-keys" }, + { name = "lazy" }, { name = "mock" }, { name = "pytest" }, { name = "pytest-cov" }, @@ -1554,12 +1565,14 @@ test = [ requires-dist = [ { name = "build", marker = "extra == 'dev'" }, { name = "coverage", marker = "extra == 'test'" }, + { name = "ddt", marker = "extra == 'test'" }, { name = "django", specifier = ">=4.2" }, { name = "django-crum" }, { name = "edx-codejail" }, { name = "edx-i18n-tools", marker = "extra == 'dev'" }, { name = "edx-lint", marker = "extra == 'test'" }, { name = "edx-opaque-keys", marker = "extra == 'test'" }, + { name = "lazy", marker = "extra == 'test'" }, { name = "mock", marker = "extra == 'test'" }, { name = "openedx-filters" }, { name = "pytest", marker = "extra == 'test'", specifier = ">=7.0" },