def getDestinationFolder(stats_folder):
portal = api.portal.get()
setSite(portal)
# Create 'stats_folder' folder if not exists
if portal.get(stats_folder) is None:
makeFolder(portal, stats_folder)
portal = portal.get(stats_folder)
today = datetime.now()
context = aq_inner(portal)
tool = getToolByName(context, 'translation_service')
month = tool.translate(today.strftime("%B"), 'ulearn', context=context).encode()
month = month.lower()
year = today.strftime("%G")
# Create year folder and month folder if not exists
if portal.get(year) is None:
makeFolder(portal, year)
portal = portal.get(year)
makeFolder(portal, month)
# Create month folder if not exists
else:
portal = portal.get(year)
if portal.get(month) is None:
makeFolder(portal, month)
portal = portal.get(month)
return portal
def ploneSite(db=None, connection=None, environ=None):
"""Context manager for working with the Plone portal during layer setup::
with ploneSite() as portal:
...
This is based on the ``z2.zopeApp()`` context manager. See the module
``plone.testing.z2`` for details.
Do not use this in a test. Use the 'portal' resource from the PloneFixture
layer instead!
Pass a ZODB handle as ``db`` to use a specificdatabase. Alternatively,
pass an open connection as ``connection`` (the connection will not be
closed).
"""
from zope.site.hooks import setSite, getSite, setHooks
setHooks()
site = getSite()
with z2.zopeApp(db, connection, environ) as app:
portal = app[PLONE_SITE_ID]
setSite(portal)
login(portal, TEST_USER_NAME)
try:
yield portal
finally:
logout()
if site is not portal:
setSite(site)
def setUp(self):
portal = self.layer['portal']
self.portal = portal
self.request = self.layer['request']
setRoles(portal, TEST_USER_ID, ['Manager'])
setHooks()
setSite(portal)
def check_root_site_manager(tool):
"""2.0.x to 2.1.0 upgrade step checker
"""
portal = aq_parent(aq_inner(tool))
try:
# We have to call setSite to make sure we have a site with a proper
# acquisition context.
setSite(portal)
sm = portal.getSiteManager()
if sm.utilities.LookupClass != FiveVerifyingAdapterLookup:
return True
except ComponentLookupError:
return True
for tool_interface in _BAD_UTILITIES:
try:
iface = resolve(tool_interface)
except ImportError:
continue
if sm.queryUtility(iface) is not None:
return True
for tool_id, tool_interface in _TOOL_UTILITIES:
tool_obj = getToolByName(portal, tool_id, default=None)
try:
iface = resolve(tool_interface)
except ImportError:
continue
if tool_obj is not None and sm.queryUtility(iface) is None:
return True
return False
def _get_site(app, args):
# Zope.Startup.zopectl.ZopeCmd.run_entrypoint promises to pass the entry
# point's name as the first argument and any further arguments after that,
# but that does not work with plone.recipe.zope2instance. Using positional
# arguments therefore is unreliable - resolve to using a flag.
parser = argparse.ArgumentParser()
parser.add_argument(
'--plonesite',
help='Name of the Plone site',
default=None
)
namespace, unused = parser.parse_known_args(args)
name = namespace.plonesite
if name is not None:
if name not in app:
logger.error("Specified site '%s' not found in database." % name)
sys.exit(1)
else:
from Products.CMFPlone.Portal import PloneSite
for k, v in app.items():
if isinstance(v, PloneSite):
name = k
break
if not name:
logger.error("No Plone site found in database root.")
sys.exit(1)
site = getattr(app, name)
setHooks()
setSite(site)
return site
def check_root_site_manager(tool):
"""2.0.x to 2.1.0 upgrade step checker
"""
portal = aq_parent(aq_inner(tool))
try:
# We have to call setSite to make sure we have a site with a proper
# acquisition context.
setSite(portal)
sm = portal.getSiteManager()
if sm.utilities.LookupClass != FiveVerifyingAdapterLookup:
return True
except ComponentLookupError:
return True
for tool_interface in _BAD_UTILITIES:
try:
iface = resolve(tool_interface)
except ImportError:
continue
if sm.queryUtility(iface) is not None:
return True
for tool_id, tool_interface in _TOOL_UTILITIES:
tool_obj = getToolByName(portal, tool_id, default=None)
try:
iface = resolve(tool_interface)
except ImportError:
continue
if tool_obj is not None and sm.queryUtility(iface) is None:
return True
return False
def _setup(app, site=None):
"""Set up our environment.
Create a request, log in as admin and set the traversal hooks on the site.
"""
from Testing import makerequest # Do not import this at the module level!
app = makerequest.makerequest(app)
# Login as admin
admin = app.acl_users.getUserById('admin')
if admin is None:
logger.error("No user called `admin` found in the database. "
"Use --rootpassword to create one.")
sys.exit(1)
# Wrap the admin in the right context; from inside the site if we have one
if site is not None:
admin = admin.__of__(site.acl_users)
site = app[site.getId()]
else:
admin = admin.__of__(app.acl_users)
newSecurityManager(None, admin)
# Set up local site manager, skins and language
if site is not None:
setHooks()
setSite(site)
site.setupCurrentSkin(site.REQUEST)
site.REQUEST['HTTP_ACCEPT_LANGUAGE'] = site.Language()
return (app, site)
def setUp(self):
portal = self.layer["portal"]
self.portal = portal
self.request = self.layer["request"]
setRoles(portal, TEST_USER_ID, ["Manager"])
setHooks()
setSite(portal)
def enableZope3Site(context):
portal = getToolByName(context, 'portal_url').getPortalObject()
if not ISite.providedBy(portal):
make_objectmanager_site(portal)
logger.info('Made the portal a Zope3 site.')
try:
components = portal.getSiteManager()
except ComponentLookupError:
next = find_next_sitemanager(portal)
if next is None:
next = base
name = '/'.join(portal.getPhysicalPath())
components = PersistentComponents(name, (next,))
components.__parent__ = portal
portal.setSiteManager(components)
logger.info("Site manager '%s' added." % name)
else:
if components.utilities.LookupClass != FiveVerifyingAdapterLookup:
# for CMF 2.1 beta instances
components.__parent__ = portal
components.utilities.LookupClass = FiveVerifyingAdapterLookup
components.utilities._createLookup()
components.utilities.__parent__ = components
logger.info('LookupClass replaced.')
# Make sure to set the new site as the new active one
setSite(portal)
def afterSetUp(self):
self.loginAsPortalOwner()
setSite(self.portal)
stool = self.portal.portal_setup
expected_export = stool.runAllExportSteps()
self.expected = TarballImportContext(stool, expected_export['tarball'])
setSite(None)
def silva_session_arg_generator(parent):
root, options = parent.next()
if not hasattr(options, 'paths') or not len(options.paths):
fail(u"specifiy at least one Silva root path")
for path in options.paths:
try:
silva = root.unrestrictedTraverse(path)
except KeyError:
fail("%s is not a valid Zope path" % path)
if not IRoot.providedBy(silva):
fail("%s is not a valid Silva root" % path)
if ISite.providedBy(silva):
setSite(silva)
else:
setSite(None)
setHooks()
if hasattr(options, 'username') and options.username:
user = zope_find_user(silva, options.username)
newSecurityManager(None, user)
yield silva, options
try:
parent.next()
except StopIteration:
pass
else:
fail(u"internal error")
def afterSetUp(self):
self.loginAsPortalOwner()
setSite(self.portal)
#stool = self.portal.portal_setup
#expected_export = stool.runAllExportSteps()
#self.expected = TarballImportContext(stool, expected_export['tarball'])
setSite(None)
def startKSSCommands(context, request):
view = KSSView(context, request)
# Alec suggested we should fire the BeforeTraverseEvent, but after
# debugging for a while I stopped caring about the event and think
# that setSite() is the only thing we're interested in.
setSite(view)
return view
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 addConfiguredSite(dispatcher,
site_id,
profile_id,
snapshot=True,
RESPONSE=None,
extension_ids=()):
""" Add a CMFSite to 'dispatcher', configured according to 'profile_id'.
"""
site = CMFSite(site_id)
dispatcher._setObject(site_id, site)
site = dispatcher._getOb(site_id)
setSite(site)
site._setObject(_TOOL_ID, SetupTool(_TOOL_ID))
setup_tool = getToolByName(site, _TOOL_ID)
setup_tool.setBaselineContext('profile-%s' % profile_id)
setup_tool.runAllImportStepsFromProfile('profile-%s' % profile_id)
for extension_id in extension_ids:
setup_tool.runAllImportStepsFromProfile('profile-%s' % extension_id)
if snapshot is True:
setup_tool.createSnapshot('initial_configuration')
if RESPONSE is not None:
RESPONSE.redirect('%s/%s/manage_main?update_menu=1' %
(dispatcher.absolute_url(), site_id))
def setUp(self):
zope.app.appsetup.product.setProductConfigurations(self.conf)
zope.app.wsgi.testlayer.BrowserLayer.setUp(self)
root = self.getRootFolder()
root['app'] = Uvcsite()
setSite(root['app'])
transaction.commit()
def upgrade_2001(context): # pragma: no cover
"""
"""
site = getToolByName(context, 'portal_url').getPortalObject()
portal_setup = site.portal_setup
log = logging.getLogger(
'collective.cron.upgrade.2001')
try:
from plone.app.async.interfaces import IAsyncDatabase
from plone.app.async.service import AsyncService
except:
return
service = AsyncService()
db = service._db = getUtility(IAsyncDatabase)
asyncfs = db.databases.get(db.database_name)
itransaction = Zope2.zpublisher_transactions_manager
# see plone.app.async.service.AsyncService.getQueues
try:
service._conn = asyncfs.open()
service._conn.onCloseCallback(service.__init__)
queues = service.getQueues()
queue = queues['']
s = getMultiAdapter((site, queue), i.ICrontabMarker)
for idx, item in enumerate(s.annotations['plone'][:]):
if isinstance(item, tuple):
s.annotations['plone'][idx] = item[1]
itransaction.commit()
finally:
asyncfs.close()
setSite(site)
log.info('upgrade runned')
def _get_site(app, args):
# Zope.Startup.zopectl.ZopeCmd.run_entrypoint promises to pass the entry
# point's name as the first argument and any further arguments after that,
# but that does not work with plone.recipe.zope2instance. Using positional
# arguments therefore is unreliable - resolve to using a flag.
parser = argparse.ArgumentParser()
parser.add_argument(
'--plonesite',
help='Name of the Plone site',
default=None
)
namespace, unused = parser.parse_known_args(args)
name = namespace.plonesite
if name is not None:
if name not in app:
logger.error("Specified site '%s' not found in database." % name)
sys.exit(1)
else:
from Products.CMFPlone.Portal import PloneSite
for k, v in app.items():
if isinstance(v, PloneSite):
name = k
break
if not name:
logger.error("No Plone site found in database root.")
sys.exit(1)
site = getattr(app, name)
setHooks()
setSite(site)
return site
def setUp(self):
if not os.path.exists(self.dbDir):
os.mkdir(self.dbDir)
filename = os.path.join(self.dbDir, 'TestData.fs')
fsetup = functional.FunctionalTestSetup(self.config_file)
self.original = fsetup.base_storage
if not os.path.exists(filename):
# Generate a new database from scratch and fill it
db = database(filename)
connection = db.open()
root = connection.root()
app = root[ZopePublication.root_name]
# store the site, because the connection gets closed
site = hooks.getSite()
self.setUpApplication(app)
transaction.commit()
connection.close()
db.close()
hooks.setSite(site)
# sets up the db stuff normal
fsetup.setUp()
# replace the storage with our filestorage
fsetup.base_storage = FileStorage(filename)
# override close on this instance, so files dont get closed on
# setup/teardown of functionsetup
fsetup.base_storage.close = lambda: None
def testUpgradeAllProposed(self):
request = self.app.REQUEST
oldsite = getattr(self.app, self._SITE_ID)
stool = oldsite.portal_setup
profile_id = 'Products.CMFDefault:default'
upgrades = []
for upgrade_info in stool.listUpgrades(profile_id):
if isinstance(upgrade_info, list):
for info in upgrade_info:
if info['proposed']:
upgrades.append(info['id'])
continue
if upgrade_info['proposed']:
upgrades.append(upgrade_info['id'])
request.form['profile_id'] = profile_id
request.form['upgrades'] = upgrades
stool.manage_doUpgrades(request)
self.assertEqual(stool.getLastVersionForProfile(profile_id),
('2', '2'))
newSecurityManager(None, UnrestrictedUser('god', '', ['Manager'], ''))
setSite(self.app.site)
expected_export = self.app.site.portal_setup.runAllExportSteps()
setSite(oldsite)
upgraded_export = stool.runAllExportSteps()
expected = TarballImportContext(stool, expected_export['tarball'])
upgraded = TarballImportContext(stool, upgraded_export['tarball'])
diff = stool.compareConfigurations(upgraded, expected)
self.assertEqual(diff, '', diff)
def _setup(app, site=None):
"""Set up our environment.
Create a request, log in as admin and set the traversal hooks on the site.
"""
from Testing import makerequest # Do not import this at the module level!
app = makerequest.makerequest(app)
# Login as admin
admin = app.acl_users.getUserById('admin')
if admin is None:
logger.error("No user called `admin` found in the database. "
"Use --rootpassword to create one.")
sys.exit(1)
# Wrap the admin in the right context; from inside the site if we have one
if site is not None:
admin = admin.__of__(site.acl_users)
site = app[site.getId()]
else:
admin = admin.__of__(app.acl_users)
newSecurityManager(None, admin)
# Set up local site manager, skins and language
if site is not None:
setHooks()
setSite(site)
site.setupCurrentSkin(site.REQUEST)
site.REQUEST['HTTP_ACCEPT_LANGUAGE'] = site.Language()
return (app, site)
def test_UnIndex(self):
""" Setup a catalog deeper within the containment hierarchy
and call the updateIndexes method. The indexed objects should should
be restricted to the sublocations.
"""
from zope.catalog.catalog import indexDocSubscriber
from zope.catalog.catalog import unindexDocSubscriber
from zope.container.contained import ObjectAddedEvent
from zope.container.contained import ObjectRemovedEvent
ob = Stub()
self.subfolder['ob'] = ob
id = self.utility.register(ob)
setSite(self.subfolder)
res = self.cat.searchResults(name='ob')
self.assertEqual(len(res), 0)
setSite(None)
indexDocSubscriber(ObjectAddedEvent(ob))
setSite(self.subfolder)
res = self.cat.searchResults(name='ob')
self.assertEqual(len(res), 1)
setSite(None)
unindexDocSubscriber(ObjectRemovedEvent(ob))
setSite(self.subfolder)
res = self.cat.searchResults(name='ob')
self.assertEqual(len(res), 0)
def CMFDefaultPortal(db=None, connection=None, environ=None):
"""Context manager for working with the Plone portal during layer setup::
with CMFDefaultPortal() as portal:
...
This is based on the ``z2.zopeApp()`` context manager. See the module
``plone.testing.z2`` for details.
Do not use this in a test. Use the 'portal' resource from the PloneFixture
layer instead!
Pass a ZODB handle as ``db`` to use a specificdatabase. Alternatively,
pass an open connection as ``connection`` (the connection will not be
closed).
"""
from zope.site.hooks import setSite, getSite, setHooks
setHooks()
site = getSite()
with z2.zopeApp(db, connection, environ) as app:
portal = app[SITE_ID]
setSite(portal)
z2.login(portal['acl_users'], TEST_USER_ID)
try:
yield portal
finally:
z2.logout()
if site is not portal:
setSite(site)
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 pushGlobalRegistry(portal, new=None, name=None):
"""Set a new global component registry that uses the current registry as
a base. If you use this, you *must* call ``popGlobalRegistry()`` to
restore the original state.
If ``new`` is not given, a new registry is created. If given, you must
provide a ``zope.component.globalregistry.BaseGlobalComponents`` object.
Returns the new registry.
Also ensure that the persistent component registry at ``portal`` has the
new global registry as its base.
"""
from zope.site.hooks import setSite, getSite, setHooks
site = getSite()
localSiteManager = portal.getSiteManager()
current = zca.pushGlobalRegistry(new=new)
if current not in localSiteManager.__bases__:
localSiteManager.__bases__ = (current, )
if site is not None:
setHooks()
setSite(site)
return current
def wrapped_func(*args, **kw):
sm, site = getSecurityManager(), getSite()
try:
return func(*args, **kw)
finally:
setSecurityManager(sm)
setSite(site)
def testUpgradeAllProposed(self):
request = self.app.REQUEST
oldsite = getattr(self.app, self._SITE_ID)
stool = oldsite.portal_setup
profile_id = 'Products.CMFDefault:default'
upgrades = []
for upgrade_info in stool.listUpgrades(profile_id):
if isinstance(upgrade_info, list):
for info in upgrade_info:
if info['proposed']:
upgrades.append(info['id'])
continue
if upgrade_info['proposed']:
upgrades.append(upgrade_info['id'])
request.form['profile_id'] = profile_id
request.form['upgrades'] = upgrades
stool.manage_doUpgrades(request)
self.assertEqual(stool.getLastVersionForProfile(profile_id),
('2', '2'))
newSecurityManager(None, UnrestrictedUser('god', '', ['Manager'], ''))
setSite(self.app.site)
expected_export = self.app.site.portal_setup.runAllExportSteps()
setSite(oldsite)
upgraded_export = stool.runAllExportSteps()
expected = TarballImportContext(stool, expected_export['tarball'])
upgraded = TarballImportContext(stool, upgraded_export['tarball'])
diff = stool.compareConfigurations(upgraded, expected)
self.assertEqual(diff, '', diff)
def setUp(self):
portal = self.layer['portal']
setSite(portal)
self.portal = portal
self.qi = getattr(self.portal, 'portal_quickinstaller')
self.st = getattr(self.portal, 'portal_setup')
self.setUpUser()
def run_ddl_as_script():
parser = setup_parser()
options, args = parser.parse_args()
if len(args) != 1:
parser.print_help()
sys.exit(1)
return
instance_path = args[0]
global app
# Enable Faux HTTP request object
app = spoof_request(app)
# Get Plone site object from Zope application server root
site = app.unrestrictedTraverse(instance_path)
setHooks()
setSite(site)
site.setupCurrentSkin(app.REQUEST)
# Load portal types with enabled IMirroredContent behavior
loader.load_models(site)
if options.drop:
schema.metadata.drop_all()
if not options.no_create:
schema.metadata.create_all()
def setUp(self):
portal = self.layer['portal']
self.request = self.layer['app'].REQUEST
setSite(portal)
self.portal = portal
self.setUpUser()
self.setUpContent()
def pushGlobalRegistry(portal, new=None, name=None):
"""Set a new global component registry that uses the current registry as
a base. If you use this, you *must* call ``popGlobalRegistry()`` to
restore the original state.
If ``new`` is not given, a new registry is created. If given, you must
provide a ``zope.component.globalregistry.BaseGlobalComponents`` object.
Returns the new registry.
Also ensure that the persistent component registry at ``portal`` has the
new global registry as its base.
"""
from zope.site.hooks import setSite, getSite, setHooks
site = getSite()
localSiteManager = portal.getSiteManager()
current = zca.pushGlobalRegistry(new=new)
if current not in localSiteManager.__bases__:
localSiteManager.__bases__ = (current, )
if site is not None:
setHooks()
setSite(site)
return current
def setUp(self):
portal = self.layer['portal']
setSite(portal)
self.portal = portal
self.st = getattr(self.portal, 'portal_setup')
self.base_path = os.path.dirname(i18n.__file__)
self.setUpUser()
def enableZope3Site(context):
portal = getToolByName(context, 'portal_url').getPortalObject()
if not ISite.providedBy(portal):
make_objectmanager_site(portal)
logger.info('Made the portal a Zope3 site.')
try:
components = portal.getSiteManager()
except ComponentLookupError:
next = find_next_sitemanager(portal)
if next is None:
next = base
name = '/'.join(portal.getPhysicalPath())
components = PersistentComponents(name, (next,))
components.__parent__ = portal
portal.setSiteManager(components)
logger.info("Site manager '%s' added." % name)
else:
if components.utilities.LookupClass != FiveVerifyingAdapterLookup:
# for CMF 2.1 beta instances
components.__parent__ = portal
components.utilities.LookupClass = FiveVerifyingAdapterLookup
components.utilities._createLookup()
components.utilities.__parent__ = components
logger.info('LookupClass replaced.')
# Make sure to set the new site as the new active one
setSite(portal)
def setUp(self):
portal = self.layer['portal']
setSite(portal)
self.portal = portal
self.registry = getattr(self.portal, 'portal_registry')
self.ct = getattr(self.portal, 'portal_catalog')
self.prefix = 'plone.app.querystring.field.skos'
self.setUpUser()
def setUp(self):
portal = self.layer['portal']
setSite(portal)
self.portal = portal
self.registry = getattr(self.portal, 'portal_registry')
self.ct = getattr(self.portal, 'portal_catalog')
self.prefix = 'plone.app.querystring.field.skos'
self.setUpUser()
def setUp(self):
portal = self.layer['portal']
setSite(portal)
self.portal = portal
self.qi = getattr(self.portal, 'portal_quickinstaller')
self.wt = getattr(self.portal, 'portal_workflow')
self.st = getattr(self.portal, 'portal_setup')
self.setUpUser()
def afterSetUp(self):
setHooks()
setSite(self.portal)
self.setRoles(('Manager', ))
portal_setup = self.portal.portal_setup
# wait a bit or we get duplicate ids on import
time.sleep(0.2)
portal_setup.runAllImportStepsFromProfile('profile-plone.app.portlets:z3ctesting')
def export(self):
oldsite = getattr(self.app, self.site_id)
setSite(oldsite)
stool = oldsite.portal_setup
upgraded_export = stool.runAllExportSteps()
upgraded = TarballImportContext(stool, upgraded_export['tarball'])
return stool.compareConfigurations(upgraded, self.expected)
def afterSetUp(self):
setSite(self.app.site)
self.app.site.setupCurrentSkin(self.app.REQUEST)
newSecurityManager(None, UnrestrictedUser('god', '', ['Manager'], ''))
# sessioning setup
sdm = self.app.session_data_manager
self.app.REQUEST.set_lazy('SESSION', sdm.getSessionData)
def migrate(self):
oldsite = getattr(self.app, self.site_id)
mig = oldsite.portal_migration
components = getattr(oldsite, '_components', None)
if components is not None:
setSite(oldsite)
result = mig.upgrade(swallow_errors=False)
return (oldsite, result)
def setUp(self):
portal = self.layer['portal']
setSite(portal)
self.portal = portal
self.qi = api.portal.get_tool('portal_quickinstaller')
self.wt = api.portal.get_tool('portal_workflow')
self.st = api.portal.get_tool('portal_setup')
self.setUpUser()
def migrate(self):
oldsite = getattr(self.app, self.site_id)
mig = oldsite.portal_migration
components = getattr(oldsite, '_components', None)
if components is not None:
setSite(oldsite)
result = mig.upgrade(swallow_errors=False)
return (oldsite, result)
def export(self):
oldsite = getattr(self.app, self.site_id)
setSite(oldsite)
stool = oldsite.portal_setup
upgraded_export = stool.runAllExportSteps()
upgraded = TarballImportContext(stool, upgraded_export['tarball'])
return stool.compareConfigurations(upgraded, self.expected)
def afterSetUp(self):
setHooks()
setSite(self.portal)
self.manager = getUtility(IPortletManager, name=u'plone.leftcolumn')
self.cat = self.manager[USER_CATEGORY]
self.cat[user_name] = PortletAssignmentMapping(manager=u'plone.leftcolumn',
category=USER_CATEGORY,
name=user_name)
def afterSetUp(self):
setHooks()
setSite(self.portal)
self.setRoles(('Manager'), )
self.portal.invokeFactory('Document', 'doc1')
self.portal.invokeFactory('Document', 'doc2')
self.portal.portal_membership.getMemberById('test_user_1_').setMemberProperties(
{'fullname': 'Test user'})
def addPloneSite(context,
site_id,
title='Plone site',
description='',
create_userfolder=True,
email_from_address='',
email_from_name='',
validate_email=True,
profile_id=_DEFAULT_PROFILE,
snapshot=False,
extension_ids=(),
base_contenttypes_profile=_ATCONTENTTYPES_PROFILE,
setup_content=True,
default_language='en'):
"""Add a PloneSite to the context."""
context._setObject(site_id, PloneSite(site_id))
site = context._getOb(site_id)
site.setLanguage(default_language)
site[_TOOL_ID] = SetupTool(_TOOL_ID)
setup_tool = site[_TOOL_ID]
notify(SiteManagerCreatedEvent(site))
setSite(site)
setup_tool.setBaselineContext('profile-%s' % profile_id)
setup_tool.runAllImportStepsFromProfile('profile-%s' % profile_id)
if base_contenttypes_profile is not None \
and base_contenttypes_profile in _CONTENTTYPES_PROFILES:
profile = 'profile-%s' % base_contenttypes_profile
setup_tool.runAllImportStepsFromProfile(profile)
# Only set up content if a base contenttypes profile has been provided.
if setup_content:
if base_contenttypes_profile == _ATCONTENTTYPES_PROFILE:
content_profile = _AT_CONTENT_PROFILE
else:
content_profile = _DEX_CONTENT_PROFILE
setup_tool.runAllImportStepsFromProfile('profile-%s' %
content_profile)
props = dict(
title=title,
description=description,
email_from_address=email_from_address,
email_from_name=email_from_name,
validate_email=validate_email,
)
# Do this before applying extension profiles, so the settings from a
# properties.xml file are applied and not overwritten by this
site.manage_changeProperties(**props)
for extension_id in extension_ids:
setup_tool.runAllImportStepsFromProfile('profile-%s' % extension_id)
if snapshot is True:
setup_tool.createSnapshot('initial_configuration')
return site
def pushGlobalRegistry(new=None):
"""Set a new global component registry that uses the current registry as
a a base. If you use this, you *must* call ``popGlobalRegistry()`` to
restore the original state.
If ``new`` is not given, a new registry is created. If given, you must
provide a ``zope.component.globalregistry.BaseGlobalComponents`` object.
Returns the new registry.
"""
from zope.component import globalregistry
# Save the current top of the stack in a registry
current = globalregistry.base
# The first time we're called, we need to put the default global
# registry at the bottom of the stack, and then patch the class to use
# the stack for loading pickles. Otherwise, we end up with POSKey and
# pickling errors when dealing with persistent registries that have the
# global registry (globalregistry.base) as a base
if len(_REGISTRIES) == 0:
_REGISTRIES.append(current)
globalregistry.BaseGlobalComponents._old__reduce__ = (
globalregistry.BaseGlobalComponents.__reduce__)
globalregistry.BaseGlobalComponents.__reduce__ = (lambda self:
(loadRegistry,
(self.__name__, )))
if new is None:
name = 'test-stack-%d' % len(_REGISTRIES)
new = globalregistry.BaseGlobalComponents(name=name, bases=(current, ))
logger.debug("New component registry: %s based on %s", name,
current.__name__)
else:
logger.debug("Push component registry: %s", new.__name__)
_REGISTRIES.append(new)
# Monkey patch this into the three (!) places where zope.component
# references it as a module global variable
_hookRegistry(new)
# Reset the site manager hook so that getSiteManager() returns the base
# again
from zope.component import getSiteManager
getSiteManager.reset()
try:
from zope.site.hooks import setSite, setHooks
except ImportError:
pass
else:
setSite()
setHooks()
return new
def setUp(self):
portal = self.layer['portal']
self.request = self.layer['app'].REQUEST
setSite(portal)
self.portal = portal
self.fti = add_folder_type(self.portal)
self.setUpUser()
self.portal.invokeFactory('folder', 'folder')
self.setUpContent()
def afterSetUp(self):
setHooks()
setSite(self.portal)
self.setRoles(('Manager', ))
portal_setup = self.portal.portal_setup
# wait a bit or we get duplicate ids on import
time.sleep(0.2)
portal_setup.runAllImportStepsFromProfile(
'profile-plone.app.portlets:z3ctesting')
def addPloneSite(context,
site_id,
title='Plone site',
description='',
profile_id=_DEFAULT_PROFILE,
content_profile_id=_CONTENT_PROFILE,
snapshot=False,
extension_ids=(),
setup_content=True,
default_language='en',
portal_timezone='UTC'):
"""Add a PloneSite to the context."""
context._setObject(site_id, PloneSite(site_id))
site = context._getOb(site_id)
site.setLanguage(default_language)
# Set the accepted language for the rest of the request. This makes sure
# the front-page text gets the correct translation also when your browser
# prefers non-English and you choose English as language for the Plone
# Site.
request = context.REQUEST
request['HTTP_ACCEPT_LANGUAGE'] = default_language
site[_TOOL_ID] = SetupTool(_TOOL_ID)
setup_tool = site[_TOOL_ID]
notify(SiteManagerCreatedEvent(site))
setSite(site)
setup_tool.setBaselineContext('profile-%s' % profile_id)
setup_tool.runAllImportStepsFromProfile('profile-%s' % profile_id)
reg = queryUtility(IRegistry, context=site)
reg['plone.portal_timezone'] = portal_timezone
reg['plone.available_timezones'] = [portal_timezone]
reg['plone.default_language'] = default_language
reg['plone.available_languages'] = [default_language]
if setup_content:
setup_tool.runAllImportStepsFromProfile('profile-%s' %
content_profile_id)
props = dict(
title=title,
description=description,
)
# Do this before applying extension profiles, so the settings from a
# properties.xml file are applied and not overwritten by this
site.manage_changeProperties(**props)
for extension_id in extension_ids:
setup_tool.runAllImportStepsFromProfile('profile-%s' % extension_id)
if snapshot is True:
setup_tool.createSnapshot('initial_configuration')
return site
def __init__(self, portal, admin):
root = makerequest.makerequest(app)
self.portal = getattr(root, portal, None)
admin = root.acl_users.getUserById(admin)
admin = admin.__of__(self.portal.acl_users)
newSecurityManager(None, admin)
setHooks()
setSite(self.portal)
self.portal.setupCurrentSkin(self.portal.REQUEST)
def afterSetUp(self):
site = self.app.site
setSite(site)
site.setupCurrentSkin(self.app.REQUEST)
site.acl_users._doAddUser('god', 'secret', ['Manager'], [])
user = site.acl_users.getUser('god').__of__(site.acl_users)
newSecurityManager(None, user)
# sessioning setup
sdm = self.app.session_data_manager
self.app.REQUEST.set_lazy('SESSION', sdm.getSessionData)
def testSetUp(self):
super(SilvaLayer, self).testSetUp()
# Get the Silva Root and set it as a local site
app = super(SilvaLayer, self).get_application()
self._silva_root = app.root
setSite(self._silva_root)
setHooks()
# List of created browsers
self._browsers = []
def testTearDown(self):
self.loginAsPortalOwner()
if 'test-folder' in self['portal'].objectIds():
self['portal'].manage_delObjects('test-folder')
# Set up the local site manager
from zope.site.hooks import setSite
setSite(self['portal'])
self['portal'].portal_membership.deleteMembers([PLONE_MANAGER_NAME])
self.setRoles()
self.login()
super(IntegrationTesting, self).testTearDown()
def setUp(self):
provideAdapter(SharingXMLAdapter, name='plone.app.workflow.sharing')
site = Folder('plone')
make_objectmanager_site(site)
setHooks()
setSite(site)
sm = getSiteManager()
self.site = site
self.sm = sm
