Removed nesting from Jinja templates and re-generated test files.

exercises/practice/acronym/.meta/template.j2

@@ -10,9 +10,7 @@
 {{ macros.header()}}
 
 class {{ exercise | camel_case }}Test(unittest.TestCase):
-    {% for supercase in cases %}{% for case in supercase["cases"] -%}
+    {% for case in cases %}
     {{ test_case(case) }}
-    {% endfor %}{% endfor %}
-
-
-{{ macros.footer(True)}}
+    {% endfor %}
+{{ macros.footer() }}

exercises/practice/acronym/acronym_test.py

@@ -8,10 +8,37 @@
 
 
 class AcronymTest(unittest.TestCase):
+    def test_basic(self):
+        self.assertEqual(abbreviate("Portable Network Graphics"), "PNG")
 
-    # Utility functions
-    def assertRaisesWithMessage(self, exception):
-        return self.assertRaisesRegex(exception, r".+")
+    def test_lowercase_words(self):
+        self.assertEqual(abbreviate("Ruby on Rails"), "ROR")
+
+    def test_punctuation(self):
+        self.assertEqual(abbreviate("First In, First Out"), "FIFO")
+
+    def test_all_caps_word(self):
+        self.assertEqual(abbreviate("GNU Image Manipulation Program"), "GIMP")
+
+    def test_punctuation_without_whitespace(self):
+        self.assertEqual(abbreviate("Complementary metal-oxide semiconductor"), "CMOS")
+
+    def test_very_long_abbreviation(self):
+        self.assertEqual(
+            abbreviate(
+                "Rolling On The Floor Laughing So Hard That My Dogs Came Over And Licked Me"
+            ),
+            "ROTFLSHTMDCOALM",
+        )
+
+    def test_consecutive_delimiters(self):
+        self.assertEqual(abbreviate("Something - I made up from thin air"), "SIMUFTA")
+
+    def test_apostrophes(self):
+        self.assertEqual(abbreviate("Halley's Comet"), "HC")
+
+    def test_underscore_emphasis(self):
+        self.assertEqual(abbreviate("The Road _Not_ Taken"), "TRNT")
 
 
 if __name__ == "__main__":

exercises/practice/alphametics/.meta/template.j2

@@ -2,7 +2,7 @@
 {{ macros.header() }}
 
 class {{ exercise | camel_case }}Test(unittest.TestCase):
-    {% for case in cases[0]["cases"] -%}
+    {% for case in cases -%}
     {% set description = case["description"] | to_snake -%}
     {% set testdef = "def test_" ~ description ~ "(self):" -%}
     {% set value = case["input"]["puzzle"] -%}
@@ -30,4 +30,4 @@ class {{ exercise | camel_case }}Test(unittest.TestCase):
         {% endif %}
     {% endfor %}
 
-{{ macros.footer(True)}}
+{{ macros.footer()}}

exercises/practice/alphametics/alphametics_test.py

@@ -8,10 +8,104 @@
 
 
 class AlphameticsTest(unittest.TestCase):
+    def test_puzzle_with_three_letters(self):
+        self.assertEqual(solve("I + BB == ILL"), {"I": 1, "B": 9, "L": 0})
 
