[Checkins] SVN: zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/ Scrub nasty shared fixtures.
Tres Seaver
tseaver at palladion.com
Mon Apr 19 11:18:12 EDT 2010
Log message for revision 111110:
Scrub nasty shared fixtures.
Changed:
U zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/test_interface.py
D zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/unitfixtures.py
-=-
Modified: zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/test_interface.py
===================================================================
--- zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/test_interface.py 2010-04-19 15:18:11 UTC (rev 111109)
+++ zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/test_interface.py 2010-04-19 15:18:12 UTC (rev 111110)
@@ -13,420 +13,871 @@
##############################################################################
"""Test Interface implementation
"""
+import unittest
import doctest
-import unittest
-import sys
class InterfaceTests(unittest.TestCase):
- def _makeDerivedInterface(self):
+ def test_attributes_link_to_interface(self):
from zope.interface import Interface
from zope.interface import Attribute
- class _I1(Interface):
- a1 = Attribute("This is an attribute")
+ class I1(Interface):
+ attr = Attribute("My attr")
- def f11():
+ self.failUnless(I1['attr'].interface is I1)
+
+ def test_methods_link_to_interface(self):
+ from zope.interface import Interface
+
+ class I1(Interface):
+
+ def method(foo, bar, bingo):
pass
- def f12():
+
+ self.failUnless(I1['method'].interface is I1)
+
+ def test_classImplements_simple(self):
+ from zope.interface import Interface
+ from zope.interface import implementedBy
+ from zope.interface import providedBy
+
+ class ICurrent(Interface):
+ def method1(a, b):
pass
- f12.optional = 1
+ def method2(a, b):
+ pass
- class _I1_(_I1):
+ class IOther(Interface):
pass
- class _I1__(_I1_):
+ class Current(object):
+ __implemented__ = ICurrent
+ def method1(self, a, b):
+ return 1
+ def method2(self, a, b):
+ return 2
+
+ current = Current()
+
+ self.failUnless(ICurrent.implementedBy(Current))
+ self.failIf(IOther.implementedBy(Current))
+ self.failUnless(ICurrent in implementedBy(Current))
+ self.failIf(IOther in implementedBy(Current))
+ self.failUnless(ICurrent in providedBy(current))
+ self.failIf(IOther in providedBy(current))
+
+ def test_classImplements_base_not_derived(self):
+ from zope.interface import Interface
+ from zope.interface import implementedBy
+ from zope.interface import providedBy
+ class IBase(Interface):
+ def method():
+ pass
+ class IDerived(IBase):
pass
+ class Current():
+ __implemented__ = IBase
+ def method(self):
+ pass
+ current = Current()
- class _I2(_I1__):
- def f21():
+ self.failUnless(IBase.implementedBy(Current))
+ self.failIf(IDerived.implementedBy(Current))
+ self.failUnless(IBase in implementedBy(Current))
+ self.failIf(IDerived in implementedBy(Current))
+ self.failUnless(IBase in providedBy(current))
+ self.failIf(IDerived in providedBy(current))
+
+ def test_classImplements_base_and_derived(self):
+ from zope.interface import Interface
+ from zope.interface import implementedBy
+ from zope.interface import providedBy
+
+ class IBase(Interface):
+ def method():
pass
- def f22():
+
+ class IDerived(IBase):
+ pass
+
+ class Current(object):
+ __implemented__ = IDerived
+ def method(self):
pass
- f23 = f22
- return _I2
+ current = Current()
- def testInterfaceSetOnAttributes(self):
- from zope.interface.tests.unitfixtures import FooInterface
- self.assertEqual(FooInterface['foobar'].interface,
- FooInterface)
- self.assertEqual(FooInterface['aMethod'].interface,
- FooInterface)
+ self.failUnless(IBase.implementedBy(Current))
+ self.failUnless(IDerived.implementedBy(Current))
+ self.failIf(IBase in implementedBy(Current))
+ self.failUnless(IBase in implementedBy(Current).flattened())
+ self.failUnless(IDerived in implementedBy(Current))
+ self.failIf(IBase in providedBy(current))
+ self.failUnless(IBase in providedBy(current).flattened())
+ self.failUnless(IDerived in providedBy(current))
- def testClassImplements(self):
- from zope.interface.tests.unitfixtures import A
- from zope.interface.tests.unitfixtures import B
- from zope.interface.tests.unitfixtures import C
- from zope.interface.tests.unitfixtures import D
- from zope.interface.tests.unitfixtures import E
- from zope.interface.tests.unitfixtures import I1
- from zope.interface.tests.unitfixtures import I2
- from zope.interface.tests.unitfixtures import IC
- self.assert_(IC.implementedBy(C))
+ def test_classImplements_multiple(self):
+ from zope.interface import Interface
+ from zope.interface import implementedBy
+ from zope.interface import providedBy
- self.assert_(I1.implementedBy(A))
- self.assert_(I1.implementedBy(B))
- self.assert_(not I1.implementedBy(C))
- self.assert_(I1.implementedBy(D))
- self.assert_(I1.implementedBy(E))
+ class ILeft(Interface):
+ def method():
+ pass
- self.assert_(not I2.implementedBy(A))
- self.assert_(I2.implementedBy(B))
- self.assert_(not I2.implementedBy(C))
+ class IRight(ILeft):
+ pass
- # No longer after interfacegeddon
- # self.assert_(not I2.implementedBy(D))
+ class Left(object):
+ __implemented__ = ILeft
- self.assert_(not I2.implementedBy(E))
+ def method(self):
+ pass
- def testUtil(self):
+ class Right(object):
+ __implemented__ = IRight
+
+ class Ambi(Left, Right):
+ pass
+
+ ambi = Ambi()
+
+ self.failUnless(ILeft.implementedBy(Ambi))
+ self.failUnless(IRight.implementedBy(Ambi))
+ self.failUnless(ILeft in implementedBy(Ambi))
+ self.failUnless(IRight in implementedBy(Ambi))
+ self.failUnless(ILeft in providedBy(ambi))
+ self.failUnless(IRight in providedBy(ambi))
+
+ def test_classImplements_multiple_w_explict_implements(self):
+ from zope.interface import Interface
from zope.interface import implementedBy
from zope.interface import providedBy
- from zope.interface.tests.unitfixtures import A
- from zope.interface.tests.unitfixtures import B
- from zope.interface.tests.unitfixtures import C
- from zope.interface.tests.unitfixtures import I1
- from zope.interface.tests.unitfixtures import I2
- from zope.interface.tests.unitfixtures import IC
- self.assert_(IC in implementedBy(C))
- self.assert_(I1 in implementedBy(A))
- self.assert_(not I1 in implementedBy(C))
- self.assert_(I2 in implementedBy(B))
- self.assert_(not I2 in implementedBy(C))
- self.assert_(IC in providedBy(C()))
- self.assert_(I1 in providedBy(A()))
- self.assert_(not I1 in providedBy(C()))
- self.assert_(I2 in providedBy(B()))
- self.assert_(not I2 in providedBy(C()))
+ class ILeft(Interface):
+ def method():
+ pass
- def testObjectImplements(self):
- from zope.interface.tests.unitfixtures import A
- from zope.interface.tests.unitfixtures import B
- from zope.interface.tests.unitfixtures import C
- from zope.interface.tests.unitfixtures import D
- from zope.interface.tests.unitfixtures import E
- from zope.interface.tests.unitfixtures import I1
- from zope.interface.tests.unitfixtures import I2
- from zope.interface.tests.unitfixtures import IC
- self.assert_(IC.providedBy(C()))
+ class IRight(ILeft):
+ pass
- self.assert_(I1.providedBy(A()))
- self.assert_(I1.providedBy(B()))
- self.assert_(not I1.providedBy(C()))
- self.assert_(I1.providedBy(D()))
- self.assert_(I1.providedBy(E()))
+ class IOther(Interface):
+ pass
- self.assert_(not I2.providedBy(A()))
- self.assert_(I2.providedBy(B()))
- self.assert_(not I2.providedBy(C()))
+ class Left():
+ __implemented__ = ILeft
- # Not after interface geddon
- # self.assert_(not I2.providedBy(D()))
+ def method(self):
+ pass
- self.assert_(not I2.providedBy(E()))
+ class Right(object):
+ __implemented__ = IRight
- def testDeferredClass(self):
- from zope.interface.tests.unitfixtures import A
+ class Other(object):
+ __implemented__ = IOther
+
+ class Mixed(Left, Right):
+ __implemented__ = Left.__implemented__, Other.__implemented__
+
+ mixed = Mixed()
+
+ self.failUnless(ILeft.implementedBy(Mixed))
+ self.failIf(IRight.implementedBy(Mixed))
+ self.failUnless(IOther.implementedBy(Mixed))
+ self.failUnless(ILeft in implementedBy(Mixed))
+ self.failIf(IRight in implementedBy(Mixed))
+ self.failUnless(IOther in implementedBy(Mixed))
+ self.failUnless(ILeft in providedBy(mixed))
+ self.failIf(IRight in providedBy(mixed))
+ self.failUnless(IOther in providedBy(mixed))
+
+ def test_interface_deferred_class_method_broken(self):
+ from zope.interface import Interface
from zope.interface.exceptions import BrokenImplementation
- a = A()
- self.assertRaises(BrokenImplementation, a.ma)
+ class IDeferring(Interface):
+ def method():
+ pass
+ class Deferring(IDeferring.deferred()):
+ __implemented__ = IDeferring
+
+ deferring = Deferring()
+
+ self.assertRaises(BrokenImplementation, deferring.method)
+
def testInterfaceExtendsInterface(self):
- from zope.interface.tests.unitfixtures import BazInterface
- from zope.interface.tests.unitfixtures import BarInterface
- from zope.interface.tests.unitfixtures import BobInterface
- from zope.interface.tests.unitfixtures import FunInterface
- self.assert_(BazInterface.extends(BobInterface))
- self.assert_(BazInterface.extends(BarInterface))
- self.assert_(BazInterface.extends(FunInterface))
- self.assert_(not BobInterface.extends(FunInterface))
- self.assert_(not BobInterface.extends(BarInterface))
- self.assert_(BarInterface.extends(FunInterface))
- self.assert_(not BarInterface.extends(BazInterface))
+ from zope.interface import Interface
- def testVerifyImplementation(self):
+ new = Interface.__class__
+ FunInterface = new('FunInterface')
+ BarInterface = new('BarInterface', [FunInterface])
+ BobInterface = new('BobInterface')
+ BazInterface = new('BazInterface', [BobInterface, BarInterface])
+
+ self.failUnless(BazInterface.extends(BobInterface))
+ self.failUnless(BazInterface.extends(BarInterface))
+ self.failUnless(BazInterface.extends(FunInterface))
+ self.failIf(BobInterface.extends(FunInterface))
+ self.failIf(BobInterface.extends(BarInterface))
+ self.failUnless(BarInterface.extends(FunInterface))
+ self.failIf(BarInterface.extends(BazInterface))
+
+ def test_verifyClass(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
from zope.interface.verify import verifyClass
+
+ class ICheckMe(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ pass
+
+ class CheckMe(object):
+ __implemented__ = ICheckMe
+ attr = 'value'
+
+ def method(self):
+ pass
+
+ self.failUnless(verifyClass(ICheckMe, CheckMe))
+
+ def test_verifyObject(self):
+ from zope.interface import Attribute
from zope.interface import Interface
- from zope.interface.tests.unitfixtures import Foo
- from zope.interface.tests.unitfixtures import FooInterface
- from zope.interface.tests.unitfixtures import I1
- self.assert_(verifyClass(FooInterface, Foo))
- self.assert_(Interface.providedBy(I1))
+ from zope.interface.verify import verifyObject
- def test_names(self):
- iface = self._makeDerivedInterface()
- names = list(iface.names())
- names.sort()
- self.assertEqual(names, ['f21', 'f22', 'f23'])
- all = list(iface.names(all=True))
- all.sort()
- self.assertEqual(all, ['a1', 'f11', 'f12', 'f21', 'f22', 'f23'])
+ class ICheckMe(Interface):
+ attr = Attribute(u'My attr')
- def test_namesAndDescriptions(self):
- iface = self._makeDerivedInterface()
- names = [nd[0] for nd in iface.namesAndDescriptions()]
- names.sort()
- self.assertEqual(names, ['f21', 'f22', 'f23'])
- names = [nd[0] for nd in iface.namesAndDescriptions(1)]
- names.sort()
- self.assertEqual(names, ['a1', 'f11', 'f12', 'f21', 'f22', 'f23'])
+ def method():
+ pass
- for name, d in iface.namesAndDescriptions(1):
- self.assertEqual(name, d.__name__)
+ class CheckMe(object):
+ __implemented__ = ICheckMe
+ attr = 'value'
- def test_getDescriptionFor(self):
- iface = self._makeDerivedInterface()
- self.assertEqual(iface.getDescriptionFor('f11').__name__, 'f11')
- self.assertEqual(iface.getDescriptionFor('f22').__name__, 'f22')
- self.assertEqual(iface.queryDescriptionFor('f33', self), self)
- self.assertRaises(KeyError, iface.getDescriptionFor, 'f33')
+ def method(self):
+ pass
- def test___getitem__(self):
- iface = self._makeDerivedInterface()
- self.assertEqual(iface['f11'].__name__, 'f11')
- self.assertEqual(iface['f22'].__name__, 'f22')
- self.assertEqual(iface.get('f33', self), self)
- self.assertRaises(KeyError, iface.__getitem__, 'f33')
+ check_me = CheckMe()
- def test___contains__(self):
- iface = self._makeDerivedInterface()
- self.failUnless('f11' in iface)
- self.failIf('f33' in iface)
+ self.failUnless(verifyObject(ICheckMe, check_me))
- def test___iter__(self):
- iface = self._makeDerivedInterface()
- names = list(iter(iface))
- names.sort()
- self.assertEqual(names, ['a1', 'f11', 'f12', 'f21', 'f22', 'f23'])
+ def test_interface_object_provides_Interface(self):
+ from zope.interface import Interface
- def testAttr(self):
- iface = self._makeDerivedInterface()
- description = iface.getDescriptionFor('a1')
- self.assertEqual(description.__name__, 'a1')
- self.assertEqual(description.__doc__, 'This is an attribute')
+ class AnInterface(Interface):
+ pass
- def testFunctionAttributes(self):
- # Make sure function attributes become tagged values.
+ self.assert_(Interface.providedBy(AnInterface))
+
+ def test_names_simple(self):
+ from zope.interface import Attribute
from zope.interface import Interface
- class ITest(Interface):
+
+ class ISimple(Interface):
+ attr = Attribute(u'My attr')
+
def method():
pass
+
+ self.assertEqual(sorted(ISimple.names()), ['attr', 'method'])
+
+ def test_names_derived(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+
+ class IBase(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ pass
+
+ class IDerived(IBase):
+ attr2 = Attribute(u'My attr')
+
+ def method():
+ pass
+
+ def method2():
+ pass
+
+ self.assertEqual(sorted(IDerived.names()),
+ ['attr2', 'method', 'method2'])
+ self.assertEqual(sorted(IDerived.names(all=True)),
+ ['attr', 'attr2', 'method', 'method2'])
+
+ def test_namesAndDescriptions_simple(self):
+ from zope.interface import Attribute
+ from zope.interface.interface import Method
+ from zope.interface import Interface
+
+ class ISimple(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ name_values = sorted(ISimple.namesAndDescriptions())
+
+ self.assertEqual(len(name_values), 2)
+ self.assertEqual(name_values[0][0], 'attr')
+ self.failUnless(isinstance(name_values[0][1], Attribute))
+ self.assertEqual(name_values[0][1].__name__, 'attr')
+ self.assertEqual(name_values[0][1].__doc__, 'My attr')
+ self.assertEqual(name_values[1][0], 'method')
+ self.failUnless(isinstance(name_values[1][1], Method))
+ self.assertEqual(name_values[1][1].__name__, 'method')
+ self.assertEqual(name_values[1][1].__doc__, 'My method')
+
+ def test_namesAndDescriptions_derived(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+ from zope.interface.interface import Method
+
+ class IBase(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ class IDerived(IBase):
+ attr2 = Attribute(u'My attr2')
+
+ def method():
+ "My method, overridden"
+
+ def method2():
+ "My method2"
+
+ name_values = sorted(IDerived.namesAndDescriptions())
+
+ self.assertEqual(len(name_values), 3)
+ self.assertEqual(name_values[0][0], 'attr2')
+ self.failUnless(isinstance(name_values[0][1], Attribute))
+ self.assertEqual(name_values[0][1].__name__, 'attr2')
+ self.assertEqual(name_values[0][1].__doc__, 'My attr2')
+ self.assertEqual(name_values[1][0], 'method')
+ self.failUnless(isinstance(name_values[1][1], Method))
+ self.assertEqual(name_values[1][1].__name__, 'method')
+ self.assertEqual(name_values[1][1].__doc__, 'My method, overridden')
+ self.assertEqual(name_values[2][0], 'method2')
+ self.failUnless(isinstance(name_values[2][1], Method))
+ self.assertEqual(name_values[2][1].__name__, 'method2')
+ self.assertEqual(name_values[2][1].__doc__, 'My method2')
+
+ name_values = sorted(IDerived.namesAndDescriptions(all=True))
+
+ self.assertEqual(len(name_values), 4)
+ self.assertEqual(name_values[0][0], 'attr')
+ self.failUnless(isinstance(name_values[0][1], Attribute))
+ self.assertEqual(name_values[0][1].__name__, 'attr')
+ self.assertEqual(name_values[0][1].__doc__, 'My attr')
+ self.assertEqual(name_values[1][0], 'attr2')
+ self.failUnless(isinstance(name_values[1][1], Attribute))
+ self.assertEqual(name_values[1][1].__name__, 'attr2')
+ self.assertEqual(name_values[1][1].__doc__, 'My attr2')
+ self.assertEqual(name_values[2][0], 'method')
+ self.failUnless(isinstance(name_values[2][1], Method))
+ self.assertEqual(name_values[2][1].__name__, 'method')
+ self.assertEqual(name_values[2][1].__doc__, 'My method, overridden')
+ self.assertEqual(name_values[3][0], 'method2')
+ self.failUnless(isinstance(name_values[3][1], Method))
+ self.assertEqual(name_values[3][1].__name__, 'method2')
+ self.assertEqual(name_values[3][1].__doc__, 'My method2')
+
+ def test_getDescriptionFor_nonesuch_no_default(self):
+ from zope.interface import Interface
+
+ class IEmpty(Interface):
+ pass
+
+ self.assertRaises(KeyError, IEmpty.getDescriptionFor, 'nonesuch')
+
+ def test_getDescriptionFor_simple(self):
+ from zope.interface import Attribute
+ from zope.interface.interface import Method
+ from zope.interface import Interface
+
+ class ISimple(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ a_desc = ISimple.getDescriptionFor('attr')
+ self.failUnless(isinstance(a_desc, Attribute))
+ self.assertEqual(a_desc.__name__, 'attr')
+ self.assertEqual(a_desc.__doc__, 'My attr')
+
+ m_desc = ISimple.getDescriptionFor('method')
+ self.failUnless(isinstance(m_desc, Method))
+ self.assertEqual(m_desc.__name__, 'method')
+ self.assertEqual(m_desc.__doc__, 'My method')
+
+ def test_getDescriptionFor_derived(self):
+ from zope.interface import Attribute
+ from zope.interface.interface import Method
+ from zope.interface import Interface
+
+ class IBase(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ class IDerived(IBase):
+ attr2 = Attribute(u'My attr2')
+
+ def method():
+ "My method, overridden"
+
+ def method2():
+ "My method2"
+
+ a_desc = IDerived.getDescriptionFor('attr')
+ self.failUnless(isinstance(a_desc, Attribute))
+ self.assertEqual(a_desc.__name__, 'attr')
+ self.assertEqual(a_desc.__doc__, 'My attr')
+
+ m_desc = IDerived.getDescriptionFor('method')
+ self.failUnless(isinstance(m_desc, Method))
+ self.assertEqual(m_desc.__name__, 'method')
+ self.assertEqual(m_desc.__doc__, 'My method, overridden')
+
+ a2_desc = IDerived.getDescriptionFor('attr2')
+ self.failUnless(isinstance(a2_desc, Attribute))
+ self.assertEqual(a2_desc.__name__, 'attr2')
+ self.assertEqual(a2_desc.__doc__, 'My attr2')
+
+ m2_desc = IDerived.getDescriptionFor('method2')
+ self.failUnless(isinstance(m2_desc, Method))
+ self.assertEqual(m2_desc.__name__, 'method2')
+ self.assertEqual(m2_desc.__doc__, 'My method2')
+
+ def test___getitem__nonesuch(self):
+ from zope.interface import Interface
+
+ class IEmpty(Interface):
+ pass
+
+ self.assertRaises(KeyError, IEmpty.__getitem__, 'nonesuch')
+
+ def test___getitem__simple(self):
+ from zope.interface import Attribute
+ from zope.interface.interface import Method
+ from zope.interface import Interface
+
+ class ISimple(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ a_desc = ISimple['attr']
+ self.failUnless(isinstance(a_desc, Attribute))
+ self.assertEqual(a_desc.__name__, 'attr')
+ self.assertEqual(a_desc.__doc__, 'My attr')
+
+ m_desc = ISimple['method']
+ self.failUnless(isinstance(m_desc, Method))
+ self.assertEqual(m_desc.__name__, 'method')
+ self.assertEqual(m_desc.__doc__, 'My method')
+
+ def test___getitem___derived(self):
+ from zope.interface import Attribute
+ from zope.interface.interface import Method
+ from zope.interface import Interface
+
+ class IBase(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ class IDerived(IBase):
+ attr2 = Attribute(u'My attr2')
+
+ def method():
+ "My method, overridden"
+
+ def method2():
+ "My method2"
+
+ a_desc = IDerived['attr']
+ self.failUnless(isinstance(a_desc, Attribute))
+ self.assertEqual(a_desc.__name__, 'attr')
+ self.assertEqual(a_desc.__doc__, 'My attr')
+
+ m_desc = IDerived['method']
+ self.failUnless(isinstance(m_desc, Method))
+ self.assertEqual(m_desc.__name__, 'method')
+ self.assertEqual(m_desc.__doc__, 'My method, overridden')
+
+ a2_desc = IDerived['attr2']
+ self.failUnless(isinstance(a2_desc, Attribute))
+ self.assertEqual(a2_desc.__name__, 'attr2')
+ self.assertEqual(a2_desc.__doc__, 'My attr2')
+
+ m2_desc = IDerived['method2']
+ self.failUnless(isinstance(m2_desc, Method))
+ self.assertEqual(m2_desc.__name__, 'method2')
+ self.assertEqual(m2_desc.__doc__, 'My method2')
+
+ def test___contains__nonesuch(self):
+ from zope.interface import Interface
+
+ class IEmpty(Interface):
+ pass
+
+ self.failIf('nonesuch' in IEmpty)
+
+ def test___contains__simple(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+
+ class ISimple(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ self.failUnless('attr' in ISimple)
+ self.failUnless('method' in ISimple)
+
+ def test___contains__derived(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+
+ class IBase(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ class IDerived(IBase):
+ attr2 = Attribute(u'My attr2')
+
+ def method():
+ "My method, overridden"
+
+ def method2():
+ "My method2"
+
+ self.failUnless('attr' in IDerived)
+ self.failUnless('method' in IDerived)
+ self.failUnless('attr2' in IDerived)
+ self.failUnless('method2' in IDerived)
+
+ def test___iter__empty(self):
+ from zope.interface import Interface
+
+ class IEmpty(Interface):
+ pass
+
+ self.assertEqual(list(IEmpty), [])
+
+ def test___iter__simple(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+
+ class ISimple(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ self.assertEqual(sorted(list(ISimple)), ['attr', 'method'])
+
+ def test___iter__derived(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+
+ class IBase(Interface):
+ attr = Attribute(u'My attr')
+
+ def method():
+ "My method"
+
+ class IDerived(IBase):
+ attr2 = Attribute(u'My attr2')
+
+ def method():
+ "My method, overridden"
+
+ def method2():
+ "My method2"
+
+ self.assertEqual(sorted(list(IDerived)),
+ ['attr', 'attr2', 'method', 'method2'])
+
+ def test_function_attributes_become_tagged_values(self):
+ from zope.interface import Interface
+
+ class ITagMe(Interface):
+ def method():
+ pass
method.optional = 1
- method = ITest['method']
+ method = ITagMe['method']
self.assertEqual(method.getTaggedValue('optional'), 1)
- def testInvariant(self):
+ def test___doc___non_element(self):
+ from zope.interface import Interface
+
+ class IHaveADocString(Interface):
+ "xxx"
+
+ self.assertEqual(IHaveADocString.__doc__, "xxx")
+ self.assertEqual(list(IHaveADocString), [])
+
+ def test___doc___as_element(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+
+ class IHaveADocString(Interface):
+ "xxx"
+ __doc__ = Attribute('the doc')
+
+ self.assertEqual(IHaveADocString.__doc__, "")
+ self.assertEqual(list(IHaveADocString), ['__doc__'])
+
+ def _errorsEqual(self, has_invariant, error_len, error_msgs, iface):
from zope.interface.exceptions import Invalid
+ self.assertRaises(Invalid, iface.validateInvariants, has_invariant)
+ e = []
+ try:
+ iface.validateInvariants(has_invariant, e)
+ except Invalid, error:
+ self.assertEquals(error.args[0], e)
+ else:
+ self._assert(0) # validateInvariants should always raise
+ # Invalid
+ self.assertEquals(len(e), error_len)
+ msgs = [error.args[0] for error in e]
+ msgs.sort()
+ for msg in msgs:
+ self.assertEquals(msg, error_msgs.pop(0))
+
+ def test_invariant_simple(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
from zope.interface import directlyProvides
- from zope.interface.tests.unitfixtures import BarGreaterThanFoo
- from zope.interface.tests.unitfixtures import ifFooThenBar
- from zope.interface.tests.unitfixtures import IInvariant
- from zope.interface.tests.unitfixtures import InvariantC
- from zope.interface.tests.unitfixtures import ISubInvariant
+ from zope.interface import invariant
+
+ class IInvariant(Interface):
+ foo = Attribute('foo')
+ bar = Attribute('bar; must eval to Boolean True if foo does')
+ invariant(_ifFooThenBar)
+
+ class HasInvariant(object):
+ pass
+
# set up
- o = InvariantC()
- directlyProvides(o, IInvariant)
- # a helper
- def errorsEqual(self, o, error_len, error_msgs, iface=None):
- if iface is None:
- iface = IInvariant
- self.assertRaises(Invalid, iface.validateInvariants, o)
- e = []
- try:
- iface.validateInvariants(o, e)
- except Invalid, error:
- self.assertEquals(error.args[0], e)
- else:
- self._assert(0) # validateInvariants should always raise
- # Invalid
- self.assertEquals(len(e), error_len)
- msgs = [error.args[0] for error in e]
- msgs.sort()
- for msg in msgs:
- self.assertEquals(msg, error_msgs.pop(0))
+ has_invariant = HasInvariant()
+ directlyProvides(has_invariant, IInvariant)
# the tests
self.assertEquals(IInvariant.getTaggedValue('invariants'),
- [ifFooThenBar])
- self.assertEquals(IInvariant.validateInvariants(o), None)
- o.bar = 27
- self.assertEquals(IInvariant.validateInvariants(o), None)
- o.foo = 42
- self.assertEquals(IInvariant.validateInvariants(o), None)
- del o.bar
- errorsEqual(self, o, 1, ['If Foo, then Bar!'])
+ [_ifFooThenBar])
+ self.assertEquals(IInvariant.validateInvariants(has_invariant), None)
+ has_invariant.bar = 27
+ self.assertEquals(IInvariant.validateInvariants(has_invariant), None)
+ has_invariant.foo = 42
+ self.assertEquals(IInvariant.validateInvariants(has_invariant), None)
+ del has_invariant.bar
+ self._errorsEqual(has_invariant, 1, ['If Foo, then Bar!'],
+ IInvariant)
+
+ def test_invariant_nested(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+ from zope.interface import directlyProvides
+ from zope.interface import invariant
+
+ class IInvariant(Interface):
+ foo = Attribute('foo')
+ bar = Attribute('bar; must eval to Boolean True if foo does')
+ invariant(_ifFooThenBar)
+
+ class ISubInvariant(IInvariant):
+ invariant(_barGreaterThanFoo)
+
+ class HasInvariant(object):
+ pass
+
# nested interfaces with invariants:
self.assertEquals(ISubInvariant.getTaggedValue('invariants'),
- [BarGreaterThanFoo])
- o = InvariantC()
- directlyProvides(o, ISubInvariant)
- o.foo = 42
+ [_barGreaterThanFoo])
+ has_invariant = HasInvariant()
+ directlyProvides(has_invariant, ISubInvariant)
+ has_invariant.foo = 42
# even though the interface has changed, we should still only have one
# error.
- errorsEqual(self, o, 1, ['If Foo, then Bar!'], ISubInvariant)
+ self._errorsEqual(has_invariant, 1, ['If Foo, then Bar!'],
+ ISubInvariant)
# however, if we set foo to 0 (Boolean False) and bar to a negative
# number then we'll get the new error
- o.foo = 2
- o.bar = 1
- errorsEqual(self, o, 1, ['Please, Boo MUST be greater than Foo!'],
- ISubInvariant)
+ has_invariant.foo = 2
+ has_invariant.bar = 1
+ self._errorsEqual(has_invariant, 1,
+ ['Please, Boo MUST be greater than Foo!'],
+ ISubInvariant)
# and if we set foo to a positive number and boo to 0, we'll
# get both errors!
- o.foo = 1
- o.bar = 0
- errorsEqual(self, o, 2, ['If Foo, then Bar!',
- 'Please, Boo MUST be greater than Foo!'],
- ISubInvariant)
+ has_invariant.foo = 1
+ has_invariant.bar = 0
+ self._errorsEqual(has_invariant, 2,
+ ['If Foo, then Bar!',
+ 'Please, Boo MUST be greater than Foo!'],
+ ISubInvariant)
# for a happy ending, we'll make the invariants happy
- o.foo = 1
- o.bar = 2
- self.assertEquals(IInvariant.validateInvariants(o), None) # woohoo
+ has_invariant.foo = 1
+ has_invariant.bar = 2
+ self.assertEquals(IInvariant.validateInvariants(has_invariant), None)
+
+ def test_invariant_mutandis(self):
+ from zope.interface import Attribute
+ from zope.interface import Interface
+ from zope.interface import directlyProvides
+ from zope.interface import invariant
+
+ class IInvariant(Interface):
+ foo = Attribute('foo')
+ bar = Attribute('bar; must eval to Boolean True if foo does')
+ invariant(_ifFooThenBar)
+
+ class HasInvariant(object):
+ pass
+
# now we'll do two invariants on the same interface,
# just to make sure that a small
# multi-invariant interface is at least minimally tested.
- o = InvariantC()
- directlyProvides(o, IInvariant)
- o.foo = 42
+ has_invariant = HasInvariant()
+ directlyProvides(has_invariant, IInvariant)
+ has_invariant.foo = 42
+
+ # if you really need to mutate, then this would be the way to do it.
+ # Probably a bad idea, though. :-)
old_invariants = IInvariant.getTaggedValue('invariants')
invariants = old_invariants[:]
- invariants.append(BarGreaterThanFoo) # if you really need to mutate,
- # then this would be the way to do it. Probably a bad idea, though. :-)
+ invariants.append(_barGreaterThanFoo)
IInvariant.setTaggedValue('invariants', invariants)
- #
+
# even though the interface has changed, we should still only have one
# error.
- errorsEqual(self, o, 1, ['If Foo, then Bar!'])
+ self._errorsEqual(has_invariant, 1, ['If Foo, then Bar!'],
+ IInvariant)
# however, if we set foo to 0 (Boolean False) and bar to a negative
# number then we'll get the new error
- o.foo = 2
- o.bar = 1
- errorsEqual(self, o, 1, ['Please, Boo MUST be greater than Foo!'])
+ has_invariant.foo = 2
+ has_invariant.bar = 1
+ self._errorsEqual(has_invariant, 1,
+ ['Please, Boo MUST be greater than Foo!'], IInvariant)
# and if we set foo to a positive number and boo to 0, we'll
# get both errors!
- o.foo = 1
- o.bar = 0
- errorsEqual(self, o, 2, ['If Foo, then Bar!',
- 'Please, Boo MUST be greater than Foo!'])
+ has_invariant.foo = 1
+ has_invariant.bar = 0
+ self._errorsEqual(has_invariant, 2,
+ ['If Foo, then Bar!',
+ 'Please, Boo MUST be greater than Foo!'],
+ IInvariant)
# for another happy ending, we'll make the invariants happy again
- o.foo = 1
- o.bar = 2
- self.assertEquals(IInvariant.validateInvariants(o), None) # bliss
- # clean up
- IInvariant.setTaggedValue('invariants', old_invariants)
+ has_invariant.foo = 1
+ has_invariant.bar = 2
+ self.assertEquals(IInvariant.validateInvariants(has_invariant), None)
- def test___doc___element(self):
- from zope.interface import Interface
- from zope.interface import Attribute
- class I(Interface):
- "xxx"
-
- self.assertEqual(I.__doc__, "xxx")
- self.assertEqual(list(I), [])
-
- class I(Interface):
- "xxx"
-
- __doc__ = Attribute('the doc')
-
- self.assertEqual(I.__doc__, "")
- self.assertEqual(list(I), ['__doc__'])
-
def testIssue228(self):
- from zope.interface import Interface
# Test for http://collector.zope.org/Zope3-dev/228
- if sys.version[0] == '3':
+ # Old style classes don't have a '__class__' attribute
+ import sys
+ if sys.version[0] < '3':
# No old style classes in Python 3, so the test becomes moot.
- return
- class I(Interface):
- "xxx"
- class Bad:
- __providedBy__ = None
- # Old style classes don't have a '__class__' attribute
- self.failUnlessRaises(AttributeError, I.providedBy, Bad)
+ from zope.interface import Interface
+ class I(Interface):
+ "xxx"
+ class OldStyle:
+ __providedBy__ = None
-if sys.version_info >= (2, 4):
+ self.assertRaises(AttributeError, I.providedBy, OldStyle)
- def test_invariant_as_decorator():
- """Invaiants can be deined in line
+ def test_invariant_as_decorator(self):
+ from zope.interface import Interface
+ from zope.interface import Attribute
+ from zope.interface import implements
+ from zope.interface import invariant
+ from zope.interface.exceptions import Invalid
- >>> from zope.interface.exceptions import Invalid
- >>> from zope.interface import Interface
- >>> from zope.interface import Attribute
- >>> from zope.interface import implements
- >>> from zope.interface import invariant
- >>> class IRange(Interface):
- ... min = Attribute("Lower bound")
- ... max = Attribute("Upper bound")
- ...
- ... @invariant
- ... def range_invariant(ob):
- ... if ob.max < ob.min:
- ... raise Invalid('max < min')
+ class IRange(Interface):
+ min = Attribute("Lower bound")
+ max = Attribute("Upper bound")
+
+ @invariant
+ def range_invariant(ob):
+ if ob.max < ob.min:
+ raise Invalid('max < min')
+ class Range(object):
+ implements(IRange)
- >>> class Range(object):
- ... implements(IRange)
- ...
- ... def __init__(self, min, max):
- ... self.min, self.max = min, max
+ def __init__(self, min, max):
+ self.min, self.max = min, max
- >>> from zope.interface.exceptions import Invalid
- >>> IRange.validateInvariants(Range(1,2))
- >>> IRange.validateInvariants(Range(1,1))
- >>> try:
- ... IRange.validateInvariants(Range(2,1))
- ... except Invalid, e:
- ... str(e)
- 'max < min'
+ IRange.validateInvariants(Range(1,2))
+ IRange.validateInvariants(Range(1,1))
+ try:
+ IRange.validateInvariants(Range(2,1))
+ except Invalid, e:
+ self.assertEqual(str(e), 'max < min')
+ def test_description_cache_management(self):
+ # See https://bugs.launchpad.net/zope.interface/+bug/185974
+ # There was a bug where the cache used by Specification.get() was not
+ # cleared when the bases were changed.
+ from zope.interface import Interface
+ from zope.interface import Attribute
- """
+ class I1(Interface):
+ a = Attribute('a')
+ class I2(I1):
+ pass
-def test_description_cache_management():
- """ See https://bugs.launchpad.net/zope.interface/+bug/185974
+ class I3(I2):
+ pass
-There was a bug where the cache used by Specification.get() was not
-cleared when the bases were changed.
+ self.failUnless(I3.get('a') is I1.get('a'))
- >>> from zope.interface import Interface
- >>> from zope.interface import Attribute
- >>> class I1(Interface):
- ... a = Attribute('a')
+ I2.__bases__ = (Interface,)
+ self.failUnless(I3.get('a') is None)
- >>> class I2(I1):
- ... pass
+def _barGreaterThanFoo(obj):
+ from zope.interface.exceptions import Invalid
+ foo = getattr(obj, 'foo', None)
+ bar = getattr(obj, 'bar', None)
+ if foo is not None and isinstance(foo, type(bar)):
+ # type checking should be handled elsewhere (like, say,
+ # schema); these invariants should be intra-interface
+ # constraints. This is a hacky way to do it, maybe, but you
+ # get the idea
+ if not bar > foo:
+ raise Invalid('Please, Boo MUST be greater than Foo!')
- >>> class I3(I2):
- ... pass
+def _ifFooThenBar(obj):
+ from zope.interface.exceptions import Invalid
+ if getattr(obj, 'foo', None) and not getattr(obj, 'bar', None):
+ raise Invalid('If Foo, then Bar!')
- >>> I3.get('a') is I1.get('a')
- True
- >>> I2.__bases__ = (Interface,)
- >>> I3.get('a') is None
- True
- """
+
def test_suite():
suite = unittest.makeSuite(InterfaceTests)
+ suite.addTest(doctest.DocTestSuite())
suite.addTest(doctest.DocTestSuite("zope.interface.interface"))
- if sys.version_info >= (2, 4):
- suite.addTest(doctest.DocTestSuite())
- suite.addTest(doctest.DocFileSuite(
- '../README.txt',
- globs={'__name__': '__main__'},
- optionflags=doctest.NORMALIZE_WHITESPACE|doctest.ELLIPSIS,
- ))
- suite.addTest(doctest.DocFileSuite(
- '../README.ru.txt',
- globs={'__name__': '__main__'},
- optionflags=doctest.NORMALIZE_WHITESPACE|doctest.ELLIPSIS,
- ))
return suite
Deleted: zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/unitfixtures.py
===================================================================
--- zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/unitfixtures.py 2010-04-19 15:18:11 UTC (rev 111109)
+++ zope.interface/branches/tseaver-better_unit_tests/src/zope/interface/tests/unitfixtures.py 2010-04-19 15:18:12 UTC (rev 111110)
@@ -1,142 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2001, 2002 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.
-#
-##############################################################################
-"""Unit Test Fixtures
-
-$Id$
-"""
-from zope.interface import Interface, invariant
-from zope.interface.interface import Attribute
-from zope.interface.exceptions import Invalid
-
-class mytest(Interface):
- pass
-
-class C(object):
- def m1(self, a, b):
- "return 1"
- return 1
-
- def m2(self, a, b):
- "return 2"
- return 2
-
-# testInstancesOfClassImplements
-
-# YAGNI IC=Interface.impliedInterface(C)
-class IC(Interface):
- def m1(a, b):
- "return 1"
-
- def m2(a, b):
- "return 2"
-
-
-
-C.__implemented__=IC
-
-class I1(Interface):
- def ma():
- "blah"
-
-class I2(I1): pass
-
-class I3(Interface): pass
-
-class I4(Interface): pass
-
-class A(I1.deferred()):
- __implemented__=I1
-
-class B(object):
- __implemented__=I2, I3
-
-class D(A, B): pass
-
-class E(A, B):
- __implemented__ = A.__implemented__, C.__implemented__
-
-
-class FooInterface(Interface):
- """ This is an Abstract Base Class """
-
- foobar = Attribute("fuzzed over beyond all recognition")
-
- def aMethod(foo, bar, bingo):
- """ This is aMethod """
-
- def anotherMethod(foo=6, bar="where you get sloshed", bingo=(1,3,)):
- """ This is anotherMethod """
-
- def wammy(zip, *argues):
- """ yadda yadda """
-
- def useless(**keywords):
- """ useless code is fun! """
-
-class Foo(object):
- """ A concrete class """
-
- __implemented__ = FooInterface,
-
- foobar = "yeah"
-
- def aMethod(self, foo, bar, bingo):
- """ This is aMethod """
- return "barf!"
-
- def anotherMethod(self, foo=6, bar="where you get sloshed", bingo=(1,3,)):
- """ This is anotherMethod """
- return "barf!"
-
- def wammy(self, zip, *argues):
- """ yadda yadda """
- return "barf!"
-
- def useless(self, **keywords):
- """ useless code is fun! """
- return "barf!"
-
-foo_instance = Foo()
-
-class Blah(object):
- pass
-
-new = Interface.__class__
-FunInterface = new('FunInterface')
-BarInterface = new('BarInterface', [FunInterface])
-BobInterface = new('BobInterface')
-BazInterface = new('BazInterface', [BobInterface, BarInterface])
-
-# fixtures for invariant tests
-def ifFooThenBar(obj):
- if getattr(obj, 'foo', None) and not getattr(obj, 'bar', None):
- raise Invalid('If Foo, then Bar!')
-class IInvariant(Interface):
- foo = Attribute('foo')
- bar = Attribute('bar; must eval to Boolean True if foo does')
- invariant(ifFooThenBar)
-def BarGreaterThanFoo(obj):
- foo = getattr(obj, 'foo', None)
- bar = getattr(obj, 'bar', None)
- if foo is not None and isinstance(foo, type(bar)):
- # type checking should be handled elsewhere (like, say,
- # schema); these invariants should be intra-interface
- # constraints. This is a hacky way to do it, maybe, but you
- # get the idea
- if not bar > foo:
- raise Invalid('Please, Boo MUST be greater than Foo!')
-class ISubInvariant(IInvariant):
- invariant(BarGreaterThanFoo)
-class InvariantC(object):
- pass
More information about the checkins
mailing list