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)

 def test_do_GET_minimal(self):
     from sqlalchemy.orm import object_session
     from zope.publisher.browser import TestRequest
     from euphorie.client.model import Risk
     self.loginAsPortalOwner()
     (account, survey, survey_session) = _setup_session(self.portal)
     survey['1'].title = u'Module title.'
     risk = survey['1']['2']
     risk.title = u'Everything is under control.'
     risk.problem_description = u'Not everything under control.'
     risk.description = None
     risk.evaluation_method = 'direct'
     risk.image = None
     request = TestRequest()
     request.survey = survey
     risk = object_session(survey_session).query(Risk).first()
     view = self.View(risk, request)
     response = view.do_GET()
     self.assertEqual(
             set(response),
             set(['id', 'type', 'title', 'module-title',
                   'problem-description', 'show-not-applicable',
                   'evaluation-method', 'present', 'priority', 'comment']))
     self.assertEqual(response['id'], 2)
     self.assertEqual(response['type'], 'risk')
     self.assertEqual(response['title'], u'Everything is under control.')
     self.assertEqual(response['module-title'], u'Module title.')
     self.assertEqual(
             response['problem-description'],
             u'Not everything under control.')
     self.assertEqual(response['show-not-applicable'], False)
     self.assertEqual(response['evaluation-method'], 'direct')
     self.assertEqual(response['present'], None)
     self.assertEqual(response['priority'], u'high')

    def test_update(self):
        c = C()
        request = TestRequest()
        v = EV(c, request)
        request.form[Update] = ''
        request.form['field.foo'] = u'r foo'
        request.form['field.bar'] = u'r bar'
        request.form['field.getbaz'] = u'r baz'
        request.form['field.a'] = u'c a'

        message = v.update()
        self.assertTrue(message.startswith('Updated '), message)
        self.assertEqual(c.foo, u'r foo')
        self.assertEqual(c.bar, u'r bar')
        self.assertEqual(c.a  , u'c a')
        self.assertEqual(c.b  , u'c b') # missing from form - unchanged
        self.assertEqual(c.getbaz(), u'r baz')

        # Verify that calling update multiple times has no effect

        c.__dict__.clear()
        self.assertEqual(v.update(), message)
        self.assertEqual(c.foo, u'c foo')
        self.assertEqual(c.bar, u'c bar')
        self.assertEqual(c.a  , u'c a')
        self.assertEqual(c.b  , u'c b')
        self.assertEqual(c.getbaz(), u'c baz')

    def test_retry_keeps_everything(self):
        """lowlevel test for retry (see #98440)"""
        from zope.publisher.browser import TestRequest
        from zope.publisher.skinnable import setDefaultSkin
        from zope.publisher.interfaces import IDefaultSkin
        from zope.publisher.interfaces.browser import IBrowserRequest
        from zope.publisher.interfaces.browser import IBrowserSkinType
        # create a retryable request
        request = TestRequest()
        self.assertTrue(request.supportsRetry())
        # create a skin and register it as the default skin
        class ISomeSkin(Interface):
            pass
        alsoProvides(ISomeSkin, IBrowserSkinType)
        provideAdapter(ISomeSkin, (IBrowserRequest,), IDefaultSkin)
        # set the default skin for the request
        setDefaultSkin(request)

        # create a retried request
        retried = request.retry()

        # the requests are not the same
        self.assertTrue(request is not retried)
        # the requests both provide the default skin
        self.assertTrue(ISomeSkin.providedBy(request))
        self.assertTrue(ISomeSkin.providedBy(retried))

    def testUnauthorized(self):
        component.provideAdapter(DummyTemplate, name="default")
        exception = Exception()
        try:
            raise exception
        except:
            pass
        request = TestRequest()
        request.setPrincipal(DummyPrincipal(23))
        u = Unauthorized(exception, request)
        res = u()

        # Make sure that we rendered the expected template
        self.assertEqual("You are not authorized", res)

        # Make sure the response status was set
        self.assertEqual(request.response.getStatus(), 403)

        # check headers that work around squid "negative_ttl"
        self.assertEqual(request.response.getHeader('Expires'),
                         'Mon, 26 Jul 1997 05:00:00 GMT')
        self.assertEqual(request.response.getHeader('Pragma'),
                         'no-cache')
        self.assertEqual(request.response.getHeader('Cache-Control'),
                         'no-store, no-cache, must-revalidate')

        # Make sure the auth utility was called
        self.failUnless(self.auth.request is request)
        self.assertEqual(self.auth.principal_id, 23)

    def test_double_validation(self):
        """ If a field already has an error and it is validated again,
        we cut the validation short and return the original error.

        Here we test that we do not lose the original error in the
        process.  We do that by adding the fieldsets twice in the
        request, which can happen if you have some whacky javascript
        that tries to clone too many inputs.
        """
        dummy = self.makeDummy()
        request = TestRequest()
        alsoProvides(request, IAttributeAnnotatable)
        my_values = field_values.copy()
        my_values['fixedpointfield2'] = 'an_error'
        request.form.update(my_values)
        request.form['fieldset'] = 'default'
        request.form['fieldsets'] = ['default', 'default']
        errors = {}
        dummy.validate(errors=errors, REQUEST=request)
        self.assertTrue(errors, errors)
        # The validation error looks a bit weird because of the
        # [[plone]] domain that is added by the translation testing
        # machinery.
        self.assertEqual(errors['fixedpointfield2'],
                         (u"[[plone][Validation failed(isDecimal): "
                          "'an_error' [[plone][is not a decimal number.]]]]"))

    def test_applyUpdates_and_setPrefix(self):
        registry = TestingRegistrationStack(a, b, c)
        request = TestRequest()
        view = ChangeRegistrations(registry, request)
        view.setPrefix("Pigs")

        # Make sure we don't apply updates unless asked to
        request.form = {'Pigs.active': 'disable'}
        view.applyUpdates()
        data = [(info['active'], info['registration'])
                for info in registry.info()]
        self.assertEqual(data, [(True, a), (False, b), (False, c)])

        # Now test disabling
        request.form = {'submit_update': '', 'Pigs.active': 'disable'}
        view.applyUpdates()
        data = [(info['active'], info['registration'])
                for info in registry.info()]
        self.assertEqual(data, [(False, a), (False, b), (False, c)])

        # Now test enabling c
        request.form = {'submit_update': '', 'Pigs.active': 'c'}
        view.applyUpdates()
        data = [(info['active'], info['registration'])
                for info in registry.info()]
        self.assertEqual(data, [(True, c), (False, a), (False, b)])

        class Instance(object):
            def __init__(self):
                self.context = context
                self.request = TestRequest()
                self.request.setPrincipal(self)

            title = 'principal'

    def __call__(self, filename, title, description, content_type, data,
                 portal_type):
        context = aq_inner(self.context)
        error = ''
        result = {}
        result['success'] = None
        newid = get_id_from_filename(filename, context)
        chooser = INameChooser(context)
        newid = chooser.chooseName(newid, context)
        # consolidation because it's different upon Plone versions
        if not title:
            # try to split filenames because we don't want
            # big titles without spaces
            title = filename.rsplit('.', 1)[0]\
                .replace('_', ' ')\
                .replace('-', ' ')

        if newid in context:
            # only here for flashupload method since a check_id is done
            # in standard uploader - see also XXX in quick_upload.py
            raise NameError, 'Object id %s already exists' % newid
        else:
            upload_lock.acquire()
            try:
                transaction.begin()
                try:
                    from zope.publisher.browser import TestRequest
                    request = TestRequest()
                    dataobj = FileObj(data)
                    dataobj.filename = filename
                    request.form['doc'] = dataobj
                    request.form['ajax'] = '1'
                    from fhnw.office2plone.browser.docx_importer import DocxImporter
                    docximport = DocxImporter(self.context, request)
                    docximport.docx_import()
                except ImportError:
                    error = ''
                except Unauthorized:
                    error = u'serverErrorNoPermission'
                except ConflictError:
                    # rare with xhr upload / happens sometimes with flashupload
                    error = u'serverErrorZODBConflict'
                except ValueError:
                    error = u'serverErrorDisallowedType'
                except Exception, e:
                    error = u'serverError'
                    logger.exception(e)

                if error:
                    if error == u'serverError':
                        logger.info(
                            "An error happens with setId from filename, "
                            "the file has been created with a bad id, "
                            "can't find %s", newid)
                else:
                    pass

                #@TODO : rollback if there has been an error
                transaction.commit()
            finally:

    def testUnauthorized(self):
        exception = Exception()
        try:
            raise exception
        except:
            pass
        request = TestRequest()
        request.setPrincipal(DummyPrincipal(23))
        u = Unauthorized(exception, request)
        u.issueChallenge()

        # Make sure the response status was set
        self.assertEqual(request.response.getStatus(), 403)

        # check headers that work around squid "negative_ttl"
        self.assertEqual(request.response.getHeader('Expires'),
                         'Mon, 26 Jul 1997 05:00:00 GMT')
        self.assertEqual(request.response.getHeader('Pragma'),
                         'no-cache')
        self.assertEqual(request.response.getHeader('Cache-Control'),
                         'no-store, no-cache, must-revalidate')
        
        # Make sure the auth utility was called
        self.failUnless(self.auth.request is request)
        self.assertEqual(self.auth.principal_id, 23)

 def testGlobalInVirtualHost(self):
     req = TestRequest()
     req.setVirtualHostRoot(['x', 'y'])
     r = Resource(req)
     req._vh_root = support.site
     r.__parent__ = support.site
     r.__name__ = 'foo'
     self.assertEqual(r(), 'http://127.0.0.1/x/y/@@/foo')

 def testURL(self):
     request = TestRequest()
     request._vh_root = support.site
     path = os.path.join(test_directory, 'testfiles')
     files = DirectoryResourceFactory(path, checker, 'test_files')(request)
     files.__parent__ = support.site
     file = files['test.gif']
     self.assertEquals(file(), 'http://127.0.0.1/@@/test_files/test.gif')

    def test_hooks(self):

        @implementer(IAdding)
        class Adding(object):
            pass

        adding = Adding()
        self._invoke_add()
        (descriminator, callable, args, kw) = self._context.last_action
        factory = AddViewFactory(*args)
        request = TestRequest()

        request.form.update(dict([
            ("field.%s" % k, v)
            for (k, v) in dict(SampleData.__dict__).items()
            ]))
        request.form[Update] = ''
        view = getMultiAdapter((adding, request), name='addthis')

        # Add hooks to V

        l=[None]

        def add(aself, ob):
            l[0] = ob
            self.assertEqual(
                ob.__dict__,
                {'args': ("bar", "baz"),
                 'kw': {'email': '[email protected]'},
                 '_foo': 'foo',
                 })
            return ob

        V.add = add

        V.nextURL = lambda self: 'next'

        try:
            self.assertEqual(view.update(), '')

            self.assertEqual(view.errors, ())

            self.assertEqual(l[0].extra1, "extra1")
            self.assertEqual(l[0].extra2, "extra2")
            self.assertEqual(l[0].name, "foo")
            self.assertEqual(l[0].address, "aa")

            self.assertEqual(request.response.getHeader("Location"), "next")

            # Verify that calling update again doesn't do anything.
            l[0] = None
            self.assertEqual(view.update(), '')
            self.assertEqual(l[0], None)

        finally:
            # Uninstall hooks
            del V.add
            del V.nextURL

