Ability to set values during Sequence initialization

[pyderasn.git] / tests / test_pyderasn.py

diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index 498b160a23698a7ba37848c3a2cbf87e9f627034..dfea4300e78a6e4ccc8c17cd05457e6a3bc07fb6 100644 (file)
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -18,6 +18,7 @@
 
 from datetime import datetime
 from string import ascii_letters
+from string import digits
 from string import printable
 from string import whitespace
 from unittest import TestCase
@@ -48,6 +49,7 @@ from six import int2byte
 from six import iterbytes
 from six import PY2
 from six import text_type
+from six import unichr as six_unichr
 
 from pyderasn import _pp
 from pyderasn import abs_decode_path
@@ -57,8 +59,8 @@ from pyderasn import BMPString
 from pyderasn import Boolean
 from pyderasn import BoundsError
 from pyderasn import Choice
-from pyderasn import decode_path_defby
 from pyderasn import DecodeError
+from pyderasn import DecodePathDefBy
 from pyderasn import Enumerated
 from pyderasn import GeneralizedTime
 from pyderasn import GeneralString
@@ -106,11 +108,11 @@ from pyderasn import VideotexString
 from pyderasn import VisibleString
 
 
-settings.register_profile('local', settings(
+settings.register_profile("local", settings(
     deadline=5000,
     perform_health_check=False,
 ))
-settings.load_profile('local')
+settings.load_profile("local")
 LONG_TEST_MAX_EXAMPLES = settings().max_examples * 4
 
 tag_classes = sampled_from((
@@ -529,8 +531,9 @@ class TestBoolean(CommonMixin, TestCase):
         booleans(),
         integers(min_value=1).map(tag_ctxc),
         integers(min_value=0),
+        binary(max_size=5),
     )
-    def test_symmetric(self, values, value, tag_expl, offset):
+    def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
         for klass in (Boolean, BooleanInherited):
             _, _, _, default, optional, _decoded = values
             obj = klass(
@@ -548,10 +551,13 @@ class TestBoolean(CommonMixin, TestCase):
             repr(obj_expled)
             pprint(obj_expled)
             obj_expled_encoded = obj_expled.encode()
-            obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+            obj_decoded, tail = obj_expled.decode(
+                obj_expled_encoded + tail_junk,
+                offset=offset,
+            )
             repr(obj_decoded)
             pprint(obj_decoded)
-            self.assertEqual(tail, b"")
+            self.assertEqual(tail, tail_junk)
             self.assertEqual(obj_decoded, obj_expled)
             self.assertNotEqual(obj_decoded, obj)
             self.assertEqual(bool(obj_decoded), bool(obj_expled))
@@ -904,8 +910,9 @@ class TestInteger(CommonMixin, TestCase):
         integers(),
         integers(min_value=1).map(tag_ctxc),
         integers(min_value=0),
+        binary(max_size=5),
     )
-    def test_symmetric(self, values, value, tag_expl, offset):
+    def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
         for klass in (Integer, IntegerInherited):
             _, _, _, _, default, optional, _, _decoded = values
             obj = klass(
@@ -923,10 +930,13 @@ class TestInteger(CommonMixin, TestCase):
             repr(obj_expled)
             pprint(obj_expled)
             obj_expled_encoded = obj_expled.encode()
-            obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+            obj_decoded, tail = obj_expled.decode(
+                obj_expled_encoded + tail_junk,
+                offset=offset,
+            )
             repr(obj_decoded)
             pprint(obj_decoded)
-            self.assertEqual(tail, b"")
+            self.assertEqual(tail, tail_junk)
             self.assertEqual(obj_decoded, obj_expled)
             self.assertNotEqual(obj_decoded, obj)
             self.assertEqual(int(obj_decoded), int(obj_expled))
@@ -1279,6 +1289,7 @@ class TestBitString(CommonMixin, TestCase):
             optional,
             _decoded,
         ) = d.draw(bit_string_values_strategy(value_required=True))
+        tail_junk = d.draw(binary(max_size=5))
         tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
         offset = d.draw(integers(min_value=0))
         for klass in (BitString, BitStringInherited):
@@ -1299,10 +1310,13 @@ class TestBitString(CommonMixin, TestCase):
             repr(obj_expled)
             pprint(obj_expled)
             obj_expled_encoded = obj_expled.encode()
-            obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+            obj_decoded, tail = obj_expled.decode(
+                obj_expled_encoded + tail_junk,
+                offset=offset,
+            )
             repr(obj_decoded)
             pprint(obj_decoded)
-            self.assertEqual(tail, b"")
+            self.assertEqual(tail, tail_junk)
             self.assertEqual(obj_decoded, obj_expled)
             self.assertNotEqual(obj_decoded, obj)
             self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
@@ -1637,8 +1651,9 @@ class TestOctetString(CommonMixin, TestCase):
         binary(),
         integers(min_value=1).map(tag_ctxc),
         integers(min_value=0),
+        binary(max_size=5),
     )
-    def test_symmetric(self, values, value, tag_expl, offset):
+    def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
         for klass in (OctetString, OctetStringInherited):
             _, _, _, _, default, optional, _decoded = values
             obj = klass(
@@ -1656,10 +1671,13 @@ class TestOctetString(CommonMixin, TestCase):
             repr(obj_expled)
             pprint(obj_expled)
             obj_expled_encoded = obj_expled.encode()
-            obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+            obj_decoded, tail = obj_expled.decode(
+                obj_expled_encoded + tail_junk,
+                offset=offset,
+            )
             repr(obj_decoded)
             pprint(obj_decoded)
-            self.assertEqual(tail, b"")
+            self.assertEqual(tail, tail_junk)
             self.assertEqual(obj_decoded, obj_expled)
             self.assertNotEqual(obj_decoded, obj)
             self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
@@ -1816,8 +1834,9 @@ class TestNull(CommonMixin, TestCase):
         null_values_strategy(),
         integers(min_value=1).map(tag_ctxc),
         integers(min_value=0),
+        binary(max_size=5),
     )
-    def test_symmetric(self, values, tag_expl, offset):
+    def test_symmetric(self, values, tag_expl, offset, tail_junk):
         for klass in (Null, NullInherited):
             _, _, optional, _decoded = values
             obj = klass(optional=optional, _decoded=_decoded)
@@ -1830,10 +1849,13 @@ class TestNull(CommonMixin, TestCase):
             repr(obj_expled)
             pprint(obj_expled)
             obj_expled_encoded = obj_expled.encode()
-            obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+            obj_decoded, tail = obj_expled.decode(
+                obj_expled_encoded + tail_junk,
+                offset=offset,
+            )
             repr(obj_decoded)
             pprint(obj_decoded)
-            self.assertEqual(tail, b"")
+            self.assertEqual(tail, tail_junk)
             self.assertEqual(obj_decoded, obj_expled)
             self.assertNotEqual(obj_decoded, obj)
             self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
@@ -2136,8 +2158,9 @@ class TestObjectIdentifier(CommonMixin, TestCase):
         oid_strategy(),
         integers(min_value=1).map(tag_ctxc),
         integers(min_value=0),
+        binary(max_size=5),
     )
-    def test_symmetric(self, values, value, tag_expl, offset):
+    def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
         for klass in (ObjectIdentifier, ObjectIdentifierInherited):
             _, _, _, default, optional, _decoded = values
             obj = klass(
@@ -2155,10 +2178,13 @@ class TestObjectIdentifier(CommonMixin, TestCase):
             repr(obj_expled)
             pprint(obj_expled)
             obj_expled_encoded = obj_expled.encode()
-            obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+            obj_decoded, tail = obj_expled.decode(
+                obj_expled_encoded + tail_junk,
+                offset=offset,
+            )
             repr(obj_decoded)
             pprint(obj_decoded)
-            self.assertEqual(tail, b"")
+            self.assertEqual(tail, tail_junk)
             self.assertEqual(obj_decoded, obj_expled)
             self.assertNotEqual(obj_decoded, obj)
             self.assertEqual(tuple(obj_decoded), tuple(obj_expled))
@@ -2413,6 +2439,7 @@ class TestEnumerated(CommonMixin, TestCase):
         tag_expl = d.draw(integers(min_value=1).map(tag_ctxc))
         offset = d.draw(integers(min_value=0))
         value = d.draw(sampled_from(sorted([v for _, v in schema_input])))
+        tail_junk = d.draw(binary(max_size=5))
 
         class E(Enumerated):
             schema = schema_input
@@ -2431,10 +2458,13 @@ class TestEnumerated(CommonMixin, TestCase):
         repr(obj_expled)
         pprint(obj_expled)
         obj_expled_encoded = obj_expled.encode()
-        obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+        obj_decoded, tail = obj_expled.decode(
+            obj_expled_encoded + tail_junk,
+            offset=offset,
+        )
         repr(obj_decoded)
         pprint(obj_decoded)
-        self.assertEqual(tail, b"")
+        self.assertEqual(tail, tail_junk)
         self.assertEqual(obj_decoded, obj_expled)
         self.assertNotEqual(obj_decoded, obj)
         self.assertEqual(int(obj_decoded), int(obj_expled))
@@ -2724,6 +2754,7 @@ class StringMixin(object):
         value = d.draw(text(alphabet=self.text_alphabet()))
         tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
         offset = d.draw(integers(min_value=0))
+        tail_junk = d.draw(binary(max_size=5))
         _, _, _, _, default, optional, _decoded = values
         obj = self.base_klass(
             value=value,
@@ -2740,10 +2771,13 @@ class StringMixin(object):
         repr(obj_expled)
         pprint(obj_expled)
         obj_expled_encoded = obj_expled.encode()
-        obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+        obj_decoded, tail = obj_expled.decode(
+            obj_expled_encoded + tail_junk,
+            offset=offset,
+        )
         repr(obj_decoded)
         pprint(obj_decoded)
-        self.assertEqual(tail, b"")
+        self.assertEqual(tail, tail_junk)
         self.assertEqual(obj_decoded, obj_expled)
         self.assertNotEqual(obj_decoded, obj)
         self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
@@ -2770,35 +2804,110 @@ class TestUTF8String(StringMixin, CommonMixin, TestCase):
     base_klass = UTF8String
 
 
+class UnicodeDecodeErrorMixin(object):
+    @given(text(
+        alphabet="".join(six_unichr(i) for i in list(range(0x0410, 0x044f + 1))),
+        min_size=1,
+        max_size=5,
+    ))
+    def test_unicode_decode_error(self, cyrillic_text):
+        with self.assertRaises(DecodeError):
+            self.base_klass(cyrillic_text)
+
+
 class TestNumericString(StringMixin, CommonMixin, TestCase):
     base_klass = NumericString
 
+    def text_alphabet(self):
+        return digits
+
+    @given(text(alphabet=ascii_letters, min_size=1, max_size=5))
+    def test_non_numeric(self, cyrillic_text):
+        with assertRaisesRegex(self, DecodeError, "non-numeric"):
+            self.base_klass(cyrillic_text)
 
-class TestPrintableString(StringMixin, CommonMixin, TestCase):
+    @given(
+        sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
+        integers(min_value=0),
+        lists(integers()),
+    )
+    def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
+        decode_path = tuple(str(i) for i in decode_path)
+        value, bound_min = list(sorted(ints))
+
+        class String(self.base_klass):
+            bounds = (bound_min, bound_min)
+        with self.assertRaises(DecodeError) as err:
+            String().decode(
+                self.base_klass(b"1" * value).encode(),
+                offset=offset,
+                decode_path=decode_path,
+            )
+        repr(err.exception)
+        self.assertEqual(err.exception.offset, offset)
+        self.assertEqual(err.exception.decode_path, decode_path)
+
+
+class TestPrintableString(
+        UnicodeDecodeErrorMixin,
+        StringMixin,
+        CommonMixin,
+        TestCase,
+):
     base_klass = PrintableString
 
 
-class TestTeletexString(StringMixin, CommonMixin, TestCase):
+class TestTeletexString(
+        UnicodeDecodeErrorMixin,
+        StringMixin,
+        CommonMixin,
+        TestCase,
+):
     base_klass = TeletexString
 
 
-class TestVideotexString(StringMixin, CommonMixin, TestCase):
+class TestVideotexString(
+        UnicodeDecodeErrorMixin,
+        StringMixin,
+        CommonMixin,
+        TestCase,
+):
     base_klass = VideotexString
 
 
-class TestIA5String(StringMixin, CommonMixin, TestCase):
+class TestIA5String(
+        UnicodeDecodeErrorMixin,
+        StringMixin,
+        CommonMixin,
+        TestCase,
+):
     base_klass = IA5String
 
 
-class TestGraphicString(StringMixin, CommonMixin, TestCase):
+class TestGraphicString(
+        UnicodeDecodeErrorMixin,
+        StringMixin,
+        CommonMixin,
+        TestCase,
+):
     base_klass = GraphicString
 
 
-class TestVisibleString(StringMixin, CommonMixin, TestCase):
+class TestVisibleString(
+        UnicodeDecodeErrorMixin,
+        StringMixin,
+        CommonMixin,
+        TestCase,
+):
     base_klass = VisibleString
 
 
-class TestGeneralString(StringMixin, CommonMixin, TestCase):
+class TestGeneralString(
+        UnicodeDecodeErrorMixin,
+        StringMixin,
+        CommonMixin,
+        TestCase,
+):
     base_klass = GeneralString
 
 
@@ -3008,6 +3117,7 @@ class TimeMixin(object):
         ))
         tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
         offset = d.draw(integers(min_value=0))
+        tail_junk = d.draw(binary(max_size=5))
         _, _, _, default, optional, _decoded = values
         obj = self.base_klass(
             value=value,
@@ -3024,10 +3134,13 @@ class TimeMixin(object):
         repr(obj_expled)
         pprint(obj_expled)
         obj_expled_encoded = obj_expled.encode()
-        obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+        obj_decoded, tail = obj_expled.decode(
+            obj_expled_encoded + tail_junk,
+            offset=offset,
+        )
         repr(obj_decoded)
         pprint(obj_decoded)
-        self.assertEqual(tail, b"")
+        self.assertEqual(tail, tail_junk)
         self.assertEqual(obj_decoded, obj_expled)
         self.assertEqual(obj_decoded.todatetime(), obj_expled.todatetime())
         self.assertEqual(obj_decoded.todatetime(), obj.todatetime())
@@ -3326,8 +3439,9 @@ class TestAny(CommonMixin, TestCase):
         integers().map(lambda x: Integer(x).encode()),
         integers(min_value=1).map(tag_ctxc),
         integers(min_value=0),
+        binary(max_size=5),
     )
-    def test_symmetric(self, values, value, tag_expl, offset):
+    def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
         for klass in (Any, AnyInherited):
             _, _, optional, _decoded = values
             obj = klass(value=value, optional=optional, _decoded=_decoded)
@@ -3340,10 +3454,13 @@ class TestAny(CommonMixin, TestCase):
             repr(obj_expled)
             pprint(obj_expled)
             obj_expled_encoded = obj_expled.encode()
-            obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+            obj_decoded, tail = obj_expled.decode(
+                obj_expled_encoded + tail_junk,
+                offset=offset,
+            )
             repr(obj_decoded)
             pprint(obj_decoded)
-            self.assertEqual(tail, b"")
+            self.assertEqual(tail, tail_junk)
             self.assertEqual(obj_decoded, obj_expled)
             self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
             self.assertEqual(bytes(obj_decoded), bytes(obj))
@@ -3570,6 +3687,7 @@ class TestChoice(CommonMixin, TestCase):
         )
         tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
         offset = d.draw(integers(min_value=0))
