release v0.1.8

1 files changed, 41 insertions, 39 deletions

diff --git a/frozen_deps/ecdsa/test_der.py b/frozen_deps/ecdsa/test_der.py
index 0ca5bd7..0c2dc4d 100644
--- a/frozen_deps/ecdsa/test_der.py
+++ b/frozen_deps/ecdsa/test_der.py
@@ -7,9 +7,9 @@ try:
     import unittest2 as unittest
 except ImportError:
     import unittest
-from six import b
+import sys
 import hypothesis.strategies as st
-from hypothesis import given
+from hypothesis import given, settings
 import pytest
 from ._compat import str_idx_as_int
 from .curves import NIST256p, NIST224p
@@ -32,44 +32,44 @@ class TestRemoveInteger(unittest.TestCase):
     # interpreted as negative, check if those errors are detected
     def test_non_minimal_encoding(self):
         with self.assertRaises(UnexpectedDER):
-            remove_integer(b("\x02\x02\x00\x01"))
+            remove_integer(b"\x02\x02\x00\x01")
 
     def test_negative_with_high_bit_set(self):
         with self.assertRaises(UnexpectedDER):
-            remove_integer(b("\x02\x01\x80"))
+            remove_integer(b"\x02\x01\x80")
 
     def test_minimal_with_high_bit_set(self):
-        val, rem = remove_integer(b("\x02\x02\x00\x80"))
+        val, rem = remove_integer(b"\x02\x02\x00\x80")
 
         self.assertEqual(val, 0x80)
         self.assertEqual(rem, b"")
 
     def test_two_zero_bytes_with_high_bit_set(self):
         with self.assertRaises(UnexpectedDER):
-            remove_integer(b("\x02\x03\x00\x00\xff"))
+            remove_integer(b"\x02\x03\x00\x00\xff")
 
     def test_zero_length_integer(self):
         with self.assertRaises(UnexpectedDER):
-            remove_integer(b("\x02\x00"))
+            remove_integer(b"\x02\x00")
 
     def test_empty_string(self):
         with self.assertRaises(UnexpectedDER):
-            remove_integer(b(""))
+            remove_integer(b"")
 
     def test_encoding_of_zero(self):
-        val, rem = remove_integer(b("\x02\x01\x00"))
+        val, rem = remove_integer(b"\x02\x01\x00")
 
         self.assertEqual(val, 0)
         self.assertEqual(rem, b"")
 
     def test_encoding_of_127(self):
-        val, rem = remove_integer(b("\x02\x01\x7f"))
+        val, rem = remove_integer(b"\x02\x01\x7f")
 
         self.assertEqual(val, 127)
         self.assertEqual(rem, b"")
 
     def test_encoding_of_128(self):
-        val, rem = remove_integer(b("\x02\x02\x00\x80"))
+        val, rem = remove_integer(b"\x02\x02\x00\x80")
 
         self.assertEqual(val, 128)
         self.assertEqual(rem, b"")
@@ -92,37 +92,37 @@ class TestReadLength(unittest.TestCase):
     # form and lengths above that encoded with minimal number of bytes
     # necessary
     def test_zero_length(self):
-        self.assertEqual((0, 1), read_length(b("\x00")))
+        self.assertEqual((0, 1), read_length(b"\x00"))
 
     def test_two_byte_zero_length(self):
         with self.assertRaises(UnexpectedDER):
-            read_length(b("\x81\x00"))
+            read_length(b"\x81\x00")
 
     def test_two_byte_small_length(self):
         with self.assertRaises(UnexpectedDER):
-            read_length(b("\x81\x7f"))
+            read_length(b"\x81\x7f")
 
     def test_long_form_with_zero_length(self):
         with self.assertRaises(UnexpectedDER):
-            read_length(b("\x80"))
+            read_length(b"\x80")
 
     def test_smallest_two_byte_length(self):
-        self.assertEqual((128, 2), read_length(b("\x81\x80")))
+        self.assertEqual((128, 2), read_length(b"\x81\x80"))
 
     def test_zero_padded_length(self):
         with self.assertRaises(UnexpectedDER):
