golden hour

/lib/python2.7/site-packages/zope/component/tests

File/Folder	Size	Actions
__init__.py	16 B
__init__.pyc	152 B
__init__.pyo	152 B
examples.py	3.16 KB
examples.pyc	7.99 KB
examples.pyo	7.99 KB
test___init__.py	3.12 KB
test___init__.pyc	5.24 KB
test___init__.pyo	5.24 KB
test__api.py	41.84 KB
test__api.pyc	74.24 KB
test__api.pyo	74.24 KB
test__declaration.py	7.01 KB
test__declaration.pyc	12.41 KB
test__declaration.pyo	12.41 KB
test_event.py	2.3 KB
test_event.pyc	2.85 KB
test_event.pyo	2.85 KB
test_factory.py	3.7 KB
test_factory.pyc	6.09 KB
test_factory.pyo	6.09 KB
test_globalregistry.py	8.47 KB
test_globalregistry.pyc	14.39 KB
test_globalregistry.pyo	14.29 KB
test_hookable.py	4 KB
test_hookable.pyc	6.62 KB
test_hookable.pyo	6.62 KB
test_hooks.py	11.42 KB
test_hooks.pyc	17.43 KB
test_hooks.pyo	17.43 KB
test_interface.py	14.15 KB
test_interface.pyc	23.29 KB
test_interface.pyo	23.29 KB
test_persistentregistry.py	6.27 KB
test_persistentregistry.pyc	8.41 KB
test_persistentregistry.pyo	8.41 KB
test_registry.py	4.55 KB
test_registry.pyc	7.34 KB
test_registry.pyo	7.34 KB
test_security.py	9.15 KB
test_security.pyc	16.49 KB
test_security.pyo	16.49 KB
test_standalone.py	1.99 KB
test_standalone.pyc	1.77 KB
test_standalone.pyo	1.77 KB
test_zcml.py	47.22 KB
test_zcml.pyc	56.41 KB
test_zcml.pyo	56.41 KB

Edit: test__declaration.py

##############################################################################
#
# Copyright (c) 2012 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.
#
##############################################################################
"""Test adapter declaration helpers
"""
import unittest

class Test_adapter(unittest.TestCase):

def _getTargetClass(self):
        from zope.component._declaration import adapter
        return adapter

def _makeOne(self, *interfaces):
        return self._getTargetClass()(*interfaces)

def test_ctor_no_interfaces(self):
        deco = self._makeOne()
        self.assertEqual(list(deco.interfaces), [])

def test_ctor_w_interfaces(self):
        from zope.interface import Interface
        class IFoo(Interface):
            pass
        class IBar(Interface):
            pass
        deco = self._makeOne(IFoo, IBar)
        self.assertEqual(list(deco.interfaces), [IFoo, IBar])

def test__call___w_class(self):
        from zope.interface import Interface
        class IFoo(Interface):
            pass
        class IBar(Interface):
            pass
        @self._makeOne(IFoo, IBar)
        class Baz(object):
            pass
        self.assertEqual(Baz.__component_adapts__, (IFoo, IBar))

def test__call___w_inst_of_decorated_class(self):
        from zope.interface import Interface
        class IFoo(Interface):
            pass
        class IBar(Interface):
            pass
        @self._makeOne(IFoo, IBar)
        class Baz(object):
            pass
        baz = Baz()
        self.assertRaises(AttributeError,
                          getattr, baz, '__component_adapts_')

def test__call___w_non_class(self):
        from zope.interface import Interface
        class IFoo(Interface):
            pass
        class IBar(Interface):
            pass
        class Baz(object):
            pass
        deco = self._makeOne(IFoo, IBar)
        baz = deco(Baz())
        self.assertEqual(baz.__component_adapts__, (IFoo, IBar))

class Test_adapts(unittest.TestCase):

