diff options
author | Ilya Etingof <etingof@gmail.com> | 2017-10-29 16:04:01 +0100 |
---|---|---|
committer | GitHub <noreply@github.com> | 2017-10-29 16:04:01 +0100 |
commit | 4d7232a5dfdedf38d80bb406f1814b40f638e2f2 (patch) | |
tree | 658c3b3622514c16d2c548f93becee592f8978f0 /tests | |
parent | 8c5a8a9caa3ddbf659e4c260c78f3a4a37ae714c (diff) | |
download | pyasn1-4d7232a5dfdedf38d80bb406f1814b40f638e2f2.tar.gz |
Pickle protocol fixes (#99)
* do not blow up on pickle protocol attributes look up
* added Pickle tests
* More fixes to pickle protocol support
* __slots__ lookup allowed at NoValue
* SizedInteger moved from BitString scope to the univ module scope
Diffstat (limited to 'tests')
-rw-r--r-- | tests/type/test_char.py | 16 | ||||
-rw-r--r-- | tests/type/test_univ.py | 254 | ||||
-rw-r--r-- | tests/type/test_useful.py | 38 |
3 files changed, 308 insertions, 0 deletions
diff --git a/tests/type/test_char.py b/tests/type/test_char.py index 74550c0..1301a50 100644 --- a/tests/type/test_char.py +++ b/tests/type/test_char.py @@ -5,6 +5,7 @@ # License: http://pyasn1.sf.net/license.html # import sys +import pickle try: import unittest2 as unittest @@ -111,6 +112,21 @@ class AbstractStringTestCase(object): def testReverse(self): assert list(reversed(self.asn1String)) == list(reversed(self.pythonString)) + def testSchemaPickling(self): + old_asn1 = self.asn1Type() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == self.asn1Type + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = self.asn1String + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == self.asn1String + class VisibleStringTestCase(AbstractStringTestCase, BaseTestCase): diff --git a/tests/type/test_univ.py b/tests/type/test_univ.py index 166af44..36a3fd4 100644 --- a/tests/type/test_univ.py +++ b/tests/type/test_univ.py @@ -6,6 +6,7 @@ # import sys import math +import pickle try: import unittest2 as unittest @@ -296,6 +297,24 @@ class IntegerTestCase(BaseTestCase): ) +class IntegerPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.Integer() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.Integer + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.Integer(-123) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == -123 + + class BooleanTestCase(BaseTestCase): def testTruth(self): assert univ.Boolean(True) and univ.Boolean(1), 'Truth initializer fails' @@ -328,6 +347,24 @@ class BooleanTestCase(BaseTestCase): assert 0, 'constraint fail' +class BooleanPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.Boolean() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.Boolean + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.Boolean(True) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == True + + class BitStringTestCase(BaseTestCase): def setUp(self): BaseTestCase.setUp(self) @@ -407,6 +444,24 @@ class BitStringTestCase(BaseTestCase): assert BitString('11000000011001').asInteger() == 12313 +class BitStringPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.BitString() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.BitString + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.BitString((1, 0, 1, 0)) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == (1, 0, 1, 0) + + class OctetStringWithUnicodeMixIn(object): initializer = () @@ -545,6 +600,24 @@ class OctetStringTestCase(BaseTestCase): assert OctetString(hexValue="FA9823C43E43510DE3422") == ints2octs((250, 152, 35, 196, 62, 67, 81, 13, 227, 66, 32)) +class OctetStringPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.BitString() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.BitString + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.BitString((1, 0, 1, 0)) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == (1, 0, 1, 0) + + class Null(BaseTestCase): def testInit(self): @@ -594,6 +667,24 @@ class Null(BaseTestCase): assert not Null('') +class NullPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.Null() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.Null + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.Null('') + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert not new_asn1 + + class RealTestCase(BaseTestCase): def testFloat4BinEnc(self): assert univ.Real((0.25, 2, 3)) == 2.0, 'float initializer for binary encoding fails' @@ -727,6 +818,24 @@ class RealTestCase(BaseTestCase): assert Real(1.0) == 1.0 +class RealPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.Real() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.Real + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.Real((1, 10, 3)) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == 1000 + + class ObjectIdentifier(BaseTestCase): def testStr(self): assert str(univ.ObjectIdentifier((1, 3, 6))) == '1.3.6', 'str() fails' @@ -787,6 +896,24 @@ class ObjectIdentifier(BaseTestCase): assert str(ObjectIdentifier((1, 3, 6))) == '1.3.6' +class ObjectIdentifierPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.ObjectIdentifier() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.ObjectIdentifier + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.ObjectIdentifier('2.3.1.1.2') + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == (2, 3, 1, 1, 2) + + class SequenceOf(BaseTestCase): def setUp(self): BaseTestCase.setUp(self) @@ -1027,6 +1154,26 @@ class SequenceOf(BaseTestCase): assert s.getComponentByPosition(0, instantiate=False) is univ.noValue +class SequenceOfPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.SequenceOf(componentType=univ.OctetString()) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.SequenceOf + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.SequenceOf(componentType=univ.OctetString()) + old_asn1[0] = 'test' + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 + assert new_asn1 == [str2octs('test')] + + class Sequence(BaseTestCase): def setUp(self): BaseTestCase.setUp(self) @@ -1329,6 +1476,34 @@ class SequenceWithoutSchema(BaseTestCase): assert 'field-0' not in s +class SequencePicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.Sequence( + componentType=namedtype.NamedTypes( + namedtype.NamedType('name', univ.OctetString()) + ) + ) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.Sequence + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.Sequence( + componentType=namedtype.NamedTypes( + namedtype.NamedType('name', univ.OctetString()) + ) + ) + old_asn1['name'] = 'test' + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 + assert new_asn1['name'] == str2octs('test') + + class SetOf(BaseTestCase): def setUp(self): BaseTestCase.setUp(self) @@ -1357,6 +1532,27 @@ class SetOf(BaseTestCase): assert s == [str2octs('abc')] + +class SetOfPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.SetOf(componentType=univ.OctetString()) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.SetOf + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.SetOf(componentType=univ.OctetString()) + old_asn1[0] = 'test' + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 + assert new_asn1 == [str2octs('test')] + + class Set(BaseTestCase): def setUp(self): BaseTestCase.setUp(self) @@ -1443,6 +1639,34 @@ class Set(BaseTestCase): assert s.getComponentByPosition(1, instantiate=False) is univ.noValue +class SetPicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.Set( + componentType=namedtype.NamedTypes( + namedtype.NamedType('name', univ.OctetString()) + ) + ) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.Set + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.Set( + componentType=namedtype.NamedTypes( + namedtype.NamedType('name', univ.OctetString()) + ) + ) + old_asn1['name'] = 'test' + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 + assert new_asn1['name'] == str2octs('test') + + class Choice(BaseTestCase): def setUp(self): BaseTestCase.setUp(self) @@ -1590,6 +1814,36 @@ class Choice(BaseTestCase): assert s.getComponentByPosition(1, instantiate=False) is univ.noValue +class ChoicePicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = univ.Choice( + componentType=namedtype.NamedTypes( + namedtype.NamedType('name', univ.OctetString()), + namedtype.NamedType('id', univ.Integer()) + ) + ) + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == univ.Choice + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = univ.Choice( + componentType=namedtype.NamedTypes( + namedtype.NamedType('name', univ.OctetString()), + namedtype.NamedType('id', univ.Integer()) + ) + ) + old_asn1['name'] = 'test' + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 + assert new_asn1['name'] == str2octs('test') + + suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__]) if __name__ == '__main__': diff --git a/tests/type/test_useful.py b/tests/type/test_useful.py index 82a97d7..2af17ff 100644 --- a/tests/type/test_useful.py +++ b/tests/type/test_useful.py @@ -7,6 +7,7 @@ import sys import datetime from copy import deepcopy +import pickle try: import unittest2 as unittest @@ -78,6 +79,24 @@ class GeneralizedTimeTestCase(BaseTestCase): assert dt == deepcopy(dt) +class GeneralizedTimePicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = useful.GeneralizedTime() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == useful.GeneralizedTime + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = useful.GeneralizedTime("20170916234254+0130") + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == old_asn1 + + class UTCTimeTestCase(BaseTestCase): def testFromDateTime(self): @@ -98,6 +117,25 @@ class UTCTimeTestCase(BaseTestCase): def testToDateTime4(self): assert datetime.datetime(2017, 7, 11, 0, 1) == useful.UTCTime('1707110001').asDateTime + +class UTCTimePicklingTestCase(unittest.TestCase): + + def testSchemaPickling(self): + old_asn1 = useful.UTCTime() + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert type(new_asn1) == useful.UTCTime + assert old_asn1.isSameTypeWith(new_asn1) + + def testValuePickling(self): + old_asn1 = useful.UTCTime("170711000102") + serialized = pickle.dumps(old_asn1) + assert serialized + new_asn1 = pickle.loads(serialized) + assert new_asn1 == old_asn1 + + suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__]) if __name__ == '__main__': |