Normalize interface conformance tests.

3 files changed, 88 insertions, 85 deletions

diff --git a/pyramid/tests/test_events.py b/pyramid/tests/test_events.py
index f35083c02..3e9c959d9 100644
--- a/pyramid/tests/test_events.py
+++ b/pyramid/tests/test_events.py
@@ -9,13 +9,13 @@ class NewRequestEventTests(unittest.TestCase):
     def _makeOne(self, request):
         return self._getTargetClass()(request)
 
-    def test_class_implements(self):
+    def test_class_conforms_to_INewRequest(self):
         from pyramid.interfaces import INewRequest
         from zope.interface.verify import verifyClass
         klass = self._getTargetClass()
         verifyClass(INewRequest, klass)
         
-    def test_instance_implements(self):
+    def test_instance_conforms_to_INewRequest(self):
         from pyramid.interfaces import INewRequest
         from zope.interface.verify import verifyObject
         request = DummyRequest()
@@ -35,13 +35,13 @@ class NewResponseEventTests(unittest.TestCase):
     def _makeOne(self, request, response):
         return self._getTargetClass()(request, response)
 
-    def test_class_implements(self):
+    def test_class_conforms_to_INewResponse(self):
         from pyramid.interfaces import INewResponse
         from zope.interface.verify import verifyClass
         klass = self._getTargetClass()
         verifyClass(INewResponse, klass)
         
-    def test_instance_implements(self):
+    def test_instance_conforms_to_INewResponse(self):
         from pyramid.interfaces import INewResponse
         from zope.interface.verify import verifyObject
         request = DummyRequest()
@@ -57,68 +57,72 @@ class NewResponseEventTests(unittest.TestCase):
         self.assertEqual(inst.response, response)
 
 class ApplicationCreatedEventTests(unittest.TestCase):
-    def test_alias_object_implements(self):
-        from pyramid.events import WSGIApplicationCreatedEvent
-        event = WSGIApplicationCreatedEvent(object())
-        from pyramid.interfaces import IWSGIApplicationCreatedEvent
-        from pyramid.interfaces import IApplicationCreated
-        from zope.interface.verify import verifyObject
-        verifyObject(IWSGIApplicationCreatedEvent, event)
-        verifyObject(IApplicationCreated, event)
+    def _getTargetClass(self):
+        from pyramid.events import ApplicationCreated
+        return ApplicationCreated
 
-    def test_alias_class_implements(self):
-        from pyramid.events import WSGIApplicationCreatedEvent
-        from pyramid.interfaces import IWSGIApplicationCreatedEvent
+    def _makeOne(self, context=object()):
+        return self._getTargetClass()(context)
+
+    def test_class_conforms_to_IApplicationCreated(self):
         from pyramid.interfaces import IApplicationCreated
         from zope.interface.verify import verifyClass
-        verifyClass(IWSGIApplicationCreatedEvent, WSGIApplicationCreatedEvent)
-        verifyClass(IApplicationCreated, WSGIApplicationCreatedEvent)
+        verifyClass(IApplicationCreated, self._getTargetClass())
 
-    def test_object_implements(self):
-        from pyramid.events import ApplicationCreated
-        event = ApplicationCreated(object())
+    def test_object_conforms_to_IApplicationCreated(self):
         from pyramid.interfaces import IApplicationCreated
         from zope.interface.verify import verifyObject
-        verifyObject(IApplicationCreated, event)
+        verifyObject(IApplicationCreated, self._makeOne())
 
-    def test_class_implements(self):
-        from pyramid.events import ApplicationCreated
-        from pyramid.interfaces import IApplicationCreated
+class WSGIApplicationCreatedEventTests(ApplicationCreatedEventTests):
+    def _getTargetClass(self):
+        from pyramid.events import WSGIApplicationCreatedEvent
+        return WSGIApplicationCreatedEvent
+
+    def test_class_conforms_to_IWSGIApplicationCreatedEvent(self):
+        from pyramid.interfaces import IWSGIApplicationCreatedEvent
         from zope.interface.verify import verifyClass
-        verifyClass(IApplicationCreated, ApplicationCreated)
+        verifyClass(IWSGIApplicationCreatedEvent, self._getTargetClass())
+
+    def test_object_conforms_to_IWSGIApplicationCreatedEvent(self):
+        from pyramid.interfaces import IWSGIApplicationCreatedEvent
+        from zope.interface.verify import verifyObject
+        verifyObject(IWSGIApplicationCreatedEvent, self._makeOne())
 
 class ContextFoundEventTests(unittest.TestCase):
-    def test_alias_class_implements(self):
+    def _getTargetClass(self):
+        from pyramid.events import ContextFound
+        return ContextFound
+
+    def _makeOne(self, request=None):
+        if request is None:
+            request = DummyRequest()
+        return self._getTargetClass()(request)
+
+    def test_class_conforms_to_IContextFound(self):
         from zope.interface.verify import verifyClass
-        from pyramid.events import AfterTraversal
-        from pyramid.interfaces import IAfterTraversal
         from pyramid.interfaces import IContextFound
