Python testing.registerContentFactory函数代码示例

    def test_with_tag_multiple_users(self):
        from zope.interface import directlyProvides
        from repoze.lemonade.testing import registerContentFactory
        context = testing.DummyModel()
        context.title = 'title'
        karltesting.registerModels({'/foo': context})
        directlyProvides(context, IDummyBlogEntry)
        registerContentFactory(testing.DummyModel, IDummyBlogEntry)
        tags = context.tags = DummyTags(users=('dummy', 'dummy2'))
        def _getRelated(tag, degree=1, community=None, user=None):
            assert tag == 'tag1'
            assert degree == 1
            assert community is None
            assert user is None
            return []
        tags.getRelatedTags = _getRelated
        context.catalog = karltesting.DummyCatalog({1:'/foo'})
        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/')
        self.assertEqual(entry['tagusers_count'], '2 people')
        self.assertEqual(entry['type'], 'Blog Entry')
        self.assertEqual(entry['tagusers_href'],
                         'http://example.com/tagusers.html?tag=tag1&docid=1')
        self.assertEqual(len(result['related']), 0)

    def test_submitted_toobig(self):
        self._register()
        self._registerLayoutProvider()

        from repoze.bfg.formish import ValidationError

        def check_upload_size(*args):
            raise ValidationError(file='TEST VALIDATION ERROR')

        testing.registerDummySecurityPolicy('userid')
        context = self._makeContext()
        context.catalog = DummyCatalog()
        request = self._makeRequest()
        from schemaish.type import File as SchemaFile
        fs = SchemaFile('abc', 'filename', 'x/foo')
        converted = {
            'file': fs,
            'title': 'a title',
            'sendalert': False,
            'security_state': 'public',
            'tags':[],
            }
        from karl.content.interfaces import ICommunityFile
        from repoze.lemonade.testing import registerContentFactory
        registerContentFactory(DummyCommunityFile, ICommunityFile)
        controller = self._makeOne(context, request, check_upload_size)
        self.assertRaises(ValidationError, controller.handle_submit, converted)

 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_no_creator(self):
     from webob.multidict import MultiDict
     context = testing.DummyModel()
     context.catalog = {}
     context['profiles'] = testing.DummyModel()
     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)
     class LocalDummyContent(testing.DummyModel):
         implements(IDummyContent)
         import datetime
         title = 'Dummy Content'
         modified = datetime.datetime(2010, 5, 12, 2, 42)
     class LocalDummySearch(DummySearch):
         content = LocalDummyContent()
     karltesting.registerAdapter(LocalDummySearch, (Interface),
                             ICatalogSearch)
     karltesting.registerAdapter(DummySearchResultsDisplay,
                             (Interface, Interface),
                             IAdvancedSearchResultsDisplay)
     result = self._callFUT(context, request)
     self.assertEqual(result['terms'], ['yo'])
     self.assertEqual(len(result['results']), 1)

 def test_handle_submit(self):
     from karl.testing import DummyUpload
     attachment = DummyUpload(filename='newfile.txt')
     converted = {'title': u'New Title',
                  'text': u'New page text.',
                  'tags': [u'foo', u'bar'],
                  'attachments': [attachment],
                  }
     self._registerTags(self.parent)
     from karl.content.interfaces import ICommunityFile
     from karl.testing import DummyFile
     registerContentFactory(DummyFile, ICommunityFile)
     context = self.context
     controller = self._makeOne(context, self.request)
     response = controller.handle_submit(converted)
     self.failUnless('Page%20edited' in response.location)
     self.failUnless(
         response.location.startswith('http://example.com/child/'))
     self.assertEqual(context.title, u'New Title')
     self.assertEqual(context.text, u'New page text.')
     attachments_folder = context['attachments']
     self.failUnless('newfile.txt' in attachments_folder)
     self.failIf(len(attachments_folder) > 1)
     self.assertEqual(self.parent.tags._called_with[1]['tags'],
                      [u'foo', u'bar'])

    def test_upload_has_mimetype_instead_of_type(self):
        from cStringIO import StringIO
        from karl.content.interfaces import ICommunityFile
        from repoze.lemonade.testing import registerContentFactory
        karl.testing.registerDummySecurityPolicy("userid")
        def make_image(title, stream, mimetype, filename, creator):
            res = testing.DummyModel()
            res.title = title
            res.mimetype = mimetype
            res.data = stream.read()
            res.filename = filename
            res.creator = creator
            res.is_image = True
            return res
        registerContentFactory(make_image, ICommunityFile)

        context = makeRoot()
        context.title = 'Howdy Doody'
        context.__name__ = 'howdydoody'
        context.size = 1000
        dummy_upload = DummyUpload(StringIO(one_pixel_jpeg), 'image/jpeg')
        dummy_upload.mimetype = dummy_upload.type
        del dummy_upload.type

        form = {'photo': dummy_upload}
        self._callFUT(context, form)
        self.assertTrue('photo' in context)
        photo = context['photo']
        self.assertEqual(photo.title, 'Photo of Howdy Doody')
        self.assertEqual(photo.mimetype, 'image/jpeg')
        self.assertEqual(photo.data, one_pixel_jpeg)
        self.assertEqual(photo.filename, 'test.dat')
        self.assertEqual(photo.creator, 'userid')

    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
        karltesting.registerUtility(nonrandom, IRandomId)
        registerContentFactory(DummyInvitation, IInvitation)
        controller = self._makeOne(context, request)
        converted = {
            'email_addresses': [u'[email protected]'],
            'text': u'some text',
            }

        karltesting.registerDummyRenderer(
            'karl.views:templates/email_invite_new.pt')
        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_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
     karltesting.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_handle_submit_already_in_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()
     profile = karltesting.DummyProfile(security_state='active')
     profile.__name__ = 'd'
     registerCatalogSearch(results={'[email protected]': [profile,]})
     def nonrandom(size=6):
         return 'A' * size
     karltesting.registerUtility(nonrandom, IRandomId)
     registerContentFactory(DummyInvitation, IInvitation)
     controller = self._makeOne(context, request)
     converted = {
         'email_addresses': [u'[email protected]'],
         'text': u'some text',
         }
     karltesting.registerDummyRenderer(
         'karl.views:templates/email_add_existing.pt')
     response = controller.handle_submit(converted)
     self.assertEqual(response.location,
       'http://example.com/manage.html?status_message=One+existing+Karl+user+added+to+community.++'
                      )
     self.failIf('A'*6 in context)
     self.assertEqual(context.users.added_groups,
                      [('d', 'group:community:members')])

    def test_handle_submit_full_path_filename(self):
        from schemaish.type import File as SchemaFile
        from karl.content.interfaces import ICommunityFile
        from repoze.lemonade.testing import registerContentFactory
        from repoze.bfg.formish import ValidationError
        self._register()
        self._registerLayoutProvider()

        testing.registerDummySecurityPolicy('userid')
        context = self._makeContext()
        context.catalog = DummyCatalog()
        fs = SchemaFile('abc', r"C:\Documents and Settings\My Tests\filename",
                        'x/foo')
        converted = {
            'file': fs,
            'title': 'a title',
            'sendalert': False,
            'security_state': 'public',
            'tags':['thetesttag'],
            }
        request = self._makeRequest()
        registerContentFactory(DummyCommunityFile, ICommunityFile)
        controller = self._makeOne(context, request)
        response = controller.handle_submit(converted)
        self.assertEqual(response.location, 'http://example.com/filename/')
        self.assertEqual(context['filename'].title, u'a title')
        self.assertEqual(context['filename'].creator, 'userid')
        self.assertEqual(context['filename'].stream, 'abc')
        self.assertEqual(context['filename'].mimetype, 'x/foo')
        self.assertEqual(context['filename'].filename, 'filename')

        # attempt a duplicate upload
        self.assertRaises(ValidationError, controller.handle_submit, converted)

 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
     karltesting.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)
     karltesting.registerAdapter(DummySearch, (Interface),
                             ICatalogSearch)
     karltesting.registerAdapter(DummySearchResultsDisplay,
                             (Interface, Interface),
                             IAdvancedSearchResultsDisplay)
     result = self._callFUT(context, request)
     self.assertEqual(result['terms'], ['People'])
     self.assertEqual(len(result['results']), 1)

 def test_handle_submit(self):
     from karl.models.interfaces import ISite
     from zope.interface import directlyProvides
     site = testing.DummyModel(sessions=DummySessions())
     directlyProvides(site, ISite)
     from karl.testing import DummyCatalog
     from karl.models.adapters import CatalogSearch
     from karl.models.interfaces import ICatalogSearch
     from zope.interface import Interface
     site.catalog = DummyCatalog()
     karl.testing.registerAdapter(CatalogSearch, (Interface), ICatalogSearch)
     context = self.context
     site['newsfolder'] = context
     tags = DummyTags()
     site.tags = tags
     controller = self._makeOne(context, self.request)
     from karl.content.views.newsitem import _now
     from karl.testing import DummyUpload
     attachment1 = DummyUpload(filename='test1.txt')
     attachment2 = DummyUpload(filename=r'C:\My Documents\Ha Ha\test2.txt')
     photo = DummyUpload(filename='test.jpg',
                         mimetype='image/jpeg',
                         data=dummy_photo)
     now = _now()
     converted = {
         'title': 'Foo',
         'text': 'text',
         'publication_date': now,
         'caption': 'caption',
         'tags': ['tag1', 'tag2'],
         'attachments': [attachment1, attachment2],
         'photo': photo
         }
     from karl.content.interfaces import INewsItem
     from karl.content.interfaces import ICommunityFile
     from repoze.lemonade.testing import registerContentFactory
     registerContentFactory(DummyNewsItem, INewsItem)
     registerContentFactory(DummyFile, ICommunityFile)
     response = controller.handle_submit(converted)
     newsitem_url = 'http://example.com/newsfolder/foo/'
     self.assertEqual(response.location, newsitem_url)
     self.failUnless('foo' in context)
     newsitem = context['foo']
     self.assertEqual(newsitem.title, 'Foo')
     self.assertEqual(newsitem.text, 'text')
     self.assertEqual(newsitem.publication_date, now)
     self.assertEqual(newsitem.caption, 'caption')
     self.failUnless('attachments' in newsitem)
     attachments_folder = newsitem['attachments']
     self.failUnless('test1.txt' in attachments_folder)
     self.failUnless('test2.txt' in attachments_folder)
     self.assertEqual(attachments_folder['test1.txt'].filename,
                      'test1.txt')
     self.assertEqual(attachments_folder['test2.txt'].filename,
                      'test2.txt')
     self.failUnless('photo' in newsitem)
     self.assertEqual(newsitem['photo'].data, dummy_photo)
     self.assertEqual(site.tags._called_with[1]['tags'],
                      ['tag1', 'tag2'])

 def test_handle_submit(self):
     from karl.models.interfaces import ISite
     from zope.interface import directlyProvides
     site = testing.DummyModel(sessions=DummySessions())
     directlyProvides(site, ISite)
     from karl.testing import DummyCatalog
     from karl.models.adapters import CatalogSearch
     from karl.models.interfaces import ICatalogSearch
     from zope.interface import Interface
     site.catalog = DummyCatalog()
     testing.registerAdapter(CatalogSearch, (Interface), ICatalogSearch)
     context = self.context
     site['newsitem'] = context
     tags = DummyTags()
     site.tags = tags
     controller = self._makeOne(context, self.request)
     from karl.content.views.newsitem import _now
     now = _now()
     simple = {
         'title': 'NewFoo',
         'text': 'text',
         'caption': 'caption',
         'publication_date': now
         }
     from karl.models.tests.test_image import one_pixel_jpeg as dummy_photo
     from karl.testing import DummyUpload
     attachment1 = DummyUpload(filename='test1.txt')
     attachment2 = DummyUpload(filename=r'C:\My Documents\Ha Ha\test2.txt')
     photo = DummyUpload(filename='test.jpg',
                         mimetype='image/jpeg',
                         data=dummy_photo)
     converted = {
         'tags': ['tag1', 'tag2'],
         'attachments': [attachment1, attachment2],
         'photo': photo,
         }
     converted.update(simple)
     from karl.models.interfaces import IImageFile
     from karl.content.interfaces import ICommunityFile
     from karl.views.tests.test_file import DummyImageFile
     from repoze.lemonade.testing import registerContentFactory
     registerContentFactory(DummyImageFile, IImageFile)
     registerContentFactory(DummyFile, ICommunityFile)
     response = controller.handle_submit(converted)
     msg = "?status_message=News%20Item%20edited"
     self.assertEqual(response.location,
                      'http://example.com/newsitem/%s' % msg)
     for field, value in simple.items():
         self.assertEqual(getattr(context, field), value)
     attachments_folder = context['attachments']
     self.failUnless('test1.txt' in attachments_folder)
     self.failUnless('test2.txt' in attachments_folder)
     self.assertEqual(attachments_folder['test1.txt'].filename,
                      'test1.txt')
     self.assertEqual(attachments_folder['test2.txt'].filename,
                      'test2.txt')
     self.failUnless('photo.jpg' in context)
     self.assertEqual(site.tags._called_with[1]['tags'],
                      ['tag1', 'tag2'])

 def test_blog_entry(self):
     from karl.content.interfaces import IBlogEntry as ctype
     from zope.interface import directlyProvides
     from repoze.lemonade.testing import registerContentFactory
     registerContentFactory(testing.DummyModel, ctype)
     context = testing.DummyModel()
     directlyProvides(context, ctype)
     self.assertEqual(self._callFUT(context), ('Blog Entry', 'blog.png'))

 def setUp(self):
     self.config = setUp()
     from adhocracy.core.models.references import child_factory
     from repoze.lemonade.testing import registerContentFactory
     registerContentFactory(child_factory, self._target_marker_interface)
     from adhocracy.core.models.references import Child
     self.config.registry.registerAdapter(Child)
     self.graph = get_graph()