Python interface.directlyProvides函数代码示例

    def test_process_message_report(self):
        from zope.interface import directlyProvides
        from pyramid.testing import DummyModel
        from karl.models.interfaces import IPeopleDirectory
        INFO = {'targets': [{'report': 'section+testing',
                             'community': None,
                             'tool': None,}],
                'author': 'phreddy',
                'subject': 'Feedback'
               }
        text = 'This entry stinks!'
        attachments = [('foo.txt', 'text/plain', 'My attachment')]
        message = DummyMessage(INFO, text, attachments)
        self._set_up_queue([message,])

        mailin = self._makeOne()
        pd = mailin.root['people'] = DummyModel()
        directlyProvides(pd, IPeopleDirectory)
        section = pd['section'] = DummyModel()
        testing = section['testing'] = DummyModel()

        mailin()

        self.assertEqual(len(self.handlers), 1)
        handler = self.handlers[0]
        self.failUnless(handler.context is testing)
        self.assertEqual(handler.handle_args,
                         (message, INFO, text, attachments))
        self.assertEqual(len(self.mailer), 0)

        def startTLS(self, contextFactory, normal=True):
            """
            @see: L{ITLSTransport.startTLS}
            """
            # Figure out which direction the SSL goes in.  If normal is True,
            # we'll go in the direction indicated by the subclass.  Otherwise,
            # we'll go the other way (client = not normal ^ _tlsClientDefault,
            # in other words).
            if normal:
                client = self._tlsClientDefault
            else:
                client = not self._tlsClientDefault

            tlsFactory = TLSMemoryBIOFactory(contextFactory, client, None)
            tlsProtocol = TLSMemoryBIOProtocol(tlsFactory, self.protocol, False)
            self.protocol = tlsProtocol

            self.getHandle = tlsProtocol.getHandle
            self.getPeerCertificate = tlsProtocol.getPeerCertificate

            # Mark the transport as secure.
            directlyProvides(self, interfaces.ISSLTransport)

            # Remember we did this so that write and writeSequence can send the
            # data to the right place.
            self._tls = True

            # Hook it up
            self.protocol.makeConnection(_BypassTLS(self))

 def test_call_view_exception_propagating(self):
     from zope.interface import Interface
     from zope.interface import directlyProvides
     class IContext(Interface):
         pass
     from pyramid.interfaces import IRequest
     from pyramid.interfaces import IViewClassifier
     from pyramid.interfaces import IRequestFactory
     def rfactory(environ):
         return request
     self.registry.registerUtility(rfactory, IRequestFactory)
     from pyramid.request import Request
     request = Request.blank('/')
     context = DummyContext()
     directlyProvides(context, IContext)
     self._registerTraverserFactory(context, subpath=[''])
     response = DummyResponse()
     view = DummyView(response, raise_exception=RuntimeError)
     environ = self._makeEnviron()
     self._registerView(view, '', IViewClassifier, IRequest, IContext)
     router = self._makeOne()
     start_response = DummyStartResponse()
     self.assertRaises(RuntimeError, router, environ, start_response)
     # ``exception`` must be attached to request even if a suitable
     # exception view cannot be found
     self.assertEqual(request.exception.__class__, RuntimeError)

 def _makeCommunity(self):
     from karl.models.interfaces import ICommunity
     from karl.models.interfaces import IInvitation
     from zope.interface import directlyProvides
     community = testing.DummyModel()
     community.member_names = set(['a'])
     community.moderator_names = set(['b', 'c'])
     site = testing.DummyModel()
     site['communities'] = testing.DummyModel()
     site['communities']['community'] = community
     profiles = testing.DummyModel()
     profiles['a'] = karltesting.DummyProfile()
     profiles['b'] = karltesting.DummyProfile()
     profiles['c'] = karltesting.DummyProfile()
     invitation = testing.DummyModel(email='[email protected]',
                                     message='message')
     directlyProvides(invitation, IInvitation)
     community['invitation'] = invitation
     site['profiles'] = profiles
     users = karltesting.DummyUsers(community)
     site.users = users
     directlyProvides(community, ICommunity)
     community.moderators_group_name = 'moderators'
     community.members_group_name = 'members'
     return community

    def testInitializedAndEditedEvent(self):

        component.provideHandler(created_handler, (IObject1, IObjectCreatedEvent,))
        component.provideHandler(initialized_handler, (IObject1, IObjectInitializedEvent,))
        component.provideHandler(edited_handler, (IObject1, IObjectEditedEvent,))

        ob = Dummy('dummy')
        directlyProvides(ob, IObject1)
        self.folder._setObject('dummy', ob)
        ob = self.folder.dummy

        ob._initializedCaught = False
        ob._editedCaught = False

        # Simulate first edit
        ob._at_creation_flag = True
        ob.processForm(REQUEST=TestRequest())

        self.assertEqual(True, ob._initializedCaught)
        self.assertEqual(False, ob._editedCaught)

        # Simulate subsequent edit
        ob.processForm(REQUEST=TestRequest())
        self.assertEqual(True, ob._editedCaught)

        sm = component.getSiteManager()
        sm.unregisterHandler(created_handler, (IObject1, IObjectCreatedEvent,))
        sm.unregisterHandler(initialized_handler, (IObject1, IObjectCreatedEvent,))
        sm.unregisterHandler(edited_handler, (IObject1, IObjectCreatedEvent,))

    def test_widget_addform_url_on_addform(self):
        from plone.app.widgets.dx import AjaxSelectWidget
        widget = AjaxSelectWidget(self.request)
        form = Mock()
        from zope.interface import directlyProvides
        from z3c.form.interfaces import IAddForm
        directlyProvides(form, IAddForm)
        form.request = {'URL': 'http://addform_url'}
        widget.form = form
        self.assertEqual(
            {
                'name': None,
                'value': u'',
                'pattern': 'select2',
                'pattern_options': {'separator': ';'},
            },
            widget._base_args(),
        )
        widget.vocabulary = 'vocabulary1'
        self.assertEqual(
            {
                'name': None,
                'value': u'',
                'pattern': 'select2',
                'pattern_options': {
                    'separator': ';',
                    'vocabularyUrl':
                    'http://addform_url/@@getVocabulary?name=vocabulary1'}

            },
            widget._base_args(),
        )

 def test_community_search(self):
     context = testing.DummyModel()
     context.title = 'Citizens'
     context.catalog = {}
     context['profiles'] = profiles = testing.DummyModel()
     profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee')
     from webob.multidict import MultiDict
     from karl.models.interfaces import ICommunity
     from zope.interface import directlyProvides
     directlyProvides(context, ICommunity)
     request = testing.DummyRequest(params=MultiDict({'body':'yo'}))
     from zope.interface import Interface
     from karl.models.interfaces import ICatalogSearch
     from karl.views.interfaces import IAdvancedSearchResultsDisplay
     from repoze.lemonade.testing import registerContentFactory
     registerContentFactory(DummyContent, IDummyContent)
     karltesting.registerAdapter(DummySearch, (Interface),
                             ICatalogSearch)
     karltesting.registerAdapter(DummySearchResultsDisplay,
                             (Interface, Interface),
                             IAdvancedSearchResultsDisplay)
     result = self._callFUT(context, request)
     self.assertEqual(result['community'], 'Citizens')
     self.assertEqual(result['terms'], ['yo'])
     self.assertEqual(len(result['results']), 1)

 def test_show_workflow_custom_acl(self):
     from repoze.workflow.testing import DummyWorkflow
     from zope.interface import Interface
     from zope.interface import directlyProvides
     workflow = DummyWorkflow()
     def state_info(context, request):
         return [{'name': 'foo', 'current': True, 'transitions': True},
                 {'name': 'bar', 'current': False, 'transitions': True}]
     workflow.state_info = state_info
     def get_dummy_workflow(*args, **kw):
         return workflow
     import karl.views.acl
     old_f = karl.views.acl.get_context_workflow
     karl.views.acl.get_context_workflow = get_dummy_workflow
     try:
         context = testing.DummyModel()
         context.state = 'foo'
         context.__custom_acl__ = []
         directlyProvides(Interface)
         request = testing.DummyRequest()
         renderer = karl.testing.registerDummyRenderer('templates/edit_acl.pt')
         self._callFUT(context, request)
         self.assertEqual(renderer.security_state, 'CUSTOM')
         self.assertEqual(renderer.security_states, ['CUSTOM', 'foo', 'bar'])
     finally:
         karl.views.acl.get_context_workflow = old_f

 def testAddMenuRelativeToNonStructuralFolder(self):
     self.folder.invokeFactory('Folder', 'f1')
     directlyProvides(self.folder.f1, INonStructuralFolder)
     items = self.menu.getMenuItems(self.folder.f1, self.request)
     factoriesMenuItem = [i for i in items if
                          i['extra']['id'] == 'plone-contentmenu-factories']
     self.failIf(factoriesMenuItem)

 def create_viewlet(self, viewlet, context=None, view=None, manager=None):
     if context is None:
         context = self.portal
     request = TestRequest()
     directlyProvides(request, IAttributeAnnotatable)
     request.set = mock.Mock()
     return viewlet(context, request, view, manager)

 def test_statusupdate_context_roundtrip(self):
     """Unittests fake uuids. Integration test with real uuids."""
     self.portal.invokeFactory('Folder', 'f1', title=u"Folder 1")
     f1 = self.portal['f1']
     directlyProvides(f1, IMicroblogContext)
     update = StatusUpdate('test', context=f1)
     self.assertEquals(update.context, f1)

 def test_in_intranet(self):
     from karl.content.interfaces import IIntranets
     from zope.interface import directlyProvides
     intranet = testing.DummyModel()
     directlyProvides(intranet, IIntranets)
     intranet['foo'] = context = testing.DummyModel()
     self.failIf(self._call_fut(context, None))

    def setUp(self):
        self.portal = self.layer['portal']
        setRoles(self.portal, TEST_USER_ID, ['Manager'])
        workflowTool = getToolByName(self.portal, 'portal_workflow')
        workflowTool.setDefaultChain('simple_publication_workflow')
        workflowTool.updateRoleMappings()
        f1 = api.content.create(self.portal, 'Folder', 'f1', title=u'Folder 1')
        directlyProvides(f1, IMicroblogContext)
        f1.reindexObject()
        f2 = api.content.create(self.portal, 'Folder', 'f2', title=u'Folder 2')
        directlyProvides(f2, IMicroblogContext)
        f2.reindexObject()

        api.content.transition(f2, 'publish')
        self.assertEqual(api.content.get_state(f1), 'private')
        self.assertEqual(api.content.get_state(f2), 'published')

        tool = queryUtility(IMicroblogTool)
        self.su1 = su1 = StatusUpdate('test #foo', f1)
        tool.add(su1)
        self.su2 = su2 = StatusUpdate('test #foo', f2)
        tool.add(su2)
        # the tool is queued
        tool.flush_queue()

        # set up new user
        api.user.create('[email protected]', username='user1', password='secret')

 def test_workflow_transition_from_custom(self):
     registerDummyRenderer('templates/edit_acl.pt')
     from repoze.workflow.testing import DummyWorkflow
     from zope.interface import Interface
     from zope.interface import directlyProvides
     workflow = DummyWorkflow()
     def state_info(context, request):
         return [{'name': 'foo', 'current': True, 'transitions': True},
                 {'name': 'bar', 'current': False, 'transitions': True}]
     workflow.state_info = state_info
     def get_dummy_workflow(*args, **kw):
         return workflow
     import karl.views.acl
     old_f = karl.views.acl.get_context_workflow
     karl.views.acl.get_context_workflow = get_dummy_workflow
     try:
         context = testing.DummyModel()
         context.state = 'foo'
         context.__custom_acl__ = []
         directlyProvides(Interface)
         request = testing.DummyRequest()
         request.POST['form.security_state'] = 1
         request.POST['security_state'] = 'bar'
         self._callFUT(context, request)
         self.assertEqual(workflow.transitioned[0]['to_state'], 'bar')
         self.assertEqual(workflow.resetted, [context,])
         self.failIf(hasattr(context, '__custom_acl__'))
     finally:
         karl.views.acl.get_context_workflow = old_f

    def test_cutpaste_duplicated_id_object(self):

        root = self.getRootFolder()

        # Create a principal Folder
        root['pf'] = PrincipalFolder()
        pf = root['pf']

        # Create a principal with p1 as login
        principal = Principal('p1')
        principal.login = 'p1'
        directlyProvides(principal, IInternalPrincipal)

        pf['p1'] = principal

        transaction.commit()
        self.assertEqual(len(pf.keys()), 1)
        #raise str([x for x in pf.keys()])

        response = self.publish('/pf/@@contents.html',
                                basic='mgr:mgrpw',
                                form={'ids': [u'p1'],
                                      'container_cut_button': u'Cut'})
        self.assertEqual(response.getStatus(), 302)


        # Try to paste the file
        try:
            response = self.publish('/pf/@@contents.html',
                                    basic='mgr:mgrpw',
                                    form={'container_paste_button': ''})
        except UserError, e:
            self.assertEqual(
                str(e),
                "The given name(s) [u'p1'] is / are already being used")