Current File : //lib/python3/dist-packages/zope/interface/tests/test_ro.py
##############################################################################
#
# Copyright (c) 2014 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Resolution ordering utility tests"""
import unittest
# pylint:disable=blacklisted-name,protected-access,attribute-defined-outside-init
class Test__mergeOrderings(unittest.TestCase):
def _callFUT(self, orderings):
from zope.interface.ro import _legacy_mergeOrderings
return _legacy_mergeOrderings(orderings)
def test_empty(self):
self.assertEqual(self._callFUT([]), [])
def test_single(self):
self.assertEqual(self._callFUT(['a', 'b', 'c']), ['a', 'b', 'c'])
def test_w_duplicates(self):
self.assertEqual(self._callFUT([['a'], ['b', 'a']]), ['b', 'a'])
def test_suffix_across_multiple_duplicates(self):
O1 = ['x', 'y', 'z']
O2 = ['q', 'z']
O3 = [1, 3, 5]
O4 = ['z']
self.assertEqual(self._callFUT([O1, O2, O3, O4]),
['x', 'y', 'q', 1, 3, 5, 'z'])
class Test__flatten(unittest.TestCase):
def _callFUT(self, ob):
from zope.interface.ro import _legacy_flatten
return _legacy_flatten(ob)
def test_w_empty_bases(self):
class Foo(object):
pass
foo = Foo()
foo.__bases__ = ()
self.assertEqual(self._callFUT(foo), [foo])
def test_w_single_base(self):
class Foo(object):
pass
self.assertEqual(self._callFUT(Foo), [Foo, object])
def test_w_bases(self):
class Foo(object):
pass
class Bar(Foo):
pass
self.assertEqual(self._callFUT(Bar), [Bar, Foo, object])
def test_w_diamond(self):
class Foo(object):
pass
class Bar(Foo):
pass
class Baz(Foo):
pass
class Qux(Bar, Baz):
pass
self.assertEqual(self._callFUT(Qux),
[Qux, Bar, Foo, object, Baz, Foo, object])
class Test_ro(unittest.TestCase):
maxDiff = None
def _callFUT(self, ob, **kwargs):
from zope.interface.ro import _legacy_ro
return _legacy_ro(ob, **kwargs)
def test_w_empty_bases(self):
class Foo(object):
pass
foo = Foo()
foo.__bases__ = ()
self.assertEqual(self._callFUT(foo), [foo])
def test_w_single_base(self):
class Foo(object):
pass
self.assertEqual(self._callFUT(Foo), [Foo, object])
def test_w_bases(self):
class Foo(object):
pass
class Bar(Foo):
pass
self.assertEqual(self._callFUT(Bar), [Bar, Foo, object])
def test_w_diamond(self):
class Foo(object):
pass
class Bar(Foo):
pass
class Baz(Foo):
pass
class Qux(Bar, Baz):
pass
self.assertEqual(self._callFUT(Qux),
[Qux, Bar, Baz, Foo, object])
def _make_IOErr(self):
# This can't be done in the standard C3 ordering.
class Foo(object):
def __init__(self, name, *bases):
self.__name__ = name
self.__bases__ = bases
def __repr__(self): # pragma: no cover
return self.__name__
# Mimic what classImplements(IOError, IIOError)
# does.
IEx = Foo('IEx')
IStdErr = Foo('IStdErr', IEx)
IEnvErr = Foo('IEnvErr', IStdErr)
IIOErr = Foo('IIOErr', IEnvErr)
IOSErr = Foo('IOSErr', IEnvErr)
IOErr = Foo('IOErr', IEnvErr, IIOErr, IOSErr)
return IOErr, [IOErr, IIOErr, IOSErr, IEnvErr, IStdErr, IEx]
def test_non_orderable(self):
IOErr, bases = self._make_IOErr()
self.assertEqual(self._callFUT(IOErr), bases)
def test_mixed_inheritance_and_implementation(self):
# https://github.com/zopefoundation/zope.interface/issues/8
# This test should fail, but doesn't, as described in that issue.
# pylint:disable=inherit-non-class
from zope.interface import implementer
from zope.interface import Interface
from zope.interface import providedBy
from zope.interface import implementedBy
class IFoo(Interface):
pass
@implementer(IFoo)
class ImplementsFoo(object):
pass
class ExtendsFoo(ImplementsFoo):
pass
class ImplementsNothing(object):
pass
class ExtendsFooImplementsNothing(ExtendsFoo, ImplementsNothing):
pass
self.assertEqual(
self._callFUT(providedBy(ExtendsFooImplementsNothing())),
[implementedBy(ExtendsFooImplementsNothing),
implementedBy(ExtendsFoo),
implementedBy(ImplementsFoo),
IFoo,
Interface,
implementedBy(ImplementsNothing),
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):
Test_ro.setUp(self)
from zope.testing.loggingsupport import InstalledHandler
self.log_handler = handler = InstalledHandler('zope.interface.ro')
self.addCleanup(handler.uninstall)
def _callFUT(self, ob, **kwargs):
from zope.interface.ro import ro
return ro(ob, **kwargs)
def test_complex_diamond(self, base=object):
# https://github.com/zopefoundation/zope.interface/issues/21
O = base
class F(O):
pass
class E(O):
pass
class D(O):
pass
class C(D, F):
pass
class B(D, E):
pass
class A(B, C):
pass
if hasattr(A, 'mro'):
self.assertEqual(A.mro(), self._callFUT(A))
return A
def test_complex_diamond_interface(self):
from zope.interface import Interface
IA = self.test_complex_diamond(Interface)
self.assertEqual(
[x.__name__ for x in IA.__iro__],
['A', 'B', 'C', 'D', 'E', 'F', 'Interface']
)
def test_complex_diamond_use_legacy_argument(self):
from zope.interface import Interface
A = self.test_complex_diamond(Interface)
legacy_A_iro = self._callFUT(A, use_legacy_ro=True)
self.assertNotEqual(A.__iro__, legacy_A_iro)
# And logging happened as a side-effect.
self._check_handler_complex_diamond()
def test_complex_diamond_compare_legacy_argument(self):
from zope.interface import Interface
A = self.test_complex_diamond(Interface)
computed_A_iro = self._callFUT(A, log_changed_ro=True)
# It matches, of course, but we did log a warning.
self.assertEqual(tuple(computed_A_iro), A.__iro__)
self._check_handler_complex_diamond()
def _check_handler_complex_diamond(self):
handler = self.log_handler
self.assertEqual(1, len(handler.records))
record = handler.records[0]
self.assertEqual('\n'.join(l.rstrip() for l in record.getMessage().splitlines()), """\
Object <InterfaceClass zope.interface.tests.test_ro.A> has different legacy and C3 MROs:
Legacy RO (len=7) C3 RO (len=7; inconsistent=no)
==================================================================
zope.interface.tests.test_ro.A zope.interface.tests.test_ro.A
zope.interface.tests.test_ro.B zope.interface.tests.test_ro.B
- zope.interface.tests.test_ro.E
zope.interface.tests.test_ro.C zope.interface.tests.test_ro.C
zope.interface.tests.test_ro.D zope.interface.tests.test_ro.D
+ zope.interface.tests.test_ro.E
zope.interface.tests.test_ro.F zope.interface.tests.test_ro.F
zope.interface.Interface zope.interface.Interface""")
def test_ExtendedPathIndex_implement_thing_implementedby_super(self):
# See https://github.com/zopefoundation/zope.interface/pull/182#issuecomment-598754056
from zope.interface import ro
# pylint:disable=inherit-non-class
class _Based(object):
__bases__ = ()
def __init__(self, name, bases=(), attrs=None):
self.__name__ = name
self.__bases__ = bases
def __repr__(self):
return self.__name__
Interface = _Based('Interface', (), {})
class IPluggableIndex(Interface):
pass
class ILimitedResultIndex(IPluggableIndex):
pass
class IQueryIndex(IPluggableIndex):
pass
class IPathIndex(Interface):
pass
# A parent class who implements two distinct interfaces whose
# only common ancestor is Interface. An easy case.
# @implementer(IPathIndex, IQueryIndex)
# class PathIndex(object):
# pass
obj = _Based('object')
PathIndex = _Based('PathIndex', (IPathIndex, IQueryIndex, obj))
# Child class that tries to put an interface the parent declares
# later ahead of the parent.
# @implementer(ILimitedResultIndex, IQueryIndex)
# class ExtendedPathIndex(PathIndex):
# pass
ExtendedPathIndex = _Based('ExtendedPathIndex',
(ILimitedResultIndex, IQueryIndex, PathIndex))
# 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, strict=False)
self.assertEqual(result, [
ExtendedPathIndex,
ILimitedResultIndex,
PathIndex,
IPathIndex,
IQueryIndex,
IPluggableIndex,
Interface,
obj])
record, = self.log_handler.records
self.assertIn('used the legacy', record.getMessage())
with self.assertRaises(ro.InconsistentResolutionOrderError):
self._callFUT(ExtendedPathIndex, strict=True)
def test_OSError_IOError(self):
if OSError is not IOError:
# Python 2
self.skipTest("Requires Python 3 IOError == OSError")
from zope.interface.common import interfaces
from zope.interface import providedBy
self.assertEqual(
list(providedBy(OSError()).flattened()),
[
interfaces.IOSError,
interfaces.IIOError,
interfaces.IEnvironmentError,
interfaces.IStandardError,
interfaces.IException,
interfaces.Interface,
])
def test_non_orderable(self):
import warnings
from zope.interface import ro
try:
# If we've already warned, we must reset that state.
del ro.__warningregistry__
except AttributeError:
pass
with warnings.catch_warnings():
warnings.simplefilter('error')
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()
IOErr, _ = self._make_IOErr()
with self.assertRaises(ro.InconsistentResolutionOrderError):
self._callFUT(IOErr, strict=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)
iro = self._callFUT(IOErr, strict=False)
legacy_iro = self._callFUT(IOErr, use_legacy_ro=True, strict=False)
self.assertEqual(iro, legacy_iro)
class TestC3(unittest.TestCase):
def _makeOne(self, C, strict=False, base_mros=None):
from zope.interface.ro import C3
return C3.resolver(C, strict, base_mros)
def test_base_mros_given(self):
c3 = self._makeOne(type(self), base_mros={unittest.TestCase: unittest.TestCase.__mro__})
memo = c3.memo
self.assertIn(unittest.TestCase, memo)
# We used the StaticMRO class
self.assertIsNone(memo[unittest.TestCase].had_inconsistency)
def test_one_base_optimization(self):
c3 = self._makeOne(type(self))
# Even though we didn't call .mro() yet, the MRO has been
# computed.
self.assertIsNotNone(c3._C3__mro) # pylint:disable=no-member
c3._merge = None
self.assertEqual(c3.mro(), list(type(self).__mro__))
class Test_ROComparison(unittest.TestCase):
class MockC3(object):
direct_inconsistency = False
bases_had_inconsistency = False
def _makeOne(self, c3=None, c3_ro=(), legacy_ro=()):
from zope.interface.ro import _ROComparison
return _ROComparison(c3 or self.MockC3(), c3_ro, legacy_ro)
def test_inconsistent_label(self):
comp = self._makeOne()
self.assertEqual('no', comp._inconsistent_label)
comp.c3.direct_inconsistency = True
self.assertEqual("direct", comp._inconsistent_label)
comp.c3.bases_had_inconsistency = True
self.assertEqual("direct+bases", comp._inconsistent_label)
comp.c3.direct_inconsistency = False
self.assertEqual('bases', comp._inconsistent_label)
Mini Shell