def setUpPloneSite(self, portal):
session.current_session = session.BuilderSession()
session.current_session.session = create_session()
super(ContentFixtureLayer, self).setUpPloneSite(portal)
portal.portal_languages.use_combined_language_codes = True
portal.portal_languages.addSupportedLanguage('de-ch')
if not DB_CACHE_MANAGER.is_loaded_from_cache(CACHE_GEVER_FIXTURE):
sqlite_testing.create_tables()
# Avoid circular imports:
from opengever.testing.fixtures import OpengeverContentFixture
setRequest(portal.REQUEST)
self['fixture_lookup_table'] = OpengeverContentFixture()()
setRequest(None)
DB_CACHE_MANAGER.data['fixture_lookup_table'] = (
self['fixture_lookup_table'])
DB_CACHE_MANAGER.dump_to_cache(self['zodbDB'], CACHE_GEVER_FIXTURE)
else:
DB_CACHE_MANAGER.apply_cache_fixes(CACHE_GEVER_FIXTURE)
self['fixture_lookup_table'] = (
DB_CACHE_MANAGER.data['fixture_lookup_table'])
# bumblebee should only be turned on on-demand with the feature flag.
# if this assertion fails a profile in the fixture enables bumblebee,
# or if was left on by mistake after fixture setup.
assert not is_bumblebee_feature_enabled()
def testSetUp(self):
"""Do not mess up here with another stacked
demo storage!!!"""
import Zope2
environ = {
'SERVER_NAME': 'localhost',
'SERVER_PORT': str(self['port']),
}
app = z2.addRequestContainer(
Zope2.app(), environ=environ)
request = app.REQUEST
request['PARENTS'] = [app]
# Make sure we have a zope.globalrequest request
try:
from zope.globalrequest import setRequest
setRequest(request)
except ImportError:
pass
self['app'] = app
self['request'] = request
self['portal'] = portal = self['app'][PLONE_SITE_ID]
transaction.commit()
self.setUpEnvironment(portal)
transaction.commit()
LayerMixin.testSetUp(self)
transaction.commit()
def testSetUp(self):
import Zope2
import transaction
# Open a new app and save it as the resource ``app``.
environ = {
'SERVER_NAME': self['host'],
'SERVER_PORT': str(self['port']),
}
app = addRequestContainer(Zope2.app(), environ=environ)
request = app.REQUEST
request['PARENTS'] = [app]
# Make sure we have a zope.globalrequest request
try:
from zope.globalrequest import setRequest
setRequest(request)
except ImportError:
pass
# Start a transaction
transaction.begin()
# Save resources for tests to access
self['app'] = app
self['request'] = request
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://*****:*****@@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 testSetUp(self):
import Zope2
import transaction
# Override zodbDB from the layer setup. Since it was set up by
# this layer, we can't just assign a new shadow. We therefore keep
# track of the original so that we can restore it on tear-down.
self['zodbDB'] = zodb.stackDemoStorage(self.get('zodbDB'), name='FunctionalTest')
# Save the app
environ = {
'SERVER_NAME': self['host'],
'SERVER_PORT': str(self['port']),
}
app = addRequestContainer(Zope2.app(), environ=environ)
request = app.REQUEST
request['PARENTS'] = [app]
# Make sure we have a zope.globalrequest request
try:
from zope.globalrequest import setRequest
setRequest(request)
except ImportError:
pass
# Start a transaction
transaction.begin()
# Save resources for the test
self['app'] = app
self['request'] = request
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 test_enabled(self):
context = FauxContext()
request = FauxRequest()
alsoProvides(request, IAttributeAnnotatable)
setRequest(request)
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://localhost:1234',)
@implementer(IPurgePaths)
@adapter(FauxContext)
class FauxPurgePaths(object):
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.assertEqual({'plone.cachepurging.urls': set(['/foo', '/bar'])},
dict(IAnnotations(request)))
def __call__(self):
celery = getCelery()
if celery.conf.CELERY_ALWAYS_EAGER:
self.eager = True
# dive out of setup, this is not run in a celery task runner
self.app = getApp()
return self._run()
self.app = makerequest(getApp())
self.app.REQUEST['PARENTS'] = [self.app]
setRequest(self.app.REQUEST)
transaction.begin()
try:
try:
result = self._run()
# commit transaction
transaction.commit()
return result
except ConflictError, e:
# On ZODB conflicts, retry using celery's mechanism
transaction.abort()
raise Retry(exc=e)
except:
logger.warn('Error running task: %s' % traceback.format_exc())
transaction.abort()
raise
def __call__(self):
celery = getCelery()
if celery.conf.task_always_eager:
self.eager = True
# dive out of setup, this is not run in a celery task runner
self.app = getApp()
return self._run()
self.app = makerequest(getApp())
self.app.REQUEST['PARENTS'] = [self.app]
setRequest(self.app.REQUEST)
transaction.begin()
try:
try:
result = self._run()
# commit transaction
transaction.commit()
return result
except ConflictError as e:
# On ZODB conflicts, retry using celery's mechanism
transaction.abort()
raise Retry(exc=e)
except Exception:
logger.warn('Error running task: %s' % traceback.format_exc())
transaction.abort()
raise
finally:
noSecurityManager()
setSite(None)
self.app._p_jar.close()
clearRequest()
def setUp(self):
self.app = self.layer["app"]
self.portal = self.layer["portal"]
setRequest(self.portal.REQUEST)
applyProfile(self.portal, "plone.app.caching:with-caching-proxy")
self.registry = getUtility(IRegistry)
self.cacheSettings = self.registry.forInterface(ICacheSettings)
self.cacheSettings.enabled = True
# some test content
setRoles(self.portal, TEST_USER_ID, ("Manager", ))
self.portal.invokeFactory("Folder", "f1")
self.portal["f1"].title = "Folder one"
self.portal.portal_workflow.doActionFor(self.portal["f1"], "publish")
self.portal["f1"].invokeFactory("Folder", "f2")
self.portal["f1"]["f2"].title = "Folder one sub one"
self.portal.portal_workflow.doActionFor(self.portal["f1"]["f2"],
"publish")
self.portal.invokeFactory("Collection", "c")
self.portal["c"].title = "A Collection"
self.portal.portal_workflow.doActionFor(self.portal["c"], "publish")
transaction.commit()
# restapi test session
self.api_session = RelativeSession(self.layer["portal"].absolute_url())
self.api_session.headers.update({"Accept": "application/json"})
def get_site(zopeapp=None):
# if 'PROJECT_ID' in os.environ:
# plone_path = os.environ['PROJECT_ID']
# conf_path = '/home/imio/imio-website/parts/instance/etc/zope.conf'
# else:
# args = parser.parse_args()
# plone_path = args.plone_path
# conf_path = 'parts/instance/etc/zope.conf'
# if not plone_path:
# return
# if not zopeapp:
# configure(conf_path)
# zopeapp = Zope2.app()
zopeapp = makerequest.makerequest(app) # noqa
zopeapp.REQUEST['PARENTS'] = [app] # noqa
setRequest(zopeapp.REQUEST)
# newSecurityManager(None, user)
user = app.acl_users.getUser('admin') # noqa
newSecurityManager(None, user.__of__(app.acl_users)) # noqa
portal = None
for oid in app.objectIds(): # noqa
obj = app[oid] # noqa
if IPloneSiteRoot.providedBy(obj):
portal = obj
if not portal:
raise('Do not find portal')
return portal
def test_off_switch(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = False
z3c.caching.registry.register(DummyView, 'testrule')
settings.operationMapping = {'testrule': 'op1'}
@implementer(ICachingOperation)
@adapter(Interface, Interface)
class DummyOperation(object):
def __init__(self, published, request):
self.published = published
self.request = request
def interceptResponse(self, rulename, response):
return None
def modifyResponse(self, rulename, response):
response['X-Mutated'] = rulename
provideAdapter(DummyOperation, name='op1')
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def setup_plone(plone, options=None):
"""Takes care of setting up a request, manager security context and
setting up the site manager for the given Plone site.
Returns the Plone site root object.
This is based on the setup code found in p.recipe.zope2instance.ctl:
https://github.com/plone/plone.recipe.zope2instance/blob/
02bfb735/src/plone/recipe/zope2instance/ctl.py#L672-L680
"""
app = plone.restrictedTraverse('/')
# Set up request for debug / bin/instance run mode.
app = makerequest(app)
app.REQUEST['PARENTS'] = [app]
setRequest(app.REQUEST)
# Get a reference to the Plone site *inside* the request-wrapped app
plone = app.restrictedTraverse(plone.id)
# Set up Manager security context
user = AccessControl.SecurityManagement.SpecialUsers.system
user = user.__of__(app.acl_users)
newSecurityManager(app, user)
# Set up site to make component registry work
setSite(plone)
return plone
def setUpPloneSite(self, portal):
request = FauxRequest()
setRequest(request)
applyProfile(portal, "plone.app.caching:default")
applyProfile(portal, "design.plone.policy:default")
quickInstallProduct(portal, "collective.MockMailHost")
applyProfile(portal, "collective.MockMailHost:default")
def upgrade(
self, upgrade_portal=True,
upgrade_all_profiles=True, upgrade_profiles=(), **kw):
hooks.setSite(self.context)
setRequest(self.context.REQUEST)
# initialize portal_skins
self.context.setupCurrentSkin(self.context.REQUEST)
# setup language for plone 4: see https://docs.plone.org/manage/upgrading/version_specific_migration/p4x_to_p5x_upgrade.html#portal-languages-is-now-a-utility # noqa
if getattr(self.context, 'portal_languages', None):
self.context.portal_languages(self.context, self.context.REQUEST)
self.setup = getToolByName(self.context, 'portal_setup')
self.log('Upgrading {0}'.format(self.context))
# setup BrowserLayer, see: https://dev.plone.org/ticket/11673
notify(BeforeTraverseEvent(self.context, self.context.REQUEST))
baseline = self.setup.getBaselineContextID()
prof_type, profile_id = baseline.split('-', 1)
self.base_profile = profile_id
if upgrade_portal:
# Do the baseline profile upgrade first
self.upgradeProfile(profile_id, **kw)
# Upgrade extension profiles
if upgrade_all_profiles:
if upgrade_profiles:
raise ValueError(
'upgrade_profiles conflicts with upgrade_all_profiles')
upgrade_profiles = self.setup.listProfilesWithPendingUpgrades()
if upgrade_profiles:
self.upgradeExtensions(upgrade_profiles, **kw)
self.log('Upgraded {0}'.format(self.context))
def testGetURL_catalog_as_utility(self):
request = DummyRequest()
b = self._makeBrain(0)
setRequest(request)
self.assertEqual(b.getURL(), 'http://superbad.com/conflicter')
clearRequest()
def run_it(module):
cwd = os.getcwd()
conf_path = None
lookup_paths = [
'/opt/plone/parts/client1/etc/zope.conf',
os.path.join(cwd, 'parts/instance/etc/zope.conf'),
os.path.join(cwd, 'parts/client1/etc/zope.conf'),
]
for path in lookup_paths:
if os.path.exists(path):
conf_path = path
break
if conf_path is None:
raise Exception('Could not find zope.conf in {}'.format(lookup_paths))
from Zope2 import configure
configure(conf_path)
import Zope2
app = Zope2.app()
from Testing.ZopeTestCase.utils import makerequest
app = makerequest(app)
app.REQUEST['PARENTS'] = [app]
from zope.globalrequest import setRequest
setRequest(app.REQUEST)
from AccessControl.SpecialUsers import system as user
from AccessControl.SecurityManagement import newSecurityManager
newSecurityManager(None, user)
from zope.dottedname.resolve import resolve
mod = resolve('castle.cms.cron.' + module)
mod.run(app)
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://*****:*****@@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_no_registry(self):
context = FauxContext()
request = FauxRequest()
alsoProvides(request, IAttributeAnnotatable)
setRequest(request)
@implementer(IPurgePaths)
@adapter(FauxContext)
class FauxPurgePaths(object):
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.assertEqual({}, dict(IAnnotations(request)))
def testSetUp(self):
import Zope2
import transaction
# Override zodbDB from the layer setup. Since it was set up by
# this layer, we can't just assign a new shadow. We therefore keep
# track of the original so that we can restore it on tear-down.
self['zodbDB'] = zodb.stackDemoStorage(self.get('zodbDB'),
name='FunctionalTest')
# Save the app
environ = {
'SERVER_NAME': self['host'],
'SERVER_PORT': str(self['port']),
}
app = addRequestContainer(Zope2.app(), environ=environ)
request = app.REQUEST
request['PARENTS'] = [app]
# Make sure we have a zope.globalrequest request
try:
from zope.globalrequest import setRequest
setRequest(request)
except ImportError:
pass
# Start a transaction
transaction.begin()
# Save resources for the test
self['app'] = app
self['request'] = request
def test_request_not_annotatable(self):
context = FauxContext()
request = FauxRequest()
setRequest(request)
registry = Registry()
registry.registerInterface(ICachePurgingSettings)
provideUtility(registry, IRegistry)
settings = registry.forInterface(ICachePurgingSettings)
settings.enabled = True
settings.cachingProxies = ('http://localhost:1234',)
@implementer(IPurgePaths)
@adapter(FauxContext)
class FauxPurgePaths(object):
def __init__(self, context):
self.context = context
def getRelativePaths(self):
return ['/foo', '/bar']
def getAbsolutePaths(self):
return []
provideAdapter(FauxPurgePaths, name="test1")
try:
notify(Purge(context))
except:
self.fail()
def getPortal(self):
"""Returns the portal object, i.e. the "fixture root".
Rewrap the portal in an independant request for this test.
"""
if self.portal is not None:
return self.portal
from Products.ERP5.ERP5Site import getSite
site = getSite()
# reconstruct the acquistion chain with an independant request.
# RequestContainer -> Application -> Site
from Testing.ZopeTestCase.utils import makerequest
portal = getattr(makerequest(site.aq_parent), site.getId())
# Make the various get_request patches return this request.
# This is for ERP5TypeTestCase patch
from Testing.ZopeTestCase.connections import registry
if registry:
registry._conns[-1] = portal
# This is for Localizer patch
from zope.globalrequest import setRequest
request = portal.REQUEST
setRequest(request)
# Make live tests run under the same server URL than the host instance.
if _request_server_url:
request['SERVER_URL'] = _request_server_url
request._resetURLS()
self.portal = portal
return portal
def testSetUp(self):
import Zope2
import transaction
# Open a new app and save it as the resource ``app``.
environ = {
'SERVER_NAME': self['host'],
'SERVER_PORT': str(self['port']),
}
app = addRequestContainer(Zope2.app(), environ=environ)
request = app.REQUEST
request['PARENTS'] = [app]
# Make sure we have a zope.globalrequest request
try:
from zope.globalrequest import setRequest
setRequest(request)
except ImportError:
pass
# Start a transaction
transaction.begin()
# Save resources for tests to access
self['app'] = app
self['request'] = request
def test_request_not_annotatable(self):
context = FauxContext()
request = FauxRequest()
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")
try:
notify(Purge(context))
except:
self.fail()
def main(app, user_id):
parser = argparse.ArgumentParser()
parser.add_argument('-p',
'--new-password',
dest='new_password',
type=str,
help='New zope admin password for Plone instance')
parser.add_argument('-c',
'--change_file',
dest='change_file',
type=str,
default='update-admin-password.py',
help='File use to zope')
args = parser.parse_args()
new_password = args.new_password
app = makerequest.makerequest(app)
# support plone.subrequest
app.REQUEST['PARENTS'] = [app]
setRequest(app.REQUEST)
acl_users = app.acl_users
user = acl_users.getUser(user_id)
if user:
# update zope password
users = acl_users.users
users.updateUserPassword(user_id, new_password)
transaction.commit()
else:
logger.info('User {0} doesn\'t exists'.format(user_id))
def get_plone_site():
import Zope2
app = Zope2.app()
from Testing.ZopeTestCase import utils
utils._Z2HOST = HOST
path = PLONE.split('/')
app = utils.makerequest(app)
app.REQUEST['PARENTS'] = [app]
app.REQUEST.other['VirtualRootPhysicalPath'] = path
from zope.globalrequest import setRequest
setRequest(app.REQUEST)
from AccessControl.SpecialUsers import system as user
from AccessControl.SecurityManagement import newSecurityManager
newSecurityManager(None, user)
_site = app[path[-1]]
site = _site.__of__(app)
from zope.site.hooks import setSite
setSite(site)
return site
def get(self, path):
if path == '/logout':
if users.get_current_user():
self.redirect(users.create_logout_url('/'))
else:
self.redirect(self.request.relative_url('/'))
return
setRequest(self.request)
app = createObject('Application', self.request, self.response)
setSite(app)
traverser = ITraverser(app)
stack = path.split('/')
if stack[-1] == '':
stack = stack[:-1]
if stack[0] == '':
stack = stack[1:]
obj = traverser.traverse(self.request, self.response, stack)
requires = getattr(obj, 'permission_required', None)
if requires:
user = users.get_current_user()
if not checkPermission(obj, user, requires):
self.redirect(users.create_login_url(self.request.uri))
return
if getattr(obj, 'render', None):
self.response.out.write(obj.render())
else:
self.response.headers['Content-Type'] = 'text/plain'
self.response.out.write(obj)
getUtility(ISession).commit()
clearRequest()
def get_plone_site(PLONE):
import Zope2
app = Zope2.app()
from Testing.ZopeTestCase import utils
utils._Z2HOST = HOST
path = PLONE.split('/')
app = utils.makerequest(app)
app.REQUEST['PARENTS'] = [app]
app.REQUEST.other['VirtualRootPhysicalPath'] = path
from zope.globalrequest import setRequest
setRequest(app.REQUEST)
from AccessControl.SpecialUsers import system as user
from AccessControl.SecurityManagement import newSecurityManager
newSecurityManager(None, user)
_site = app[path[-1]]
site = _site.__of__(app)
from zope.site.hooks import setSite
setSite(site)
return site
def setUp(self):
self.settings = getUtility(IRegistry).forInterface(IThemeSettings)
self.settings.enabled = True
self.settings.rules = u'python://plone.app.theming/tests/rules.xml'
self.settings.parameterExpressions = {
'stringParam': 'string:string param value',
'boolParam': 'python:False',
'contextParam': 'context/absolute_url | string:no context',
'requestParam': 'request/useother | string:off',
}
self.portal = self.layer['portal']
setRequest(self.portal.REQUEST)
applyProfile(self.portal, 'plone.app.caching:without-caching-proxy')
self.cacheSettings = getUtility(IRegistry).forInterface(ICacheSettings)
self.cacheSettings.enabled = True
self.cacheSettings.operationMapping = {
'plone.content.folderView': 'plone.app.caching.weakCaching'}
registry = getUtility(IRegistry)
registry['plone.app.caching.weakCaching.ramCache'] = True
import transaction
transaction.commit()
def setUpPloneSite(self, portal):
session.current_session = session.BuilderSession()
session.current_session.session = create_session()
super(TestserverLayer, self).setUpPloneSite(portal)
applyProfile(portal, 'plonetheme.teamraum:gever')
portal.portal_languages.use_combined_language_codes = True
portal.portal_languages.addSupportedLanguage('de-ch')
api.portal.set_registry_record('use_solr',
True,
interface=ISearchSettings)
activate_bumblebee_feature()
setRequest(portal.REQUEST)
print 'Installing fixture. Have patience.'
self.get_fixture_class()()
print 'Finished installing fixture.'
setRequest(None)
# Commit before creating the solr backup, since collective.indexing
# flushes on commit.
transaction.commit()
SolrReplicationAPIClient.get_instance().create_backup('fixture')
def testGetURL_catalog_as_utility(self):
request = DummyRequest()
b = self._makeBrain(0)
setRequest(request)
self.assertEqual(b.getURL(), 'http://superbad.com/conflicter')
clearRequest()
def test_isolate_globalrequest(self):
setRequest(self.layer['request'])
with isolate_globalrequest():
self.assertIsNone(None, getRequest())
setRequest('bar')
self.assertEquals(self.layer['request'], getRequest())
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
setRequest(self.portal.REQUEST)
self.registry = getUtility(IRegistry)
self.cacheSettings = self.registry.forInterface(ICacheSettings)
self.cacheSettings.enabled = True
def publish_module(
environ,
start_response,
_publish=publish, # only for testing
_response=None,
_response_factory=WSGIResponse,
_request=None,
_request_factory=WSGIRequest,
_module_name='Zope2'):
module_info = get_module_info(_module_name)
result = ()
with closing(BytesIO()) as stdout, closing(BytesIO()) as stderr:
response = (_response if _response is not None else _response_factory(
stdout=stdout, stderr=stderr))
response._http_version = environ['SERVER_PROTOCOL'].split('/')[1]
response._server_version = environ.get('SERVER_SOFTWARE')
request = (_request if _request is not None else _request_factory(
environ['wsgi.input'], environ, response))
for i in range(getattr(request, 'retry_max_count', 3) + 1):
setRequest(request)
try:
with load_app(module_info) as new_mod_info:
with transaction_pubevents(request, response):
response = _publish(request, new_mod_info)
break
except (ConflictError, TransientError) as exc:
if request.supports_retry():
new_request = request.retry()
request.close()
request = new_request
response = new_request.response
else:
raise
finally:
request.close()
clearRequest()
# Start the WSGI server response
status, headers = response.finalize()
start_response(status, headers)
if (isinstance(response.body, _FILE_TYPES)
or IUnboundStreamIterator.providedBy(response.body)):
result = response.body
else:
# If somebody used response.write, that data will be in the
# stdout BytesIO, so we put that before the body.
result = (stdout.getvalue(), response.body)
for func in response.after_list:
func()
# Return the result body iterable.
return result
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
setRequest(self.portal.REQUEST)
self.registry = getUtility(IRegistry)
self.cacheSettings = self.registry.forInterface(ICacheSettings)
self.cacheSettings.enabled = True
def testGetObjectHappy_catalog_as_utility(self):
request = DummyRequest()
b = self._makeBrain(1)
setRequest(request)
self.assertEqual(b.getPath(), '/happy')
self.assertEqual(b.getObject().REQUEST, request)
self.assertTrue(
aq_base(b.getObject()) is aq_base(self.cat.getobject(1)))
clearRequest()
def testGetObjectHappy_catalog_as_utility(self):
request = DummyRequest()
b = self._makeBrain(1)
setRequest(request)
self.assertEqual(b.getPath(), '/happy')
self.assertEqual(b.getObject().REQUEST, request)
self.assertTrue(aq_base(b.getObject()) is
aq_base(self.cat.getobject(1)))
clearRequest()
def _setup_plone(self, plone_site_obj):
app = self._find_app(plone_site_obj)
app = makerequest(app)
setRequest(app.REQUEST)
self.obj = app.unrestrictedTraverse(
'/'.join(plone_site_obj.getPhysicalPath()))
user = AccessControl.SecurityManagement.SpecialUsers.system
user = user.__of__(self.obj.acl_users)
newSecurityManager(self.obj, user)
setSite(self.obj)
def setUpPloneSite(self, portal):
#make global request work
from zope.globalrequest import setRequest
setRequest(portal.REQUEST)
# login doesn't work so we need to call z2.login directly
z2.login(portal.__parent__.acl_users, SITE_OWNER_NAME)
# setRoles(portal, TEST_USER_ID, ('Manager',))
# login(portal, TEST_USER_NAME)
self.portal = portal
def test_decorator_isolates_globalrequest(self):
setRequest(self.layer['request'])
@isolated
def foo():
self.assertIsNone(None, getRequest())
setRequest('bar')
return 'Foo'
self.assertEquals('Foo', foo())
self.assertEquals(self.layer['request'], getRequest())
def runscript(zopeconf, script_name, *extra_args):
make_wsgi_app({}, zopeconf)
app = Zope2.app()
app = makerequest(app)
app.REQUEST['PARENTS'] = [app]
setRequest(app.REQUEST)
newSecurityManager(None, user)
scriptglobals = {'__name__': '__main__', 'app': app}
with open(script_name) as script:
scriptcode = script.read()
exec(compile(scriptcode, script_name, 'exec'), scriptglobals)
def test_no_registry(self):
provideAdapter(DefaultRulesetLookup)
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEqual({'PUBLISHED': view}, dict(request))
self.assertEqual({}, dict(request.response))
def setUpPloneSite(self, portal):
applyProfile(portal, 'xtgl.policy:default')
# applyProfile(portal, 'my315ok.socialorgnization:default')
# applyProfile(portal, 'dexterity.membrane:default')
# applyProfile(portal, 'dexterity.membrane.content:example')
# portal = self.layer['portal']
#make global request work
from zope.globalrequest import setRequest
setRequest(portal.REQUEST)
# login doesn't work so we need to call z2.login directly
z2.login(portal.__parent__.acl_users, SITE_OWNER_NAME)
def setUp(self):
self.request = TestRequest(environ={'HTTP_ACCEPT_LANGUAGE': 'en'})
setRequest(self.request)
self.portal = self.layer['portal']
login(self.portal, TEST_USER_NAME)
setRoles(self.portal, TEST_USER_ID, ['Manager'])
provideUtility(ExampleVocabulary(), name=u'vocab_class')
provideUtility(ExampleFunctionVocabulary, name=u'vocab_function')
vocabulary._permissions.update({
'vocab_class': 'Modify portal content',
'vocab_function': 'Modify portal content',
})
def test_no_tool(self):
root = FauxContent('')
content = FauxContent('foo').__of__(root)
discussable = FauxDiscussable().__of__(content)
request = FauxRequest()
setRequest(request)
purge = DiscussionItemPurgePaths(discussable)
self.assertEqual([], list(purge.getRelativePaths()))
self.assertEqual([], list(purge.getAbsolutePaths()))
def test_no_tool(self):
root = FauxContent('')
content = FauxContent('foo').__of__(root)
discussable = FauxDiscussable().__of__(content)
request = FauxRequest()
setRequest(request)
purge = DiscussionItemPurgePaths(discussable)
self.assertEqual([], list(purge.getRelativePaths()))
self.assertEqual([], list(purge.getAbsolutePaths()))
def setUp(self):
self.request = TestRequest(environ={'HTTP_ACCEPT_LANGUAGE': 'en'})
setRequest(self.request)
self.portal = self.layer['portal']
login(self.portal, TEST_USER_NAME)
setRoles(self.portal, TEST_USER_ID, ['Manager'])
provideUtility(ExampleVocabulary(), name=u'vocab_class')
provideUtility(ExampleFunctionVocabulary, name=u'vocab_function')
vocabulary._permissions.update({
'vocab_class': 'Modify portal content',
'vocab_function': 'Modify portal content',
})
def test_no_records(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
view = DummyView()
response = DummyResponse()
request = DummyRequest(view, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEquals({"PUBLISHED": view}, dict(request))
self.assertEquals({}, dict(request.response))
def isolate_globalrequest():
"""Context manager for global request isolation.
"""
if not HAS_GLOBALREQUEST:
yield
return
request = getRequest()
setRequest(None)
try:
yield
finally:
setRequest(request)
def testTearDown(self):
LayerMixin.testTearDown(self)
# Make sure we have a zope.globalrequest request
try:
from zope.globalrequest import setRequest
setRequest(None)
except ImportError:
pass
# Close the database connection and the request
app = self['app']
app.REQUEST.close()
del self['portal']
del self['app']
del self['request']
def setUpPloneSite(self, portal):
session.current_session = session.BuilderSession()
session.current_session.session = create_session()
super(TestserverLayer, self).setUpPloneSite(portal)
applyProfile(portal, 'plonetheme.teamraum:gever')
portal.portal_languages.use_combined_language_codes = True
portal.portal_languages.addSupportedLanguage('de-ch')
setRequest(portal.REQUEST)
print 'Installing fixture. Have patience.'
self.get_fixture_class()()
print 'Finished installing fixture.'
setRequest(None)
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
setRequest(self.portal.REQUEST)
applyProfile(self.portal, 'plone.app.caching:without-caching-proxy')
self.registry = getUtility(IRegistry)
self.cacheSettings = self.registry.forInterface(ICacheSettings)
self.cachePurgingSettings = self.registry.forInterface(ICachePurgingSettings)
self.ploneCacheSettings = self.registry.forInterface(IPloneCacheSettings)
self.cacheSettings.enabled = True
def test_no_published_object(self):
provideAdapter(DefaultRulesetLookup)
provideUtility(Registry(), IRegistry)
registry = getUtility(IRegistry)
registry.registerInterface(ICacheSettings)
settings = registry.forInterface(ICacheSettings)
settings.enabled = True
response = DummyResponse()
request = DummyRequest(None, response)
setRequest(request)
modifyStreamingResponse(DummyStreamingEvent(response))
self.assertEqual({'PUBLISHED': None}, dict(request))
self.assertEqual({}, dict(request.response))
