Example #1
0
 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)
Example #2
0
    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)
Example #3
0
 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))
Example #4
0
 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
Example #5
0
 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)
Example #6
0
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
Example #7
0
 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 test_it(self):
     from zope.interface import Interface
     from zope.interface import directlyProvides
     from karl.models.interfaces import ICatalogSearch
     from karl.models.interfaces import ICommunity
     context = testing.DummyModel()
     directlyProvides(context, ICommunity)
     context.member_names = set('a',)
     context.moderator_names = set()
     request = testing.DummyRequest(params={'val':'a'})
     profiles = testing.DummyModel()
     profile_1 = karltesting.DummyProfile(__name__='a',
                                          security_state='active')
     profile_2 = karltesting.DummyProfile(__name__='b',
                                          security_state='active')
     profile_3 = karltesting.DummyProfile(__name__='c',
                                          security_state='active')
     profile_4 = karltesting.DummyProfile(__name__='d',
                                          security_state='inactive')
     def resolver(docid):
         d = {1:profile_1, 2:profile_2, 3:profile_3, 4:profile_4}
         return d.get(docid)
     def dummy_catalog_search(context):
         def search(**kw):
             return 3, [1,2,3], resolver
         return search
     karltesting.registerAdapter(dummy_catalog_search, (Interface),
                             ICatalogSearch)
     response = self._callFUT(context, request)
     self.assertEqual(
         response.body,
         '[{"text": "title", "id": "b"}, '
         '{"text": "title", "id": "c"}]')
 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='*****@*****.**',
                                     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
Example #10
0
    def test_handle_submit_success(self):
        self._register()
        from zope.interface import directlyProvides
        from karl.models.interfaces import ISite
        from karl.models.interfaces import ICommunity
        from repoze.lemonade.interfaces import IContentFactory
        context = testing.DummyModel()
        directlyProvides(context, ISite)
        tags = context.tags = testing.DummyModel()
        _tagged = []
        def _update(item, user, tags):
            _tagged.append((item, user, tags))
        tags.update = _update
        testing.registerDummySecurityPolicy('userid')
        workflow = self._registerDummyWorkflow()
        testing.registerAdapter(lambda *arg: DummyCommunity,
                                (ICommunity,),
                                IContentFactory)
        dummy_tool_factory = DummyToolFactory()
        self._registerAddables([{'name':'blog', 'title':'blog',
                                 'component':dummy_tool_factory}])
        context.users = karltesting.DummyUsers({})
        context.catalog = karltesting.DummyCatalog({1:'/foo'})
        request = testing.DummyRequest()
        controller = self._makeOne(context, request)
        converted = {'title':'Thetitle yo',
                     'description':'thedescription',
                     'text':'thetext',
                     'tools': ['blog'],
                     'security_state': 'private',
                     'tags': ['foo'],
                     'default_tool': 'blog',
                     }
        result = controller.handle_submit(converted)
        rl = 'http://example.com/thetitle-yo/members/add_existing.html'
        self.failUnless(result.location.startswith(rl))
        community = context['thetitle-yo']
        self.assertEqual(community.title, 'Thetitle yo')
        self.assertEqual(community.description, 'thedescription')
        self.assertEqual(community.text, 'thetext')
        self.assertEqual(community.default_tool, 'blog')
        self.assertEqual(community.creator, 'userid')
        self.assertEqual(community.modified_by, 'userid')
        self.assertEqual(
            context.users.added_groups,
            [('userid', 'moderators'), ('userid', 'members') ]
        )
        self.assertEqual(dummy_tool_factory.added, True)
        self.assertEqual(len(_tagged), 1)
        self.assertEqual(_tagged[0][0], None)
        self.assertEqual(_tagged[0][1], 'userid')
        self.assertEqual(_tagged[0][2], ['foo'])
        self.assertEqual(workflow.transitioned[0]['to_state'], 'private')

        # try again w/ an invalid default_tool
        converted['title'] = 'Another title yo'
        converted['default_tool'] = 'wiki'
        result = controller.handle_submit(converted)
        community = context['another-title-yo']
        self.failUnless(community.default_tool is None)
Example #11
0
    def __init__(self, terms, *interfaces, **kwargs):
        """Initialize the vocabulary given a list of terms.

        The vocabulary keeps a reference to the list of terms passed
        in; it should never be modified while the vocabulary is used.

        One or more interfaces may also be provided so that alternate
        widgets may be bound without subclassing.

        By default, ValueErrors are thrown if duplicate values or tokens
        are passed in. If you want to swallow these exceptions, pass
        in swallow_duplicates=True. In this case, the values will
        override themselves.
        """
        self.by_value = {}
        self.by_token = {}
        self._terms = terms
        for term in self._terms:
            swallow_dupes = kwargs.get('swallow_duplicates', False)
            if not swallow_dupes:
                if term.value in self.by_value:
                    raise ValueError(
                        'term values must be unique: %s' % repr(term.value))
                if term.token in self.by_token:
                    raise ValueError(
                        'term tokens must be unique: %s' % repr(term.token))
            self.by_value[term.value] = term
            self.by_token[term.token] = term
        if interfaces:
            directlyProvides(self, *interfaces)