+        tail_junk = d.draw(binary(max_size=5))
 
         class Wahl(self.base_klass):
             schema = _schema
@@ -3588,10 +3706,13 @@ class TestChoice(CommonMixin, TestCase):
         repr(obj_expled)
         pprint(obj_expled)
         obj_expled_encoded = obj_expled.encode()
-        obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+        obj_decoded, tail = obj_expled.decode(
+            obj_expled_encoded + tail_junk,
+            offset=offset,
+        )
         repr(obj_decoded)
         pprint(obj_decoded)
-        self.assertEqual(tail, b"")
+        self.assertEqual(tail, tail_junk)
         self.assertEqual(obj_decoded, obj_expled)
         self.assertEqual(obj_decoded.choice, obj_expled.choice)
         self.assertEqual(obj_decoded.value, obj_expled.value)
@@ -3651,6 +3772,26 @@ class TestChoice(CommonMixin, TestCase):
         with self.assertRaises(TagMismatch):
             obj.decode(int_encoded)
 
+    def test_tag_mismatch_underlying(self):
+        class SeqOfBoolean(SequenceOf):
+            schema = Boolean()
+
+        class SeqOfInteger(SequenceOf):
+            schema = Integer()
+
+        class Wahl(Choice):
+            schema = (
+                ("erste", SeqOfBoolean()),
+            )
+
+        int_encoded = SeqOfInteger((Integer(123),)).encode()
+        bool_encoded = SeqOfBoolean((Boolean(False),)).encode()
+        obj = Wahl()
+        obj.decode(bool_encoded)
+        with self.assertRaises(TagMismatch) as err:
+            obj.decode(int_encoded)
+        self.assertEqual(err.exception.decode_path, ("erste", "0"))
+
 
 @composite
 def seq_values_strategy(draw, seq_klass, do_expl=False):
