Enable high-scores "after" tests with a test helper

exercises/practice/high-scores/.meta/example.py

@@ -1,11 +1,12 @@
+class HighScores:
+    def __init__(self, scores):
+        self.scores = scores
 
-def latest(scores):
-    return scores[-1]
+    def latest(self):
+        return self.scores[-1]
 
+    def personal_best(self):
+        return max(self.scores)
 
-def personal_best(scores):
-    return max(scores)
-
-
-def personal_top_three(scores):
-    return sorted(scores, reverse=True)[:3]
+    def personal_top_three(self):
+        return sorted(self.scores, reverse=True)[:3]

exercises/practice/high-scores/.meta/template.j2

@@ -3,15 +3,25 @@
     def test_{{ case["description"] | to_snake }}(self):
         scores = {{ case["input"]["scores"] }}
         expected = {{ case["expected"] }}
-        self.assertEqual({{ case["property"] | to_snake }}(scores), expected)
+        {%- if "latest_after_" not in ( case["property"] | to_snake ) %}
+        self.assertEqual(HighScores(scores).{{ case["property"] | to_snake }}(), expected)
+        {%- else %}
+        highscores = HighScores(scores)
+        highscores.{{ case["property"] | to_snake | replace("latest_after_", "personal_") }}()
+        self.assertEqual(highscores.latest(), expected)
+        {% endif -%}
 {% endmacro -%}
-{{ macros.header(ignore=["scores"]) }}
+
+{{ macros.header(["HighScores"]) }}
+
 
 class {{ exercise | camel_case }}Test(unittest.TestCase):
     {%- for case in cases -%}
     {%- if "cases" in case -%}
     {%- for subcase in case["cases"] -%}
+    {%- if "scores_after_" not in ( subcase["property"] | to_snake ) %}
     {{- testcase(subcase) -}}
+    {% endif -%}
     {% endfor %}
     {%- else %}
     {%- if case["property"] != "scores" %}

exercises/practice/high-scores/.meta/tests.toml

@@ -35,8 +35,6 @@ description = "Top 3 scores -> Personal top when there is only one"
 
 [2df075f9-fec9-4756-8f40-98c52a11504f]
 description = "Top 3 scores -> Latest score after personal top scores"
-include = false
 
 [809c4058-7eb1-4206-b01e-79238b9b71bc]
 description = "Top 3 scores -> Scores after personal top scores"
-include = false

exercises/practice/high-scores/high_scores.py

@@ -1,10 +1,3 @@
-def latest(scores):
-    pass
-
-
-def personal_best(scores):
-    pass
-
-
-def personal_top_three(scores):
-    pass
+class HighScores:
+    def __init__(self, scores):
+        pass

exercises/practice/high-scores/high_scores_test.py

@@ -1,9 +1,7 @@
 import unittest
 
 from high_scores import (
-    latest,
-    personal_best,
-    personal_top_three,
+    HighScores,
 )
 
 # Tests adapted from `problem-specifications//canonical-data.json`
@@ -13,34 +11,41 @@ class HighScoresTest(unittest.TestCase):
     def test_latest_score(self):
         scores = [100, 0, 90, 30]
         expected = 30
-        self.assertEqual(latest(scores), expected)
+        self.assertEqual(HighScores(scores).latest(), expected)
 
     def test_personal_best(self):
         scores = [40, 100, 70]
         expected = 100
-        self.assertEqual(personal_best(scores), expected)
+        self.assertEqual(HighScores(scores).personal_best(), expected)
 
     def test_personal_top_three_from_a_list_of_scores(self):
         scores = [10, 30, 90, 30, 100, 20, 10, 0, 30, 40, 40, 70, 70]
         expected = [100, 90, 70]
-        self.assertEqual(personal_top_three(scores), expected)
+        self.assertEqual(HighScores(scores).personal_top_three(), expected)
 
     def test_personal_top_highest_to_lowest(self):
         scores = [20, 10, 30]
         expected = [30, 20, 10]
-        self.assertEqual(personal_top_three(scores), expected)
+        self.assertEqual(HighScores(scores).personal_top_three(), expected)
 
     def test_personal_top_when_there_is_a_tie(self):
         scores = [40, 20, 40, 30]
         expected = [40, 40, 30]
-        self.assertEqual(personal_top_three(scores), expected)
+        self.assertEqual(HighScores(scores).personal_top_three(), expected)
 
     def test_personal_top_when_there_are_less_than_3(self):
         scores = [30, 70]
         expected = [70, 30]
-        self.assertEqual(personal_top_three(scores), expected)
+        self.assertEqual(HighScores(scores).personal_top_three(), expected)
 
     def test_personal_top_when_there_is_only_one(self):
         scores = [40]
         expected = [40]
-        self.assertEqual(personal_top_three(scores), expected)
+        self.assertEqual(HighScores(scores).personal_top_three(), expected)
+
+    def test_latest_score_after_personal_top_scores(self):
+        scores = [70, 50, 20, 30]
+        expected = 30
+        highscores = HighScores(scores)
+        highscores.personal_top_three()
+        self.assertEqual(highscores.latest(), expected)