Example #12
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))
Example #13
0
 def test_call_view_registered_specific_success(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
     context = DummyContext()
     directlyProvides(context, IContext)
     self._registerTraverserFactory(context)
     self._registerRootFactory(context)
     response = DummyResponse()
     response.app_iter = ['Hello world']
     view = DummyView(response)
     environ = self._makeEnviron()
     self._registerView(view, '', IViewClassifier, IRequest, IContext)
     router = self._makeOne()
     start_response = DummyStartResponse()
     result = router(environ, start_response)
     self.assertEqual(result, ['Hello world'])
     self.assertEqual(start_response.headers, ())
     self.assertEqual(start_response.status, '200 OK')
     request = view.request
     self.assertEqual(request.view_name, '')
     self.assertEqual(request.subpath, [])
     self.assertEqual(request.context, context)
     self.assertEqual(request.root, context)
Example #14
0
 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)
Example #15
0
    def test_including_replace_image_fulldomain(self):
        import simplejson
        from karl.content.interfaces import IImage
        from zope.interface import directlyProvides

        context = testing.DummyModel()
        image = context["boo.jpg"] = testing.DummyModel()
        image.title = "Boo"
        directlyProvides(image, IImage)

        # It must also work, when the image url is
        # a full domain. This happens on IE.
        # XXX The server should _not_ check the domain
        # at all, simply use the path.

        # XXX For a reason unknown, this test passes even
        # if the traverse the full domain instead of just the
        # path... while, the same thing fails in "real life" on IE.
        # So, this test probably does not test what it should...
        request = testing.DummyRequest(
            params={"include_image_url": "http://lcd.tv:9876/boo.jpg/thumb", "source": "myrecent"}
        )
        response = self._call_fut(context, request)
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(
            self.dummy_get_images_batch.called,
            (context, request, {"community": None, "batch_start": 0, "batch_size": 12, "creator": None}),
        )
        data = simplejson.loads(response.body)
        self.assertEqual(data["images_info"], {"totalRecords": 6, "start": 0, "records": ["Boo", "foo", "bar"]})
Example #16
0
 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()
Example #17
0
    def test_including_replace_image(self):
        ## if we are replacing, the passed-in image url
        ## is added as a fake 1th element.
        import simplejson
        from karl.content.interfaces import IImage
        from zope.interface import directlyProvides

        context = testing.DummyModel()
        image = context["boo.jpg"] = testing.DummyModel()
        image.title = "Boo"
        directlyProvides(image, IImage)

        request = testing.DummyRequest(params={"include_image_url": "/boo.jpg", "source": "myrecent"})
        response = self._call_fut(context, request)
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(
            self.dummy_get_images_batch.called,
            (context, request, {"community": None, "batch_start": 0, "batch_size": 12, "creator": None}),
        )
        data = simplejson.loads(response.body)
        self.assertEqual(data["images_info"], {"totalRecords": 6, "start": 0, "records": ["Boo", "foo", "bar"]})

        # if we don't ask for the 0th index: it's not
        # added, but the sizes and indexes are aligned.
        request = testing.DummyRequest(params={"include_image_url": "/boo.jpg", "source": "myrecent", "start": "1"})
        response = self._call_fut(context, request)
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(
            self.dummy_get_images_batch.called,
            (context, request, {"community": None, "batch_start": 0, "batch_size": 12, "creator": None}),
        )
        data = simplejson.loads(response.body)
        self.assertEqual(data["images_info"], {"totalRecords": 6, "start": 1, "records": ["foo", "bar"]})
Example #18
0
    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 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 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')
Example #21
0
 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 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,))
Example #23
0
 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)
Example #24
0
    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 = '******'
        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")
Example #25
0
 def test_no_content(self):
     from repoze.lemonade.content import IContent
     from zope.interface import directlyProvides
     context = self.context
     directlyProvides(context, IContent)
     textrepr = self._callFUT(context, 'default')
     self.assertEqual(textrepr, 'default')
Example #26
0
    def publishTraverse(self, request, name):
        request.survey = self.context
        utils.setLanguage(request, self.context, self.context.language)

        if name not in ["view", "index_html"] and \
                not self.hasValidSession(request):
            request.response.redirect(
                    aq_parent(aq_parent(self.context)).absolute_url(),
                    lock=True)
            return self.context

        if name not in self.phases:
            return super(SurveyPublishTraverser, self)\
                    .publishTraverse(request, name)

        # Decorate the request with the right skin layer and add to the aq path
        directlyProvides(request, self.phases[name],
                         *directlyProvidedBy(request))
        self.context = PathGhost(name).__of__(self.context)

        session = SessionManager.session
        tree_id = find_sql_context(session.id,
                request['TraversalRequestNameStack'])
        if tree_id is not None:
            return build_tree_aq_chain(self.context, tree_id)

        # No SQL based traversal possible, return the existing context with the
        # new skin layer applied
        return self.context
    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('*****@*****.**', username='******', password='******')
Example #28
0
    def testDefaultSkin(self):
        request = TestRequest()

        self.assertEqual(zapi.queryMultiAdapter((ob, request), name='test'),
                         None)
        xmlconfig(StringIO(template % (
            '''
            <browser:layer name="zmi" />
            <browser:skin name="zmi" layers="zmi" />
            <browser:defaultSkin name="zmi" />
            <browser:page name="test"
                class="zope.app.component.tests.views.VZMI"
                layer="zmi"
                for="zope.app.component.tests.views.IC"
                permission="zope.Public"
                attribute="index"
                />
            <browser:page name="test"
                class="zope.app.component.tests.views.V1"
                for="zope.app.component.tests.views.IC"
                permission="zope.Public"
                attribute="index"
                />
            '''
            )))

        # Simulate Zope Publication behavior in beforeTraversal()
        adapters = zapi.getSiteManager().adapters
        skin = adapters.lookup((providedBy(request),), IDefaultSkin, '')
        directlyProvides(request, skin)

        v = zapi.queryMultiAdapter((ob, request), name='test')
        self.assert_(issubclass(v.__class__, VZMI))
 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)