-            read_length(b("\x82\x00\x80"))
+            read_length(b"\x82\x00\x80")
 
     def test_two_three_byte_length(self):
         self.assertEqual((256, 3), read_length(b"\x82\x01\x00"))
 
     def test_empty_string(self):
         with self.assertRaises(UnexpectedDER):
-            read_length(b(""))
+            read_length(b"")
 
     def test_length_overflow(self):
         with self.assertRaises(UnexpectedDER):
-            read_length(b("\x83\x01\x00"))
+            read_length(b"\x83\x01\x00")
 
 
 class TestEncodeBitstring(unittest.TestCase):
@@ -144,26 +144,22 @@ class TestEncodeBitstring(unittest.TestCase):
 
     def test_new_call_convention(self):
         """This is how it should be called now."""
-        warnings.simplefilter("always")
-        with pytest.warns(None) as warns:
+        # make sure no warnings are raised
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
             der = encode_bitstring(b"\xff", 0)
 
-        # verify that new call convention doesn't raise Warnings
-        self.assertEqual(len(warns), 0)
-
         self.assertEqual(der, b"\x03\x02\x00\xff")
 
     def test_implicit_unused_bits(self):
         """
         Writing bit string with already included the number of unused bits.
         """
-        warnings.simplefilter("always")
-        with pytest.warns(None) as warns:
+        # make sure no warnings are raised
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
             der = encode_bitstring(b"\x00\xff", None)
 
-        # verify that new call convention doesn't raise Warnings
-        self.assertEqual(len(warns), 0)
-
         self.assertEqual(der, b"\x03\x02\x00\xff")
 
     def test_explicit_unused_bits(self):
@@ -203,22 +199,20 @@ class TestRemoveBitstring(unittest.TestCase):
         self.assertEqual(rest, b"")
 
     def test_new_call_convention(self):
-        warnings.simplefilter("always")
-        with pytest.warns(None) as warns:
+        # make sure no warnings are raised
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
             bits, rest = remove_bitstring(b"\x03\x02\x00\xff", 0)
 
-        self.assertEqual(len(warns), 0)
-
         self.assertEqual(bits, b"\xff")
         self.assertEqual(rest, b"")
 
     def test_implicit_unexpected_unused(self):
-        warnings.simplefilter("always")
-        with pytest.warns(None) as warns:
+        # make sure no warnings are raised
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
             bits, rest = remove_bitstring(b"\x03\x02\x00\xff", None)
 
-        self.assertEqual(len(warns), 0)
-
         self.assertEqual(bits, (b"\xff", 0))
         self.assertEqual(rest, b"")
 
@@ -275,10 +269,10 @@ class TestStrIdxAsInt(unittest.TestCase):
 class TestEncodeOid(unittest.TestCase):
     def test_pub_key_oid(self):
         oid_ecPublicKey = encode_oid(1, 2, 840, 10045, 2, 1)
-        self.assertEqual(hexlify(oid_ecPublicKey), b("06072a8648ce3d0201"))
+        self.assertEqual(hexlify(oid_ecPublicKey), b"06072a8648ce3d0201")
 
     def test_nist224p_oid(self):
-        self.assertEqual(hexlify(NIST224p.encoded_oid), b("06052b81040021"))
+        self.assertEqual(hexlify(NIST224p.encoded_oid), b"06052b81040021")
 
     def test_nist256p_oid(self):
         self.assertEqual(
@@ -468,6 +462,14 @@ def st_oid(draw, max_value=2**512, max_size=50):
     return (first, second) + tuple(rest)
 
 
+HYP_SETTINGS = {}
+
+
+if "--fast" in sys.argv:  # pragma: no cover
+    HYP_SETTINGS["max_examples"] = 2
+
+
+@settings(**HYP_SETTINGS)
 @given(st_oid())
 def test_oids(ids):
     encoded_oid = encode_oid(*ids)