Python testing.registerDummyWorkflow函数代码示例

 def _register(self):
     from zope.interface import Interface
     from karl.models.interfaces import ITagQuery
     karl.testing.registerAdapter(DummyTagQuery, (Interface, Interface),
                                  ITagQuery)
     from repoze.workflow.testing import registerDummyWorkflow
     registerDummyWorkflow('security')

 def _register(self):
     from zope.interface import Interface
     from karl.utilities.interfaces import IKarlDates
     from karl.models.interfaces import ITagQuery
     testing.registerUtility(dummy, IKarlDates)
     testing.registerAdapter(DummyTagQuery, (Interface, Interface),
                             ITagQuery)
     from repoze.workflow.testing import registerDummyWorkflow
     registerDummyWorkflow('security')

    def setUp(self):
        cleanUp()

        from repoze.lemonade.testing import registerContentFactory
        from karl.content.interfaces import ICommunityFile
        registerContentFactory(testing.DummyModel, ICommunityFile)

        from zope.interface import Interface
        from repoze.workflow.testing import registerDummyWorkflow
        self.workflow = DummyWorkflow()
        registerDummyWorkflow('security', self.workflow, Interface)

    def setUp(self):
        testing.cleanUp()

        from repoze.lemonade.testing import registerContentFactory
        from karl.content.interfaces import ICommunityFile
        from karl.content.models.files import CommunityFile

        registerContentFactory(CommunityFile, ICommunityFile)

        from zope.interface import Interface
        from repoze.workflow.testing import registerDummyWorkflow

        self.workflow = DummyWorkflow()
        registerDummyWorkflow("security", self.workflow, Interface)

 def _registerDummyWorkflow(self):
     from repoze.workflow.testing import registerDummyWorkflow
     wf = DummyWorkflow(
         [{'transitions':['private'],'name': 'public', 'title':'Public'},
          {'transitions':['public'], 'name': 'private', 'title':'Private'}])
     workflow = registerDummyWorkflow('security', wf)
     return workflow

 def test_it_two_comments(self):
     from karl.models.interfaces import ICommunity
     from karl.models.interfaces import ISite
     from zope.interface import directlyProvides
     from karl.testing import DummyProfile
     from repoze.workflow.testing import registerDummyWorkflow
     site = testing.DummyModel()
     site['test'] = context = testing.DummyModel()
     directlyProvides(context, ICommunity, ISite)
     registerDummyWorkflow('security')
     context.catalog = {'creation_date': DummyCreationDateIndex()}
     context['profiles'] = profiles = testing.DummyModel()
     profiles['dummy'] = DummyProfile(title='Dummy Creator')
     from webob.multidict import MultiDict
     request = testing.DummyRequest(
         params=MultiDict({'year': 2009, 'month': 4}))
     request.layout_manager = mock.Mock()
     from karl.utilities.interfaces import IKarlDates
     karl.testing.registerUtility(dummy, IKarlDates)
     from datetime import datetime
     entry = testing.DummyModel(
         creator='dummy', title='Dummy Entry',
         description='Some words',
         created=datetime(2009, 4, 15))
     from zope.interface import directlyProvides
     from karl.content.interfaces import IBlogEntry
     directlyProvides(entry, IBlogEntry)
     entry['comments'] = testing.DummyModel()
     entry['comments']['1'] = DummyComment()
     entry['comments']['2'] = DummyComment()
     context['e1'] = entry
     def dummy_byline_info(context, request):
         return context
     from zope.interface import Interface
     from karl.content.views.interfaces import IBylineInfo
     karl.testing.registerAdapter(dummy_byline_info, (Interface, Interface),
                                  IBylineInfo)
     response = self._callFUT(context, request)
     self.assertEqual(len(response['entries']), 1)
     self.assertEqual(response['entries'][0]['title'], 'Dummy Entry')
     self.assertEqual(response['entries'][0]['creator_href'],
                      'http://example.com/test/e1/')
     self.assertEqual(response['entries'][0]['href'],
                      'http://example.com/test/e1/')
     self.assertEqual(response['entries'][0]['creator_title'],
                      'Dummy Creator')

 def test_handle_submit_success(self):
     from karl.models.interfaces import IProfile
     from repoze.lemonade.testing import registerContentFactory
     from repoze.sendmail.interfaces import IMailDelivery
     from repoze.workflow.testing import registerDummyWorkflow
     from karl.models.interfaces import ICommunity
     from zope.interface import directlyProvides
     workflow = registerDummyWorkflow('security')
     mailer = karltesting.DummyMailer()
     karltesting.registerUtility(mailer, IMailDelivery)
     registerContentFactory(DummyContent, IProfile)
     class DummyWhoPlugin(object):
         def remember(self, environ, identity):
             self.identity = identity
             return []
     request = self._makeRequest()
     community = testing.DummyModel()
     profiles = testing.DummyModel()
     community['profiles'] = profiles
     community.users = karltesting.DummyUsers()
     community.members_group_name = 'community:members'
     directlyProvides(community, ICommunity)
     context = self._makeContext()
     community['invite'] = context
     community.title = 'Community'
     community.description = 'Community'
     community.sessions = DummySessions()
     context.email = '[email protected]'
     controller = self._makeOne(context, request)
     converted = {'password':'1', 'password_confirm':'1',
                  'username':'username',
                  'firstname':'firstname', 'lastname':'lastname',
                  'phone':'phone', 'extension':'extension',
                  'department':'department', 'position':'position',
                  'organization':'organization', 'location':'location',
                  'country':'country', 'websites':['website'],
                  'languages':'languages', 'date_format':'en-US',
                  'biography':'bio',
                  }
     karltesting.registerDummyRenderer(
         'karl.views:templates/email_accept_invitation.pt')
     response = controller.handle_submit(converted)
     self.assertEqual(response.location,
                      'http://example.com/?status_message=Welcome%21')
     self.assertEqual(community.users.added,
                      ('username', 'username', '1', ['community:members']))
     profiles = community['profiles']
     self.failUnless('username' in profiles)
     self.assertEqual(workflow.initialized,[profiles['username']])
     profile = profiles['username']
     self.assertEqual('phone', profile.phone)
     self.assertEqual('firstname', profile.firstname)
     self.assertEqual('lastname', profile.lastname)
     self.assertEqual('bio', profile.biography)
     self.failIf('invite' in community)
     self.assertEqual(len(mailer), 1)

    def setUp(self):
        cleanUp()

        site = testing.DummyModel()
        profiles = site['profiles'] = testing.DummyModel()
        encrypt = lambda x: 'sha:' + x
        users = site.users = karltesting.DummyUsers(encrypt=encrypt)
        self.site = site

        self.renderer = testing.registerDummyRenderer(
            'templates/admin/upload_users_csv.pt'
        )

        from repoze.lemonade.testing import registerContentFactory
        from karl.models.interfaces import IProfile
        registerContentFactory(testing.DummyModel, IProfile)

        from repoze.workflow.testing import registerDummyWorkflow
        registerDummyWorkflow('security')

    def test_handle_submit(self):
        controller = self._makeOne(self.context, self.request)
        # first set up the easier fields
        converted = {'login': 'login',
                     'password': 'password',
                     'groups': ['group.KarlLovers'],
                     'home_path': '/home_path'}
        for fieldname, value in profile_data.items():
            if fieldname == 'photo':
                continue
            converted[fieldname] = value
        # then set up the photo
        from karl.models.interfaces import IImageFile
        from karl.models.tests.test_image import one_pixel_jpeg as dummy_photo
        from karl.testing import DummyUpload
        from karl.views.tests.test_file import DummyImageFile
        from repoze.lemonade.interfaces import IContentFactory
        from repoze.lemonade.testing import registerContentFactory
        testing.registerAdapter(lambda *arg: DummyImageFile, (IImageFile,),
                                IContentFactory)
        converted['photo'] = DummyUpload(filename='test.jpg',
                                         mimetype='image/jpeg',
                                         data=dummy_photo)
        # next the workflow
        from repoze.workflow.testing import registerDummyWorkflow
        workflow = registerDummyWorkflow('security')
        # and the profile content factory
        from karl.models.profile import Profile
        from karl.models.interfaces import IProfile
        registerContentFactory(Profile, IProfile)
        # finally submit our constructed form
        response = controller.handle_submit(converted)
        self.assertEqual('http://example.com/profile/login/', response.location)
        user = self.users.get_by_id('login')
        self.failIf(user is None)
        self.assertEqual(user['groups'], ['group.KarlLovers'])
        self.assertEqual(len(workflow.initialized), 1)
        self.failUnless('login' in self.context)
        profile = self.context['login']
        self.failUnless('photo.jpg' in profile)
        self.failUnless(len(profile['photo.jpg'].stream.read()) > 0)

        # try again and make sure it fails
        converted['firstname'] = 'different'
        from repoze.bfg.formish import ValidationError
        self.assertRaises(ValidationError, controller.handle_submit, converted)
        profile = self.context['login']
        self.failIf(profile.firstname != 'firstname')

        # once more, testing URL prepending
        converted['login'] = 'newlogin'
        converted['website'] = 'www.example.com'
        response = controller.handle_submit(converted)
        profile = self.context['newlogin']
        self.assertEqual(profile.website, 'http://www.example.com')

    def _registerSecurityWorkflow(self):
        from repoze.workflow.testing import registerDummyWorkflow

        wf = DummyWorkflow(
            [
                {"transitions": ["private"], "name": "public", "title": "Public"},
                {"transitions": ["public"], "name": "private", "title": "Private"},
            ]
        )
        workflow = registerDummyWorkflow("security", wf)
        return workflow

    def setUp(self):
        testing.cleanUp()

        self.root = root = testing.DummyModel()
        root.users = karl.testing.DummyUsers()
        root['profiles'] = testing.DummyModel()

        from repoze.lemonade.testing import registerContentFactory
        from karl.models.interfaces import IProfile
        registerContentFactory(karl.testing.DummyProfile, IProfile)

        from repoze.workflow.testing import registerDummyWorkflow
        self.wf = registerDummyWorkflow('security')

 def test_object_is_reset(self):
     from repoze.lemonade.testing import registerContentFactory
     from repoze.workflow.testing import registerDummyWorkflow
     from repoze.lemonade.interfaces import IContent
     workflow = registerDummyWorkflow('security')
     from zope.interface import directlyProvides
     from zope.interface import Interface
     class IFoo(Interface):
         pass
     registerContentFactory(testing.DummyModel, IFoo)
     root = testing.DummyModel()
     directlyProvides(root, (IContent, IFoo))
     root.state = 'state'
     L = self._callFUT(root)
     self.assertEqual(workflow.resetted, [root])
     self.assertEqual(L, ['updated 1 content objects'])

 def test_object_with_custom_acl_matches_object_acl(self):
     from repoze.lemonade.testing import registerContentFactory
     from repoze.workflow.testing import registerDummyWorkflow
     from repoze.lemonade.interfaces import IContent
     workflow = registerDummyWorkflow('security')
     from zope.interface import directlyProvides
     from zope.interface import Interface
     class IFoo(Interface):
         pass
     registerContentFactory(testing.DummyModel, IFoo)
     root = testing.DummyModel()
     root.state = 'state'
     acl = []
     root.__acl__ = acl
     root.__custom_acl__ = acl
     directlyProvides(root, (IContent, IFoo))
     L = self._callFUT(root)
     self.assertEqual(workflow.resetted, [])
     self.assertEqual(L, ['updated 0 content objects'])

    def test_duplicate_filenames(self):
        from zope.interface import directlyProvides
        from karl.content.interfaces import IImage
        from repoze.workflow.testing import registerDummyWorkflow
        from karl.content.interfaces import ICommunityFile
        workflow = registerDummyWorkflow(
            'security', content_type=ICommunityFile)
        root = testing.DummyModel()
        tempfolder = root['TEMP'] = DummyTempFolder()
        image = tempfolder['1234'] = testing.DummyModel(
            filename='kids.png'
        )
        directlyProvides(image, IImage)
        doc = root['doc'] = testing.DummyModel(
            text='Hey, check out this picture of my kids! '
                 '<img alt="My Kids"'
                 '     src="http://example.com/TEMP/1234/thumb/300x300.jpg"'
                 '     width="300" height="200"/>'
                 ' - Doting Father'
                '<img alt="My Kids"'
                '     src="http://example.com/doc/kids.png/thumb/300x300.jpg"'
                '     width="300" height="200"/>')
        doc['kids.png'] = testing.DummyModel(
            filename='kids.png'
        )
        doc.get_attachments = lambda: doc

        self._call_fut(doc, testing.DummyRequest())
        self.failIf('1234' in tempfolder)
        self.failUnless('kids.png' in doc)
        self.assertEqual(doc.text,
                'Hey, check out this picture of my kids! '
                '<img alt="My Kids"'
                '     src="http://example.com/doc/kids-1.png/thumb/300x300.jpg"'
                '     width="300" height="200"/>'
                ' - Doting Father'
                '<img alt="My Kids"'
                '     src="http://example.com/doc/kids.png/thumb/300x300.jpg"'
                '     width="300" height="200"/>')
        self.failUnless(tempfolder.cleanedup)
        self.assertEqual(workflow.initialized, [image])

    def test_object_with_custom_acl_different_than_object_acl(self):
        from repoze.lemonade.testing import registerContentFactory
        from repoze.workflow.testing import registerDummyWorkflow
        from repoze.lemonade.interfaces import IContent

        workflow = registerDummyWorkflow("security")
        from zope.interface import directlyProvides
        from zope.interface import Interface

        class IFoo(Interface):
            pass

        registerContentFactory(testing.DummyModel, IFoo)
        root = testing.DummyModel()
        root.state = "state"
        root.__acl__ = ["123"]
        root.__custom_acl__ = []
        directlyProvides(root, (IContent, IFoo))
        L = self._callFUT(root)
        self.assertEqual(workflow.resetted, [root])
        self.assertEqual(L, ["updated 1 content objects"])