queen-attack: add test template (#2099)

Author: beatorizu

exercises/queen-attack/.meta/additional_tests.json

@@ -0,0 +1,25 @@
+{
+  "cases": [
+    {
+      "description": "queens same position can attack",
+      "property": "canAttack",
+      "input": {
+        "white_queen": {
+          "position": {
+            "row": 2,
+            "column": 2
+          }
+        },
+        "black_queen": {
+          "position": {
+            "row": 2,
+            "column": 2
+          }
+        }
+      },
+      "expected": {
+        "error": "Invalid queen position: both queens in the same square"
+      }
+    }
+  ]
+}

exercises/queen-attack/.meta/template.j2

@@ -0,0 +1,43 @@
+{%- import "generator_macros.j2" as macros with context -%}
+{{ macros.header(imports=['Queen']) }}
+
+class {{ exercise | camel_case }}Test(unittest.TestCase):
+{% set suite_tests = cases -%}
+
+{%- macro test_case(case) -%}
+    def test_{{ case["description"] | to_snake }}(self):
+        {% if case["property"] == "canAttack" -%}
+        {% set white_queen = case["input"]["white_queen"]["position"] -%}
+        {% set black_queen = case["input"]["black_queen"]["position"] -%}
+        {% if case is error_case -%}
+        with self.assertRaisesWithMessage(ValueError):
+            Queen({{ white_queen["row"] }}, {{ white_queen["column"] }}).can_attack(Queen({{ black_queen["row"] }}, {{ black_queen["column"] }}))
+        {% else -%}
+        self.assertIs(Queen({{ white_queen["row"] }}, {{ white_queen["column"] }}).can_attack(Queen({{ black_queen["row"] }}, {{ black_queen["column"] }})), {{ case["expected"] }})
+        {% endif %}
+        {% else -%}
+        {% set queen = case["input"]["queen"]["position"] -%}
+        {% if case is error_case -%}
+        with self.assertRaisesWithMessage(ValueError):
+            Queen({{ queen["row"] }}, {{ queen["column"] }})
+        {% else -%}
+        Queen({{ queen["row"] }}, {{ queen["column"] }})
+        {% endif %}
+        {% endif %}
+{%- endmacro -%}
+
+{% for cases in suite_tests -%}
+    # {{ cases["description"] }}
+    {% for case in cases["cases"] -%}
+    {{ test_case(case) }}
+    {% endfor %}
+
+{% endfor %}
+    {% if additional_cases | length -%}
+    # Track-specific tests
+    {% for case in additional_cases -%}
+    {{ test_case(case) }}
+    {% endfor %}
+    {% endif %}
+
+{{ macros.footer() }}

exercises/queen-attack/queen_attack_test.py

@@ -2,54 +2,50 @@
 
 from queen_attack import Queen
 
-
 # Tests adapted from `problem-specifications//canonical-data.json` @ v2.3.0
 
-class QueenAttackTest(unittest.TestCase):
 
+class QueenAttackTest(unittest.TestCase):
     # Test creation of Queens with valid and invalid positions
-    def test_queen_valid_position(self):
-        try:
-            Queen(2, 2)
-        except ValueError:
-            self.fail("Unexpected Exception")
+    def test_queen_with_a_valid_position(self):
+        Queen(2, 2)
 
-    def test_queen_negative_row(self):
+    def test_queen_must_have_positive_row(self):
         with self.assertRaisesWithMessage(ValueError):
             Queen(-2, 2)
 
-    def test_queen_invalid_row(self):
+    def test_queen_must_have_row_on_board(self):
         with self.assertRaisesWithMessage(ValueError):
             Queen(8, 4)
 
-    def test_queen_negative_column(self):
+    def test_queen_must_have_positive_column(self):
         with self.assertRaisesWithMessage(ValueError):
             Queen(2, -2)
 
-    def test_queen_invalid_column(self):
+    def test_queen_must_have_column_on_board(self):
         with self.assertRaisesWithMessage(ValueError):
             Queen(4, 8)
 
     # Test the ability of one queen to attack another
-    def test_attack_false(self):
+    def test_can_not_attack(self):
         self.assertIs(Queen(2, 4).can_attack(Queen(6, 6)), False)
 
-    def test_attack_same_row(self):
+    def test_can_attack_on_same_row(self):
         self.assertIs(Queen(2, 4).can_attack(Queen(2, 6)), True)
 
-    def test_attack_same_column(self):
+    def test_can_attack_on_same_column(self):
         self.assertIs(Queen(4, 5).can_attack(Queen(2, 5)), True)
 
-    def test_attack_diagonal1(self):
+    def test_can_attack_on_first_diagonal(self):
         self.assertIs(Queen(2, 2).can_attack(Queen(0, 4)), True)
 
-    def test_attack_diagonal2(self):
+    def test_can_attack_on_second_diagonal(self):
         self.assertIs(Queen(2, 2).can_attack(Queen(3, 1)), True)
 
-    def test_attack_diagonal3(self):
+    def test_can_attack_on_third_diagonal(self):
         self.assertIs(Queen(2, 2).can_attack(Queen(1, 1)), True)
 
-    def test_attack_diagonal4(self):
+    def test_can_attack_on_fourth_diagonal(self):
         self.assertIs(Queen(1, 7).can_attack(Queen(0, 6)), True)
 
     # Track-specific tests
@@ -62,5 +58,5 @@ def assertRaisesWithMessage(self, exception):
         return self.assertRaisesRegex(exception, r".+")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()