def afterSetUp(self):
     classImplements(ATDocument, IOrderable)
     # have to delete previously created content manually
     # because of test isolation problems
     if 'test' in self.portal:
         del self.portal['test']
         transaction.commit()

    def test_builtins(self):
        # Setup

        intspec = implementedBy(int)
        olddeclared = intspec.declared

        classImplements(int, I1)
        class myint(int):
            implements(I2)

        x = 42
        self.assertEqual([i.getName() for i in providedBy(x)],
                         ['I1'])

        x = myint(42)
        directlyProvides(x, I3)
        self.assertEqual([i.getName() for i in providedBy(x)],
                         ['I3', 'I2', 'I1'])

        # cleanup
        intspec.declared = olddeclared
        classImplements(int)

        x = 42
        self.assertEqual([i.getName() for i in providedBy(x)],
                         [])

 def infoClass(self, data, ds=False):
     '''build info class'''
     if ds == True:  self.infoclass = type(self.infoname,(RRDDataSourceInfo,),data)
     else:  self.infoclass = type(self.infoname,(ComponentInfo,),data)
     classImplements(self.infoclass,self.interfaceclass)
     self.info_path = "%s.info.%s" % (self.zenpackname, self.infoname)
     self.addClassData(self.infoname, self.info_path, self.infoclass)

def apply_customization_workflow(name, ti):
    """Apply customizations, features as per configuration from a workflow. 
    Must (currently) be run after db setup.
    """
    # support to infer/get the domain class from the type key
    from bungeni.models import domain, orm
    def get_domain_kls(name):
        """Infer the target domain kls from the type key, following underscore 
        naming to camel case convention.
        """
        return getattr(domain, naming.camel(name))
    
    # get the domain class, and associate with type
    kls = get_domain_kls(name)
    ti.domain_model = kls
    
    # We "mark" the domain class with IWorkflowed, to be able to 
    # register/lookup adapters generically on this single interface.
    classImplements(kls, IWorkflowed)
    
    # dynamic features from workflow
    wf = ti.workflow
    # decorate/modify domain/schema/mapping as needed
    kls = domain.configurable_domain(kls, wf)
    orm.configurable_mappings(kls)
    
    # !+ following should be part of the domain.feature_audit(kls) logic
    if wf.has_feature("audit"):
        # create/set module-level dedicated auditor singleton for auditable kls
        bungeni.core.audit.set_auditor(kls)

    def _register(name, category, schema, klass, title, description):
        ConfigletClass = configlettype.ConfigletType(
            str(name), schema, klass, title, description)
        interface.classImplements(ConfigletClass, schema)

        # register behavior for configlet
        bname = 'memphis.controlpanel-%s'%name

        # behavior
        bfactory = configlet.BehaviorFactory(name, bname)
        storage.registerBehavior(
            bname, schema, bfactory, schema = IConfigletData,
            title=title, description=description, configContext=None)

        # set additional attributes
        ConfigletClass.__category__ = category

        # configlet instance
        inst = ConfigletClass()

        # register configlet as utility
        config.registerUtility(inst, schema, '')

        # register configlet in control panel
        getUtility(IControlPanel).addConfiglet(inst)
        inst.__behavior__ = storage.getBehavior(schema)

    def prepareContent(self):
        
        classImplements(ATNewsItem, ITestTaggable)
        provideAdapter(TestExtender, name=u"archetypes.schemaextender.test.adapter")

        self.portal.invokeFactory('News Item', 'taggable-news')
        self.taggable_news = getattr(self.portal, 'taggable-news')

    def __call__(aspect, origin=None, *args, **kw):
        if kw.get('pdb'):
            import pdb;pdb.set_trace()

        # if called without positional arg, return partially applied
        # aspect
        if origin is None:
            if not kw:
                raise NeedKw
            return Partial(aspect, **kw)

        workbench = Workbench(origin, **kw)
        Instructions(aspect)(workbench)

            #raise AspectCollision(instr.name, aspect, target)

            # in case of instances functions need to be bound
            # if not x_is_class and (type(instr) is types.FunctionType):
            #     instr = instr.__get__(x)

        # build a new class, with the same name and bases as the
        # target class, but a new dictionary with the aspect applied.
        cls = workbench.type(workbench.name, workbench.baseclasses,
                             workbench.dct)
        if ZOPE_INTERFACE_AVAILABLE:
            classImplements(cls, *tuple(implementedBy(aspect)))
        if isclass(origin):
            if type(cls) is AspectMeta and kw:
                return Partial(cls, **kw)
            return cls
        return cls()