-    # Utility functions
-    def assertRaisesWithMessage(self, exception):
-        return self.assertRaisesRegex(exception, r".+")
+    def test_solution_must_have_unique_value_for_each_letter(self):
+        self.assertEqual(solve("A == B"), None)
+
+    def test_leading_zero_solution_is_invalid(self):
+        self.assertEqual(solve("ACA + DD == BD"), None)
+
+    def test_puzzle_with_two_digits_final_carry(self):
+        self.assertEqual(
+            solve("A + A + A + A + A + A + A + A + A + A + A + B == BCC"),
+            {"A": 9, "B": 1, "C": 0},
+        )
+
+    def test_puzzle_with_four_letters(self):
+        self.assertEqual(solve("AS + A == MOM"), {"A": 9, "S": 2, "M": 1, "O": 0})
+
+    def test_puzzle_with_six_letters(self):
+        self.assertEqual(
+            solve("NO + NO + TOO == LATE"),
+            {"N": 7, "O": 4, "T": 9, "L": 1, "A": 0, "E": 2},
+        )
+
+    def test_puzzle_with_seven_letters(self):
+        self.assertEqual(
+            solve("HE + SEES + THE == LIGHT"),
+            {"E": 4, "G": 2, "H": 5, "I": 0, "L": 1, "S": 9, "T": 7},
+        )
+
+    def test_puzzle_with_eight_letters(self):
+        self.assertEqual(
+            solve("SEND + MORE == MONEY"),
+            {"S": 9, "E": 5, "N": 6, "D": 7, "M": 1, "O": 0, "R": 8, "Y": 2},
+        )
+
+    def test_puzzle_with_ten_letters(self):
+        self.assertEqual(
+            solve("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"),
+            {
+                "A": 5,
+                "D": 3,
+                "E": 4,
+                "F": 7,
+                "G": 8,
+                "N": 0,
+                "O": 2,
+                "R": 1,
+                "S": 6,
+                "T": 9,
+            },
+        )
+
+    # See https://github.com/exercism/python/pull/1358
+    @unittest.skip("extra-credit")
+    def test_puzzle_with_ten_letters_and_199_addends(self):
+        """This test may take a long time to run. Please be patient when running it."""
+        puzzle = (
+            "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + TELL"
+            "+ A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS + A + LIE +"
+            "THE + TALE + OF + THE + LAST + FIRE + HORSES + LATE + AFTER +"
+            "THE + FIRST + FATHERS + FORESEE + THE + HORRORS + THE + LAST +"
+            "FREE + TROLL + TERRIFIES + THE + HORSES + OF + FIRE + THE +"
+            "TROLL + RESTS + AT + THE + HOLE + OF + LOSSES + IT + IS +"
+            "THERE + THAT + SHE + STORES + ROLES + OF + LEATHERS + AFTER +"
+            "SHE + SATISFIES + HER + HATE + OFF + THOSE + FEARS + A + TASTE"
+            "+ RISES + AS + SHE + HEARS + THE + LEAST + FAR + HORSE + THOSE"
+            "+ FAST + HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE +"
+            "OFF + TO + THE + FOREST + THE + HORSES + THAT + ALERTS + RAISE"
+            "+ THE + STARES + OF + THE + OTHERS + AS + THE + TROLL +"
+            "ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR + HOOF"
+            "+ OFF + TORSO + AS + THE + LAST + HORSE + FORFEITS + ITS +"
+            "LIFE + THE + FIRST + FATHERS + HEAR + OF + THE + HORRORS +"
+            "THEIR + FEARS + THAT + THE + FIRES + FOR + THEIR + FEASTS +"
+            "ARREST + AS + THE + FIRST + FATHERS + RESETTLE + THE + LAST +"
+            "OF + THE + FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE"
+            "+ FOREST + HEART + FREE + AT + LAST + OF + THE + LAST + TROLL"
+            "+ ALL + OFFER + THEIR + FIRE + HEAT + TO + THE + ASSISTERS +"
+            "FAR + OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS +"
+            "STARS + RISE + THE + HORSES + REST + SAFE + AFTER + ALL +"
+            "SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A +"
+            "ROOFS + FOR + THEIR + SAFE == FORTRESSES"
+        )
+        self.assertEqual(
+            solve(puzzle),
+            {
+                "A": 1,
+                "E": 0,
+                "F": 5,
+                "H": 8,
+                "I": 7,
+                "L": 2,
+                "O": 6,
+                "R": 3,
+                "S": 4,
+                "T": 9,
+            },
+        )
 
 
 if __name__ == "__main__":

exercises/practice/book-store/.meta/template.j2

@@ -8,11 +8,9 @@
 {{ macros.header() }}
 
 class {{ exercise | camel_case }}Test(unittest.TestCase):
-    {% for casegroup in cases %}
-    {% for case in casegroup["cases"] -%}
+    {% for case in cases %}
     {{ test_case(case) }}
     {% endfor %}
-    {% endfor %}
 
     {% if additional_cases | length -%}
 

exercises/practice/book-store/book_store_test.py

@@ -8,6 +8,67 @@
 
 
 class BookStoreTest(unittest.TestCase):