@@ -3826,7 +3967,7 @@ def sequences_strategy(draw, seq_klass):
 class SeqMixing(object):
     def test_invalid_value_type(self):
         with self.assertRaises(InvalidValueType) as err:
-            self.base_klass((1, 2, 3))
+            self.base_klass(123)
         repr(err.exception)
 
     def test_invalid_value_type_set(self):
@@ -4057,14 +4198,15 @@ class SeqMixing(object):
     @given(data_strategy())
     def test_symmetric(self, d):
         seq, expects = d.draw(sequence_strategy(seq_klass=self.base_klass))
+        tail_junk = d.draw(binary(max_size=5))
         self.assertTrue(seq.ready)
         self.assertFalse(seq.decoded)
         self._assert_expects(seq, expects)
         repr(seq)
         pprint(seq)
         seq_encoded = seq.encode()
-        seq_decoded, tail = seq.decode(seq_encoded)
-        self.assertEqual(tail, b"")
+        seq_decoded, tail = seq.decode(seq_encoded + tail_junk)
+        self.assertEqual(tail, tail_junk)
         self.assertTrue(seq.ready)
         self._assert_expects(seq_decoded, expects)
         self.assertEqual(seq, seq_decoded)
@@ -4592,8 +4734,9 @@ class SeqOfMixing(object):
         lists(integers().map(Integer)),
         integers(min_value=1).map(tag_ctxc),
         integers(min_value=0),
