Make the RO for InterfaceClass consistent and fix handling of the STRICT_IRO env variable.issue192-issue194

Fixes #192 and fixes #194.

Also fix the IRO for OrderedDict on CPython 2

2 files changed, 52 insertions, 13 deletions

diff --git a/src/zope/interface/tests/test_interfaces.py b/src/zope/interface/tests/test_interfaces.py
index 285d857..3f9a504 100644
--- a/src/zope/interface/tests/test_interfaces.py
+++ b/src/zope/interface/tests/test_interfaces.py
@@ -93,3 +93,36 @@ class UnregisteredTests(unittest.TestCase,
         from zope.interface.interfaces import IUnregistered
         from zope.interface.verify import verifyObject
         verifyObject(IUnregistered, self._makeOne())
+
+
+class InterfaceClassTests(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from zope.interface.interface import InterfaceClass
+        return InterfaceClass
+
+    def _getTargetInterface(self):
+        from zope.interface.interfaces import IInterface
+        return IInterface
+
+    def _makeOne(self):
+        from zope.interface.interface import Interface
+        return Interface
+
+    def test_class_conforms(self):
+        from zope.interface.verify import verifyClass
+        verifyClass(self._getTargetInterface(), self._getTargetClass())
+
+    def test_instance_conforms(self):
+        from zope.interface.verify import verifyObject
+        verifyObject(self._getTargetInterface(), self._makeOne())
+
+    def test_instance_consistent__iro__(self):
+        from zope.interface import ro
+        self.assertTrue(ro.is_consistent(self._getTargetInterface()))
+
+    def test_class_consistent__iro__(self):
+        from zope.interface import ro
+        from zope.interface import implementedBy
+
+        self.assertTrue(ro.is_consistent(implementedBy(self._getTargetClass())))
diff --git a/src/zope/interface/tests/test_ro.py b/src/zope/interface/tests/test_ro.py
index ce0a6f4..61f92b6 100644
--- a/src/zope/interface/tests/test_ro.py
+++ b/src/zope/interface/tests/test_ro.py
@@ -176,6 +176,20 @@ class Test_ro(unittest.TestCase):
              implementedBy(object)])
 
 
+class C3Setting(object):
+
+    def __init__(self, setting, value):
+        self._setting = setting
+        self._value = value
+
+    def __enter__(self):
+        from zope.interface import ro
+        setattr(ro.C3, self._setting.__name__, self._value)
+
+    def __exit__(self, t, v, tb):
+        from zope.interface import ro
+        setattr(ro.C3, self._setting.__name__, self._setting)
+
 class Test_c3_ro(Test_ro):
 
     def setUp(self):
@@ -302,7 +316,7 @@ Object <InterfaceClass zope.interface.tests.test_ro.A> has different legacy and
 
         # We were able to resolve it, and in exactly the same way as
         # the legacy RO did, even though it is inconsistent.
-        result = self._callFUT(ExtendedPathIndex, log_changed_ro=True)
+        result = self._callFUT(ExtendedPathIndex, log_changed_ro=True, strict=False)
         self.assertEqual(result, [
             ExtendedPathIndex,
             ILimitedResultIndex,
@@ -348,30 +362,22 @@ Object <InterfaceClass zope.interface.tests.test_ro.A> has different legacy and
 
         with warnings.catch_warnings():
             warnings.simplefilter('error')
-            orig_val = ro.C3.WARN_BAD_IRO
-            ro.C3.WARN_BAD_IRO = True
-            try:
+            with C3Setting(ro.C3.WARN_BAD_IRO, True), C3Setting(ro.C3.STRICT_IRO, False):
                 with self.assertRaises(ro.InconsistentResolutionOrderWarning):
                     super(Test_c3_ro, self).test_non_orderable()
-            finally:
-                ro.C3.WARN_BAD_IRO = orig_val
 
         IOErr, _ = self._make_IOErr()
         with self.assertRaises(ro.InconsistentResolutionOrderError):
             self._callFUT(IOErr, strict=True)
 
-        old_val = ro.C3.TRACK_BAD_IRO
-        try:
-            ro.C3.TRACK_BAD_IRO = True
+        with C3Setting(ro.C3.TRACK_BAD_IRO, True), C3Setting(ro.C3.STRICT_IRO, False):
             with warnings.catch_warnings():
                 warnings.simplefilter('ignore')
                 self._callFUT(IOErr)
             self.assertIn(IOErr, ro.C3.BAD_IROS)
-        finally:
-            ro.C3.TRACK_BAD_IRO = old_val
 
-        iro = self._callFUT(IOErr)
-        legacy_iro = self._callFUT(IOErr, use_legacy_ro=True)
+        iro = self._callFUT(IOErr, strict=False)
+        legacy_iro = self._callFUT(IOErr, use_legacy_ro=True, strict=False)
         self.assertEqual(iro, legacy_iro)