Merge pull request #31 from saxbophone/josh/26-reject-non-unique-encoding-alphabets

Reject non unique encoding alphabets and `None` being used in them

Author: saxbophone

basest/core/decode.py

@@ -5,7 +5,7 @@
 )
 
 from .encode import encode_raw
-from .utils import ints_to_symbols, 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,6 +54,12 @@ def decode(
     Assumes standard base64-style padding using the given input padding symbol,
     but can handle unpadded input just fine.
     """
+    # 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, symbols_to_ints
+from .utils import ints_to_symbols, symbols_to_ints, validate_symbol_tables
 
 
 def _nearest_length(input_length, input_ratio):
@@ -96,6 +96,12 @@ def encode(
     Uses standard base64-style padding if needed, using the given padding
     symbol.
     """
+    # 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

@@ -19,3 +19,38 @@ def symbols_to_ints(symbols, symbol_table):
     convert them to an iterable of ints and return this.
     """
     return [symbol_table.index(s) for s in symbols]
+
+
+def symbol_table_is_unique(symbol_table, padding_symbol=None):
+    """
+    Returns True if the given symbol table and padding symbol are unique,
+    otherwise returns False.
+    """
+    # simple way of checking if a list of hashables is unique
+    if len(symbol_table) != len(set(symbol_table)):
+        return False
+    else:
+        # 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.
+    """
+    # first check that they all do not contain None
+    if None in (symbol_table + [padding_symbol] + other_symbol_table):
+        raise ValueError(
+            'None cannot be used in symbol tables nor for padding'
+        )
+    # if that check passes, validate tables (and padding) for uniqueness
+    # the padding symbol is evaluated with the first symbol table
+    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

@@ -127,6 +127,65 @@ def test_encode(
 
         self.assertEqual(output_data, expected_output_data)
 
+    @data(
+        (list('abcd'), list('ccccc'), '1'),
+        (list('!!!!!'), list('abcdef'), '#')
+    )
+    @unpack
+    def test_encode_rejects_non_unique_symbol_tables(
+        self,
+        input_symbol_table,
+        output_symbol_table,
+        padding_symbol
+    ):
+        """
+        When a non-unique input or output symbol table is passed to encode(),
+        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,
+                []
+            )
+
+    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
         (
@@ -222,6 +281,65 @@ def test_decode(
 
         self.assertEqual(output_data, expected_output_data)
 
+    @data(
+        (list('abcd'), list('ccccc'), '1'),
+        (list('!!!!!'), list('abcdef'), '#')
+    )
+    @unpack
+    def test_decode_rejects_non_unique_symbol_tables(
+        self,
+        input_symbol_table,
+        output_symbol_table,
+        padding_symbol
+    ):
+        """
+        When a non-unique input or output symbol table is passed to decode(),
+        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,
+                []
+            )
+
+    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
         (