Added instructions append for error handling and updated exemplar, stub, and test files.

Author: BethanyG

exercises/practice/tree-building/.docs/instructions.append.md

@@ -0,0 +1,7 @@
+# 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 refactor how/where the [raise statement](https://docs.python.org/3/reference/simple_stmts.html#the-raise-statement) is used to "throw" a `ValueError` for invalid tree input. The tests will only pass if the code both `raise`s the appropriate `exception` and includes an appropriate message with it.

exercises/practice/tree-building/.meta/example.py

@@ -15,15 +15,17 @@ def __init__(self, node_id):
 
 def validateRecord(record):
     if record.equal_id() and record.record_id != 0:
-        raise ValueError("Only root should have equal record and parent id")
-    elif not record.equal_id() and record.parent_id >= record.record_id:
-        raise ValueError("Node record_id should be smaller than its parent_id")
+        raise ValueError("Only root should have equal record and parent id.")
+
+    if not record.equal_id() and record.parent_id >= record.record_id:
+        raise ValueError("Node record_id should be smaller than it's parent_id.")
 
 
 def BuildTree(records):
     parent_dict = {}
     node_dict = {}
     ordered_id = sorted((i.record_id for i in records))
+
     for record in records:
         validateRecord(record)
         parent_dict[record.record_id] = record.parent_id
@@ -34,7 +36,8 @@ def BuildTree(records):
 
     for index, record_id in enumerate(ordered_id):
         if index != record_id:
-            raise ValueError("Record id is invalid or out of order")
+            raise ValueError("Record id is invalid or out of order.")
+
         if record_id == root_id:
             root = node_dict[record_id]
         else:

exercises/practice/tree-building/tree_building.py

@@ -16,22 +16,22 @@ def BuildTree(records):
     ordered_id = [i.record_id for i in records]
     if records:
         if ordered_id[-1] != len(ordered_id) - 1:
-            raise ValueError('Tree must be continuous')
+            raise ValueError('broken tree')
         if ordered_id[0] != 0:
-            raise ValueError('Tree must start with id 0')
+            raise ValueError('invalid')
     trees = []
     parent = {}
     for i in range(len(ordered_id)):
         for j in records:
             if ordered_id[i] == j.record_id:
                 if j.record_id == 0:
                     if j.parent_id != 0:
-                        raise ValueError('Root node cannot have a parent')
+                        raise ValueError('error!')
                 if j.record_id < j.parent_id:
-                    raise ValueError('Parent id must be lower than child id')
+                    raise ValueError('something went wrong!')
                 if j.record_id == j.parent_id:
                     if j.record_id != 0:
-                        raise ValueError('Tree is a cycle')
+                        raise ValueError('error!')
                 trees.append(Node(ordered_id[i]))
     for i in range(len(ordered_id)):
         for j in trees:

exercises/practice/tree-building/tree_building_test.py

@@ -108,17 +108,21 @@ def test_root_node_has_parent(self):
             Record(1, 0)
         ]
         # Root parent_id should be equal to record_id(0)
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             BuildTree(records)
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "Node record_id should be smaller than it's parent_id.")
 
     def test_no_root_node(self):
         records = [
             Record(1, 0),
             Record(2, 0)
         ]
         # Record with record_id 0 (root) is missing
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             BuildTree(records)
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "Record id is invalid or out of order.")
 
     def test_non_continuous(self):
         records = [
@@ -128,8 +132,10 @@ def test_non_continuous(self):
             Record(0, 0)
         ]
         # Record with record_id 3 is missing
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             BuildTree(records)
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "Record id is invalid or out of order.")
 
     def test_cycle_directly(self):
         records = [
@@ -142,8 +148,10 @@ def test_cycle_directly(self):
             Record(6, 3)
         ]
         # Cycle caused by Record 2 with parent_id pointing to itself
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             BuildTree(records)
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "Only root should have equal record and parent id.")
 
     def test_cycle_indirectly(self):
         records = [
@@ -156,8 +164,10 @@ def test_cycle_indirectly(self):
             Record(6, 3)
         ]
         # Cycle caused by Record 2 with parent_id(6) greater than record_id(2)
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             BuildTree(records)
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "Node record_id should be smaller than it's parent_id.")
 
     def test_higher_id_parent_of_lower_id(self):
         records = [
@@ -166,8 +176,10 @@ def test_higher_id_parent_of_lower_id(self):
             Record(1, 2)
         ]
         # Record 1 have parent_id(2) greater than record_id(1)
-        with self.assertRaisesWithMessage(ValueError):
+        with self.assertRaises(ValueError) as err:
             BuildTree(records)
+        self.assertEqual(type(err.exception), ValueError)
+        self.assertEqual(err.exception.args[0], "Node record_id should be smaller than it's parent_id.")
 
     def assert_node_is_branch(self, node, node_id, children_count):
         self.assertEqual(node.node_id, node_id)
@@ -177,11 +189,3 @@ def assert_node_is_branch(self, node, node_id, children_count):
     def assert_node_is_leaf(self, node, node_id):
         self.assertEqual(node.node_id, node_id)
         self.assertEqual(len(node.children), 0)
-
-    # Utility functions
-    def assertRaisesWithMessage(self, exception):
-        return self.assertRaisesRegex(exception, r".+")
-
-
-if __name__ == '__main__':
-    unittest.main()