-        verifyClass(IAfterTraversal, AfterTraversal)
-        verifyClass(IContextFound, AfterTraversal)
+        verifyClass(IContextFound, self._getTargetClass())
         
-    def test_alias_instance_implements(self):
+    def test_instance_conforms_to_IContextFound(self):
         from zope.interface.verify import verifyObject
-        from pyramid.events import AfterTraversal
-        from pyramid.interfaces import IAfterTraversal
         from pyramid.interfaces import IContextFound
-        request = DummyRequest()
-        inst = AfterTraversal(request)
-        verifyObject(IAfterTraversal, inst)
-        verifyObject(IContextFound, inst)
+        verifyObject(IContextFound, self._makeOne())
 
-    def test_class_implements(self):
+class AfterTraversalEventTests(ContextFoundEventTests):
+    def _getTargetClass(self):
+        from pyramid.events import AfterTraversal
+        return AfterTraversal
+
+    def test_class_conforms_to_IAfterTraversal(self):
         from zope.interface.verify import verifyClass
-        from pyramid.events import ContextFound
-        from pyramid.interfaces import IContextFound
-        verifyClass(IContextFound, ContextFound)
+        from pyramid.interfaces import IAfterTraversal
+        verifyClass(IAfterTraversal, self._getTargetClass())
         
-    def test_instance_implements(self):
+    def test_instance_conforms_to_IAfterTraversal(self):
         from zope.interface.verify import verifyObject
-        from pyramid.events import ContextFound
-        from pyramid.interfaces import IContextFound
-        request = DummyRequest()
-        inst = ContextFound(request)
-        verifyObject(IContextFound, inst)
+        from pyramid.interfaces import IAfterTraversal
+        verifyObject(IAfterTraversal, self._makeOne())
 
 class TestSubscriber(unittest.TestCase):
     def setUp(self):
diff --git a/pyramid/tests/test_path.py b/pyramid/tests/test_path.py
index 42b38d785..ccc56fb0d 100644
--- a/pyramid/tests/test_path.py
+++ b/pyramid/tests/test_path.py
@@ -259,17 +259,15 @@ class TestPkgResourcesAssetDescriptor(unittest.TestCase):
     def _makeOne(self, pkg='pyramid.tests', path='test_asset.py'):
         return self._getTargetClass()(pkg, path)
 
-    def test_class_implements(self):
+    def test_class_conforms_to_IAssetDescriptor(self):
         from pyramid.interfaces import IAssetDescriptor
         from zope.interface.verify import verifyClass
-        klass = self._getTargetClass()
-        verifyClass(IAssetDescriptor, klass)
+        verifyClass(IAssetDescriptor, self._getTargetClass())
         
-    def test_instance_implements(self):
+    def test_instance_conforms_to_IAssetDescriptor(self):
         from pyramid.interfaces import IAssetDescriptor
         from zope.interface.verify import verifyObject
-        inst = self._makeOne()
-        verifyObject(IAssetDescriptor, inst)
+        verifyObject(IAssetDescriptor, self._makeOne())
 
     def test_absspec(self):
         inst = self._makeOne()
@@ -316,17 +314,15 @@ class TestFSAssetDescriptor(unittest.TestCase):
     def _makeOne(self, path=os.path.join(here, 'test_asset.py')):
         return self._getTargetClass()(path)
 
-    def test_class_implements(self):
+    def test_class_conforms_to_IAssetDescriptor(self):
         from pyramid.interfaces import IAssetDescriptor
         from zope.interface.verify import verifyClass
-        klass = self._getTargetClass()
-        verifyClass(IAssetDescriptor, klass)
+        verifyClass(IAssetDescriptor, self._getTargetClass())
         
-    def test_instance_implements(self):
+    def test_instance_conforms_to_IAssetDescriptor(self):
         from pyramid.interfaces import IAssetDescriptor
         from zope.interface.verify import verifyObject
-        inst = self._makeOne()
-        verifyObject(IAssetDescriptor, inst)
+        verifyObject(IAssetDescriptor, self._makeOne())
 
     def test_absspec(self):
         inst = self._makeOne()
diff --git a/pyramid/tests/test_request.py b/pyramid/tests/test_request.py
index 6d5131013..a95d614f9 100644
--- a/pyramid/tests/test_request.py
+++ b/pyramid/tests/test_request.py
@@ -18,13 +18,15 @@ class TestRequest(unittest.TestCase):
     def tearDown(self):
         testing.tearDown()
 
-    def _makeOne(self, environ):
-        return self._getTargetClass()(environ)
-
     def _getTargetClass(self):
         from pyramid.request import Request
         return Request
 
+    def _makeOne(self, environ=None):
+        if environ is None:
+            environ = {}
+        return self._getTargetClass()(environ)
+
     def _registerResourceURL(self):
         from pyramid.interfaces import IResourceURL
         from zope.interface import Interface
@@ -36,6 +38,17 @@ class TestRequest(unittest.TestCase):
             DummyResourceURL, (Interface, Interface),
             IResourceURL)
 
