diffie-hellman: add test template (exercism#2203)

pyropy · cmccandless · web-flow · commit b4bc89aebc7b · 2020-05-28T11:18:13.000-04:00
Co-authored-by: Corey McCandless &lt;cmccandless@users.noreply.github.com&gt;
diff --git a/bin/generate_tests.py b/bin/generate_tests.py
@@ -59,13 +59,16 @@ def replace_all(string, chars, rep):
     )
 
 
-def to_snake(string):
+def to_snake(string, wordchars_only=False):
     """
     Convert pretty much anything to to_snake.
+
+    By default whitespace and punctuation will be converted
+    to underscores as well, pass wordchars_only=True to preserve these as is.
     """
     clean = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", string)
     clean = re.sub("([a-z0-9])([A-Z])", r"\1_\2", clean).lower()
-    return replace_all(clean, whitespace + punctuation, "_")
+    return clean if wordchars_only else replace_all(clean, whitespace + punctuation, "_")
 
 
 def camel_case(string):
diff --git a/exercises/diffie-hellman/.meta/template.j2 b/exercises/diffie-hellman/.meta/template.j2
@@ -0,0 +1,37 @@
+{%- import "generator_macros.j2" as macros with context -%}
+{% set class = exercise | camel_case -%}
+{{ macros.header(["private_key", "public_key", "secret"]) }}
+
+class {{ exercise | camel_case }}Test(unittest.TestCase):
+    {% for case in cases -%}
+    {% set property = case["property"] | to_snake -%}
+    {% set description = case["description"] | to_snake -%}
+    {% set expected = case['expected'] %}
+    {% set input = case['input'] %}
+    def test_{{ description }}(self):
+    {%- if property == "private_key_is_in_range" %}
+        primes = [5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
+        for p in primes:
+            self.assertTrue(1 < private_key(p) < p)
+    {%- elif property == "private_key_is_random" %}
+        """
+        Can fail due to randomness, but most likely will not,
+        due to pseudo-randomness and the large number chosen
+        """
+        p = 2147483647
+        private_keys = [private_key(p) for _ in range(5)]
+        self.assertEqual(len(set(private_keys)), len(private_keys))
+    {%- elif property == "key_exchange" %}
+        {% for key, val in input.items() -%}
+            {{ key | to_snake }} = {{ val | string | to_snake(wordchars_only=True) }}
+        {% endfor -%}
+        self.assertTrue({{ expected | to_snake(wordchars_only=True) }})
+    {%-  else %}
+        {% for key, val in input.items() -%}
+            {{ key | to_snake }} = {{ val }}
+        {% endfor -%}
+        self.assertEqual({{ expected }}, {{ property }}({% for key in input.keys() %}{{ key | to_snake }},{% endfor %}))
+    {%- endif -%}
+    {% endfor %}
+
+{{ macros.footer() }}
diff --git a/exercises/diffie-hellman/diffie_hellman_test.py b/exercises/diffie-hellman/diffie_hellman_test.py
@@ -1,56 +1,48 @@
 import unittest
 
-import diffie_hellman
-
+from diffie_hellman import private_key, public_key, secret
 
 # Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
-class DiffieHellmanTest(unittest.TestCase):
 
-    def test_private_key_is_in_range(self):
+class DiffieHellmanTest(unittest.TestCase):
+    def test_private_key_is_in_range_1_p(self):
         primes = [5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
-        for i in primes:
-            self.assertTrue(1 < diffie_hellman.private_key(i) < i)
+        for p in primes:
+            self.assertTrue(1 < private_key(p) < p)
 
-    # Can fail due to randomness, but most likely will not,
-    # due to pseudo-randomness and the large number chosen
     def test_private_key_is_random(self):
+        """
+        Can fail due to randomness, but most likely will not,
+        due to pseudo-randomness and the large number chosen
+        """
         p = 2147483647
-        private_keys = []
-        for i in range(5):
-            private_keys.append(diffie_hellman.private_key(p))
+        private_keys = [private_key(p) for _ in range(5)]
         self.assertEqual(len(set(private_keys)), len(private_keys))
 
     def test_can_calculate_public_key_using_private_key(self):
         p = 23
         g = 5
-        private = 6
-        expected = 8
-
-        actual = diffie_hellman.public_key(p, g, private)
-        self.assertEqual(actual, expected)
+        private_key = 6
+        self.assertEqual(8, public_key(p, g, private_key))
 
     def test_can_calculate_secret_using_other_party_s_public_key(self):
         p = 23
-        public = 19
-        private = 6
-        expected = 2
-
-        actual = diffie_hellman.secret(p, public, private)
-        self.assertEqual(actual, expected)
+        their_public_key = 19
+        my_private_key = 6
+        self.assertEqual(2, secret(p, their_public_key, my_private_key))
 
     def test_key_exchange(self):
         p = 23
         g = 5
-        alice_private_key = diffie_hellman.private_key(p)
-        bob_private_key = diffie_hellman.private_key(p)
-        alice_public_key = diffie_hellman.public_key(p, g, alice_private_key)
-        bob_public_key = diffie_hellman.public_key(p, g, bob_private_key)
-        secret_a = diffie_hellman.secret(p, bob_public_key, alice_private_key)
-        secret_b = diffie_hellman.secret(p, alice_public_key, bob_private_key)
-
-        self.assertEqual(secret_a, secret_b)
+        alice_private_key = private_key(p)
+        bob_private_key = private_key(p)
+        alice_public_key = public_key(p, g, alice_private_key)
+        bob_public_key = public_key(p, g, bob_private_key)
+        secret_a = secret(p, bob_public_key, alice_private_key)
+        secret_b = secret(p, alice_public_key, bob_private_key)
+        self.assertTrue(secret_a == secret_b)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