def patch():
    CMFCatalogTool.unindexObject = unindexObjectCMF
    setattr(CMFCatalogTool, '__old_unindexObject', original_unindexObjectCMF)

    CatalogMultiplex.unindexObject = unindexObject
    setattr(CatalogMultiplex, '__old_unindexObject', original_unindexObject)

    DefaultOrdering.moveObjectsByDelta = moveObjectsByDelta
    setattr(DefaultOrdering, '__old_moveObjectsByDelta',
            original_moveObjectsByDelta)

    PloneSite.moveObjectsByDelta = PloneSite_moveObjectsByDelta
    setattr(PloneSite, '__old_moveObjectsByDelta',
            original_PloneSite_moveObjectsByDelta)

    prefix = '__old_'
    for patch in patches:
        klass = patch.kls
        if not IElasticSearchCatalog.implementedBy(klass):
            patched[klass] = {}
            for name, method in patch.method_map.items():
                classImplements(klass, IElasticSearchCatalog)
                old = getattr(klass, name, method)
                patched[klass][name] = old
                setattr(klass, prefix + name, old)
                setattr(klass, name, method)
                info('patched %s', str(getattr(klass, name)))

    def execute(self, renderer, config, layer, name,
                macro, target, template, configuration, **kw):
        """Register a renderer.
        """        
        provides = (name == DEFAULT and interfaces.IStructuredDefaultRenderer
                    or interfaces.IStructuredRenderer)

        renderer.__view_name__ = name
        renderer.__renderer_macro__ = macro
        templates = renderer.module_info.getAnnotation(
            'grok.templates', None
            )

        if configuration is not None:
            classImplements(renderer, interfaces.IConfigurableRenderer)
        
        if templates is not None:
            config.action(
                discriminator=None,
                callable=self.checkTemplates,               
                args=(templates, renderer.module_info, renderer)
                )

        for context in target:
            adapts = (context, layer)
            config.action(
                discriminator=('adapter', adapts, provides, name),
                callable=zope.component.provideAdapter,
                args=(renderer, adapts, provides, name),
                )
        return True

 def updateSchema(self):
     sch = getUtility(ISchemaType, self.__context__.oid)
     sch.spec = self.schema
     sch.Type.__schema__ = self.schema
     interface.classImplements(sch.Type, self.schema)
     
     self.model = unicode(supermodel.serializeSchema(self.schema))

 def testNoViewOnClassicClassException(self):
     from zope.interface import Interface
     from types import ClassType
     class ClassicError:
         __metaclass__ = ClassType
     class IClassicError(Interface):
         pass
     classImplements(ClassicError, IClassicError)
     support.setDefaultViewName(IClassicError, 'name',
                                self.presentation_type)
     view_text = 'You made a classic error ;-)'
     def _view(obj, request):
         return lambda: view_text
     component.provideAdapter(
         _view, (ClassicError, self.presentation_type), Interface,
         name='name')
     try:
         raise ClassicError
     except:
         pass
     self.publication.handleException(
         self.object, self.request, sys.exc_info(), retry_allowed=False)
     # check we don't get the view we registered
     self.failIf(''.join(self.request.response._result) == view_text)
     # check we do actually get something
     self.failIf(''.join(self.request.response._result) == '')

def check_testcase_implements_trial_reporter(done=[]):
    if done:
        return
    from zope.interface import classImplements
    from twisted.trial.itrial import IReporter
    classImplements(TestCaseFunction, IReporter)
    done.append(1)

