Refactor validation code and add not-None validation

Author: saxbophone

basest/core/decode.py

@@ -5,7 +5,7 @@
 )
 
 from .encode import encode_raw
-from .utils import ints_to_symbols, symbol_table_is_unique, symbols_to_ints
+from .utils import ints_to_symbols, symbols_to_ints, validate_symbol_tables
 
 
 def decode_raw(input_base, output_base, input_ratio, output_ratio, input_data):
@@ -54,12 +54,12 @@ def decode(
     Assumes standard base64-style padding using the given input padding symbol,
     but can handle unpadded input just fine.
     """
-    # validate the uniqueness of both symbol tables before continuing
-    if (
-        (not symbol_table_is_unique(input_symbol_table, input_padding)) or
-        (not symbol_table_is_unique(output_symbol_table))
-    ):
-        raise ValueError('Unique symbol tables required')
+    # validate both symbol tables and the padding symbol before continuing
+    validate_symbol_tables(
+        input_symbol_table,
+        input_padding,
+        output_symbol_table
+    )
     # create workon copy of input data and convert symbols to raw ints
     # NOTE: input symbol table here includes the padding character
     input_workon = symbols_to_ints(

basest/core/encode.py

@@ -4,7 +4,7 @@
     absolute_import, division, print_function, unicode_literals
 )
 
-from .utils import ints_to_symbols, symbol_table_is_unique, symbols_to_ints
+from .utils import ints_to_symbols, symbols_to_ints, validate_symbol_tables
 
 
 def _nearest_length(input_length, input_ratio):
@@ -96,12 +96,12 @@ def encode(
     Uses standard base64-style padding if needed, using the given padding
     symbol.
     """
-    # validate the uniqueness of both symbol tables before continuing
-    if (
-        (not symbol_table_is_unique(input_symbol_table)) or
-        (not symbol_table_is_unique(output_symbol_table, output_padding))
-    ):
-        raise ValueError('Unique symbol tables required')
+    # validate both symbol tables and the padding symbol before continuing
+    validate_symbol_tables(
+        output_symbol_table,
+        output_padding,
+        input_symbol_table
+    )
     # create workon copy of input data and convert symbols to raw ints
     input_workon = symbols_to_ints(input_data, input_symbol_table)
     # use encode_raw() to encode the data

basest/core/utils.py

@@ -33,3 +33,21 @@ def symbol_table_is_unique(symbol_table, padding_symbol=None):
         # otherwise, check that padding_symbol isn't in the symbol table
         # NOTE: this assumes that `None` is never in the symbol table
         return padding_symbol not in symbol_table
+
+
+def validate_symbol_tables(symbol_table, padding_symbol, other_symbol_table):
+    """
+    Validates two symbol tables (the padding symbol being used alongside the
+    first one).
+    Raises ValueError if either of the symbol tables (or padding symbol) fail
+    validation.
+    """
+    if None in (symbol_table + [padding_symbol] + other_symbol_table):
+        raise ValueError(
+            'None cannot be used in symbol tables nor for padding'
+        )
+    elif (
+        (not symbol_table_is_unique(symbol_table, padding_symbol)) or
+        (not symbol_table_is_unique(other_symbol_table))
+    ):
+        raise ValueError('Unique symbol tables required')

tests/core/test_encode_decode.py

@@ -151,6 +151,41 @@ def test_encode_rejects_non_unique_symbol_tables(
                 []
             )
 
+    def test_encode_rejects_output_symbol_table_containing_padding_symbol(
+        self
+    ):
+        """
+        When the output symbol table passed to encode() contains the padding
+        symbol, ValueError should be raised.
+        """
+        with self.assertRaises(ValueError):
+            encode(1, ['a'], 1, ['b'], 'b', 1, 1, [])
+
+    @data(
+        (list('abcd'), list('efghijk'), None),
+        (list('1234'), [1, 2, 3, None], '#'),
+        ([None, 2, 3, 4], list('cabuges'), '#')
+    )
+    @unpack
+    def test_encode_rejects_none_used_in_symbol_tables_and_padding(
+        self,
+        input_symbol_table,
+        output_symbol_table,
+        padding_symbol
+    ):
+        """
+        When any of the symbol tables or the padding symbol passed to encode()
+        are or contain None, ValueError should be raised.
+        """
+        with self.assertRaises(ValueError):
+            encode(
+                len(input_symbol_table), input_symbol_table,
+                len(output_symbol_table), output_symbol_table,
+                padding_symbol,
+                1, 1,
+                []
+            )
+
     @data(
         # Base-64, using most common alphabet - no padding
         (
@@ -270,6 +305,41 @@ def test_decode_rejects_non_unique_symbol_tables(
                 []
             )
 
+    def test_decode_rejects_input_symbol_table_containing_padding_symbol(
+        self
+    ):
+        """
+        When the input symbol table passed to decode() contains the padding
+        symbol, ValueError should be raised.
+        """
+        with self.assertRaises(ValueError):
+            decode(1, ['a'], 'a', 1, ['b'], 1, 1, [])
+
+    @data(
+        (list('abcd'), list('efghijk'), None),
+        (list('1234'), [1, 2, 3, None], '#'),
+        ([None, 2, 3, 4], list('cabuges'), '#')
+    )
+    @unpack
+    def test_decode_rejects_none_used_in_symbol_tables_and_padding(
+        self,
+        input_symbol_table,
+        output_symbol_table,
+        padding_symbol
+    ):
+        """
+        When any of the symbol tables or the padding symbol passed to decode()
+        are or contain None, ValueError should be raised.
+        """
+        with self.assertRaises(ValueError):
+            decode(
+                len(input_symbol_table), input_symbol_table,
+                padding_symbol,
+                len(output_symbol_table), output_symbol_table,
+                1, 1,
+                []
+            )
+
     @data(
         # Base-64, using most common alphabet with no padding needed
         (