def test_IndexRaisingValueGetter(self):
        """We can have indexes whose values are determined by callable
        methods.
        Raising an exception in the method should not be silently ignored
        That would cause index corruption -- the index would be out of sync"""
        uidutil = IntIdsStub()
        provideUtility(uidutil, IIntIds)

        catalog = Catalog()
        index = FieldIndex('getAuthor', None, field_callable=True)
        catalog['author'] = index

        ob1 = stoopidCallable(author = "joe")
        ob1id = uidutil.register(ob1)
        catalog.index_doc(ob1id, ob1)

        res = catalog.searchResults(author=('joe','joe'))
        names = [x.author for x in res]
        names.sort()
        self.assertEqual(len(names), 1)
        self.assertEqual(names, ['joe'])

        ob2 = stoopidCallable() # no author here, will raise AttributeError
        ob2id = uidutil.register(ob2)
        try:
            catalog.index_doc(ob2id, ob2)
            self.fail("AttributeError exception should be raised")
        except AttributeError:
            #this is OK, we WANT to have the exception
            pass

def xsltSetUp(test):
    sectionsSetUp(test)

    class XSLTSource(SampleSource):
        classProvides(ISectionBlueprint)
        implements(ISection)

        def __init__(self, *args, **kw):
            super(XSLTSource, self).__init__(*args, **kw)
            self.sample = (
                {},
                {'_type': 'Weblog'},
                {'_old_type': 'Blog'},
                {'_old_type': 'Blog',
                 '_type': 'Weblog',
                 '_files': {'manifest': {'data': 'xml', 'name': 'manifest.xml'}}},
                {'_old_type': 'Blog',
                 '_type': 'Weblog',
                 '_files': {'marshall': {'data': 'xml', 'name': 'marshall.xml'}}},
            )

    provideUtility(XSLTSource,
        name=u'quintagroup.transmogrifier.tests.xsltsource')

    from quintagroup.transmogrifier.xslt import XSLTSection, stylesheet_registry

    XSLTSection.applyTransformations = lambda self, xml, xslt: 'transformed xml'
    test.globs['stylesheet_registry'] = stylesheet_registry

    def test_basic_tile_purge_cache(self):
        provideHandler(queuePurge)

        request = self.request
        alsoProvides(request, IAttributeAnnotatable)
        setRequest(request)

        registry = queryUtility(IRegistry)
        registry.registerInterface(ICachePurgingSettings)
        provideUtility(registry, IRegistry)

        settings = registry.forInterface(ICachePurgingSettings)
        settings.enabled = True
        settings.cachingProxies = ('http://localhost:1234',)

        obj = self.portal['my-image']
        data = self.tile.data
        scales = api.content.get_view(u'images', obj, self.request)
        self.tile.data['image'] = NamedBlobImage(str(scales.scale('image').data))
        data_mgr = ITileDataManager(self.tile)
        data_mgr.set(data)

        self.assertEqual(
            set([
                '/c1/@@collective.cover.basic/test',
                '/c1/@@collective.cover.basic/test/@@images/image',
                '/c1/@@collective.cover.basic/test/@@images/icon',
                '/c1/@@collective.cover.basic/test/@@images/mini',
                '/c1/@@collective.cover.basic/test/@@images/large',
                '/c1/@@collective.cover.basic/test/@@images/listing',
                '/c1/@@collective.cover.basic/test/@@images/thumb',
                '/c1/@@collective.cover.basic/test/@@images/preview',
                '/c1/@@collective.cover.basic/test/@@images/tile']),
            IAnnotations(request)['plone.cachepurging.urls'])

    def test_purge(self):
        request = FauxRequest()
        alsoProvides(request, IAttributeAnnotatable)
        
        IAnnotations(request)['zojax.cachepurging.urls'] = set(['/foo', '/bar'])

        configlet= CachePurgingConfiglet()
        provideUtility(configlet, ICachePurgingConfiglet)

        settings = getUtility(ICachePurgingConfiglet)
        settings.enabled = True
        settings.cachingProxies = ('http://localhost:1234',)
        
        class FauxPurger(object):
            implements(IPurger)
            
            def __init__(self):
                self.purged = []
            
            def purgeAsync(self, url, httpVerb='PURGE'):
                self.purged.append(url)
        
        purger = FauxPurger()
        provideUtility(purger)
        
        notify(EndRequestEvent(None, request))
        
        self.assertEquals(['http://localhost:1234/foo', 'http://localhost:1234/bar'],
                          purger.purged)

 def setUp(self):
     provideUtility(SolrConnectionConfig(), ISolrConnectionConfig)
     self.mngr = SolrConnectionManager()
     self.mngr.setHost(active=True)
     self.conn = self.mngr.getConnection()
     self.search = Search()
     self.search.manager = self.mngr

    def test_applyTransform_streamiterator(self):
        tmp = tempfile.mkstemp()[1]
        try:

            with open(tmp, 'w') as out:
                out.write('foo')

            @implementer(ITransformer)
            class FauxTransformer(object):

                def __call__(self, request, result, encoding):
                    return filestream_iterator(tmp)

            transformer = FauxTransformer()
            provideUtility(transformer)

            published = FauxPublished()
            request = FauxRequest(published)
            applyTransformOnSuccess(FauxPubEvent(request))

            self.assertTrue(
                isinstance(
                    request.response.getBody(),
                    filestream_iterator
                )
            )
        finally:
            os.unlink(tmp)

    def test_enabled(self):
        context = FauxContext()
        
        request = FauxRequest()
        alsoProvides(request, IAttributeAnnotatable)
        setRequest(request)

        configlet= CachePurgingConfiglet()
        provideUtility(configlet, ICachePurgingConfiglet)

        settings = getUtility(ICachePurgingConfiglet)
        settings.enabled = True
        settings.cachingProxies = ('http://localhost:1234',)
        
        class FauxPurgePaths(object):
            implements(IPurgePaths)
            adapts(FauxContext)
        
            def __init__(self, context):
                self.context = context
        
            def getRelativePaths(self):
                return ['/foo', '/bar']
        
            def getAbsolutePaths(self):
                return []
        
        provideAdapter(FauxPurgePaths, name="test1")
        
        notify(Purge(context))
        
        self.assertEquals({'zojax.cachepurging.urls': set(['/foo', '/bar'])},
                          dict(IAnnotations(request)))

    def testSkipItems(self):
        class Skip(object):
            implements(ISection)

            def __init__(self, transmogrifier, name, options, previous):
                self.previous = previous

            def __iter__(self):
                count = 0
                for item in self.previous:
                    if count % 2:
                        item["pipeline"] = 1
                        yield item
                    count += 1

        provideUtility(Skip, ISectionBlueprint, name=u"collective.transmogrifier.tests.skip")
        splitter = self._makeOne(
            dict(skip=dict(blueprint="collective.transmogrifier.tests.skip")),
            {"pipeline-1": "skip", "pipeline-2": ""},
            (dict(id="item-%02d" % i) for i in range(4)),
        )
        self.assertEqual(
            list(splitter),
            [
                dict(id="item-01", pipeline=1),  # p1 is ahead
                dict(id="item-00"),  # p2 advanced, p1 is skipped
                dict(id="item-01"),  # p2 advanced, p1 no longer ahead
                dict(id="item-03", pipeline=1),  # p1 is ahead again
                dict(id="item-02"),  # p2 advanced, p1 is skipped
                dict(id="item-03"),  # p2 advanced, p1 no longer ahead
            ],
        )  # p1 is done, p2 is done

 def testSkipItems(self):
     class Skip(object):
         implements(ISection)
         def __init__(self, transmogrifier, name, options, previous):
             self.previous = previous
         def __iter__(self):
             count = 0
             for item in self.previous:
                 if count % 2:
                     item['pipeline'] = 1
                     yield item
                 count += 1
     provideUtility(Skip, ISectionBlueprint,
         name=u'collective.transmogrifier.tests.skip')
     splitter = self._makeOne(dict(
         skip=dict(
             blueprint='collective.transmogrifier.tests.skip')),
         {'pipeline-1': 'skip', 'pipeline-2': ''},
         (dict(id='item-%02d' % i) for i in range(4)))
     self.assertEqual(list(splitter), [
         dict(id='item-01', pipeline=1), # p1 is ahead
         dict(id='item-00'),             # p2 advanced, p1 is skipped
         dict(id='item-01'),             # p2 advanced, p1 no longer ahead
         dict(id='item-03', pipeline=1), # p1 is ahead again
         dict(id='item-02'),             # p2 advanced, p1 is skipped
         dict(id='item-03')              # p2 advanced, p1 no longer ahead
     ])                                  # p1 is done, p2 is done

    def setUp(self):
        super(TestArchiver, self).setUp()
        grok('opengever.dossier.archive')
        grok('opengever.dossier.behaviors.filing')

        file_path = os.path.join(
            os.path.dirname(opengever.dossier.__file__),
            'vdexvocabs',
            'type_prefixes.vdex')

        vocabulary_registry = getVocabularyRegistry()
        try:
            vocabulary_registry.get(None, 'opengever.dossier.type_prefixes')
        except VocabularyRegistryError:
            vocabulary_registry.register(
                'opengever.dossier.type_prefixes', VdexVocabulary(file_path))

        proxy = self.mocker.mock()
        proxy.client_id
        self.mocker.result('SKA ARCH')
        self.mocker.count(0, None)

        registry = self.mocker.mock()
        provideUtility(provides=IRegistry, component=registry)
        registry.forInterface(IBaseClientID)
        self.mocker.result(proxy)
        self.mocker.count(0, None)

    def testInsertExtra(self):
        class Inserter(object):
            implements(ISection)

            def __init__(self, transmogrifier, name, options, previous):
                self.previous = previous

            def __iter__(self):
                count = 0
                for item in self.previous:
                    item["pipeline"] = 1
                    yield item
                    yield dict(id="extra-%02d" % count)
                    count += 1

        provideUtility(Inserter, ISectionBlueprint, name=u"collective.transmogrifier.tests.inserter")
        splitter = self._makeOne(
            dict(inserter=dict(blueprint="collective.transmogrifier.tests.inserter")),
            {"pipeline-1": "inserter", "pipeline-2": ""},
            (dict(id="item-%02d" % i) for i in range(3)),
        )
        self.assertEqual(
            list(splitter),
            [
                dict(id="item-00", pipeline=1),  # p1 advanced, look at p2
                dict(id="item-00"),  # p2 advanced, look at p1
                dict(id="extra-00"),  # p1 did not advance
                dict(id="item-01", pipeline=1),  # p1 advanced, look at p2
                dict(id="item-01"),  # p2 advanced, look at p1
                dict(id="extra-01"),  # p1 did not advance
                dict(id="item-02", pipeline=1),  # p1 advanced, condition isDone
                dict(id="extra-02"),  # last in p1 after isDone, l.a. p2
                dict(id="item-02"),  # p2 advanced
            ],
        )  # p2 is done