def _run_generated_code(self, code, globs, locs,
                            fails_under_py3k=True,
                           ):
        import warnings
        #from zope.component._compat import PYTHON3
        PYTHON3 = False
        with warnings.catch_warnings(record=True) as log:
            warnings.resetwarnings()
            if not PYTHON3:
                exec(code, globs, locs)
                self.assertEqual(len(log), 0) # no longer warn
                return True
            else:
                try:
                    exec(code, globs, locs)
                except TypeError:
                    return False
                else:
                    if fails_under_py3k:
                        self.fail("Didn't raise TypeError")

def test_instances_not_affected(self):
        from zope.component._declaration import adapts
        class C(object):
            adapts()

self.assertEqual(C.__component_adapts__, ())
        def _try():
            return C().__component_adapts__
        self.assertRaises(AttributeError, _try)

def test_called_from_function(self):
        import warnings
        from zope.component._declaration import adapts
        from zope.interface import Interface
        class IFoo(Interface):
            pass
        globs = {'adapts': adapts, 'IFoo': IFoo}
        locs = {}
        CODE = "\n".join([
            'def foo():',
            '    adapts(IFoo)'
            ])
        if self._run_generated_code(CODE, globs, locs, False):
            foo = locs['foo']
            with warnings.catch_warnings(record=True) as log:
                warnings.resetwarnings()
                self.assertRaises(TypeError, foo)
                self.assertEqual(len(log), 0) # no longer warn

def test_called_twice_from_class(self):
        import warnings
        from zope.component._declaration import adapts
        from zope.interface import Interface
        from zope.interface._compat import PYTHON3
        class IFoo(Interface):
            pass
        class IBar(Interface):
            pass
        globs = {'adapts': adapts, 'IFoo': IFoo, 'IBar': IBar}
        locs = {}
        CODE = "\n".join([
            'class Foo(object):',
            '    adapts(IFoo)',
            '    adapts(IBar)',
            ])
        with warnings.catch_warnings(record=True) as log:
            warnings.resetwarnings()
            try:
                exec(CODE, globs, locs)
            except TypeError:
                if not PYTHON3:
                    self.assertEqual(len(log), 0) # no longer warn
            else:
                self.fail("Didn't raise TypeError")

def test_called_once_from_class(self):
        from zope.component._declaration import adapts
        from zope.interface import Interface
        class IFoo(Interface):
            pass
        globs = {'adapts': adapts, 'IFoo': IFoo}
        locs = {}
        CODE = "\n".join([
            'class Foo(object):',
            '    adapts(IFoo)',
            ])
        if self._run_generated_code(CODE, globs, locs):
            Foo = locs['Foo']
            spec = Foo.__component_adapts__
            self.assertEqual(list(spec), [IFoo])

class Test_adaptedBy(unittest.TestCase):

def _callFUT(self, obj):
        from zope.component._declaration import adaptedBy
        return adaptedBy(obj)

def test_obj_w_no_attr(self):
        self.assertEqual(self._callFUT(object()), None)

def test__call___w_class(self):
        from zope.interface import Interface
        class IFoo(Interface):
            pass
        class IBar(Interface):
            pass
        class Baz(object):
            __component_adapts__ = (IFoo, IBar)
        self.assertEqual(self._callFUT(Baz), (IFoo, IBar))

def test__call___w_inst_of_decorated_class(self):
        from zope.interface import Interface
        from zope.component._declaration import _adapts_descr
        class IFoo(Interface):
            pass
        class IBar(Interface):
            pass
        class Baz(object):
            __component_adapts__ = _adapts_descr((IFoo, IBar))
        baz = Baz()
        self.assertEqual(self._callFUT(baz), None)

def test__call___w_non_class(self):
        from zope.interface import Interface
        class IFoo(Interface):
            pass
        class IBar(Interface):
            pass
        class Baz(object):
            pass
        baz = Baz()
        baz.__component_adapts__ = (IFoo, IBar)
        self.assertEqual(self._callFUT(baz), (IFoo, IBar))

def test_suite():
    return unittest.TestSuite((
        unittest.makeSuite(Test_adapter),
        unittest.makeSuite(Test_adapts),
        unittest.makeSuite(Test_adaptedBy),
    ))