Example #30
0
    def test_handle_submit_valid_nofile_withremove(self):
        from repoze.bfg.formish import ValidationError
        from karl.models.interfaces import ISite
        from zope.interface import directlyProvides
        from schemaish.type import File as SchemaFile
        from karl.models.interfaces import IObjectModifiedEvent
        from karl.content.interfaces import ICommunityFile
        from repoze.lemonade.interfaces import IContentFactory

        self._register()

        context = DummyFile(title='oldtitle')
        context.__name__ = None
        context.__parent__ = None
        context.mimetype = 'old/type'
        context.filename = 'old_name'
        context.stream = 'old'
        context.sessions = DummySessions()
        context.catalog = DummyCatalog()
        directlyProvides(context, ISite)
        converted = {
            'title': 'new title',
            'file': SchemaFile(None, None, None, metadata={'remove':True}),
            'security_state': 'public',
            'tags': ['thetesttag'],
            }
        testing.registerAdapter(lambda *arg: DummyCommunityFile,
                                (ICommunityFile,),
                                IContentFactory)
        testing.registerDummySecurityPolicy('testeditor')
        request = self._makeRequest()
        controller = self._makeOne(context, request)
        self.assertRaises(ValidationError, controller.handle_submit, converted)
Example #31
0
 def test_handle_submit_attachment_is_None(self):
     """
     There seems to be some set of circumstances under which formish will
     return a None as a value in the attachments sequence.
     """
     from karl.models.interfaces import IObjectModifiedEvent
     from zope.interface import Interface
     from karl.models.interfaces import ITagQuery
     from karl.content.interfaces import IBlogEntry
     from repoze.lemonade.testing import registerContentFactory
     from karl.testing import DummyCatalog
     karl.testing.registerAdapter(DummyTagQuery, (Interface, Interface),
                                  ITagQuery)
     self._registerDummyWorkflow()
     context = DummyBlogEntry()
     context.sessions = DummySessions()
     context.__name__ ='ablogentry'
     context.catalog = DummyCatalog()
     context['attachments'] = testing.DummyModel()
     from karl.models.interfaces import ISite
     from zope.interface import directlyProvides
     directlyProvides(context, ISite)
     converted = {'title':'foo',
                  'text':'text',
                  'security_state':'public',
                  'tags':'thetesttag',
                  'attachments':[None],
                  }
     registerContentFactory(DummyBlogEntry, IBlogEntry)
     L = karl.testing.registerEventListener(
         (Interface, IObjectModifiedEvent))
     karl.testing.registerDummySecurityPolicy('testeditor')
     request = self._makeRequest()
     controller = self._makeOne(context, request)
     response = controller.handle_submit(converted)
     self.assertEqual(response.location, 'http://example.com/ablogentry/')
     self.assertEqual(len(L), 2)
     self.assertEqual(context.title, 'foo')
     self.assertEqual(context.text, 'text')
     self.assertEqual(context.modified_by, 'testeditor')
Example #32
0
 def test_tabs_requestcontext_iscommunity(self):
     from karl.models.interfaces import ICommunity
     from karl.models.interfaces import IToolFactory
     from repoze.lemonade.testing import registerListItem
     from zope.interface import directlyProvides
     tool_factory = DummyToolFactory()
     registerListItem(IToolFactory, tool_factory, 'one', title='One')
     context = self._makeCommunity()
     directlyProvides(context, ICommunity)
     request = testing.DummyRequest()
     request.context = context
     adapter = self._makeOne(context, request)
     tabs = adapter.tabs
     self.assertEqual(len(tabs), 2)
     self.assertEqual(tabs[0],
                      {'url': 'http://example.com/view.html',
                       'css_class': 'curr', 'name': 'OVERVIEW'}
                      )
     self.assertEqual(tabs[1],
                      {'url': 'http://example.com/tab',
                       'css_class': '', 'name': 'ONE'}
                      )
Example #33
0
 def test_get_info_alpha(self):
     request = testing.DummyRequest()
     context = testing.DummyModel()
     context.alpha = {'A':1}
     from zope.interface import directlyProvides
     directlyProvides(context, DummyInterface)
     adapter = self._makeOne(context)
     letters = adapter.get_info(request)
     self.assertEqual(len(letters), 27)
     self.assertEqual(letters[0]['name'], 'A')
     self.assertEqual(letters[0]['css_class'], 'notcurrent')
     self.assertEqual(letters[0]['href'],
                      'http://example.com?titlestartswith=A')
     self.assertEqual(letters[0]['is_current'], False)
     self.assertEqual(letters[1]['name'], 'B')
     self.assertEqual(letters[1]['css_class'], 'notcurrent')
     self.assertEqual(letters[1]['href'], None)
     self.assertEqual(letters[1]['is_current'], False)
     self.assertEqual(letters[26]['name'], 'Any')
     self.assertEqual(letters[26]['css_class'], 'current')
     self.assertEqual(letters[26]['href'], None)
     self.assertEqual(letters[26]['is_current'], True)
    def test_ObjectSpecification(self):
        c = C()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I31', 'I1', 'I2'])
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I31', 'I3', 'I1', 'I2', 'Interface'])
        self.failUnless(I1 in providedBy(c))
        self.failIf(I3 in providedBy(c))
        self.failUnless(providedBy(c).extends(I3))
        self.failUnless(providedBy(c).extends(I31))
        self.failIf(providedBy(c).extends(I5))

        class COnly(A, B):
            pass

        classImplementsOnly(COnly, I31)

        class D(COnly):
            pass

        classImplements(D, I5)

        classImplements(D, I5)

        c = D()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I5', 'I31'])
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I5', 'I31', 'I3', 'Interface'])
        self.failIf(I1 in providedBy(c))
        self.failIf(I3 in providedBy(c))
        self.failUnless(providedBy(c).extends(I3))
        self.failIf(providedBy(c).extends(I1))
        self.failUnless(providedBy(c).extends(I31))
        self.failUnless(providedBy(c).extends(I5))

        class COnly(A, B):
            __implemented__ = I31

        class D(COnly):
            pass

        classImplements(D, I5)

        classImplements(D, I5)
        c = D()
        directlyProvides(c, I4)
        self.assertEqual([i.getName() for i in providedBy(c)],
                         ['I4', 'I5', 'I31'])
        self.assertEqual([i.getName() for i in providedBy(c).flattened()],
                         ['I4', 'I5', 'I31', 'I3', 'Interface'])
        self.failIf(I1 in providedBy(c))
        self.failIf(I3 in providedBy(c))
        self.failUnless(providedBy(c).extends(I3))
        self.failIf(providedBy(c).extends(I1))
        self.failUnless(providedBy(c).extends(I31))
        self.failUnless(providedBy(c).extends(I5))