+    def test_class_conforms_to_IRequest(self):
+        from zope.interface.verify import verifyClass
+        from pyramid.interfaces import IRequest
+        verifyClass(IRequest, self._getTargetClass())
+        klass = self._getTargetClass()
+
+    def test_instance_conforms_to_IRequest(self):
+        from zope.interface.verify import verifyObject
+        from pyramid.interfaces import IRequest
+        verifyObject(IRequest, self._makeOne())
+
     def test_charset_defaults_to_utf8(self):
         r = self._makeOne({'PATH_INFO':'/'})
         self.assertEqual(r.charset, 'UTF-8')
@@ -61,25 +74,15 @@ class TestRequest(unittest.TestCase):
         request.charset = None
         self.assertEqual(request.GET['la'], text_(b'La Pe\xf1a'))
 
-    def test_class_implements(self):
-        from pyramid.interfaces import IRequest
-        klass = self._getTargetClass()
-        self.assertTrue(IRequest.implementedBy(klass))
-
-    def test_instance_provides(self):
-        from pyramid.interfaces import IRequest
-        inst = self._makeOne({})
-        self.assertTrue(IRequest.providedBy(inst))
-
     def test_tmpl_context(self):
         from pyramid.request import TemplateContext
-        inst = self._makeOne({})
+        inst = self._makeOne()
         result = inst.tmpl_context
         self.assertEqual(result.__class__, TemplateContext)
 
     def test_session_configured(self):
         from pyramid.interfaces import ISessionFactory
-        inst = self._makeOne({})
+        inst = self._makeOne()
         def factory(request):
             return 'orangejuice'
         self.config.registry.registerUtility(factory, ISessionFactory)
@@ -88,12 +91,12 @@ class TestRequest(unittest.TestCase):
         self.assertEqual(inst.__dict__['session'], 'orangejuice')
 
     def test_session_not_configured(self):
-        inst = self._makeOne({})
+        inst = self._makeOne()
         inst.registry = self.config.registry
         self.assertRaises(AttributeError, getattr, inst, 'session')
 
     def test_setattr_and_getattr_dotnotation(self):
-        inst = self._makeOne({})
+        inst = self._makeOne()
         inst.foo = 1
         self.assertEqual(inst.foo, 1)
 
@@ -105,7 +108,7 @@ class TestRequest(unittest.TestCase):
         self.assertEqual(environ, {}) # make sure we're not using adhoc attrs
 
     def test_add_response_callback(self):
-        inst = self._makeOne({})
+        inst = self._makeOne()
         self.assertEqual(inst.response_callbacks, ())
         def callback(request, response):
             """ """
@@ -115,7 +118,7 @@ class TestRequest(unittest.TestCase):
         self.assertEqual(inst.response_callbacks, [callback, callback])
 
     def test__process_response_callbacks(self):
-        inst = self._makeOne({})
+        inst = self._makeOne()
         def callback1(request, response):
             request.called1 = True
             response.called1 = True
@@ -132,7 +135,7 @@ class TestRequest(unittest.TestCase):
         self.assertEqual(inst.response_callbacks, [])
 
     def test_add_finished_callback(self):
-        inst = self._makeOne({})
+        inst = self._makeOne()
         self.assertEqual(inst.finished_callbacks, ())
         def callback(request):
             """ """
@@ -142,7 +145,7 @@ class TestRequest(unittest.TestCase):
         self.assertEqual(inst.finished_callbacks, [callback, callback])
 
     def test__process_finished_callbacks(self):
-        inst = self._makeOne({})
+        inst = self._makeOne()
         def callback1(request):
             request.called1 = True
         def callback2(request):
@@ -219,13 +222,13 @@ class TestRequest(unittest.TestCase):
                          ('pyramid.tests:static/foo.css', request, {}) )
 
     def test_is_response_false(self):
-        request = self._makeOne({})
+        request = self._makeOne()
         request.registry = self.config.registry
         self.assertEqual(request.is_response('abc'), False)
 
     def test_is_response_false_adapter_is_not_self(self):
         from pyramid.interfaces import IResponse
-        request = self._makeOne({})
+        request = self._makeOne()
         request.registry = self.config.registry
         def adapter(ob):
             return object()
@@ -237,7 +240,7 @@ class TestRequest(unittest.TestCase):
         
     def test_is_response_adapter_true(self):
         from pyramid.interfaces import IResponse
-        request = self._makeOne({})
+        request = self._makeOne()
         request.registry = self.config.registry
         class Foo(object):
             pass
@@ -277,7 +280,7 @@ class TestRequest(unittest.TestCase):
         self.assertRaises(ValueError, getattr, request, 'json_body')
 
     def test_set_property(self):
-        request = self._makeOne({})
+        request = self._makeOne()
         opts = [2, 1]
         def connect(obj):
             return opts.pop()
@@ -286,7 +289,7 @@ class TestRequest(unittest.TestCase):
         self.assertEqual(2, request.db)
 
     def test_set_property_reify(self):
-        request = self._makeOne({})
+        request = self._makeOne()
         opts = [2, 1]
         def connect(obj):
             return opts.pop()