def Portlet(name, class_=None, title='', description='',
            template=None, schema=None, **kw):
    cdict = {}
    cdict.update(kw)
    cdict['__name__'] = name
    cdict['title'] = title
    cdict['description'] = description

    if template:
        cdict['template'] = ViewPageTemplateFile(template)

    if class_ is not None:
        class_name = 'Portlet<%s:%s>'%(class_.__name__, name)
    else:
        class_name = 'Portlet<%s>'%name

    if class_ is None:
        bases = (PortletBase,)
    else:
        bases = (class_, PortletBase)

    PortletClass = type(str(class_name), bases, cdict)

    if schema is not None:
        for f_id in getFields(schema):
            if not hasattr(PortletClass, f_id):
                setattr(PortletClass, f_id, ConfigurationProperty(schema[f_id]))

        PortletClass.__schema__ = schema
        interface.classImplements(PortletClass, schema)

    return PortletClass

 def testExceptionSideEffects(self):
     from zope.publisher.interfaces import IExceptionSideEffects
     @implementer(IExceptionSideEffects)
     class SideEffects(object):
         def __init__(self, exception):
             self.exception = exception
         def __call__(self, obj, request, exc_info):
             self.obj = obj
             self.request = request
             self.exception_type = exc_info[0]
             self.exception_from_info = exc_info[1]
     class SideEffectsFactory:
         def __call__(self, exception):
             self.adapter = SideEffects(exception)
             return self.adapter
     factory = SideEffectsFactory()
     from ZODB.POSException import ConflictError
     from zope.interface import Interface
     class IConflictError(Interface):
         pass
     classImplements(ConflictError, IConflictError)
     component.provideAdapter(factory, (IConflictError,),
                              IExceptionSideEffects)
     exception = ConflictError()
     try:
         raise exception
     except:
         self.publication.handleException(
             self.object, self.request, sys.exc_info(), retry_allowed=False)
     adapter = factory.adapter
     self.assertEqual(exception, adapter.exception)
     self.assertEqual(exception, adapter.exception_from_info)
     self.assertEqual(ConflictError, adapter.exception_type)
     self.assertEqual(self.object, adapter.obj)
     self.assertEqual(self.request, adapter.request)

def viewletManager(
    _context, name, permission,
    for_=Interface, layer=interfaces.IFlourishLayer, view=interfaces.IPageBase,
    provides=interfaces.IViewletManager,
    class_=ViewletManager, template=None,
    update='update', render='render',
    allowed_interface=(), allowed_attributes=(),
    **kwargs):

    bases = (class_, )
    if not interfaces.IViewletManager.implementedBy(class_):
        bases = bases + (ViewletManager, )
    class_ = type(class_.__name__, bases, {})

    allowed_interface = (tuple(allowed_interface) +
                         (interfaces.IViewletManager, ))

    if not provides.implementedBy(class_):
        classImplements(class_, provides)

    contentDirective(
        _context, name, permission,
        for_=for_, layer=layer, view=view,
        class_=class_, template=template,
        update=update, render=render,
        allowed_interface=allowed_interface,
        allowed_attributes=allowed_attributes,
        **kwargs)

def PortletManager(
    name, class_=None, provides=(),
    title='', description='', schema=None, portlettype=IPortlet, **kw):

    # configuration schema
    if schema is None:
        schema = IPortletManagerConfiguration

    cdict = {}
    cdict.update(kw)
    cdict['__name__'] = name
    cdict['__schema__'] = schema
    cdict['title'] = title
    cdict['description'] = description
    cdict['portlettype'] = portlettype

    class_name = 'PortletManager<%s>'%name

    if class_ is None:
        bases = (PortletManagerBase,)
    else:
        bases = (class_, PortletManagerBase)

    ManagerClass = type(str(class_name), bases, cdict)

    if provides:
        interface.classImplements(ManagerClass, *provides)

    for f_id in getFields(schema):
        if not hasattr(ManagerClass, f_id):
            setattr(ManagerClass, f_id, ConfigurationProperty(schema[f_id]))

    interface.classImplements(ManagerClass, schema)

    return ManagerClass

