Python testing.registerUtility函数代码示例

    def test_submit_form(self):
        from repoze.sendmail.interfaces import IMailDelivery
        testing.registerDummyRenderer("templates/join_community.pt")

        c = karltesting.DummyCommunity()
        c.moderator_names = set(["moderator1", "moderator2"])
        site = c.__parent__.__parent__
        profiles = site["profiles"] = testing.DummyModel()
        profiles["user"] = karltesting.DummyProfile()
        profiles["moderator1"] = karltesting.DummyProfile()
        profiles["moderator2"] = karltesting.DummyProfile()

        mailer = karltesting.DummyMailer()
        testing.registerUtility(mailer, IMailDelivery)

        testing.registerDummySecurityPolicy("user")
        request = testing.DummyRequest({
            "form.submitted": "1",
            "message": "Message text.",
        })
        testing.registerDummyRenderer(
            'karl.views:templates/email_join_community.pt')
        response = self._callFUT(c, request)

        self.assertEqual(response.location,
                         "http://example.com/communities/community/"
                         "?status_message=Your+request+has+been+sent+"
                         "to+the+moderators.")
        self.assertEqual(len(mailer), 1)
        msg = mailer.pop()
        self.assertEqual(msg.mto, ["[email protected]",
                                   "[email protected]"])

    def test_getMessageTarget_report_alias_w_subdomain(self):
        from repoze.bfg.interfaces import ISettings
        from repoze.bfg.testing import registerUtility
        from repoze.bfg.traversal import model_path
        from zope.interface import directlyProvides
        from karl.models.interfaces import IPeopleDirectory
        class DummySettings:
            system_list_subdomain = 'lists.example.com'
        registerUtility(DummySettings(), ISettings)
        context = self._makeRoot()
        cf = context['communities'] = self._makeContext()
        cf['testing'] = self._makeContext()
        pd = context['people'] = self._makeContext()
        directlyProvides(pd, IPeopleDirectory)
        section = pd['section'] = self._makeContext()
        extant = section['extant'] = self._makeContext()
        context.list_aliases['testing'] = model_path(extant)
        mailin = self._makeOne(context)
        message = DummyMessage()
        message.to = ('[email protected]',)

        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 test_known_kind_no_text_term(self):
     from webob.multidict import MultiDict
     from karl.models.interfaces import IGroupSearchFactory
     from repoze.lemonade.testing import registerContentFactory
     from zope.interface import Interface
     content = DummyCommunityContent()
     def search_factory(*arg, **kw):
         return DummySearchFactory(content)
     search_factory.icon = 'foo.jpg'
     search_factory.advanced_search = True
     testing.registerUtility(
         search_factory, IGroupSearchFactory, name='People')
     context = testing.DummyModel()
     context.catalog = {}
     context['profiles'] = profiles = testing.DummyModel()
     profiles['tweedle dee'] = testing.DummyModel(title='Tweedle Dee')
     request = testing.DummyRequest(
         params=MultiDict({'kind':'People'}))
     from karl.models.interfaces import ICatalogSearch
     from karl.views.interfaces import IAdvancedSearchResultsDisplay
     registerContentFactory(DummyContent, IDummyContent)
     testing.registerAdapter(DummySearch, (Interface),
                             ICatalogSearch)
     testing.registerAdapter(DummySearchResultsDisplay,
                             (Interface, Interface),
                             IAdvancedSearchResultsDisplay)
     result = self._callFUT(context, request)
     self.assertEqual(result['terms'], ['People'])
     self.assertEqual(len(result['results']), 1)

    def test_comment_ordering(self):
        context = DummyBlogEntry()
        context['comments']['2'] = DummyComment(now=1233149510, text=u'before')
        from karl.models.interfaces import ISite
        from zope.interface import directlyProvides
        from karl.testing import DummyProfile
        directlyProvides(context, ISite)
        from karl.content.interfaces import IBlog
        from zope.interface import alsoProvides

        alsoProvides(context, IBlog)
        context['profiles'] = profiles = testing.DummyModel()
        profiles['dummy'] = DummyProfile(title='Dummy Profile')
        request = testing.DummyRequest()
        def dummy_byline_info(context, request):
            return context
        from zope.interface import Interface
        from karl.content.views.interfaces import IBylineInfo
        testing.registerAdapter(dummy_byline_info, (Interface, Interface),
                                IBylineInfo)
        self._register()
        from karl.utilities.interfaces import IKarlDates
        testing.registerUtility(dummy, IKarlDates)
        renderer = testing.registerDummyRenderer('templates/show_blogentry.pt')
        self._callFUT(context, request)
        self.assertEqual(len(renderer.comments), 2)
        self.assertEqual('before', renderer.comments[0]['text'])
        self.assertEqual('sometext', renderer.comments[1]['text'])

 def test_handle_submit_already_in_community(self):
     from repoze.lemonade.testing import registerContentFactory
     from karl.models.interfaces import IInvitation
     from karl.utilities.interfaces import IRandomId
     request = testing.DummyRequest()
     context = self._makeCommunity()
     mailer = self._registerMailer()
     registerCatalogSearch()
     profile = karltesting.DummyProfile()
     profile.__name__ = 'a'
     registerCatalogSearch(results={'[email protected]': [profile,]})
     def nonrandom(size=6):
         return 'A' * size
     testing.registerUtility(nonrandom, IRandomId)
     registerContentFactory(DummyInvitation, IInvitation)
     controller = self._makeOne(context, request)
     converted = {
         'email_addresses': [u'[email protected]'],
         'text': u'some text',
         }
     response = controller.handle_submit(converted)
     self.assertEqual(response.location,
       'http://example.com/manage.html?status_message=One+user+already+member.'
                      )
     self.failIf('A'*6 in context)
     self.assertEqual(context.users.added_groups, [])

    def test_respect_alert_prefs(self):
        from repoze.sendmail.interfaces import IMailDelivery
        from repoze.bfg.interfaces import IRequest
        from karl.models.interfaces import IProfile
        from karl.testing import DummyMailer

        mailer = DummyMailer()
        testing.registerUtility(mailer, IMailDelivery)

        community = DummyCommunity()
        community["foo"] = context = testing.DummyModel()
        directlyProvides(context, IDummy)

        site = community.__parent__.__parent__
        site["profiles"] = profiles = testing.DummyModel()
        profiles["a"] = DummyProfile()
        profiles["b"] = DummyProfile()
        profiles["b"].set_alerts_preference(community.__name__,
                                            IProfile.ALERT_DIGEST)
        profiles["c"] = DummyProfile()
        profiles["c"].set_alerts_preference(community.__name__,
                                            IProfile.ALERT_NEVER)

        community.member_names = set(("a","c",))
        community.moderator_names = set(("b",))

        request = testing.DummyRequest()
        testing.registerAdapter(DummyEmailAlertAdapter,
                                (IDummy, IProfile, IRequest), IAlert)

        self._get_instance().emit(context, request)
        self.assertEqual(1, len(mailer))
        self.assertEqual(1, len(profiles["b"]._pending_alerts))

    def test_crackPayload_multiple_w_text(self):
        from repoze.bfg.testing import registerUtility
        from karl.utilities.interfaces import IMailinTextScrubber
        _called_with = []
        def _fooScrubber(text, text_mimetype=None):
            _called_with.append((text, text_mimetype))
            return text.upper()
        registerUtility(_fooScrubber, IMailinTextScrubber, 'foo')
        mailin = self._makeOne()
        mailin.text_scrubber = 'foo'
        message = DummyMessage()
        filepart = DummyMessage()
        filepart.filename = 'file1.bin'
        filepart.payload = '0123456789ABCDEF'
        filepart.content_type = 'application/octet-stream'
        textpart = DummyMessage()
        textpart.payload = 'payload'
        textpart.charset = 'rot13'
        textpart.content_type = 'text/plain'
        message.payload = (filepart, textpart)

        text, attachments = mailin.crackPayload(message)

        self.assertEqual(text, u'CNLYBNQ')
        self.assertEqual(len(attachments), 1)
        filename, mimetype, data = attachments[0]
        self.assertEqual(filename, 'file1.bin')
        self.assertEqual(mimetype, 'application/octet-stream')
        self.assertEqual(data, '0123456789ABCDEF')
        self.assertEqual(len(_called_with), 1)
        self.assertEqual(_called_with[0][0], 'cnlybnq')
        self.assertEqual(_called_with[0][1], 'text/plain')

    def test_no_security_policy(self):
        context = DummyBlogEntry()
        from karl.models.interfaces import ISite
        from zope.interface import directlyProvides
        from karl.testing import DummyProfile
        directlyProvides(context, ISite)
        from karl.content.interfaces import IBlog
        from zope.interface import alsoProvides

        alsoProvides(context, IBlog)
        context['profiles'] = profiles = testing.DummyModel()
        profiles['dummy'] = DummyProfile(title='Dummy Profile')
        request = testing.DummyRequest()
        def dummy_byline_info(context, request):
            return context
        from zope.interface import Interface
        from karl.content.views.interfaces import IBylineInfo
        testing.registerAdapter(dummy_byline_info, (Interface, Interface),
                                IBylineInfo)
        self._register()
        from karl.utilities.interfaces import IKarlDates
        testing.registerUtility(dummy, IKarlDates)
        renderer = testing.registerDummyRenderer('templates/show_blogentry.pt')
        self._callFUT(context, request)
        self.assertEqual(len(renderer.comments), 1)
        c0 = renderer.comments[0]
        self.assertEqual(c0['text'], 'sometext')

        self.assertEqual(d1, renderer.comments[0]['date'])
        self.assertEqual(c0['author_name'], 'Dummy Profile')
        self.assertEqual(renderer.comments[0]['edit_url'],
                         'http://example.com/blogentry/comments/1/edit.html')

    def test_handle_submit_new_to_karl(self):
        from repoze.lemonade.testing import registerContentFactory
        from karl.models.interfaces import IInvitation
        from karl.utilities.interfaces import IRandomId
        request = testing.DummyRequest()
        context = self._makeCommunity()
        mailer = self._registerMailer()
        registerCatalogSearch()
        def nonrandom(size=6):
            return 'A' * size
        testing.registerUtility(nonrandom, IRandomId)
        registerContentFactory(DummyInvitation, IInvitation)
        controller = self._makeOne(context, request)
        converted = {
            'email_addresses': [u'[email protected]'],
            'text': u'some text',
            }

        response = controller.handle_submit(converted)
        self.assertEqual(response.location,
          'http://example.com/manage.html?status_message=One+user+invited.++'
                         )
        invitation = context['A'*6]
        self.assertEqual(invitation.email, '[email protected]')
        self.assertEqual(1, len(mailer))
        self.assertEqual(mailer[0].mto, [u"[email protected]",])

 def test_configure_by_utility(self):
     from repoze.bfg.interfaces import ISettings
     testing.registerUtility(DummySettings(None), ISettings)
     logger = self._makeOne()
     self.assertEquals(logger._configured, False)
     logger(DummyQueryEvent())
     self.assertEquals(logger._configured, True)
     self.assertEquals(logger.log_dir, None)

 def test_with_settings_and_suppress_mail(self):
     from repoze.bfg.interfaces import ISettings
     from opencore.utilities.mailer import FakeMailDelivery
     settings = DummySettings()
     testing.registerUtility(settings, ISettings)
     os = FakeOS(SUPPRESS_MAIL='1')
     delivery = self._callFUT(os)
     self.assertEqual(delivery.__class__, FakeMailDelivery)

 def zztest_with_settings_for_real_messenger(self):
     from repoze.bfg.interfaces import ISettings
     from opencore.utilities.messenger import Messenger
     settings = DummySettings()
     testing.registerUtility(settings, ISettings)
     os = FakeOS()
     delivery = self._callFUT(os)
     self.assertEqual(delivery.__class__, Messenger) 

 def test_custom_logo_url(self):
     context = testing.DummyModel()
     request = testing.DummyRequest()
     from repoze.bfg.interfaces import ISettings
     settings = karltesting.DummySettings()
     settings.logo_path = 'mylogo.png'
     testing.registerUtility(settings, ISettings)
     api = self._makeOne(context, request)
     self.assertEqual(api.logo_url, api.static_url + '/mylogo.png')

 def test_mimeinfo_with_mimetype(self):
     def m(mimetype):
         return 123
     from karl.utilities.interfaces import IMimeInfo
     testing.registerUtility(m, IMimeInfo)
     context = testing.DummyModel(mimetype='abc')
     request = testing.DummyRequest()
     adapter = self._makeOne(context, request)
     self.assertEqual(adapter.mimeinfo, 123)

 def _register(self):
     d1 = 'Wednesday, January 28, 2009 08:32 AM'
     def dummy(date, flavor):
         return d1
     from karl.utilities.interfaces import IKarlDates
     testing.registerUtility(dummy, IKarlDates)
     from karl.models.interfaces import ITagQuery
     testing.registerAdapter(DummyTagQuery, (Interface, Interface),
                             ITagQuery)