def lockingSetUp(test):
    placelesssetup.setUp(test)
    z3c.etree.testing.etreeSetup(test)

    # create principal
    participation = TestRequest(environ = {"REQUEST_METHOD": "PUT"})
    participation.setPrincipal(Principal("michael"))
    if queryInteraction() is not None:
        queryInteraction().add(participation)
    else:
        newInteraction(participation)

    events = test.globs["events"] = []
    zope.event.subscribers.append(events.append)

    gsm = zope.component.getGlobalSiteManager()

    gsm.registerAdapter(DemoKeyReference,
                        (IDemo,),
                        zope.app.keyreference.interfaces.IKeyReference)
    gsm.registerAdapter(PhysicallyLocatable, (Demo,))
    gsm.registerAdapter(PhysicallyLocatable, (DemoFolder,))
    gsm.registerAdapter(DemoKeyReference, (IDemoFolder,),
                        zope.app.keyreference.interfaces.IKeyReference)
    gsm.registerAdapter(SiteManagerAdapter,
                        (zope.interface.Interface,), IComponentLookup)
    gsm.registerAdapter(DemoAbsoluteURL,
                        (IDemo, zope.interface.Interface),
                        zope.traversing.browser.interfaces.IAbsoluteURL)
    gsm.registerAdapter(DemoAbsoluteURL,
                        (IDemoFolder, zope.interface.Interface),
                        zope.traversing.browser.interfaces.IAbsoluteURL)

    # register some IDAVWidgets so that we can render the activelock and
    # supportedlock widgets.
    gsm.registerAdapter(z3c.dav.widgets.ListDAVWidget,
                        (zope.schema.interfaces.IList,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.ObjectDAVWidget,
                        (zope.schema.interfaces.IObject,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.TextDAVWidget,
                        (zope.schema.interfaces.IText,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.properties.OpaqueWidget,
                        (z3c.dav.properties.DeadField,
                         z3c.dav.interfaces.IWebDAVRequest))
    gsm.registerAdapter(z3c.dav.widgets.TextDAVWidget,
                        (zope.schema.interfaces.IURI,
                         z3c.dav.interfaces.IWebDAVRequest))

    # Need connection to a database to manage locking
    db = test.globs["db"] = ZODB.DB(ZODB.MappingStorage.MappingStorage())
    test.globs["conn"] = db.open()

    # expose these classes to the test
    test.globs["Demo"] = Demo
    test.globs["DemoFolder"] = DemoFolder

 def testGlobal(self):
     req = TestRequest()
     r = Resource(req)
     req._vh_root = support.site
     r.__parent__ = support.site
     r.__name__ = 'foo'
     self.assertEqual(r(), 'http://127.0.0.1/@@/foo')
     r.__name__ = '++resource++foo'
     self.assertEqual(r(), 'http://127.0.0.1/@@/foo')

 def test_recipient_from_request(self):
     request = TestRequest(mail=self.ascii)
     request.form['recipient'] = '[email protected]'
     view = getMultiAdapter((self.portal, request), name='mail-inbound')
     self.assertEquals('[email protected]', view.recipient())
     request = TestRequest(mail=self.resent)
     request.form['recipient'] = '[email protected]'
     view = getMultiAdapter((self.portal, request), name='mail-inbound')
     self.assertEquals('[email protected]', view.recipient())

 def testNull(self):
     container = self.Container({'foo': 42})
     request = TestRequest()
     request.method = 'PUT'
     traverser = self.Traverser(container, request)
     null = traverser.publishTraverse(request, 'bar')
     self.assertEqual(null.__class__, NullResource)
     self.assertEqual(null.container, container)
     self.assertEqual(null.name, 'bar')

 def test_allowable_content_types_ok(self):
     dummy = self.makeDummy()
     request = TestRequest()
     request.form.update(field_values)
     request.form['fieldset'] = 'default'
     dummy.REQUEST = request
     errors = {}
     dummy.validate(REQUEST=request, errors=errors)
     self.assertFalse(errors, errors)

    def test_make_extra_principal(self):
        class MockPrincipal(object):
            id = 'foo'

        request = TestRequest()
        request.setPrincipal(MockPrincipal())
        reporter = SentryAwareLoggingErrorReporting()
        result = reporter.make_extra(request)
        self.assertTrue('sentry.interfaces.User' in result)
        self.assertEqual('foo', result['sentry.interfaces.User']['id'])

 def testSelectedFacetValues(self):
     request = TestRequest()
     selected = SearchFacetsView(Dummy(), request).selected
     info = lambda: [(i["title"], i["value"]) for i in selected()]
     request.form["fq"] = 'foo:"xy"'
     self.assertEqual(info(), [("foo", "Title of Xy")])
     request.form["fq"] = ['foo:"x"', 'bar:"y"']
     self.assertEqual(info(), [("foo", "Title of X"), ("bar", "Title of Y")])
     request.form["fq"] = ['foo:"x"', 'bar:"y"', 'bah:"z"']
     self.assertEqual(info(), [("foo", "Title of X"), ("bar", "Title of Y"), ("bah", "Title of Z")])