Add a bunch of tests which assert that extension types are defined nicely.
diff --git a/test/test_crypto.py b/test/test_crypto.py
index 9500e41..fce2441 100644
--- a/test/test_crypto.py
+++ b/test/test_crypto.py
@@ -174,7 +174,6 @@
"""
-
class X509ExtTests(TestCase):
"""
Tests for L{OpenSSL.crypto.X509Extension}.
@@ -203,6 +202,16 @@
self.x509.set_notAfter(expire)
+ def test_type(self):
+ """
+ L{X509Extension} and L{X509ExtensionType} refer to the same type object
+ and can be used to create instances of that type.
+ """
+ self.assertIdentical(X509Extension, X509ExtensionType)
+ self.assertConsistentType(
+ X509Extension, 'X509Extension', 'basicConstraints', True, 'CA:true')
+
+
def test_construction(self):
"""
L{X509Extension} accepts an extension type name, a critical flag,
@@ -366,9 +375,18 @@
"""
Unit tests for L{OpenSSL.crypto.PKey}.
"""
+ def test_type(self):
+ """
+ L{PKey} and L{PKeyType} refer to the same type object and can be used
+ to create instances of that type.
+ """
+ self.assertIdentical(PKey, PKeyType)
+ self.assertConsistentType(PKey, 'PKey')
+
+
def test_construction(self):
"""
- L{PKey} takes no arguments and returns a new L{PKeyType} instance.
+ L{PKey} takes no arguments and returns a new L{PKey} instance.
"""
self.assertRaises(TypeError, PKey, None)
key = PKey()
@@ -477,6 +495,21 @@
return name
+ def test_type(self):
+ """
+ The type of X509Name objects is L{X509NameType}.
+ """
+ self.assertIdentical(X509Name, X509NameType)
+ self.assertEqual(X509NameType.__name__, 'X509Name')
+ self.assertTrue(isinstance(X509NameType, type))
+
+ name = self._x509name()
+ self.assertTrue(
+ isinstance(name, X509NameType),
+ "%r is of type %r, should be %r" % (
+ name, type(name), X509NameType))
+
+
def test_attributes(self):
"""
L{X509NameType} instances have attributes for each standard (?)
@@ -688,6 +721,15 @@
return X509Req()
+ def test_type(self):
+ """
+ L{X509Req} and L{X509ReqType} refer to the same type object and can be
+ used to create instances of that type.
+ """
+ self.assertIdentical(X509Req, X509ReqType)
+ self.assertConsistentType(X509Req, 'X509Req')
+
+
def test_construction(self):
"""
L{X509Req} takes no arguments and returns an L{X509ReqType} instance.
@@ -744,6 +786,15 @@
return X509()
+ def test_type(self):
+ """
+ L{X509} and L{X509Type} refer to the same type object and can be used
+ to create instances of that type.
+ """
+ self.assertIdentical(X509, X509Type)
+ self.assertConsistentType(X509, 'X509')
+
+
def test_construction(self):
"""
L{X509} takes no arguments and returns an instance of L{X509Type}.
@@ -754,6 +805,10 @@
"%r is of type %r, should be %r" % (certificate,
type(certificate),
X509Type))
+ self.assertEqual(type(X509Type).__name__, 'type')
+ self.assertEqual(type(certificate).__name__, 'X509')
+ self.assertEqual(type(certificate), X509Type)
+ self.assertEqual(type(certificate), X509)
def test_serial_number(self):
@@ -1034,10 +1089,51 @@
+class PKCS7Tests(TestCase):
+ """
+ Tests for L{PKCS7Type}.
+ """
+ def test_type(self):
+ """
+ L{PKCS7Type} is a type object.
+ """
+ self.assertTrue(isinstance(PKCS7Type, type))
+ self.assertEqual(PKCS7Type.__name__, 'PKCS7')
+
+ # XXX This doesn't currently work.
+ # self.assertIdentical(PKCS7, PKCS7Type)
+
+
+
+class PKCS12Tests(TestCase):
+ """
+ Tests for L{PKCS12Type}.
+ """
+ def test_type(self):
+ """
+ L{PKCS12Type} is a type object.
+ """
+ self.assertTrue(isinstance(PKCS12Type, type))
+ self.assertEqual(PKCS12Type.__name__, 'PKCS12')
+
+ # XXX This doesn't currently work.
+ # self.assertIdentical(PKCS12, PKCS12Type)
+
+
+
class NetscapeSPKITests(TestCase):
"""
Tests for L{OpenSSL.crypto.NetscapeSPKI}.
"""
+ def test_type(self):
+ """
+ L{NetscapeSPKI} and L{NetscapeSPKIType} refer to the same type object
+ and can be used to create instances of that type.
+ """
+ self.assertIdentical(NetscapeSPKI, NetscapeSPKIType)
+ self.assertConsistentType(NetscapeSPKI, 'NetscapeSPKI')
+
+
def test_construction(self):
"""
L{NetscapeSPKI} returns an instance of L{NetscapeSPKIType}.
diff --git a/test/test_ssl.py b/test/test_ssl.py
index a7c744e..bf28ca3 100644
--- a/test/test_ssl.py
+++ b/test/test_ssl.py
@@ -11,9 +11,9 @@
from unittest import main
from OpenSSL.crypto import TYPE_RSA, FILETYPE_PEM, PKey, dump_privatekey, load_certificate, load_privatekey
-from OpenSSL.SSL import WantReadError, Context, Connection, Error
+from OpenSSL.SSL import WantReadError, Context, ContextType, Connection, ConnectionType, Error
from OpenSSL.SSL import SSLv2_METHOD, SSLv3_METHOD, SSLv23_METHOD, TLSv1_METHOD
-from OpenSSL.SSL import OP_NO_SSLv2, OP_NO_SSLv3, OP_SINGLE_DH_USE
+from OpenSSL.SSL import OP_NO_SSLv2, OP_NO_SSLv3, OP_SINGLE_DH_USE
from OpenSSL.SSL import VERIFY_PEER, VERIFY_FAIL_IF_NO_PEER_CERT, VERIFY_CLIENT_ONCE
from OpenSSL.test.util import TestCase
from OpenSSL.test.test_crypto import cleartextCertificatePEM, cleartextPrivateKeyPEM
@@ -33,8 +33,7 @@
def socket_pair():
"""
- Establish and return a pair of network sockets connected
- to each other.
+ Establish and return a pair of network sockets connected to each other.
"""
# Connect a pair of sockets
port = socket()
@@ -77,6 +76,15 @@
self.assertRaises(ValueError, Context, 10)
+ def test_type(self):
+ """
+ L{Context} and L{ContextType} refer to the same type object and can be
+ used to create instances of that type.
+ """
+ self.assertIdentical(Context, ContextType)
+ self.assertConsistentType(Context, 'Context', TLSv1_METHOD)
+
+
def test_use_privatekey(self):
"""
L{Context.use_privatekey} takes an L{OpenSSL.crypto.PKey} instance.
@@ -272,6 +280,34 @@
+class ConnectionTests(TestCase):
+ """
+ Unit tests for L{OpenSSL.SSL.Connection}.
+ """
+ def test_type(self):
+ """
+ L{Connection} and L{ConnectionType} refer to the same type object and
+ can be used to create instances of that type.
+ """
+ self.assertIdentical(Connection, ConnectionType)
+ ctx = Context(TLSv1_METHOD)
+ self.assertConsistentType(Connection, 'Connection', ctx, None)
+
+
+
+class ErrorTests(TestCase):
+ """
+ Unit tests for L{OpenSSL.SSL.Error}.
+ """
+ def test_type(self):
+ """
+ L{Error} is an exception type.
+ """
+ self.assertTrue(issubclass(Error, Exception))
+ self.assertEqual(Error.__name__, 'Error')
+
+
+
class ConstantsTests(TestCase):
"""
Tests for the values of constants exposed in L{OpenSSL.SSL}.
diff --git a/test/util.py b/test/util.py
index e0e25f9..d195d95 100644
--- a/test/util.py
+++ b/test/util.py
@@ -118,3 +118,22 @@
def assertFalse(self, *a, **kw):
return self.failIf(*a, **kw)
+
+
+ # Other stuff
+ def assertConsistentType(self, theType, name, *constructionArgs):
+ """
+ Perform various assertions about C{theType} to ensure that it is a
+ well-defined type. This is useful for extension types, where it's
+ pretty easy to do something wacky. If something about the type is
+ unusual, an exception will be raised.
+
+ @param theType: The type object about which to make assertions.
+ @param name: A string giving the name of the type.
+ @param constructionArgs: Positional arguments to use with C{theType} to
+ create an instance of it.
+ """
+ self.assertEqual(theType.__name__, name)
+ self.assertTrue(isinstance(theType, type))
+ instance = theType(*constructionArgs)
+ self.assertIdentical(type(instance), theType)