+        binary(max_size=5),
     )
-    def test_symmetric(self, values, value, tag_expl, offset):
+    def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
         _, _, _, _, _, default, optional, _decoded = values
 
         class SeqOf(self.base_klass):
@@ -4613,10 +4756,13 @@ class SeqOfMixing(object):
         repr(obj_expled)
         pprint(obj_expled)
         obj_expled_encoded = obj_expled.encode()
-        obj_decoded, tail = obj_expled.decode(obj_expled_encoded, offset=offset)
+        obj_decoded, tail = obj_expled.decode(
+            obj_expled_encoded + tail_junk,
+            offset=offset,
+        )
         repr(obj_decoded)
         pprint(obj_decoded)
-        self.assertEqual(tail, b"")
+        self.assertEqual(tail, tail_junk)
         self._test_symmetric_compare_objs(obj_decoded, obj_expled)
         self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
         self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
@@ -5003,6 +5149,9 @@ class TestDefinesByPath(TestCase):
         self.assertIsNotNone(seq_integered["value"].defined)
         self.assertEqual(seq_integered["value"].defined[0], type_integered)
         self.assertEqual(seq_integered["value"].defined[1], Integer(123))
+        self.assertTrue(seq_integered_raw[
+            seq_integered["value"].defined[1].offset:
+        ].startswith(Integer(123).encode()))
 
         seq_sequenced, _ = Seq().decode(
             seq_sequenced_raw,
@@ -5014,7 +5163,7 @@ class TestDefinesByPath(TestCase):
         self.assertIsNone(seq_inner["valueInner"].defined)
 
         defines_by_path.append((
-            ("value", decode_path_defby(type_sequenced), "typeInner"),
+            ("value", DecodePathDefBy(type_sequenced), "typeInner"),
             ((("valueInner",), {type_innered: Pairs()}),),
         ))
         seq_sequenced, _ = Seq().decode(
@@ -5033,9 +5182,9 @@ class TestDefinesByPath(TestCase):
         defines_by_path.append((
             (
                 "value",
-                decode_path_defby(type_sequenced),
+                DecodePathDefBy(type_sequenced),
                 "valueInner",
-                decode_path_defby(type_innered),
+                DecodePathDefBy(type_innered),
                 any,
                 "type",
             ),
@@ -5081,6 +5230,7 @@ class TestDefinesByPath(TestCase):
         decoded, _ = Outer().decode(outer.encode())
         self.assertEqual(decoded["tgt"].defined[1], Integer(tgt))
 
+
 class TestAbsDecodePath(TestCase):
     @given(
         lists(text(alphabet=ascii_letters, min_size=1)).map(tuple),
@@ -5112,3 +5262,26 @@ class TestAbsDecodePath(TestCase):
             abs_decode_path(decode_path, tuple([".."] * number_of_dots) + rel_path),
             decode_path[:-number_of_dots] + rel_path,
         )
+
+
+class TestStrictDefaultExistence(TestCase):
+    @given(data_strategy())
+    def runTest(self, d):
+        count = d.draw(integers(min_value=1, max_value=10))
+        chosen = d.draw(integers(min_value=0, max_value=count - 1))
+        _schema = [
+            ("int%d" % i, Integer(expl=tag_ctxc(i + 1)))
+            for i in range(count)
+        ]
+
+        class Seq(Sequence):
+            schema = _schema
+        seq = Seq()
+        for i in range(count):
+            seq["int%d" % i] = Integer(123)
+        raw = seq.encode()
+        chosen = "int%d" % chosen
+        seq.specs[chosen] = seq.specs[chosen](default=123)
+        seq.decode(raw)
+        with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
+            seq.decode(raw, ctx={"strict_default_existence": True})