Added error handling instruction append, added additional test cases, corrected JinJa2 template, and regenerated test cases.

Author: BethanyG

exercises/practice/palindrome-products/.docs/instructions.append.md

@@ -1,9 +1,25 @@
-# Notes regarding the implementation of `smallest` and `largest`:
+# Instructions append
+
+## Notes regarding the implementation of `smallest` and `largest`:
 
 Both functions must take two keyword arguments:
 - `max_factor`: int
 - `min_factor`: int, default 0
 
-Their return value must be a tuple (value, factors) where value is the
-palindrome itself, and factors is an iterable containing both factors of the
-palindrome in arbitrary order.
+Their return value must be a `tuple -- (value, factors)` where `value` is the
+palindrome itself, and `factors` is an `iterable` containing both factors of the
+palindrome in arbitrary order.
+
+
+## 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` when the `largest()` or `smallest()` function receives a pair of factors that are not in the correct range. 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 max_factor is less than the min_factor
+raise ValueError("min must be <= max")
+```

exercises/practice/palindrome-products/.meta/example.py

@@ -1,16 +1,13 @@
-from __future__ import division
 from itertools import chain
 from math import log10, floor, ceil
 
 
 def largest(min_factor, max_factor):
-    return get_extreme_palindrome_with_factors(max_factor, min_factor,
-                                               "largest")
+    return get_extreme_palindrome_with_factors(max_factor, min_factor, "largest")
 
 
 def smallest(max_factor, min_factor):
-    return get_extreme_palindrome_with_factors(max_factor, min_factor,
-                                               "smallest")
+    return get_extreme_palindrome_with_factors(max_factor, min_factor, "smallest")
 
 
 def get_extreme_palindrome_with_factors(max_factor, min_factor, extreme):
@@ -53,10 +50,7 @@ def palindromes(max_factor, min_factor, reverse=False):
     most of the palindromes just to find the one it needs.
     """
     if max_factor < min_factor:
-        raise ValueError("invalid input: min is {min_factor} "
-                         "and max is {max_factor}"
-                         .format(min_factor=min_factor,
-                                 max_factor=max_factor))
+        raise ValueError("min must be <= max")
 
     minimum = min_factor ** 2
     maximum = max_factor ** 2

exercises/practice/palindrome-products/.meta/template.j2

@@ -9,8 +9,10 @@
     {%- set expected = case["expected"] -%}
     def test_{{ case["description"] | to_snake }}(self):
     {%- if case is error_case %}
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             {{ value_factor_unpacking(case) }}
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "{{ case["expected"]["error"] }}")
     {%- else %}
         {{ value_factor_unpacking(case) }}
         {%- if expected["value"] is none %}
@@ -31,5 +33,3 @@ class {{ exercise | camel_case }}Test(unittest.TestCase):
 
     def assertFactorsEqual(self, actual, expected):
         self.assertEqual(set(map(frozenset, actual)), set(map(frozenset, expected)))
-
-{{ macros.footer() }}

exercises/practice/palindrome-products/palindrome_products.py

@@ -1,6 +1,24 @@
 def largest(min_factor, max_factor):
+    """Given a range of numbers, find the largest palindromes which
+       are products of two numbers within that range.
+
+    :param min_factor: int with a default value of 0
+    :param max_factor: int
+    :return: tuple of (palindrome, iterable).
+             Iterable should contain both factors of the palindrome in an arbitrary order.
+    """
+
     pass
 
 
 def smallest(min_factor, max_factor):
+    """Given a range of numbers, find the smallest palindromes which
+    are products of two numbers within that range.
+
+    :param min_factor: int with a default value of 0
+    :param max_factor: int
+    :return: tuple of (palindrome, iterable).
+    Iterable should contain both factors of the palindrome in an arbitrary order.
+    """
+
     pass

exercises/practice/palindrome-products/palindrome_products_test.py

@@ -60,20 +60,16 @@ def test_empty_result_for_largest_if_no_palindrome_in_the_range(self):
         self.assertFactorsEqual(factors, [])
 
     def test_error_result_for_smallest_if_min_is_more_than_max(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             value, factors = smallest(min_factor=10000, max_factor=1)
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "min must be <= max")
 
     def test_error_result_for_largest_if_min_is_more_than_max(self):
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             value, factors = largest(min_factor=2, max_factor=1)
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "min must be <= max")
 
     def assertFactorsEqual(self, actual, expected):
         self.assertEqual(set(map(frozenset, actual)), set(map(frozenset, expected)))
-
-    # Utility functions
-    def assertRaisesWithMessage(self, exception):
-        return self.assertRaisesRegex(exception, r".+")
-
-
-if __name__ == "__main__":
-    unittest.main()