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")

 def test_it(self):
     class DummyModel(testing.DummyModel):
         def _p_deactivate(self):
             self.deactivated = True
     from repoze.folder.interfaces import IFolder
     from zope.interface import directlyProvides
     request = testing.DummyRequest()
     context2 = DummyModel()
     context2.__acl__ = ['Allow', 'fred', ('read',)]
     context2.security_state = 'fred-ish'
     context = DummyModel()
     context['context2'] = context2
     directlyProvides(context, IFolder)
     renderer = karl.testing.registerDummyRenderer('templates/acl_tree.pt')
     self._callFUT(context, request)
     self.assertEqual(len(renderer.acls), 2)
     context_acl = renderer.acls[0]
     self.assertEqual(context_acl,
                      {'path': '/',
                       'acl': None,
                       'name': '/',
                       'offset': 0,
                       'url':'http://example.com/',
                       'security_state':None})
     context2_acl = renderer.acls[1]
     self.assertEqual(context2_acl,
                      {'path': '/context2',
                       'acl': ['Allow', 'fred', ('read',)],
                       'name': 'context2',
                       'offset': 1,
                       'url':'http://example.com/context2/',
                       'security_state':'fred-ish'})
     self.assertEqual(context.deactivated, True)
     self.assertEqual(context2.deactivated, True)

 def setUp(self):
     self.app = self.layer['app']
     self.portal = self.layer['portal']
     self.request = self.layer['request']
     directlyProvides(self.request, IBrowserLayer)
     office = create_ombudsoffice(self, 'office')
     self.claim = api.content.create(office, 'Claim', 'claim')

def create_components_registry(parent=None, name='', bases=()):
    if parent is None:
        parent = contextualSiteManager()
    registry = BaseComponents(parent, name, bases)
    directlyProvides(registry, IComponents)
    provideUtility(registry, provides=IComponents, name=name)
    return registry

 def makeConnection(self, transport):
     directlyProvides(self, providedBy(transport))
     Protocol.makeConnection(self, transport)
     
     if not self.method in self.allowedMethods:
         self.sendHeaders({'status': '405 Method Not Supported','allow': ', '.join(self.allowedMethods)})
         self.transport.write("\r\n")
         self.transport.loseConnection()
         return
     elif self.method == 'OPTIONS':
         self.sendHeaders()
         self.transport.write("")
         self.transport.loseConnection()
         return
     
     if not self.writeOnly:
         if self.session in self.factory.sessions:
             self.wrappedProtocol = self.factory.sessions[self.session]
         else:
             self.wrappedProtocol = RelayProtocol(self.factory, self.factory.wrappedFactory.buildProtocol(self.transport.addr), self.session, self)
         
         if self.wrappedProtocol.attached:
             self.wrappedProtocol = None
             self.failConnect()
         else:
             if not self.prepConnection():
                 self.disconnecting = False
                 self.wrappedProtocol.makeConnection(self)
     else:
         if self.session in self.factory.sessions:
             self.wrappedProtocol = self.factory.sessions[self.session]
         else:
             self.sendHeaders({'status': '404 Not Found'})
             self.transport.write("\r\n")
             self.transport.loseConnection()

def proxyForInterface(iface, originalAttribute='original'):
    """
    Create a class which proxies all method calls which adhere to an interface
    to another provider of that interface.

    This function is intended for creating specialized proxies. The typical way
    to use it is by subclassing the result::

      class MySpecializedProxy(proxyForInterface(IFoo)):
          def someInterfaceMethod(self, arg):
              if arg == 3:
                  return 3
              return self.original.someInterfaceMethod(arg)

    @param iface: The Interface to which the resulting object will conform, and
        which the wrapped object must provide.

    @param originalAttribute: name of the attribute used to save the original
        object in the resulting class. Default to C{original}.
    @type originalAttribute: C{str}

    @return: A class whose constructor takes the original object as its only
        argument. Constructing the class creates the proxy.
    """
    def __init__(self, original):
        setattr(self, originalAttribute, original)
    contents = {"__init__": __init__}
    for name in iface:
        contents[name] = _ProxyDescriptor(name, originalAttribute)
    proxy = type("(Proxy for %s)"
                 % (reflect.qual(iface),), (object,), contents)
    directlyProvides(proxy, iface)
    return proxy