Example #35
0
    def __call__(self, context, request):
        if request.get('ploneintranet.layout.app.enabled'):
            return
        # manipulate the same request only once, and only for one app
        request.set('ploneintranet.layout.app.enabled', True)

        app_layers = list(context.app_layers)

        # do not undo themeswitching
        policy = theming_policy(request)
        if ISwitchableThemingPolicy.providedBy(policy) \
           and policy.isFallbackActive():  # only applies to Barceloneta
            switcher = policy.getSwitcherSettings()
            # respect themeswitching blacklist
            remove_layers = [
                resolveDottedName(x) for x in switcher.browserlayer_filterlist
            ]
            # enable only non-blacklisted IAppLayers
            app_layers = [x for x in app_layers if x not in remove_layers]

        active_layers = app_layers + get_layers(request)
        directlyProvides(request, *active_layers)
Example #36
0
    def test_getMessageTarget_report_valid_report(self):
        from zope.interface import directlyProvides
        from karl.models.interfaces import IPeopleDirectory
        context = self._makeRoot()
        pd = context['people'] = self._makeContext()
        directlyProvides(pd, IPeopleDirectory)
        section = pd['section'] = self._makeContext()
        section['extant'] = self._makeContext()
        mailin = self._makeOne(context)
        message = DummyMessage()
        message.to = ('*****@*****.**', )

        info = mailin.getMessageTargets(message)

        self.failIf(info.get('error'), info)
        targets = info['targets']
        self.assertEqual(len(targets), 1)
        info = targets[0]
        self.assertEqual(info['report'], 'section+extant')
        self.assertEqual(info['community'], None)
        self.assertEqual(info['tool'], None)
        self.failIf(info.get('in_reply_to'), info)
    def testHeadingLinkRootless(self):
        """
        See that heading link points to a global sitemap if no root item is set.
        """

        directlyProvides(self.portal.folder2, INavigationRoot)
        view = self.renderer(self.portal.folder2, assignment=navigation.Assignment(topLevel=0))
        link = view.heading_link_target()
        # The root is not given -> should render the sitemap in the navigation root
        self.assertEqual(link, 'http://nohost/plone/folder2/sitemap')

        # Even if the assignment contains no topLevel options and no self.root
        # one should get link to the navigation root sitemap
        view = self.renderer(self.portal.folder2.doc21, assignment=navigation.Assignment())
        link = view.heading_link_target()
        # The root is not given -> should render the sitemap in the navigation root
        self.assertEqual(link, 'http://nohost/plone/folder2/sitemap')

        view = self.renderer(self.portal.folder1, assignment=navigation.Assignment(topLevel=0))
        link = view.heading_link_target()
        # The root is not given -> should render the sitemap in the navigation root
        self.assertEqual(link, 'http://nohost/plone/sitemap')
def transmute(table, annotation=None, __module__=None, **kw):

    # if no module given, use the callers module
    if __module__ is None:
        import sys
        __module__ = sys._getframe(1).f_globals['__name__']

    z3iface = SQLAlchemySchemaTranslator().translate(table, annotation,
                                                     __module__, **kw)

    # mark the interface itself as being model driven
    interface.directlyProvides(z3iface, IIModelInterface)

    # provide a named annotation adapter to go from the iface back to the annotation
    if annotation is not None:
        name = "%s.%s" % (z3iface.__module__, z3iface.__name__)
        component.provideAdapter(annotation,
                                 adapts=(IIModelInterface, ),
                                 provides=IModelDescriptor,
                                 name=name)

    return z3iface
Example #39
0
    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
Example #40
0
    def _handleRawStream(self):
        """
        Switch the current connection to be a "hijacked" aka raw stream: one
        where bytes just get naively proxied back and forth.
        """
        def loseWriteConnectionReason(reason):
            # discard the reason, for compatibility with readConnectionLost
            self.transport.loseWriteConnection()

        self.father.transport.readConnectionLost = loseWriteConnectionReason
        directlyProvides(self.father.transport, IHalfCloseableProtocol)
        self.http = False
        self.father.transport.write(
            "HTTP/1.1 200 OK\r\n"
            "Content-Type: application/vnd.docker.raw-stream\r\n"
            "\r\n")

        def stdinHandler(data):
            self.transport.write(data)

        self.father.transport.protocol.dataReceived = stdinHandler
        self.setStreamingMode(True)
