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

 def _callFUT(self, name, workflow=None):
     from repoze.workflow.testing import registerDummyWorkflow
     return registerDummyWorkflow(name, workflow)

def registerSecurityWorkflow():
    from repoze.workflow.testing import registerDummyWorkflow
    return registerDummyWorkflow('security')

    def _mk_dummy_site(self):
        import datetime
        from karl.content.interfaces import IBlogEntry
        from karl.content.interfaces import ICalendarEvent
        from karl.content.interfaces import ICommunityFile
        from karl.content.interfaces import IWikiPage
        from karl.models.interfaces import IComment
        from karl.testing import DummyCommunity
        from karl.testing import DummyModel
        from karl.testing import DummyRoot
        from repoze.workflow.testing import registerDummyWorkflow
        from repoze.workflow.testing import DummyWorkflow
        from zope.interface import directlyProvides

        site = DummyRoot()
        site.tags = DummyTags()
        communities = site['communities'] = DummyModel()

        big_endians = communities['big_endians'] = DummyCommunity()
        big_endians.title = 'Big Endians'
        big_endians.member_names = ['fred', 'martin', 'daniela']
        big_endians.moderator_names = ['fred', 'daniela']
        big_endians.created = datetime.datetime(2010, 5, 12, 2, 42)
        big_endians.creator = 'daniela'
        big_endians.content_modified = datetime.datetime(2010, 6, 12, 2, 42)
        big_endians.__custom_acl__ = True

        content = big_endians['wiki1'] = DummyModel()
        content.created = datetime.datetime(2010, 5, 12, 3, 42)
        content.creator = 'daniela'
        directlyProvides(content, IWikiPage)

        content = big_endians['wiki2'] = DummyModel()
        content.created = datetime.datetime(1975, 7, 7, 7, 23)
        content.creator = 'fred'
        directlyProvides(content, IWikiPage)

        little_endians = communities['little_endians'] = DummyCommunity()
        little_endians.title = 'Little Endians'
        little_endians.member_names = ['dusty', 'roberta', 'nina']
        little_endians.moderator_names = ['nina']
        little_endians.created = datetime.datetime(2010, 5, 13, 6, 23)
        little_endians.creator = 'nina'
        little_endians.content_modified = datetime.datetime(
            2010, 6, 12, 3, 42
        )
        little_endians._p_deactivate = lambda: None
        little_endians.state = 'public'

        content = little_endians['blog1'] = DummyModel()
        content.created = datetime.datetime.now()
        content.creator = 'nina'
        directlyProvides(content, IBlogEntry)

        content['comment1'] = DummyModel()
        content = content['comment1']
        content.created = datetime.datetime.now()
        content.creator = 'roberta'
        directlyProvides(content, IComment)

        content = little_endians['file1'] = DummyModel()
        content.created = datetime.datetime.now()
        content.creator = 'dusty'
        directlyProvides(content, ICommunityFile)

        content = little_endians['event1'] = DummyModel()
        content.created = datetime.datetime.now()
        content.creator = 'dusty'
        directlyProvides(content, ICalendarEvent)

        registerDummyWorkflow('security', DummyWorkflow())

        return site

 def _registerSecurityWorkflow(self):
     from repoze.workflow.testing import registerDummyWorkflow
     workflow = registerDummyWorkflow('security')
     return workflow

 def _registerWorkflow(self):
     from repoze.workflow.testing import registerDummyWorkflow
     return registerDummyWorkflow('security')