def test_filter_query_respecting_navroot(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
registry = getUtility(IRegistry)
settings = registry.forInterface(ISearchSettings)
view = getMultiAdapter((portal, request), name=u'search')
# When respect_navroot is disabled...
settings.respect_navroot = False
query = view.filter_query({'SearchableText': 'ham'})
self.assertEquals(query.get('path'), None,
"No path filter should be added if there wasn't one already")
request.form.update({'path': '/foo'})
query = view.filter_query({'SearchableText': 'ham'})
self.assertEquals(query.get('path'), '/foo',
'Existing path filter should remain unchanged')
# When respect_navroot is enabled...
settings.respect_navroot = True
del request.form['path']
query = view.filter_query({'SearchableText': 'ham'})
self.assertEquals(query.get('path'), '/plone',
'Search should be constrained to navroot')
request.form.update({'path': '/foo'})
query = view.filter_query({'SearchableText': 'ham'})
self.assertEquals(query.get('path'), '/foo',
'Existing path filter should remain unchanged')
def test_suggestions_querystring_with_list_parameter(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
request.form.update({'SearchableText': 'bidlung',
'facet.field': ['portal_type', 'review_state']})
view = getMultiAdapter((portal, request), name=u'search')
view.solr_response = SolrResponse()
view.solr_response.spellcheck = {}
view.solr_response.spellcheck['suggestions'] = {
'bidlung': {'endOffset': 246,
'numFound': 5,
'origFreq': 1,
'startOffset': 239,
'suggestion': [{'freq': 2704, 'word': 'bildung'},
{'freq': 1, 'word': 'bidlungs'},
{'freq': 1, 'word': 'bidung'},
{'freq': 561, 'word': 'bildungs'},
{'freq': 233, 'word': 'bislang'}]},
'correctlySpelled': False,
}
suggestions = view.suggestions()
self.assertEquals('bildung', suggestions[0][0])
self.assertIn('&facet.field=portal_type&facet.field=review_state',
suggestions[0][1])
self.assertIn('&SearchableText=bildung', suggestions[0][1])
def test_breadcrumbs_cropping(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
# Enable path based breadcrumbs
registry = getUtility(IRegistry)
settings = registry.forInterface(ISearchSettings)
settings.path_based_breadcrumbs = True
flare = PloneFlare(portal)
flare['path_string'] = '/plone/a/long/path/to/an/object'
view = getMultiAdapter((portal, request), name=u'search')
breadcrumbs = view.breadcrumbs(flare)
self.assertEquals(len(breadcrumbs), 4)
self.assertEquals(breadcrumbs[0]['Title'], 'a')
self.assertEquals(breadcrumbs[1]['Title'], u'…')
self.assertEquals(breadcrumbs[2]['Title'], 'to')
self.assertEquals(breadcrumbs[3]['Title'], 'an')
settings.max_breadcrumbs = 5
breadcrumbs = view.breadcrumbs(flare)
self.assertEquals(len(breadcrumbs), 5)
self.assertEquals(breadcrumbs[0]['Title'], 'a')
self.assertEquals(breadcrumbs[1]['Title'], 'long')
self.assertEquals(breadcrumbs[2]['Title'], 'path')
self.assertEquals(breadcrumbs[3]['Title'], 'to')
self.assertEquals(breadcrumbs[4]['Title'], 'an')
def setUp(self):
from zope.event import notify
from zope.traversing.interfaces import BeforeTraverseEvent
# Manually set up the browser layer, see:
# https://dev.plone.org/ticket/11673
notify(BeforeTraverseEvent(self.layer['portal'],
self.layer['request']))
def _get_request_interfaces(self):
request = self.layer['request']
# Reset _plonebrowerlayer_ marker, so that we can still register
# additional layers for testing. (WTF here?)
del request._plonebrowserlayer_
notify(BeforeTraverseEvent(self.portal, request))
iro = list(request.__provides__.__iro__)
return iro
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.request['ACTUAL_URL'] = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Manager'])
login(self.portal, TEST_USER_NAME)
notify(BeforeTraverseEvent(self.portal, self.request))
def setUp(self):
portal = self.layer['portal']
request = self.layer['request']
self.portal = portal
self.request = request
# setup manually the correct browserlayer, see:
# https://dev.plone.org/ticket/11673
notify(BeforeTraverseEvent(self.portal, self.request))
def test_suggestions_without_solr_response(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
view = getMultiAdapter((portal, request), name=u'search')
self.assertEquals([], view.suggestions())
def callTraversalHooks(self, request, ob):
""" We don't want to call _maybePlacefullyAuthenticate as does
zopepublication """
# In some cases we seem to be called more than once for a given
# traversed object, so we need to be careful here and only append an
# object the first time we see it.
if ob not in request.traversed_objects:
request.traversed_objects.append(ob)
notify(BeforeTraverseEvent(ob, request))
def setUp(self):
from imio.media import endpoints
self.app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.request['ACTUAL_URL'] = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Manager'])
login(self.portal, TEST_USER_NAME)
notify(BeforeTraverseEvent(self.portal, self.request))
self.module = endpoints
self.regex_providers = endpoints.REGEX_PROVIDERS
def _get_request_interfaces(self):
request = self.layer['request']
setDefaultSkin(request)
orig_iro = list(directlyProvidedBy(request).__iro__)
directlyProvides(request, [self.additive_layer] + orig_iro)
# Reset markers so that we can still register new skins and browserlayers
del request._plonebrowserlayer_
del request._plonetheme_
notify(BeforeTraverseEvent(self.portal, request))
iro = list(request.__provides__.__iro__)
return iro
def test_calling_search_view(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
view = getMultiAdapter((portal, request), name=u'search')
# Calling the @@search view without parameters shouldn't fail
view()
def test_interfaces(self):
from zope.traversing.interfaces import IBeforeTraverseEvent
from zope.traversing.interfaces import BeforeTraverseEvent
from zope.interface.verify import verifyObject
request = object()
target = object()
ob = BeforeTraverseEvent(target, request)
self.assertIs(request, ob.request)
self.assertIs(target, ob.object)
verifyObject(IBeforeTraverseEvent, ob)
def afterSetUp(self):
self.setRoles(['Manager'])
self.basic_auth = '%s:%s' % (default_user, default_password)
# make sure the test request gets marked with the default theme layer
notify(BeforeTraverseEvent(self.portal, self.app.REQUEST))
_createObjectByType('Folder', self.portal, 'atctfolder')
_createObjectByType('Document', self.portal, 'atctdocument')
_createObjectByType('File', self.portal, 'atctfile')
self.putils = getToolByName(self.portal, "plone_utils")
def __before_publishing_traverse__(self, arg1, arg2=None):
""" Pre-traversal hook.
"""
# XXX hack around a bug(?) in BeforeTraverse.MultiHook
REQUEST = arg2 or arg1
try:
notify(BeforeTraverseEvent(self, REQUEST))
except ComponentLookupError:
# allow ZMI access, even if the portal's site manager is missing
pass
self.setupCurrentSkin(REQUEST)
super(PortalObjectBase,
self).__before_publishing_traverse__(arg1, arg2)
def test_locale(self):
# Set up registry so that no is an accepted language and that the
# language information from the request is actually being used.
registry = getUtility(IRegistry)
settings = registry.forInterface(ILanguageSchema, prefix='plone')
settings.use_request_negotiation = True
settings.available_languages.append('no')
no = locales.getLocale('no', None, None)
self.app.REQUEST.set('HTTP_ACCEPT_LANGUAGE', 'no')
# Push request through the BeforeTraverseEvent handler again to
# update language settings
notify(BeforeTraverseEvent(self.portal, self.portal.REQUEST))
self.assertEqual(self.view.locale(), no)
def setUp(self):
self.portal = self.layer['portal']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
# make sure the test request gets marked with the default theme layer
notify(BeforeTraverseEvent(self.portal, self.layer['app'].REQUEST))
_createObjectByType('Folder', self.portal, 'folder')
_createObjectByType('Document', self.portal, 'document')
_createObjectByType('File', self.portal, 'file')
self.portal.file.file = NamedBlobFile('foo', 'text/plain', u'foo.txt')
transaction.commit()
self.putils = getToolByName(self.portal, "plone_utils")
self.browser = Browser(self.layer['app'])
self.browser.addHeader('Authorization', 'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,))
def test_can_enable_profiling_over_config(self):
# The flag profiling.enabled wins over a config that has
# disabled profiling. This permits the use of profiling on qastaging
# and similar systems.
self.pushProfilingConfig(
profiling_allowed='False', profile_all_requests='True',
memory_profile_log='.')
event = BeforeTraverseEvent(None,
self._get_request('/++profile++show&callgrind'))
with FeatureFixture({'profiling.enabled': 'on'}):
profile.before_traverse(event)
self.assertTrue(profile._profilers.profiling)
self.assertIsInstance(
profile._profilers.profiler, profile.Profiler)
self.assertEqual(
set(('show', 'callgrind', 'memory_profile_start')),
set(profile._profilers.actions))
def setUpEnvironment(self, portal):
"""Set up the local component site, reset skin data and log in as
the test user.
"""
# Set up the local site manager
from zope.site.hooks import setSite
setSite(portal)
# Reset skin data
portal.clearCurrentSkin()
portal.setupCurrentSkin(portal.REQUEST)
notify(BeforeTraverseEvent(portal, portal.REQUEST))
# Pseudo-login as the test user
from plone.app.testing import helpers
helpers.login(portal, TEST_USER_NAME)
def _notify_before_traverse_event(ob, request):
"""
Notifies a BeforeTraverseEvent, but safely: if the
handlers themselves raise a location error, turn that into
a HTTP 404 exception.
Because handlers are deliberately doing this, we stop
traversal and abort rather than try to return an information
dictionary and find a view and context, etc. This is limiting, but
safe.
"""
try:
notify(BeforeTraverseEvent(ob, request))
except LocationError:
# this is often a setup or programmer error
logger.debug("LocationError from traverse subscribers", exc_info=True)
raise HTTPNotFound("Traversal failed")
def test_no_suggest(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
# Setup solr suggest response
response = getData('nosuggest_response.txt')
proc = queryUtility(ISolrConnectionManager)
proc.setHost(active=True)
conn = proc.getConnection()
fakehttp(conn, response)
request.form.update({'term': 'abx'})
view = getMultiAdapter((portal, request), name=u'suggest-terms')
suggestions = json.loads(view())
self.assertEquals(len(suggestions), 0)
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.request['ACTUAL_URL'] = self.portal.absolute_url()
self.response = self.request.response
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.portal.invokeFactory('Link', 'link')
link = self.portal['link']
link.title = 'My Link'
link.description = 'This is my link.'
self.link = link
self.request.set('URL', link.absolute_url())
self.request.set('ACTUAL_URL', link.absolute_url())
alsoProvides(self.request, IPloneFormLayer)
# setup manually the correct browserlayer, see:
# https://dev.plone.org/ticket/11673
notify(BeforeTraverseEvent(self.portal, self.request))
def afterSetUp(self):
self.setRoles(['Manager'])
self.basic_auth = '%s:%s' % (default_user, default_password)
# make sure the test request gets marked with the default theme layer
notify(BeforeTraverseEvent(self.portal, self.app.REQUEST))
# disable auto-CSRF if it was enabled
try:
from plone.protect import auto
self._original_csrf_disabled = auto.CSRF_DISABLED
auto.CSRF_DISABLED = True
except ImportError:
pass
_createObjectByType('Folder', self.portal, 'atctfolder')
_createObjectByType('Document', self.portal, 'atctdocument')
_createObjectByType('File', self.portal, 'atctfile')
self.putils = getToolByName(self.portal, "plone_utils")
def test_breadcrumbs(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
setRoles(portal, TEST_USER_ID, ['Manager'])
f1 = portal[portal.invokeFactory('Folder', 'f1', title=u"Folder 1")]
f2 = f1[f1.invokeFactory('Folder', 'f2', title=u"Folder 2")]
f3 = f2[f2.invokeFactory('Folder', 'f3', title=u"Folder 3")]
flare = PloneFlare(portal)
flare['path_string'] = '/plone/f1/f2/f3'
view = getMultiAdapter((f3, request), name=u'search')
breadcrumbs = view.breadcrumbs(flare)
self.assertEquals(len(breadcrumbs), 2)
self.assertEquals(breadcrumbs[0]['Title'], 'Folder 1')
self.assertEquals(breadcrumbs[0]['absolute_url'], f1.absolute_url())
self.assertEquals(breadcrumbs[1]['Title'], 'Folder 2')
self.assertEquals(breadcrumbs[1]['absolute_url'], f2.absolute_url())
def traverse(self, path, default=_marker, request=None):
if not path:
return self.context
# The default traverser accepts an iterable of path segments in addition
# to a string, but we know where we're coming from and only accept a string.
# Py2: Testing: Decode bytes to the expected Unicode.
path = path.decode('utf-8') if isinstance(path, bytes) else path
__traceback_info__ = path
path = path.split(u'/')
path.reverse()
pop_path_element = path.pop
# One way we differ is that when the path is absolute, we don't
# need to use ``ILocationInfo(self.context).getRoot()``.
# In fact we must be an absolute path because we always start at the
# physical root.
assert not path[-1]
pop_path_element()
curr = self.context
with current_site(getSite()):
try:
while path:
name = pop_path_element()
if not name:
# Trailing or internal double /
continue
notify(BeforeTraverseEvent(curr, request))
curr = traversePathElement(curr,
name,
path,
request=request)
return curr
except LocationError:
if default is _marker:
raise
return default
def test_path_based_breadcrumbs(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
# Enable path based breadcrumbs
registry = getUtility(IRegistry)
settings = registry.forInterface(ISearchSettings)
settings.path_based_breadcrumbs = True
flare = PloneFlare(portal)
flare['path_string'] = '/plone/path/to/object'
view = getMultiAdapter((portal, request), name=u'search')
breadcrumbs = view.breadcrumbs(flare)
self.assertEquals(len(breadcrumbs), 2)
self.assertEquals(breadcrumbs[0]['Title'], 'path')
self.assertEquals(breadcrumbs[0]['absolute_url'],
portal.absolute_url() + '/path')
self.assertEquals(breadcrumbs[1]['Title'], 'to')
self.assertEquals(breadcrumbs[1]['absolute_url'],
portal.absolute_url() + '/path/to')
def test_suggestions(self):
portal = self.layer['portal']
request = self.layer['request']
# Setup browser layers
notify(BeforeTraverseEvent(portal, request))
request.form.update({'SearchableText': 'bidlung', })
view = getMultiAdapter((portal, request), name=u'search')
view.solr_response = SolrResponse()
view.solr_response.spellcheck = {}
view.solr_response.spellcheck['suggestions'] = {
'bidlung': {'endOffset': 246,
'numFound': 5,
'origFreq': 1,
'startOffset': 239,
'suggestion': [{'freq': 2704, 'word': 'bildung'},
{'freq': 1, 'word': 'bidlungs'},
{'freq': 1, 'word': 'bidung'},
{'freq': 561, 'word': 'bildungs'},
{'freq': 233, 'word': 'bislang'}]},
'platform': {'endOffset': 336,
'numFound': 5,
'origFreq': 9,
'startOffset': 328,
'suggestion': [{'freq': 557, 'word': 'plattform'},
{'freq': 2, 'word': 'platforma'},
{'freq': 2, 'word': 'platforme'},
{'freq': 2, 'word': 'platforms'},
{'freq': 7, 'word': 'plateforme'}]},
'correctlySpelled': False,
}
suggestions = view.suggestions()
self.assertEquals(suggestions[0][0], 'bildung')
self.assertEquals(suggestions[0][1], '&SearchableText=bildung')
def __call__(self, container, request):
zope.event.notify(BeforeTraverseEvent(container, request))
def _get_request_interfaces(self):
request = TestRequest()
notify(BeforeTraverseEvent(self.portal, request))
iro = list(request.__provides__.__iro__)
return iro
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
notify(BeforeTraverseEvent(self.portal, self.request))