def feature_audit(kls):
    """Decorator for domain types to support "audit" feature.
    """
    interface.classImplements(kls, interfaces.IFeatureAudit)
    # If a domain class is explicitly defined, then it is assumed that all 
    # necessary setup is also taken care of. Typically, only the sub-classes
    # of an archetype (mapped to a same table) need dynamic creation/setup.
    def audit_cls_exists_for(auditable_cls):
        audit_cls_name = "%sAudit" % (auditable_cls.__name__)
        return bool(globals().get(audit_cls_name))
    if not audit_cls_exists_for(kls):
        # define {kls}Audit class
        feature_audit.CREATED_AUDIT_CLASS_FOR.add(kls)
        def base_audit_class(kls):
            """Identify what should be the BASE audit class for a 
            {kls}Audit class to inherit from, and return it.
            """
            # !+ may have a deeper inheritance
            # !+ other archetypes
            if kls is not Doc and issubclass(kls, Doc):
                return DocAudit
            return Audit
        audit_kls = base_audit_class(kls).auditFactory(kls)
        globals()[audit_kls.__name__] = audit_kls
    # !+ITER_TYPE_INFO remember decorated classes, for audit.set_auditor(kls), 
    # that is called quite early, and capi.iter_type_info() is not yet ready...
    feature_audit.DECORATED.add(kls)
    return kls

def create_interface_mock(interface_class):
    '''given a Zope Interface class
    return a Mock sub class
    that implements the given Zope interface class.

    Mock objects created from this InterfaceMock will
    have Attributes and Methods required in the Interface
    will not have Attributes or Methods that are not specified
    '''

    # the init method, automatically spec the interface methods
    def init(self, *args, **kwargs):
        Mock.__init__(self, spec=interface_class.names(),
                      *args, **kwargs)

    # subclass named '<interface class name>Mock'
    name = interface_class.__name__ + "Mock"

    # create the class object and provide the init method
    klass = types.TypeType(name, (Mock, ), {"__init__": init})

    # the new class should implement the interface
    classImplements(klass, interface_class)

    return klass

def load_contenttype(_context, contenttype):
    conf = contenttype['config']
    klass = contenttype['klass']
    if 'schema' in conf:
        classImplements(klass, conf['schema'])

    Factory = resolve_dotted_name(
        conf.get('factory', 'guillotina.content.ResourceFactory')
    )

    factory = Factory(
        klass,
        title='',
        description='',
        type_name=conf['type_name'],
        schema=resolve_dotted_name(conf.get('schema', Interface)),
        behaviors=[resolve_dotted_name(b) for b in conf.get('behaviors', []) or ()],
        add_permission=conf.get('add_permission') or DEFAULT_ADD_PERMISSION,
        allowed_types=conf.get('allowed_types', None)
    )
    component.utility(
        _context,
        provides=IResourceFactory,
        component=factory,
        name=conf['type_name'],
    )

def new_custom_domain_model(type_key, domain_interface, archetype_key):
    domain_model_name = naming.model_name(type_key)
    assert archetype_key, \
        "Custom descriptor %r does not specify an archetype" % (type_key)
    archetype = getattr(MODEL_MODULE, naming.model_name(archetype_key)) # AttributeError
    # !+ assert archetype constraints
    domain_model = type(domain_model_name,
        (archetype,),
        {
            "__module__": MODEL_MODULE.__name__,
            "extended_properties": [],
        }
    )
    # apply domain_interface
    classImplements(domain_model, domain_interface)
    # set on MODEL_MODULE (register on type_info downstream)
    setattr(MODEL_MODULE, domain_model_name, domain_model)
    # db map custom domain class
    from sqlalchemy.orm import mapper
    mapper(domain_model, 
        inherits=archetype,
        polymorphic_on=utils.get_local_table(archetype).c.type,
        polymorphic_identity=type_key, #naming.polymorphic_identity(domain_model),
    )
    log.info("new_custom_domain_model [%s] %s.%s" % (
            type_key, MODEL_MODULE.__name__, domain_model_name))
    return domain_model