implement keypad size

test/test_nkode_api.py

@@ -1,6 +1,6 @@
 import pytest
 from nkode_api import NKodeAPI
-from src.models import NKodePolicy
+from src.models import NKodePolicy, KeypadSize
 
 
 @pytest.fixture()
@@ -8,17 +8,17 @@ def nkode_api() -> NKodeAPI:
     return NKodeAPI()
 
 
-@pytest.mark.parametrize("numb_of_keys,attrs_per_key,user_passcode", [
-    (10, 7, [3, 10, 27, 68]),
-    (12, 6, [3, 10, 27, 68, 32]),
+@pytest.mark.parametrize("keypad_size,user_passcode", [
+    (KeypadSize(numb_of_keys=10, attrs_per_key=7), [3, 10, 27, 68]),
+    (KeypadSize(numb_of_keys=10, attrs_per_key=7), [3, 10, 27, 68, 32]),
 ])
-def test_create_new_user_and_renew_keys(nkode_api, numb_of_keys, attrs_per_key, user_passcode):
+def test_create_new_user_and_renew_keys(nkode_api, keypad_size, user_passcode):
     username = "test_username"
     nkode_policy = NKodePolicy()  # default policy
-    customer_id = nkode_api.create_new_customer(numb_of_keys, attrs_per_key, nkode_policy)
+    customer_id = nkode_api.create_new_customer(keypad_size, nkode_policy)
     session_id, set_interface = nkode_api.generate_index_interface(customer_id)
 
-    key_selection = lambda interface: [interface.index(attr) // attrs_per_key for attr in user_passcode]
+    key_selection = lambda interface: [interface.index(attr) // keypad_size.attrs_per_key for attr in user_passcode]
     set_key_selection = key_selection(set_interface)
 
     confirm_interface = nkode_api.set_nkode(username, customer_id, set_key_selection, session_id)

test/test_nkode_interface.py

@@ -1,14 +1,15 @@
 import pytest
 from src.user_interface import UserInterface
+from src.models import KeypadSize
 
 
 @pytest.mark.parametrize(
-    "numb_of_keys,attrs_per_key",
-    [(10, 7,)]
+    "keypad_size",
+    [KeypadSize(numb_of_keys=10, attrs_per_key=7)]
 )
-def test_attr_set_idx(numb_of_keys, attrs_per_key):
-    user_interface = UserInterface.new(attrs_per_key, numb_of_keys)
+def test_attr_set_idx(keypad_size):
+    user_interface = UserInterface.new(keypad_size)
     for attr_idx in range(70):
         user_interface_idx = user_interface.attr_indices[attr_idx]
 
-        assert (attr_idx % attrs_per_key == user_interface_idx % attrs_per_key)
+        assert (attr_idx % keypad_size.attrs_per_key == user_interface_idx % keypad_size.attrs_per_key)

test/test_user_cipher_keys.py

@@ -1,4 +1,6 @@
 import pytest
+
+from src.models import KeypadSize
 from src.user_cipher_keys import UserCipherKeys, CustomerInterface
 from src.utils import generate_random_nonrepeating_list
 
@@ -18,20 +20,20 @@ def test_encode_decode_base64(passcode_len):
 
 
 @pytest.mark.parametrize(
-    "numb_of_keys,attrs_per_key,max_nkode_len",
+    "keypad_size,max_nkode_len",
     [
-        (10, 7, 10),
-        (9, 7, 10),
-        (8, 7, 12),
+        (KeypadSize(numb_of_keys=10, attrs_per_key=7), 10),
+        (KeypadSize(numb_of_keys=9, attrs_per_key=7), 10),
+        (KeypadSize(numb_of_keys=8, attrs_per_key=7), 12),
     ])
-def test_decode_mask(numb_of_keys, attrs_per_key, max_nkode_len):
-    customer = CustomerInterface.new(numb_of_keys, attrs_per_key)
+def test_decode_mask(keypad_size, max_nkode_len):
+    customer = CustomerInterface.new(keypad_size)
     passcode_entry = generate_random_nonrepeating_list(
-        numb_of_keys * attrs_per_key,
-        max_val=(numb_of_keys*attrs_per_key))[:4]
+        keypad_size.numb_of_attrs,
+        max_val=keypad_size.numb_of_attrs)[:4]
     passcode_values = [customer.attr_vals[idx] for idx in passcode_entry]
     set_vals = customer.set_vals
-    user_keys = UserCipherKeys.new(numb_of_keys, attrs_per_key, set_vals, max_nkode_len)
+    user_keys = UserCipherKeys.new(keypad_size, set_vals, max_nkode_len)
     passcode = user_keys.encipher_nkode(passcode_entry, customer)
 
     orig_passcode_set_vals = [customer.get_attr_set_val(attr) for attr in passcode_values]

test/test_user_interface.py

@@ -1,10 +1,11 @@
 import pytest
 from src.user_interface import UserInterface
+from src.models import KeypadSize
 
 
 @pytest.fixture()
 def user_interface():
-    return UserInterface.new(7, 10)
+    return UserInterface.new(keypad_size=KeypadSize(attrs_per_key=7, numb_of_keys=10))
 
 
 def test_dispersion(user_interface):