Example #41
0
 def _makeCommunity(self):
     from zope.interface import directlyProvides
     from karl.models.interfaces import ICommunity
     community = testing.DummyModel(title='thetitle')
     catalog = karltesting.DummyCatalog({
         1: '/profiles/phred',
         2: '/profiles/bharney',
         3: '/profiles/wylma',
     })
     phred = testing.DummyModel(__name__='phred')
     bharney = testing.DummyModel(__name__='bharney')
     wylma = testing.DummyModel(__name__='wylma')
     karltesting.registerModels({
         '/profiles/phred': phred,
         '/profiles/bharney': bharney,
         '/profiles/wylma': wylma,
     })
     community.catalog = catalog
     community.member_names = set(['phred', 'bharney', 'wylma'])
     community.moderator_names = set(['bharney'])
     directlyProvides(community, ICommunity)
     return community
Example #42
0
 def test_wo_conflicts(self):
     from zope.interface import directlyProvides
     from karl.models.interfaces import IPeopleReportMailingList
     ALIASES = {
         'not_people': '/somewhere/else',
     }
     site = testing.DummyModel(list_aliases=ALIASES)
     peopledir = site['people'] = testing.DummyModel()
     section = peopledir['section'] = testing.DummyModel()
     report1 = section['report1'] = testing.DummyModel()
     ml1 = report1['mailinglist'] = testing.DummyModel(short_address='one')
     directlyProvides(ml1, IPeopleReportMailingList)
     report2 = section['report2'] = testing.DummyModel()
     report3 = section['report3'] = testing.DummyModel()
     ml3 = report3['mailinglist'] = testing.DummyModel(
         short_address='three')
     directlyProvides(ml3, IPeopleReportMailingList)
     self._callFUT(peopledir)
     self.assertEqual(len(site.list_aliases), 3)
     self.assertEqual(site.list_aliases['not_people'], '/somewhere/else')
     self.assertEqual(site.list_aliases['one'], '/people/section/report1')
     self.assertEqual(site.list_aliases['three'], '/people/section/report3')
Example #43
0
    def test_render_sidebar_w_acquired_adapter(self):
        from zope.interface import directlyProvides
        from zope.interface import Interface
        from karl.models.interfaces import ICommunity
        from karl.views.interfaces import ISidebar
        parent = testing.DummyModel()
        directlyProvides(parent, ICommunity)
        context = parent['child'] = testing.DummyModel()
        _called_with = []

        def _factory(context, request):
            def _render(api):
                _called_with.append(api)
                return 'SIDEBAR'

            return _render

        karltesting.registerAdapter(_factory, (ICommunity, Interface),
                                    ISidebar)
        request = testing.DummyRequest()
        api = self._makeOne(context, request)
        self.assertEqual(api.render_sidebar(), 'SIDEBAR')
Example #44
0
 def test_lookup_all(self):
     filter_all = dict(callable="outpost.filterinc.replacestr",
                       apply_to="file",
                       path="index\.html",
                       content_type="text/*",
                       settings={
                           "str": "<body>",
                           "new": "<body>Updated!"
                       },
                       name="Filter example")
     fc = filtermanager.FilterConf.fromDict(filter_all)
     response = testing.DummyRequest().response
     response.content_type = "text/html"
     directlyProvides(response, filtermanager.IFileRequest)
     request = testing.DummyRequest()
     request.url = "http://localhost/files/index.html"
     request.registry.settings = {"filter": (fc, )}
     filter = [
         f for f in filtermanager.lookupFilter("post", response, request,
                                               request.url)
     ]
     self.assertTrue(len(filter) == 1)
Example #45
0
    def testDefaultSkin(self):
        request = TestRequest()
        self.assertEqual(
            component.queryMultiAdapter((ob, request), name='test'), None)

        XMLConfig('meta.zcml', zope.app.component)()
        xmlconfig(
            StringIO(template % ('''
            <interface
                interface="
                  zope.app.publisher.browser.tests.test_directives.ITestSkin"
                type="zope.publisher.interfaces.browser.IBrowserSkinType"
                name="Test Skin"
                />
            <browser:defaultSkin name="Test Skin" />
            <browser:page
                name="test"
                class="zope.app.component.tests.views.VZMI"
                layer="
                  zope.app.publisher.browser.tests.test_directives.ITestLayer"
                for="zope.app.component.tests.views.IC"
                permission="zope.Public"
                attribute="index"
                />
            <browser:page name="test"
                class="zope.app.component.tests.views.V1"
                for="zope.app.component.tests.views.IC"
                permission="zope.Public"
                attribute="index"
                />
            ''')))

        # Simulate Zope Publication behavior in beforeTraversal()
        adapters = component.getSiteManager().adapters
        skin = adapters.lookup((providedBy(request), ), IDefaultSkin, '')
        directlyProvides(request, skin)

        v = component.queryMultiAdapter((ob, request), name='test')
        self.assert_(issubclass(v.__class__, VZMI))
Example #46
0
    def setUp(self):
        """Custom shared utility setup for tests."""
        self.portal = self.layer['portal']
        self.request = self.layer['request']
        directlyProvides(self.request, IListUsersLayer)

        # create some dummy content
        self.createUser('user1',
                        properties={
                            'fullname': 'User 1',
                            'description': 'User 1 description',
                            'email': '*****@*****.**',
                            'location': 'Jupiter',
                        },
                        groups=['Administrators'])
        self.createUser('user2',
                        properties={
                            'fullname': 'User 2',
                            'description': 'User 2 description',
                            'email': '*****@*****.**',
                            'location': 'Moon',
                        },
                        groups=['Reviewers'])
        self.createUser('user3',
                        properties={
                            'fullname': 'User 3',
                            'description': 'User 3 description',
                            'email': '*****@*****.**',
                            'location': 'Saturn',
                        },
                        groups=['Administrators', 'Reviewers'])
        self.createUser('user4',
                        properties={
                            'fullname': 'User 4',
                            'description': 'User 4 description',
                            'email': '*****@*****.**',
                            'location': 'Pluto',
                        },
                        groups=['Site Administrators'])