def setUp(test):
    placelesssetup.setUp()

    # Attempt to initialize mappers only if their not already mapped.
    try:
        orm.class_mapper(schema.Content)
    except orm.exc.UnmappedClassError:
        schema.initialize_mapper()

    component.provideAdapter(transform.StringTransform)
    component.provideAdapter(transform.IntegerTransform)
    component.provideAdapter(transform.FloatTransform)
    component.provideAdapter(transform.DateTimeTransform)
    component.provideAdapter(transform.LinesTransform)
    component.provideAdapter(transform.BooleanTransform)
    component.provideAdapter(transform.FileTransform)
    component.provideAdapter(transform.PhotoTransform)
    component.provideAdapter(transform.ReferenceTransform)

    component.provideUtility(peer.PeerRegistry())
    component.provideAdapter(
        peer.PeerFactory,
        (interfaces.IMirrored, interfaces.ISchemaTransformer))

    component.provideAdapter(transform.SchemaTransformer,
                             (interfaces.IMirrored, interfaces.IMetaData))
    component.provideAdapter(serializer.Serializer, (interfaces.IMirrored,))
    component.provideAdapter(
        operation.OperationFactory, (interfaces.IMirrored,))
    component.provideUtility(operation.OperationBufferFactory())

    def testPortalContentLanguage(self):
        from zope.component import provideUtility
        from zope.i18n.interfaces import ITranslationDomain
        from zope.i18n.simpletranslationdomain import SimpleTranslationDomain

        # Let's fake the news title translations
        messages = {
            ('de', u'news-title'): u'Foo',
            ('pt_BR', u'news-title'): u'Bar',
        }
        pfp = SimpleTranslationDomain('plonefrontpage', messages)
        provideUtility(pfp, ITranslationDomain, name='plonefrontpage')

        # Setup the new placeholder folders
        self.folder.invokeFactory('Folder', 'brazilian')
        self.folder.invokeFactory('Folder', 'german')

        # Check if the content is being created in German
        self.folder.german.setLanguage('de')
        self.loginAsPortalOwner()
        setuphandlers.setupPortalContent(self.folder.german)
        # self.assertEqual(self.folder.german.news.Title(), 'Foo')

        # Check if the content is being created in a composite
        # language code, in this case Brazilian Portuguese
        self.folder.brazilian.setLanguage('pt-br')
        setuphandlers.setupPortalContent(self.folder.brazilian)

    def setUp( self ):
        import transaction
        from zope.component.testing import setUp as componentSetUp
        from zope.component import provideUtility
        from zope.component import provideAdapter
        from zope.traversing.adapters import DefaultTraversable
        from zope.publisher.http import HTTPCharsets
        from Testing.ZopeTestCase import ZopeLite
        from Testing.makerequest import makerequest
        from Products.PageTemplates.interfaces \
            import IUnicodeEncodingConflictResolver
        from Products.PageTemplates.unicodeconflictresolver \
            import PreferredCharsetResolver


        componentSetUp()
        provideAdapter(DefaultTraversable, (None,))
        provideUtility(PreferredCharsetResolver,
                       IUnicodeEncodingConflictResolver)
        provideAdapter(HTTPCharsets)
        transaction.begin()
        app = ZopeLite.app()
        self.root = makerequest(app)
        # set the request charset to enable conversions to utf-8
        self.root.REQUEST['HTTP_ACCEPT_CHARSET'] = '*'

    def testFilterQuerySubstitution(self):
        def optimize(**params):
            query = dict(a="a:23", b="b:42", c="c:(23 42)")
            optimizeQueryParameters(query, params)
            return query, params

        # first test without the configuration utility
        self.assertEqual(optimize(), (dict(a="a:23", b="b:42", c="c:(23 42)"), dict()))
        # now unconfigured...
        config = SolrConnectionConfig()
        provideUtility(config, ISolrConnectionConfig)
        self.assertEqual(optimize(), (dict(a="a:23", b="b:42", c="c:(23 42)"), dict()))
        config.filter_queries = ["a"]
        self.assertEqual(optimize(), (dict(b="b:42", c="c:(23 42)"), dict(fq=["a:23"])))
        self.assertEqual(optimize(fq="x:13"), (dict(b="b:42", c="c:(23 42)"), dict(fq=["x:13", "a:23"])))
        self.assertEqual(
            optimize(fq=["x:13", "y:17"]), (dict(b="b:42", c="c:(23 42)"), dict(fq=["x:13", "y:17", "a:23"]))
        )
        config.filter_queries = ["a", "c"]
        self.assertEqual(optimize(), (dict(b="b:42"), dict(fq=["a:23", "c:(23 42)"])))
        self.assertEqual(optimize(fq="x:13"), (dict(b="b:42"), dict(fq=["x:13", "a:23", "c:(23 42)"])))
        self.assertEqual(
            optimize(fq=["x:13", "y:17"]), (dict(b="b:42"), dict(fq=["x:13", "y:17", "a:23", "c:(23 42)"]))
        )
        # also test substitution of combined filter queries
        config.filter_queries = ["a c"]
        self.assertEqual(optimize(), (dict(b="b:42"), dict(fq=["a:23 c:(23 42)"])))
        config.filter_queries = ["a c", "b"]
        self.assertEqual(optimize(), ({"*": "*:*"}, dict(fq=["a:23 c:(23 42)", "b:42"])))
        # for multiple matches the first takes precedence
        config.filter_queries = ["a", "a c", "b"]
        self.assertEqual(optimize(), (dict(c="c:(23 42)"), dict(fq=["a:23", "b:42"])))
        # parameters not contained in the query must not be converted
        config.filter_queries = ["a nonexisting", "b"]
        self.assertEqual(optimize(), (dict(a="a:23", c="c:(23 42)"), dict(fq=["b:42"])))

 def testInsertExtra(self):
     class Inserter(object):
         implements(ISection)
         def __init__(self, transmogrifier, name, options, previous):
             self.previous = previous
         def __iter__(self):
             count = 0
             for item in self.previous:
                 item['pipeline'] = 1
                 yield item
                 yield dict(id='extra-%02d' % count)
                 count += 1
     
     provideUtility(Inserter, ISectionBlueprint,
         name=u'collective.transmogrifier.tests.inserter')
     splitter = self._makeOne(dict(
         inserter=dict(
             blueprint='collective.transmogrifier.tests.inserter')),
         {'pipeline-1': 'inserter', 'pipeline-2': ''},
         (dict(id='item-%02d' % i) for i in range(3)))
     self.assertEqual(list(splitter), [
         dict(id='item-00', pipeline=1), # p1 advanced, look at p2
         dict(id='item-00'),             # p2 advanced, look at p1
         dict(id='extra-00'),            # p1 did not advance
         dict(id='item-01', pipeline=1), # p1 advanced, look at p2
         dict(id='item-01'),             # p2 advanced, look at p1
         dict(id='extra-01'),            # p1 did not advance
         dict(id='item-02', pipeline=1), # p1 advanced, condition isDone
         dict(id='extra-02'),            # last in p1 after isDone, l.a. p2
         dict(id='item-02'),             # p2 advanced
     ])                                  # p2 is done

    def test_getNextUtility(self):
        # test local site vs. global site
        global_dummy = DummyUtility()
        provideUtility(global_dummy, IDummyUtility)

        local_dummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, local_dummy)

        self.assertEquals(zapi.getUtility(IDummyUtility), local_dummy)
        self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
                          global_dummy)

        # test local site vs. nested local site
        manage_addDummySite(self.folder.site, 'subsite')
        enableLocalSiteHook(self.folder.site.subsite)
        setSite(self.folder.site.subsite)

        sublocal_dummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, sublocal_dummy)

        self.assertEquals(zapi.getUtility(IDummyUtility), sublocal_dummy)
        self.assertEquals(getNextUtility(self.folder.site.subsite, IDummyUtility),
                          local_dummy)
        self.assertEquals(getNextUtility(self.folder.site, IDummyUtility),
                          global_dummy)

    def test_dont_swallow_conflict_error(self):

        @implementer(IRulesetLookup)
        @adapter(Interface, Interface)
        class DummyRulesetLookup(object):

            def __init__(self, published, request):
                self.published = published
                self.request = request

            def __call__(self):
                raise ConflictError()

        provideAdapter(DummyRulesetLookup)

        provideUtility(Registry(), IRegistry)
        registry = getUtility(IRegistry)
        registry.registerInterface(ICacheSettings)
        settings = registry.forInterface(ICacheSettings)
        settings.enabled = True
        settings.operationMapping = {'foo': 'bar'}

        view = DummyView()
        request = DummyRequest(view, DummyResponse())
        self.assertRaises(ConflictError, intercept, DummyEvent(request))

    def setUp(self):
        super(CatalogUpdaterXMLAdapterTest, self).setUp()

        self.logger = DummyLogger('CatalogUpdaterLogger', [])
        dummy_cu = DummyCatalogUpdaterUtility()
        dummy_cu._logger = self.logger
        provideUtility(dummy_cu, ICatalogUpdater, name="catalog_updater")

    def test_swallow_other_error(self):

        @implementer(IRulesetLookup)
        @adapter(Interface, Interface)
        class DummyRulesetLookup(object):

            def __init__(self, published, request):
                self.published = published
                self.request = request

            def __call__(self):
                raise AttributeError('Should be swallowed and logged')

        provideAdapter(DummyRulesetLookup)

        provideUtility(Registry(), IRegistry)
        registry = getUtility(IRegistry)
        registry.registerInterface(ICacheSettings)
        settings = registry.forInterface(ICacheSettings)
        settings.enabled = True
        settings.operationMapping = {'foo': 'bar'}

        view = DummyView()
        request = DummyRequest(view, DummyResponse())

        try:
            intercept(DummyEvent(request))
        except Exception:
            self.fail('Intercept should not raise')