Fix SequenceOf/SetOf BoundsError raising

[pyderasn.git] / tests / test_pyderasn.py

diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index 864c66bbbc847b6ed2ae573bedb4ce67e9d4ee66..c85a90a3e3e4dc737a553b3eb98aa97126e3e8f1 100644 (file)
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -77,6 +77,9 @@ from pyderasn import InvalidOID
 from pyderasn import InvalidValueType
 from pyderasn import len_decode
 from pyderasn import len_encode
+from pyderasn import LEN_YYMMDDHHMMSSZ
+from pyderasn import LEN_YYYYMMDDHHMMSSDMZ
+from pyderasn import LEN_YYYYMMDDHHMMSSZ
 from pyderasn import LENINDEF
 from pyderasn import NotEnoughData
 from pyderasn import Null
@@ -806,9 +809,19 @@ class TestInteger(CommonMixin, TestCase):
         with self.assertRaises(BoundsError) as err:
             Integer(value=values[0], bounds=(values[1], values[2]))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            Integer(bounds=(values[1], values[2])).decode(
+                Integer(values[0]).encode()
+            )
+        repr(err.exception)
         with self.assertRaises(BoundsError) as err:
             Integer(value=values[2], bounds=(values[0], values[1]))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            Integer(bounds=(values[0], values[1])).decode(
+                Integer(values[2]).encode()
+            )
+        repr(err.exception)
 
     @given(data_strategy())
     def test_call(self, d):
@@ -1759,10 +1772,20 @@ class TestOctetString(CommonMixin, TestCase):
         with self.assertRaises(BoundsError) as err:
             OctetString(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            OctetString(bounds=(bound_min, bound_max)).decode(
+                OctetString(value).encode()
+            )
+        repr(err.exception)
         value = d.draw(binary(min_size=bound_max + 1))
         with self.assertRaises(BoundsError) as err:
             OctetString(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            OctetString(bounds=(bound_min, bound_max)).decode(
+                OctetString(value).encode()
+            )
+        repr(err.exception)
 
     @given(data_strategy())
     def test_call(self, d):
@@ -2975,10 +2998,20 @@ class StringMixin(object):
         with self.assertRaises(BoundsError) as err:
             self.base_klass(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            self.base_klass(bounds=(bound_min, bound_max)).decode(
+                self.base_klass(value).encode()
+            )
+        repr(err.exception)
         value = d.draw(text(alphabet=self.text_alphabet(), min_size=bound_max + 1))
         with self.assertRaises(BoundsError) as err:
             self.base_klass(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            self.base_klass(bounds=(bound_min, bound_max)).decode(
+                self.base_klass(value).encode()
+            )
+        repr(err.exception)
 
     @given(data_strategy())
     def test_call(self, d):
@@ -3609,6 +3642,48 @@ class TestGeneralizedTime(TimeMixin, CommonMixin, TestCase):
             datetime(2010, 1, 2, 3, 4, 5, 0),
         )
 
+    @given(
+        binary(
+            min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
+            max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
+        ),
+        binary(min_size=1, max_size=1),
+        binary(
+            min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
+            max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
+        ),
+    )
+    def test_junk(self, part0, part1, part2):
+        junk = part0 + part1 + part2
+        assume(not (set(junk) <= set(digits.encode("ascii"))))
+        with self.assertRaises(DecodeError):
+            GeneralizedTime().decode(
+                GeneralizedTime.tag_default +
+                len_encode(len(junk)) +
+                junk
+            )
+
+    @given(
+        binary(
+            min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
+            max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
+        ),
+        binary(min_size=1, max_size=1),
+        binary(
+            min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
+            max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
+        ),
+    )
+    def test_junk_dm(self, part0, part1, part2):
+        junk = part0 + part1 + part2
+        assume(not (set(junk) <= set(digits.encode("ascii"))))
+        with self.assertRaises(DecodeError):
+            GeneralizedTime().decode(
+                GeneralizedTime.tag_default +
+                len_encode(len(junk)) +
+                junk
+            )
+
 
 class TestUTCTime(TimeMixin, CommonMixin, TestCase):
     base_klass = UTCTime
@@ -3673,6 +3748,27 @@ class TestUTCTime(TimeMixin, CommonMixin, TestCase):
             1900 + year,
         )
 
+    @given(
+        binary(
+            min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
+            max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
+        ),
+        binary(min_size=1, max_size=1),
+        binary(
+            min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
+            max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
+        ),
+    )
+    def test_junk(self, part0, part1, part2):
+        junk = part0 + part1 + part2
+        assume(not (set(junk) <= set(digits.encode("ascii"))))
+        with self.assertRaises(DecodeError):
+            UTCTime().decode(
+                UTCTime.tag_default +
+                len_encode(len(junk)) +
+                junk
+            )
+
 
 @composite
 def any_values_strategy(draw, do_expl=False):
@@ -5014,17 +5110,27 @@ class SeqOfMixing(object):
             schema = Boolean()
         bound_min = d.draw(integers(min_value=1, max_value=1 << 7))
         bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
-        value = [Boolean()] * d.draw(integers(max_value=bound_min - 1))
+        value = [Boolean(False)] * d.draw(integers(max_value=bound_min - 1))
         with self.assertRaises(BoundsError) as err:
             SeqOf(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
-        value = [Boolean()] * d.draw(integers(
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            SeqOf(bounds=(bound_min, bound_max)).decode(
+                SeqOf(value).encode()
+            )
+        repr(err.exception)
+        value = [Boolean(True)] * d.draw(integers(
             min_value=bound_max + 1,
             max_value=bound_max + 10,
         ))
         with self.assertRaises(BoundsError) as err:
             SeqOf(value=value, bounds=(bound_min, bound_max))
         repr(err.exception)
+        with assertRaisesRegex(self, DecodeError, "bounds") as err:
+            SeqOf(bounds=(bound_min, bound_max)).decode(
+                SeqOf(value).encode()
+            )
+        repr(err.exception)
 
     @given(integers(min_value=1, max_value=10))
     def test_out_of_bounds(self, bound_max):