Example #47
0
    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)
Example #48
0
 def test_call_request_has_finished_callbacks_when_view_succeeds(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
     context = DummyContext()
     directlyProvides(context, IContext)
     self._registerTraverserFactory(context, subpath=[''])
     response = DummyResponse('200 OK')
     def view(context, request):
         def callback(request):
             request.environ['called_back'] = True
         request.finished_callbacks = [callback]
         return response
     environ = self._makeEnviron()
     self._registerView(view, '', IViewClassifier, IRequest, IContext)
     router = self._makeOne()
     start_response = DummyStartResponse()
     router(environ, start_response)
     self.assertEqual(environ['called_back'], True)
Example #49
0
    def test_it_interface(self):
        baz = DummyContext()
        bar = DummyContext(baz)
        foo = DummyContext(bar)
        root = DummyContext(foo)
        root.__parent__ = None
        root.__name__ = 'root'
        foo.__parent__ = root
        foo.__name__ = 'foo'
        bar.__parent__ = foo
        bar.__name__ = 'bar'
        baz.__parent__ = bar
        baz.__name__ = 'baz'
        from zope.interface import directlyProvides
        from zope.interface import Interface

        class IFoo(Interface):
            pass

        directlyProvides(root, IFoo)
        result = self._callFUT(baz, IFoo)
        self.assertEqual(result.__name__, 'root')
Example #50
0
    def apply(self, contentNode):
        if not IAttributeAnnotatable.providedBy(self.context):
            directly = interface.directlyProvidedBy(self.context)
            interface.directlyProvides(self.context,
                                       directly + IAttributeAnnotatable)
        annotations = IAnnotations(self.context)
        metadata = annotations.get(self.ANNO_KEY, None)
        if metadata is None:
            metadata = PersistentDict()
            annotations[self.ANNO_KEY] = metadata

        for dl_el in contentNode.childNodes:
            if dl_el.nodeName != 'dl':
                continue

            term = None
            for el in dl_el.childNodes:
                if el.nodeName == 'dt':
                    term = self._extractText(el)
                elif el.nodeName == 'dd':
                    definition = self._extractText(el)
                    metadata[term] = definition
Example #51
0
 def test_handle_submit(self):
     from schemaish.type import File as SchemaFile
     from karl.models.interfaces import IObjectModifiedEvent
     from zope.interface import Interface
     from karl.models.interfaces import ITagQuery
     from karl.content.interfaces import IBlogEntry
     from repoze.lemonade.testing import registerContentFactory
     from karl.testing import DummyCatalog
     karl.testing.registerAdapter(DummyTagQuery, (Interface, Interface),
                                  ITagQuery)
     self._registerDummyWorkflow()
     context = DummyBlogEntry()
     context.sessions = DummySessions()
     context.__name__ = 'ablogentry'
     context.catalog = DummyCatalog()
     context['attachments'] = testing.DummyModel()
     from karl.models.interfaces import ISite
     from zope.interface import directlyProvides
     directlyProvides(context, ISite)
     converted = {
         'title': 'foo',
         'text': 'text',
         'security_state': 'public',
         'tags': 'thetesttag',
         'attachments': [SchemaFile(None, None, None)],
     }
     registerContentFactory(DummyBlogEntry, IBlogEntry)
     L = karl.testing.registerEventListener(
         (Interface, IObjectModifiedEvent))
     karl.testing.registerDummySecurityPolicy('testeditor')
     request = self._makeRequest()
     controller = self._makeOne(context, request)
     response = controller.handle_submit(converted)
     self.assertEqual(response.location, 'http://example.com/ablogentry/')
     self.assertEqual(len(L), 2)
     self.assertEqual(context.title, 'foo')
     self.assertEqual(context.text, 'text')
     self.assertEqual(context.modified_by, 'testeditor')
Example #52
0
 def test_show_members(self):
     from zope.interface import Interface
     from karl.models.interfaces import ICatalogSearch
     context = testing.DummyModel()
     context.member_names = ['a']
     context.moderator_names = ['b']
     profiles = testing.DummyModel()
     profiles['a'] = karltesting.DummyProfile()
     profiles['b'] = karltesting.DummyProfile()
     context['profiles'] = profiles
     d = {1: profiles['a'], 2: profiles['b']}
     searchkw = {}
     def resolver(docid):
         return d.get(docid)
     def dummy_catalog_search(context):
         def search(**kw):
             searchkw.update(kw)
             return 2, [1, 2], resolver
         return search
     karltesting.registerAdapter(dummy_catalog_search, (Interface),
                                 ICatalogSearch)
     from karl.models.interfaces import ICommunity
     from zope.interface import directlyProvides
     directlyProvides(context, ICommunity)
     request = testing.DummyRequest()
     request.view_name = 'list_view.html'
     response = self._callFUT(context, request)
     actions = [('Manage Members', 'manage.html'),
                ('Add Existing', 'add_existing.html'),
                ('Invite New', 'invite_new.html')]
     self.assertEqual(response['actions'], actions)
     self.assertEqual(len(response['members']), 2)
     self.assertEqual(len(response['moderators']), 1)
     self.assertEqual(response['hide_pictures'], True)
     self.assertEqual(len(response['submenu']), 2)
     self.assertEqual(response['submenu'][0]['make_link'], True)
     self.assertEqual(response['submenu'][1]['make_link'], False)
     self.assertEqual(searchkw['sort_index'], 'lastfirst')
Example #53
0
    def _loginSucceeded(self, avatar, request):
        """
        Callback for successful login.

        @param avatar: A tuple of the form (interface, avatar) as
            returned by your realm.

        @param request: L{IRequest} that encapsulates this auth
            attempt.

        @return: the IResource in C{self.wrappedResource}
        """
        request.avatarInterface, request.avatar = avatar

        directlyProvides(request, IAuthenticatedRequest)

        def _addAuthenticateHeaders(request, response):
            """
            A response filter that adds www-authenticate headers
            to an outgoing response if it's code is UNAUTHORIZED (401)
            and it does not already have them.
            """
            if response.code == responsecode.UNAUTHORIZED:
                if not response.headers.hasHeader('www-authenticate'):
                    newResp = UnauthorizedResponse(self.credentialFactories,
                                                   request.remoteAddr)

                    response.headers.setHeader(
                        'www-authenticate',
                        newResp.headers.getHeader('www-authenticate'))

            return response

        _addAuthenticateHeaders.handleErrors = True

        request.addResponseFilter(_addAuthenticateHeaders)

        return self.wrappedResource
    def test_formLayout(self):
        # Verify that exactly one of isSingleLineLayout(), isMultiLineLayout()
        # and isCheckBoxLayout() return True for particular widget.
        #
        # If more than one returns True, then that widget may get included
        # in the form twice.
        form = LaunchpadFormView(None, None)

        class FakeWidget:
            pass

        widget = FakeWidget()
        form.widgets = {'widget': widget}
        # test every combination of the three interfaces:
        for use_single_line in [False, True]:
            for use_multi_line in [False, True]:
                for use_checkbox in [False, True]:
                    provides = []
                    if use_single_line:
                        provides.append(ISingleLineWidgetLayout)
                    if use_multi_line:
                        provides.append(IMultiLineWidgetLayout)
                    if use_checkbox:
                        provides.append(ICheckBoxWidgetLayout)
                    directlyProvides(widget, *provides)

                    # Now count how many of the is* functions return True:
                    count = 0
                    if form.isSingleLineLayout('widget'):
                        count += 1
                    if form.isMultiLineLayout('widget'):
                        count += 1
                    if form.isCheckBoxLayout('widget'):
                        count += 1

                    self.assertEqual(
                        count, 1, 'Expected count of 1 for %r.  Got %d' %
                        (provides, count))
Example #55
0
    def setUp(self):
        import datetime
        from zope.interface import directlyProvides
        from karl.content.interfaces import IBlogEntry
        from karl.models.interfaces import ICommentsFolder

        cleanUp()
        karltesting.registerSettings()

        # Create dummy site skel
        community = karltesting.DummyCommunity()
        site = community.__parent__.__parent__

        profiles = testing.DummyModel()
        site["profiles"] = profiles
        self.profile = profiles["member"] = karltesting.DummyProfile()
        profiles["creator"] = karltesting.DummyProfile()

        community["blog"] = testing.DummyModel()
        community["blog"].__parent__ = community

        blogentry = testing.DummyModel(text="This is a test")
        blogentry.created = datetime.datetime(2010, 5, 12, 2, 42)
        blogentry.creator = 'member'
        community["blog"]["blogentry"] = blogentry
        blogentry.__parent__ = community['blog']
        blogentry["attachments"] = testing.DummyModel()
        blogentry["attachments"].__parent__ = blogentry
        blogentry.title = "Blog Entry"
        blogentry.docid = 0
        directlyProvides(blogentry, IBlogEntry)
        self.blogentry = blogentry

        blogentry["comments"] = testing.DummyModel()
        blogentry["comments"].__parent__ = self.blogentry
        directlyProvides(blogentry['comments'], ICommentsFolder)

        self.comment = self._add_comment(blogentry)
Example #56
0
    def makeConnection(self, transport):
        """
        Connect this wrapper to the given transport and initialize the
        necessary L{OpenSSL.SSL.Connection} with a memory BIO.
        """
        self._tlsConnection = self.factory._createConnection(self)
        self._appSendBuffer = []

        # Add interfaces provided by the transport we are wrapping:
        for interface in providedBy(transport):
            directlyProvides(self, interface)

        # Intentionally skip ProtocolWrapper.makeConnection - it might call
        # wrappedProtocol.makeConnection, which we want to make conditional.
        Protocol.makeConnection(self, transport)
        self.factory.registerProtocol(self)
        if self._connectWrapped:
            # Now that the TLS layer is initialized, notify the application of
            # the connection.
            ProtocolWrapper.makeConnection(self, transport)

        # Now that we ourselves have a transport (initialized by the
        # ProtocolWrapper.makeConnection call above), kick off the TLS
        # handshake.

        # The connection might already be aborted (eg. by a callback during
        # connection setup), so don't even bother trying to handshake in that
        # case.
        if not self._aborted:
            try:
                self._tlsConnection.do_handshake()
            except WantReadError:
                # This is the expected case - there's no data in the
                # connection's input buffer yet, so it won't be able to
                # complete the whole handshake now. If this is the speak-first
                # side of the connection, then some bytes will be in the send
                # buffer now; flush them.
                self._flushSendBIO()
Example #57
0
    def test_with_tag(self):
        from zope.interface import directlyProvides
        from repoze.lemonade.testing import registerContentFactory
        from karl.models.interfaces import ICommunity
        root = testing.DummyModel()
        tags = root.tags = DummyTags()

        def _getRelated(tag, degree=1, community=None, user=None):
            assert tag == 'tag1'
            assert degree == 1
            assert community == 'community'
            assert user is None
            return ['tag2', 'tag3']

        tags.getRelatedTags = _getRelated
        root.catalog = karltesting.DummyCatalog({1: '/community'})
        context = root['community'] = testing.DummyModel()
        context.title = 'title'
        karltesting.registerModels({'/community': context})
        directlyProvides(context, ICommunity)
        registerContentFactory(testing.DummyModel, ICommunity)
        request = testing.DummyRequest()
        request.subpath = [u'tag1']

        result = self._callFUT(context, request)

        self.assertEqual(result['tag'], u'tag1')
        self.assertEqual(len(result['entries']), 1)
        entry = result['entries'][0]
        self.assertEqual(entry['description'], '')
        self.assertEqual(entry['title'], 'title')
        self.assertEqual(entry['href'], 'http://example.com/community/')
        self.assertEqual(entry['tagusers_count'], '1 person')
        self.assertEqual(entry['type'], 'Community')
        self.assertEqual(
            entry['tagusers_href'], 'http://example.com/community/'
            'tagusers.html?tag=tag1&docid=1')
        self.assertEqual(len(result['related']), 0)
Example #58
0
def buy_n_get_m_free(price, n, m):
    '''
    Returns a :class:`checkout.interface.IPricer` which does (a version
    of) "buy N get M free". For the border-case of wishing to purchase
    fewer than you're entitled to, we opt for "screw the customer",
    basically. Alternatively, we could provide a way to update the
    count to reflect the free items.

    For example, with "buy 5 get 2 free" if you buy 5 things, you
    still pay the same as if you bought 6 or 7.
    '''
    if m >= n:
        raise RuntimeError("Can't buy %d and get %d free." % (n, m))

    # here, we implement the IPricer interface (a Functor pattern) not
    # as a class but as a function directly, to demonstrate
    # zope.interface's "directlyProvides" functionality and a Python
    # closure. Note how we satisfy the "description" attribute by
    # adding it to the method object; that can be done in- or out-side
    # of the inner method.
    def buy_n_pricer(count, **kw):
        groups = count / (n + m)
        leftover = count % (n + m)
        free = groups * m
        paid = (groups * n)
        if leftover > n:
            paid = n
            free = leftover - n
        else:
            paid += leftover
        assert paid + free == count
        total = paid * price
        return (None, total)

    buy_n_pricer.description = 'Buy %d get %d free' % (n, m)
    directlyProvides(buy_n_pricer, IPricer)

    return buy_n_pricer
Example #59
0
    def makeConnection(self, transport):
        """
        Connect this wrapper to the given transport and initialize the
        necessary L{OpenSSL.SSL.Connection} with a memory BIO.
        """
        tlsContext = self.factory._contextFactory.getContext()
        self._tlsConnection = Connection(tlsContext, None)
        if self.factory._isClient:
            self._tlsConnection.set_connect_state()
        else:
            self._tlsConnection.set_accept_state()
        self._appSendBuffer = []

        # Add interfaces provided by the transport we are wrapping:
        for interface in providedBy(transport):
            directlyProvides(self, interface)

        # Intentionally skip ProtocolWrapper.makeConnection - it might call
        # wrappedProtocol.makeConnection, which we want to make conditional.
        Protocol.makeConnection(self, transport)
        self.factory.registerProtocol(self)
        if self._connectWrapped:
            # Now that the TLS layer is initialized, notify the application of
            # the connection.
            ProtocolWrapper.makeConnection(self, transport)

        # Now that we ourselves have a transport (initialized by the
        # ProtocolWrapper.makeConnection call above), kick off the TLS
        # handshake.
        try:
            self._tlsConnection.do_handshake()
        except WantReadError:
            # This is the expected case - there's no data in the connection's
            # input buffer yet, so it won't be able to complete the whole
            # handshake now.  If this is the speak-first side of the
            # connection, then some bytes will be in the send buffer now; flush
            # them.
            self._flushSendBIO()
Example #60
0
    def test_including_replace_image_fulldomain(self):
        import simplejson
        from karl.content.interfaces import IImage
        from zope.interface import directlyProvides
        context = testing.DummyModel()
        image = context['boo.jpg'] = testing.DummyModel()
        image.title = 'Boo'
        directlyProvides(image, IImage)

        # It must also work, when the image url is
        # a full domain. This happens on IE.
        # XXX The server should _not_ check the domain
        # at all, simply use the path.

        # XXX For a reason unknown, this test passes even
        # if the traverse the full domain instead of just the
        # path... while, the same thing fails in "real life" on IE.
        # So, this test probably does not test what it should...
        request = testing.DummyRequest(
            params={
                'include_image_url': 'http://lcd.tv:9876/boo.jpg/thumb',
                'source': 'myrecent',
            })
        response = self._call_fut(context, request)
        self.assertEqual(response.status, '200 OK')
        self.assertEqual(self.dummy_get_images_batch.called,
                         (context, request, {
                             'community': None,
                             'batch_start': 0,
                             'batch_size': 12,
                             'creator': None
                         }))
        data = simplejson.loads(response.body)
        self.assertEqual(data['images_info'], {
            'totalRecords': 6,
            'start': 0,
            'records': ['Boo', 'foo', 'bar'],
        })