Added instructions append for error handling and updated example.py, JinJa2 template, and regenerated test file.

Author: BethanyG

exercises/practice/wordy/.docs/instructions.append.md

@@ -0,0 +1,17 @@
+# Instructions append
+
+## Exception messages
+
+Sometimes it is necessary to [raise an exception](https://docs.python.org/3/tutorial/errors.html#raising-exceptions). When you do this, you should always include a **meaningful error message** to indicate what the source of the error is. This makes your code more readable and helps significantly with debugging. For situations where you know that the error source will be a certain type, you can choose to raise one of the [built in error types](https://docs.python.org/3/library/exceptions.html#base-classes), but should still include a meaningful message.
+
+This particular exercise requires that you use the [raise statement](https://docs.python.org/3/reference/simple_stmts.html#the-raise-statement) to "throw" a `ValueError` if the question passed to `answer()` is malformed/invalid, or contains an unknown operation. The tests will only pass if you both `raise` the `exception` and include a message with it.
+
+To raise a `ValueError` with a message, write the message as an argument to the `exception` type:
+
+```python
+# if the question contains an unknown operation.
+raise ValueError("unknown operation")
+
+# if the question is malformed or invalid.
+raise ValueError("syntax error")
+```

exercises/practice/wordy/.meta/example.py

@@ -1,27 +1,27 @@
-import sys
 from operator import add, mul, sub
-
-if sys.version_info[0] == 2:
-    from operator import div
-else:
-    from operator import floordiv as div
+from operator import floordiv as div
 
 
 VALID_OPERATIONS = {"plus": add, "minus": sub,
                     "multiplied by": mul, "divided by": div}
 
 
 def answer(question):
-    if not (question.startswith("What is ") and question.endswith("?")):
-        raise ValueError("Ill-formed question")
-    words = question[8:-1].strip().lower().split()
-    if not words:
-        raise ValueError("Ill-formed question")
-    words.reverse()
+    if not bool(question[8:-1].strip().lower().split()):
+        raise ValueError("syntax error")
+
+    elif not question.startswith("What is "):
+        raise ValueError("unknown operation")
+
+    else:
+        words = question[8:-1].strip().lower().split()
+        words.reverse()
+
     try:
         main_value = int(words.pop())
     except ValueError:
-        raise ValueError("Ill-formed question")
+        raise ValueError("syntax error")
+
     while words:
         operation = [words.pop()]
         while words:
@@ -30,12 +30,21 @@ def answer(question):
                 second_value = int(next_to_evaluate)
                 break
             except ValueError:
-                operation.append(next_to_evaluate)
+                if next_to_evaluate == operation[-1]:
+                    raise ValueError("syntax error")
+                else:
+                    operation.append(next_to_evaluate)
         else:
-            raise ValueError("Ill-formed question")
+            if operation[-1] not in VALID_OPERATIONS and not operation[-1].isdigit() :
+                raise ValueError("unknown operation")
+            else:
+                raise ValueError("syntax error")
+
         operation = " ".join(operation)
+
         try:
             main_value = VALID_OPERATIONS[operation](main_value, second_value)
         except KeyError:
-            raise ValueError("Ill-formed question")
+            raise ValueError("unknown operation")
+
     return main_value

exercises/practice/wordy/.meta/template.j2

@@ -3,8 +3,10 @@
     def test_{{ case["description"] | to_snake }}(self):
         {%- set question = case["input"]["question"] %}
         {%- if case is error_case %}
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             {{ case["property"] }}("{{ question }}")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "{{ case["expected"]["error"] }}")
         {%- else %}
         self.assertEqual({{ case["property"] }}("{{ question }}"), {{ case["expected"] }})
         {%- endif %}
@@ -23,6 +25,3 @@ class {{ exercise | camel_case }}Test(unittest.TestCase):
     {{ test_case(case) }}
     {% endfor %}
     {%- endif %}
-
-
-{{ macros.footer() }}

exercises/practice/wordy/wordy_test.py

@@ -54,51 +54,63 @@ def test_multiple_division(self):
         self.assertEqual(answer("What is -12 divided by 2 divided by -3?"), 2)
 
     def test_unknown_operation(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is 52 cubed?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "unknown operation")
 
     def test_non_math_question(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("Who is the President of the United States?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "unknown operation")
 
     def test_reject_problem_missing_an_operand(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is 1 plus?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "syntax error")
 
     def test_reject_problem_with_no_operands_or_operators(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "syntax error")
 
     def test_reject_two_operations_in_a_row(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is 1 plus plus 2?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "syntax error")
 
     def test_reject_two_numbers_in_a_row(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is 1 plus 2 1?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "syntax error")
 
     def test_reject_postfix_notation(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is 1 2 plus?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "syntax error")
 
     def test_reject_prefix_notation(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is plus 1 2?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "syntax error")
 
     # Additional tests for this track
 
     def test_missing_operation(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is 2 2 minus 3?")
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "unknown operation")
 
     def test_missing_number(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             answer("What is 7 plus multiplied by -2?")
-
-    # Utility functions
-    def assertRaisesWithMessage(self, exception):
-        return self.assertRaisesRegex(exception, r".+")
-
-
-if __name__ == "__main__":
-    unittest.main()
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "unknown operation")