+    def test_only_a_single_book(self):
+        basket = [1]
+        self.assertEqual(total(basket), 800)
+
+    def test_two_of_the_same_book(self):
+        basket = [2, 2]
+        self.assertEqual(total(basket), 1600)
+
+    def test_empty_basket(self):
+        basket = []
+        self.assertEqual(total(basket), 0)
+
+    def test_two_different_books(self):
+        basket = [1, 2]
+        self.assertEqual(total(basket), 1520)
+
+    def test_three_different_books(self):
+        basket = [1, 2, 3]
+        self.assertEqual(total(basket), 2160)
+
+    def test_four_different_books(self):
+        basket = [1, 2, 3, 4]
+        self.assertEqual(total(basket), 2560)
+
+    def test_five_different_books(self):
+        basket = [1, 2, 3, 4, 5]
+        self.assertEqual(total(basket), 3000)
+
+    def test_two_groups_of_four_is_cheaper_than_group_of_five_plus_group_of_three(self):
+        basket = [1, 1, 2, 2, 3, 3, 4, 5]
+        self.assertEqual(total(basket), 5120)
+
+    def test_two_groups_of_four_is_cheaper_than_groups_of_five_and_three(self):
+        basket = [1, 1, 2, 3, 4, 4, 5, 5]
+        self.assertEqual(total(basket), 5120)
+
+    def test_group_of_four_plus_group_of_two_is_cheaper_than_two_groups_of_three(self):
+        basket = [1, 1, 2, 2, 3, 4]
+        self.assertEqual(total(basket), 4080)
+
+    def test_two_each_of_first_4_books_and_1_copy_each_of_rest(self):
+        basket = [1, 1, 2, 2, 3, 3, 4, 4, 5]
+        self.assertEqual(total(basket), 5560)
+
+    def test_two_copies_of_each_book(self):
+        basket = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
+        self.assertEqual(total(basket), 6000)
+
+    def test_three_copies_of_first_book_and_2_each_of_remaining(self):
+        basket = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1]
+        self.assertEqual(total(basket), 6800)
+
+    def test_three_each_of_first_2_books_and_2_each_of_remaining_books(self):
+        basket = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2]
+        self.assertEqual(total(basket), 7520)
+
+    def test_four_groups_of_four_are_cheaper_than_two_groups_each_of_five_and_three(
+        self,
+    ):
+        basket = [1, 1, 2, 2, 3, 3, 4, 5, 1, 1, 2, 2, 3, 3, 4, 5]
+        self.assertEqual(total(basket), 10240)
 
     # Additional tests for this track
 

exercises/practice/etl/.meta/template.j2

@@ -12,9 +12,9 @@
 {{ macros.header()}}
 
 class {{ exercise | camel_case }}Test(unittest.TestCase):
-    {% for supercase in cases %}{% for case in supercase["cases"] -%}
+    {% for case in cases %}
     {{ test_case(case) }}
-    {% endfor %}{% endfor %}
+    {% endfor %}
 
 
-{{ macros.footer(True) }}
+{{ macros.footer() }}

exercises/practice/etl/etl_test.py

@@ -8,10 +8,60 @@
 
 
 class EtlTest(unittest.TestCase):
+    def test_single_letter(self):
+        legacy_data = {1: ["A"]}
+        data = {"a": 1}
+        self.assertEqual(transform(legacy_data), data)
 
-    # Utility functions
-    def assertRaisesWithMessage(self, exception):
-        return self.assertRaisesRegex(exception, r".+")
+    def test_single_score_with_multiple_letters(self):
+        legacy_data = {1: ["A", "E", "I", "O", "U"]}
+        data = {"a": 1, "e": 1, "i": 1, "o": 1, "u": 1}
+        self.assertEqual(transform(legacy_data), data)
+
+    def test_multiple_scores_with_multiple_letters(self):
+        legacy_data = {1: ["A", "E"], 2: ["D", "G"]}
+        data = {"a": 1, "d": 2, "e": 1, "g": 2}
+        self.assertEqual(transform(legacy_data), data)
+
+    def test_multiple_scores_with_differing_numbers_of_letters(self):
+        legacy_data = {
+            1: ["A", "E", "I", "O", "U", "L", "N", "R", "S", "T"],
+            2: ["D", "G"],
+            3: ["B", "C", "M", "P"],
+            4: ["F", "H", "V", "W", "Y"],
+            5: ["K"],
+            8: ["J", "X"],
+            10: ["Q", "Z"],
+        }
+        data = {
+            "a": 1,
+            "b": 3,
+            "c": 3,
+            "d": 2,
+            "e": 1,
+            "f": 4,
+            "g": 2,
+            "h": 4,
+            "i": 1,
+            "j": 8,
+            "k": 5,
+            "l": 1,
+            "m": 3,
+            "n": 1,
+            "o": 1,
+            "p": 3,
+            "q": 10,
+            "r": 1,
+            "s": 1,
+            "t": 1,
+            "u": 1,
+            "v": 4,
+            "w": 4,
+            "x": 8,
+            "y": 4,
+            "z": 10,
+        }
+        self.assertEqual(transform(legacy_data), data)
 
 
 if __name__ == "__main__":

exercises/practice/food-chain/.meta/template.j2

@@ -2,15 +2,13 @@
 {{ macros.header() }}
 
 class {{ exercise | camel_case }}Test(unittest.TestCase):
-    {% for supercase in cases %}
-        {% for case in supercase["cases"] -%}
+    {% for case in cases %}
         def test_{{ case["description"] | to_snake }}(self):
             {%- set start_verse = case["input"]["startVerse"] %}
             {%- set end_verse = case["input"]["endVerse"] %}
             {%- set expected = case["expected"] %}
             self.assertEqual({{ case["property"]}}({{start_verse}}, {{end_verse}}), {{expected}})
 
         {% endfor %}
-    {% endfor %}
 
-{{ macros.footer(True) }}
+{{ macros.footer() }}