def setUp(self):
self.app = self.layer['app']
self.request = self.layer['request']
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(self.app)
self.browser.handleErrors = False
# we have to create a user on the zope root. this just does not work
# with plone.app.testing and TEST_USER or SITE_OWNER
self.app.acl_users.userFolderAddUser('app', 'secret', ['Manager'], [])
from plone.testing import z2
z2.login(self.app['acl_users'], 'app')
import transaction
transaction.commit()
self.browser.addHeader('Authorization',
'Basic %s:%s' % ('app', 'secret'))
self.site_administrator_browser = Browser(self.app)
self.site_administrator_browser.handleErrors = False
self.site_administrator_browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
def login(self, id=None):
if not id:
id = TEST_USER_NAME
try:
z2.login(self['app']['acl_users'], id)
except:
z2.login(self['portal']['acl_users'], id)
def setUp(self):
"""Login as manager."""
super(TestPortlet, self).setUp()
z2.login(self.app['acl_users'], 'admin')
self.addPythonScript('first', u'First', 'return []')
self.addPythonScript('second', u'Second', 'return []')
self.addPythonScript('third', u'Third', u"""
from Products.CMFCore.utils import getToolByName
portal_catalog = getToolByName(context, 'portal_catalog')
return portal_catalog()""")
self.addPythonScript('fourth', u'Fourth', u"""
from Products.CMFCore.utils import getToolByName
portal_catalog = getToolByName(context, 'portal_catalog')
return {'results':portal_catalog(), 'text':'Additional text', 'icon_url': '/link/to/icon.png'}
""")
manager = IPythonScriptManager(self.portal)
manager.rescanScripts()
manager.enableScript('/plone/second')
manager.enableScript('/plone/third')
manager.enableScript('/plone/fourth')
self.portal.invokeFactory("Folder", "folder")
folder = self.portal.folder
folder.setTitle(u'Folder')
folder.invokeFactory("Folder", "subfolder")
subfolder = folder.subfolder
subfolder.setTitle(u'Subfolder')
subfolder.invokeFactory("Document", "doc")
doc = subfolder.doc
doc.setTitle(u'Document')
def test_FormulaValidator(self):
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
interim_fields = [{'keyword': 'TV', 'title':'Titration Volume', 'unit':'','default':''},
{'keyword': 'TF', 'title':'Titration Factor', 'unit':'','default':''}]
calcs = self.portal.bika_setup.bika_calculations
calcs.invokeFactory('Calculation', 'calc_1', title='Titration', InterimFields=interim_fields)
calcs.calc_1.processForm()
formula = "%(TV)f * %(TF)f * %(Ash)f * %(Wrong)f"
self.portal.REQUEST.form['InterimFields'] = interim_fields
self.portal.REQUEST.form['Formula'] = formula
self.assertEqual(calcs.titration.schema.get('Formula').validate(formula, calcs.titration, REQUEST=self.portal.REQUEST),
"Validation failed: Keyword 'Wrong' is invalid.")
formula = "%(TV)f * %(TF)f * %(Ash)f"
self.portal.REQUEST.form['InterimFields'] = interim_fields
self.portal.REQUEST.form['Formula'] = formula
self.assertEqual(None, calcs.titration.schema.get('Formula').validate(formula, calcs.titration, REQUEST=self.portal.REQUEST))
formula = "[TV] * [TF] * [Ash]"
self.portal.REQUEST.form['InterimFields'] = interim_fields
self.portal.REQUEST.form['Formula'] = formula
self.assertEqual(None, calcs.titration.schema.get('Formula').validate(formula, calcs.titration, REQUEST=self.portal.REQUEST))
def test_save_attendees(self):
""" """
portal = self.layer['portal']
app = self.layer['app']
z2.login(app['acl_users'], SITE_OWNER_NAME)
self.register_users()
event = self._create_event()
storage = IAttendeesStorage(event)
self.assertFalse(hasattr(storage, 'internal_attendees'))
self.assertFalse(hasattr(storage, 'external_attendees'))
self.assertFalse(hasattr(storage, 'groups'))
data = {
'internal_attendees': ['max-musterman', 'john-doe','Administrators'],
'external_attendees': [{'name':'John Smith',
'email':'*****@*****.**',}],
}
utils.save_attendees(event, data)
self.assertTrue(hasattr(storage, 'internal_attendees'))
self.assertTrue(hasattr(storage, 'external_attendees'))
self.assertTrue(hasattr(storage, 'groups'))
self.assertEqual(storage.internal_attendees, [
{'attending': None, 'id': 'max-musterman', 'name': 'Max Musterman', 'email': '*****@*****.**'},
{'attending': None, 'id': 'john-doe', 'name': 'John Doe', 'email': '*****@*****.**'}])
self.assertEqual(storage.external_attendees, [
{'name': 'John Smith', 'email': '*****@*****.**'}])
self.assertEqual(storage.groups, [
{'attending': {'Maybe': [], 'Yes': [], 'No': []}, 'name': 'Administrators'}])
def test_confirmation(self):
portal = self.layer['portal']
app = self.layer['app']
z2.login(app['acl_users'], SITE_OWNER_NAME)
self.register_users()
event = self._create_event()
data = {
'internal_attendees': ['max-musterman', 'john-doe','Administrators', 'Reviewers'],
'external_attendees': [{'name':'John Smith',
'email':'*****@*****.**',}],
}
utils.save_attendees(event, data)
storage = IAttendeesStorage(event)
login(portal, 'max-musterman')
utils.save_confirmation(event, 'Yes')
usernames = [i['id'] for i in storage.internal_attendees]
self.assertTrue('max-musterman' in usernames)
self.assertEqual(
storage.internal_attendees[usernames.index('max-musterman')]['attending'],
'Yes')
self.assertEqual(utils.get_confirmation(event), 'Yes')
utils.save_confirmation(event, 'No')
self.assertEqual(utils.get_confirmation(event), 'No')
utils.save_confirmation(event, 'Maybe')
self.assertEqual(utils.get_confirmation(event), 'Maybe')
login(portal, 'john-doe')
utils.save_confirmation(event, 'Maybe')
self.assertEqual(utils.get_confirmation(event), 'Maybe')
utils.save_confirmation(event, 'No')
self.assertEqual(utils.get_confirmation(event), 'No')
def setUp(self):
self.app = self.layer['app']
self.request = self.layer['request']
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(self.app)
self.browser.handleErrors = False
# we have to create a user on the zope root. this just does not work
# with plone.app.testing and TEST_USER or SITE_OWNER
self.app.acl_users.userFolderAddUser('app', 'secret', ['Manager'], [])
from plone.testing import z2
z2.login(self.app['acl_users'], 'app')
import transaction
transaction.commit()
self.browser.addHeader(
'Authorization',
'Basic %s:%s' % ('app', 'secret')
)
self.site_administrator_browser = Browser(self.app)
self.site_administrator_browser.handleErrors = False
self.site_administrator_browser.addHeader(
'Authorization',
'Basic %s:%s' % (TEST_USER_NAME, TEST_USER_PASSWORD,)
)
def setUpPloneSite(self, portal):
app = portal.aq_parent
login(app['acl_users'], 'admin')
# import old ZEXP
try:
path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
'data', 'test-full.zexp')
app._importObjectFromFile(path, verify=0)
except:
logger.exception('Failed to import ZEXP from old site.')
else:
# run upgrades
self['portal'] = portal = app.test
setSite(portal)
try:
# for 5.2 we need tools as utilities
loadMigrationProfile(
portal.portal_setup,
'profile-plone.app.upgrade.v52:to52alpha1',
steps=['componentregistry'])
except KeyError:
pass
portal.portal_migration.upgrade(swallow_errors=False)
setSite(None)
def applyProfile(portal, profileName, purge_old=None,
ignore_dependencies=False, archive=None,
blacklisted_steps=None):
"""Install an extension profile into the portal. The profile name
should be a package name and a profile name, e.g. 'my.product:default'.
"""
from Acquisition import aq_parent
from AccessControl import getSecurityManager
from AccessControl.SecurityManagement import setSecurityManager
sm = getSecurityManager()
app = aq_parent(portal)
z2.login(app['acl_users'], SITE_OWNER_NAME)
try:
setupTool = portal['portal_setup']
profileId = 'profile-{0}'.format(profileName)
setupTool.runAllImportStepsFromProfile(
profileId,
purge_old=purge_old,
ignore_dependencies=ignore_dependencies,
archive=archive,
blacklisted_steps=blacklisted_steps)
portal.clearCurrentSkin()
portal.setupCurrentSkin(portal.REQUEST)
finally:
setSecurityManager(sm)
def applyProfile(portal, profileName, purge_old=None,
ignore_dependencies=False, archive=None,
blacklisted_steps=None):
"""Install an extension profile into the portal. The profile name
should be a package name and a profile name, e.g. 'my.product:default'.
"""
from Acquisition import aq_parent
from AccessControl import getSecurityManager
from AccessControl.SecurityManagement import setSecurityManager
sm = getSecurityManager()
app = aq_parent(portal)
z2.login(app['acl_users'], SITE_OWNER_NAME)
try:
setupTool = portal['portal_setup']
profileId = 'profile-%s' % (profileName, )
setupTool.runAllImportStepsFromProfile(
profileId,
purge_old=purge_old,
ignore_dependencies=ignore_dependencies,
archive=archive,
blacklisted_steps=blacklisted_steps)
portal.clearCurrentSkin()
portal.setupCurrentSkin(portal.REQUEST)
finally:
setSecurityManager(sm)
def test_migration_preserves_references(self):
portal = self.layer['portal']
z2.login(portal['acl_users'], 'manager')
portal.invokeFactory("Child Folder", "cf1")
cf1 = portal.cf1
cf1.setTitle("CF 1")
make_objectmanager_site(cf1)
pw = portal.portal_workflow
pw.doActionFor(cf1, "publish")
self.failUnless(cf1.Title() == "CF 1")
self.failUnless(pw.getInfoFor(cf1, "review_state") == "published")
self.failUnless(ISite.providedBy(cf1))
cf1.invokeFactory("Document", "doc1", Title="Doc 1")
doc1 = cf1["doc1"]
cf1.setDefaultPage("doc1")
doc2_text = (
'<p><a href="resolveuid/%s" class="internal">Link to doc 1'
'</a></p>') % doc1.UID()
cf1.invokeFactory("Document", "doc2", Title="Doc 2", text=doc2_text)
doc2 = cf1["doc2"]
# I'm not sure what layer of Plone code adds these
doc2.addReference(doc1, 'isReferencing', updateReferences=True)
self.assertEquals(
len(doc2._getReferenceAnnotations().objectItems()), 1)
self.run_migration_step()
cf1 = portal.cf1
doc2 = cf1["doc2"]
self.assertEquals(
len(doc2._getReferenceAnnotations().objectItems()), 1)
def quickInstallProduct(portal, productName, reinstall=False):
"""Install a product using the ``portal_quickinstaller`` tool. If
``reinstall`` is false and the product is already installed, do nothing.
If ``reinstall`` is true, perform an explicit reinstall if the product
is installed already.
"""
from Acquisition import aq_parent
from AccessControl import getSecurityManager
from AccessControl.SecurityManagement import setSecurityManager
sm = getSecurityManager()
app = aq_parent(portal)
z2.login(app['acl_users'], SITE_OWNER_NAME)
try:
quickinstaller = portal['portal_quickinstaller']
if quickinstaller.isProductInstalled(productName):
if reinstall:
quickinstaller.reinstallProducts([productName])
else:
quickinstaller.installProduct(productName)
portal.clearCurrentSkin()
portal.setupCurrentSkin(portal.REQUEST)
finally:
setSecurityManager(sm)
def setUpPloneSite(self, portal):
from Products.CMFPlone import factory
self.applyProfile(portal, factory._DEFAULT_PROFILE)
self.applyProfile(portal, factory._CONTENT_PROFILE)
getToolByName(portal, 'portal_css').setDebugMode(True)
getToolByName(portal, 'portal_javascripts').setDebugMode(True)
# Creates a user's home folder.
membership = getToolByName(portal, 'portal_membership')
if not membership.getMemberareaCreationFlag():
membership.setMemberareaCreationFlag()
membership.createMemberArea(testing.TEST_USER_ID)
if membership.getMemberareaCreationFlag():
membership.setMemberareaCreationFlag()
folder = membership.getHomeFolder(testing.TEST_USER_ID)
# Allow normal users to add collections.
portal.manage_permission(
'Add portal topics', roles=['Member', 'Manager'],
acquire=0)
self.applyProfile(portal, 'collective.formcriteria:default')
self.applyProfile(portal, 'collective.formcriteria:testing')
z2.login(portal.getPhysicalRoot().acl_users, testing.SITE_OWNER_NAME)
getToolByName(portal, 'portal_workflow').doActionFor(folder, 'publish')
z2.logout()
def setUpDefaultContent(self, app):
"""Add the site owner user to the root user folder and log in as that
user. Create the Silva site.
Note: There is no explicit tear-down of this setup operation, because
all persistent changes are torn down when the stacked ZODB
``DemoStorage`` is popped.
"""
# Create the owner user and "log in" so that the site object gets
# the right ownership information
app['acl_users'].userFolderAddUser(
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
['Manager'],
[]
)
z2.login(app['acl_users'], SITE_OWNER_NAME)
from Products.Silva.Root import manage_addRoot
manage_addRoot(
app, SILVA_SITE_ID,
title=SILVA_SITE_TITLE,
)
# Log out again
z2.logout()
def quickInstallProduct(portal, productName, reinstall=False):
"""Install a product using the ``portal_quickinstaller`` tool. If
``reinstall`` is false and the product is already installed, do nothing.
If ``reinstall`` is true, perform an explicit reinstall if the product
is installed already.
"""
from Acquisition import aq_parent
from AccessControl import getSecurityManager
from AccessControl.SecurityManagement import setSecurityManager
sm = getSecurityManager()
app = aq_parent(portal)
z2.login(app['acl_users'], SITE_OWNER_NAME)
try:
quickinstaller = portal['portal_quickinstaller']
if quickinstaller.isProductInstalled(productName):
if reinstall:
quickinstaller.reinstallProduct([productName])
else:
quickinstaller.installProduct(productName)
portal.clearCurrentSkin()
portal.setupCurrentSkin(portal.REQUEST)
finally:
setSecurityManager(sm)
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 login(self, id=None):
if not id:
id = TEST_USER_NAME
try:
z2.login(self["app"]["acl_users"], id)
except:
z2.login(self["portal"]["acl_users"], id)
def test_InterimFieldsValidator(self):
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
calcs = self.portal.bika_setup.bika_calculations
interim_fields = [{'keyword': 'T V', 'title':'Titration Volume', 'unit':'','default':''},]
self.portal.REQUEST.form['InterimFields'] = interim_fields
self.assertEqual(calcs.titration.schema.get('InterimFields').validate(interim_fields, calcs.titration, REQUEST=self.portal.REQUEST),
"Validation failed: keyword contains invalid characters.")
interim_fields = [{'keyword': 'TV', 'title':'Titration Volume', 'unit':'','default':''},
{'keyword': 'TV', 'title':'Titration Volume 2', 'unit':'','default':''}]
self.portal.REQUEST.form['InterimFields'] = interim_fields
self.assertEqual(calcs.titration.schema.get('InterimFields').validate(interim_fields, calcs.titration, REQUEST=self.portal.REQUEST),
"Validation failed: 'TV': duplicate keyword.")
interim_fields = [{'keyword': 'TV', 'title':'Titration Volume', 'unit':'','default':''},
{'keyword': 'TF', 'title':'Titration Volume', 'unit':'','default':''}]
self.portal.REQUEST.form['InterimFields'] = interim_fields
self.assertEqual(calcs.titration.schema.get('InterimFields').validate(interim_fields, calcs.titration, REQUEST=self.portal.REQUEST),
"Validation failed: 'Titration Volume': duplicate title.")
interim_fields = [{'keyword': 'TV', 'title':'Titration Volume', 'unit':'','default':''},
{'keyword': 'TF', 'title':'Titration Factor', 'unit':'','default':''},
{'keyword': 'Ash', 'title':'Temp', 'unit':'','default':''}]
self.portal.REQUEST.form['InterimFields'] = interim_fields
self.assertEqual(calcs.titration.schema.get('InterimFields').validate(interim_fields, calcs.titration, REQUEST=self.portal.REQUEST),
"Validation failed: 'Ash': This keyword is used by service 'Ash'.")
interim_fields = [{'keyword': 'TV', 'title':'Titration Volume', 'unit':'','default':''},
{'keyword': 'TF', 'title':'Titration Factor', 'unit':'','default':''}]
self.portal.REQUEST.form['InterimFields'] = interim_fields
self.assertEqual(None, calcs.titration.schema.get('InterimFields').validate(interim_fields, calcs.titration, REQUEST=self.portal.REQUEST))
def setUp(self):
"""Login as manager."""
super(TestPortlet, self).setUp()
z2.login(self.app['acl_users'], 'admin')
self.addPythonScript('first', u'First', 'return []')
self.addPythonScript('second', u'Second', 'return []')
self.addPythonScript(
'third', u'Third', u"""
from Products.CMFCore.utils import getToolByName
portal_catalog = getToolByName(context, 'portal_catalog')
return portal_catalog()""")
self.addPythonScript(
'fourth', u'Fourth', u"""
from Products.CMFCore.utils import getToolByName
portal_catalog = getToolByName(context, 'portal_catalog')
return {'results':portal_catalog(), 'text':'Additional text', 'icon_url': '/link/to/icon.png'}
""")
manager = IPythonScriptManager(self.portal)
manager.rescanScripts()
manager.enableScript('/plone/second')
manager.enableScript('/plone/third')
manager.enableScript('/plone/fourth')
self.portal.invokeFactory("Folder", "folder")
folder = self.portal.folder
folder.setTitle(u'Folder')
folder.invokeFactory("Folder", "subfolder")
subfolder = folder.subfolder
subfolder.setTitle(u'Subfolder')
subfolder.invokeFactory("Document", "doc")
doc = subfolder.doc
doc.setTitle(u'Document')
def login(self, user):
if user == 'admin':
acl = self.app['acl_users']
else:
acl = self.portal['acl_users']
z2.login(acl, user)
self.current_user = user
def setUp(self):
self.app = self.layer["app"]
self.portal = self.layer["portal"]
self.request = self.layer["request"]
z2.login(self.app["acl_users"], SITE_OWNER_NAME)
self.user1 = api.user.create(email="*****@*****.**", username="******", password="******")
self.workspace = api.content.create(container=self.portal, type="Workspace", id="a-workspace")
self.ws = IWorkspace(self.workspace)
def setUp(self):
self.portal = self.layer['portal']
z2.login(self.portal['acl_users'], 'contributor')
self.portal.invokeFactory('Folder', 'site1')
zope.component.provideUtility(p4a.subtyper.engine.Subtyper())
self.subtyper = zope.component.getUtility(
p4a.subtyper.interfaces.ISubtyper)
self.catalog = getToolByName(self.portal, 'portal_catalog')
def getRowForm(self):
from collective.excelimportexport.sheet import WorkbookForm
request = self.portal.REQUEST.clone()
interface.alsoProvides(request, z3cform_ifaces.IPloneFormLayer)
book_form = WorkbookForm(self.portal, request)
book_form.update()
book_form.updateSheet(self.sheet)
z2.login(self.layer['app']['acl_users'], pa_testing.SITE_OWNER_NAME)
return book_form.getRowForm(self.row)
def test_UniqueFieldValidator(self):
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
clients = self.portal.clients
clients.invokeFactory('Client', 'client_2')
clients.client_2.processForm()
self.assertEqual(clients.client_2.schema.get('title').validate('Client', clients.client_2),
"Validation failed: 'Client' is in use.")
self.assertEqual(None, clients.client_2.schema.get('title').validate('Another Client', clients.client_2))
def test_group_name_doesnt_link_to_prefs_for_reviewer(self):
""" Make sure that for admins group name links to group prefs """
z2.login(self.portal['acl_users'], 'testreviewer')
request = self.app.REQUEST
request.form['search_term'] = 'testgroup'
view = getMultiAdapter((self.portal, request), name='sharing')
self.assertNotIn('<a href="http://nohost/plone/'
'@@usergroup-groupmembership?groupname=testgroup">',
view(), msg="Group name link was unexpectedly shown "
"to reviewer.")
def test_component_registry(self):
portal = self.layer['portal']
z2.login(portal['acl_users'], 'contributor')
portal.invokeFactory('Folder', 'site1')
zope.component.provideUtility(engine.Subtyper())
subtyper = zope.component.getUtility(interfaces.ISubtyper)
subtyper.change_type(
portal.site1,
u'collective.lineage.childsite')
self.failUnless(ISite.providedBy(portal.site1))
def setUpPloneSite(self, portal):
testing.login(portal, testing.TEST_USER_NAME)
membership = getToolByName(portal, 'portal_membership')
folder = membership.getHomeFolder(testing.TEST_USER_ID)
foo_topic = folder[folder.invokeFactory(
type_name='Topic', id='foo-topic-title',
title='Foo Topic Title')]
z2.login(portal.getPhysicalRoot().acl_users, testing.SITE_OWNER_NAME)
portal.portal_workflow.doActionFor(foo_topic, 'publish')
z2.logout()
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 setUp(self):
self.app = self.layer['app']
ZopeTestCase.utils.setupCoreSessions(self.app)
self.app.REQUEST['SESSION'] = Session()
self.portal = self.layer['portal']
self.browser = Browser(self.app)
z2.logout()
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
create_members_by_debug_init(self)
def setUpPloneSite(self, portal):
# base test fixture sets default chain to nothing
pwf = portal['portal_workflow']
pwf.setDefaultChain('simple_publication_workflow')
# apply configuration profile
self.applyProfile(portal, 'org.bccvl.site:default')
app = portal.getPhysicalRoot()
z2.login(app['acl_users'], SITE_OWNER_NAME)
self.addTestContent(portal)
# run all tests as our new test user
login(portal, TEST_USER_NAME)
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
z2.login(self.portal['acl_users'], 'contributor')
self.portal.invokeFactory('Folder', 'site1')
zope.component.provideUtility(p4a.subtyper.engine.Subtyper())
self.subtyper = zope.component.getUtility(
p4a.subtyper.interfaces.ISubtyper)
self.subtyper.change_type(
self.portal.site1,
u'collective.lineage.childsite')
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
self.user1 = api.user.create(email='*****@*****.**',
username='******',
password='******')
self.workspace = api.content.create(container=self.portal,
type='Workspace',
id='a-workspace')
self.ws = IWorkspace(self.workspace)
def test_group_name_doesnt_link_to_prefs_for_reviewer(self):
""" Make sure that for admins group name links to group prefs """
z2.login(self.portal['acl_users'], 'testreviewer')
request = self.app.REQUEST
request.form['search_term'] = 'testgroup'
view = getMultiAdapter((self.portal, request), name='sharing')
self.assertNotIn(
'<a href="http://nohost/plone/'
'@@usergroup-groupmembership?groupname=testgroup">',
view(),
msg="Group name link was unexpectedly shown "
"to reviewer.")
def test_extract_update_row_data(self):
"""
Process a content row into a dict for existing content.
"""
z2.login(self.layer['app']['acl_users'], pa_testing.SITE_OWNER_NAME)
foo_doc = self.portal[
self.portal.invokeFactory('Document', 'foo-document-title')]
row_form = self.assertRow()
self.skipTest('TODO add id column support for replacing content')
self.assertEqual(
row_form.context.getPhysicalPath(), foo_doc.getPhysicalPath(),
'Wrong row edit form context')
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 test_ServiceKeywordValidator(self):
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
services = self.portal.bika_setup.bika_analysisservices
services.invokeFactory('AnalysisService', 'service_2')
services.service_2.processForm()
self.assertEqual(services.service_2.schema.get('Keyword').validate('Ash', services.service_2),
"Validation failed: 'Ash': This keyword is used by service 'Ash'.")
self.assertEqual(services.service_2.schema.get('Keyword').validate('TV', services.service_2),
"Validation failed: 'TV': This keyword is used by calculation 'Titration'.")
self.assertEqual(None, services.service_2.schema.get('Keyword').validate('ValidKeyword', services.service_2))
def setUpPloneSite(self, portal):
# Install into Plone site using portal_setup
getToolByName(portal, 'portal_quickinstaller').installProduct(
'Products.ArchAddOn')
self.applyProfile(portal, 'Products.PloneServicesCenter:default')
# Publish the folders
z2.login(aq_parent(portal).acl_users, 'admin')
wftool = getToolByName(portal, 'portal_workflow')
for id_ in ('case-studies', 'sites', 'providers'):
wftool.doActionFor(portal.support[id_], 'publish')
z2.logout()
def setUpPloneSite(self, portal):
self.applyProfile(
portal, 'collective.formcriteria:formcriteria-columns')
z2.login(portal.getPhysicalRoot().acl_users, testing.SITE_OWNER_NAME)
membership = getToolByName(portal, 'portal_membership')
folder = membership.getHomeFolder(testing.TEST_USER_ID)
folder.manage_pasteObjects(
portal.templates.manage_copyObjects(['Topic']))
folder.manage_renameObject('Topic', 'foo-topic-title')
foo_topic = folder['foo-topic-title']
foo_topic.update(title='Foo Topic Title')
z2.logout()
def setUpPloneSite(self, portal):
# Install into Plone site using portal_setup
getToolByName(
portal,
'portal_quickinstaller').installProduct('Products.ArchAddOn')
self.applyProfile(portal, 'Products.PloneServicesCenter:default')
# Publish the folders
z2.login(aq_parent(portal).acl_users, 'admin')
wftool = getToolByName(portal, 'portal_workflow')
for id_ in ('case-studies', 'sites', 'providers'):
wftool.doActionFor(portal.support[id_], 'publish')
z2.logout()
def setUpPloneSite(self, portal):
applyProfile(portal, 'cms.policy:default')
applyProfile(portal, 'cms.theme:default')
applyProfile(portal, 'cms.db:default')
# 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)
self.portal = portal
def setUp(self):
self.app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
self.user1 = api.user.create(email='*****@*****.**',
username='******',
password='******')
self.badge = api.content.create(
container=self.portal,
type='Badge',
id='test-badge',
title='Test Badge',
)
def setUpDefaultContent(self, app):
"""Add the site owner user to the root user folder and log in as that
user. Create the Plone site, installing the extension profiles listed
in the ``extensionProfiles`` layer class variable. Create the test
user inside the site, and disable the default workflow.
Note: There is no explicit tear-down of this setup operation, because
all persistent changes are torn down when the stacked ZODB
``DemoStorage`` is popped.
"""
# Create the owner user and "log in" so that the site object gets
# the right ownership information
app['acl_users'].userFolderAddUser(
SITE_OWNER_NAME,
SITE_OWNER_PASSWORD,
['Manager'],
[]
)
z2.login(app['acl_users'], SITE_OWNER_NAME)
# Create the site with the default set of extension profiles
from Products.CMFPlone.factory import addPloneSite
addPloneSite(
app,
PLONE_SITE_ID,
title=PLONE_SITE_TITLE,
setup_content=False,
default_language=DEFAULT_LANGUAGE,
extension_ids=self.extensionProfiles,
)
# Turn off default workflow
app[PLONE_SITE_ID]['portal_workflow'].setDefaultChain('')
# Create the test user. (Plone)PAS does not have an API to create a
# user with different userid and login name, so we call the plugin
# directly.
pas = app[PLONE_SITE_ID]['acl_users']
pas.source_users.addUser(
TEST_USER_ID,
TEST_USER_NAME,
TEST_USER_PASSWORD
)
for role in TEST_USER_ROLES:
pas.portal_role_manager.doAssignRoleToPrincipal(TEST_USER_ID, role)
# Log out again
z2.logout()
def setUpPloneSite(self, portal):
app = portal.aq_parent
login(app['acl_users'], 'admin')
# import old ZEXP
path = os.path.join(os.path.abspath(
os.path.dirname(__file__)), 'data', 'test-full.zexp')
app._importObjectFromFile(path, verify=0)
# run upgrades
self['portal'] = portal = app.test
setSite(portal)
portal.portal_migration.upgrade(swallow_errors=False)
setSite(None)
def setUpPloneSite(self, portal):
applyProfile(portal, 'my315ok.products:default')
applyProfile(portal, 'xtcs.policy:default')
applyProfile(portal, 'plone.app.contenttypes:default')
#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 setUp(self):
super(TestTransmogrify, self).setUp()
self.redirector = getUtility(IRedirectionStorage)
self.app = self.layer['app']
self.portal = self.layer['portal']
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
portal_path = '/'.join(self.portal.getPhysicalPath())
self.old_path = portal_path + '/' + OLD_NAME
self.new_path = portal_path + '/' + NEW_NAME
# capture all the logs of the pipeline section
self.handler = logging.handlers.BufferingHandler(sys.maxint)
from sc.transmogrifier.sections.redirector import logger as log
log.addHandler(self.handler)
self._old_log_level = log.level
log.setLevel(1)
def test_extract_replace_row_data(self):
"""
Process a content row into a dict to replace content.
"""
z2.login(self.layer['app']['acl_users'], pa_testing.SITE_OWNER_NAME)
self.portal.invokeFactory('News Item', 'foo-document-title')
self.assertRow()
self.assertIn(
'foo-document-title', self.portal,
'Only removed existing content, should be replaced')
foo_doc = self.portal['foo-document-title']
self.skipTest('TODO add id column support for replacing content')
self.assertEqual(
foo_doc.getPortalTypeName(), self.row[0].internal_value,
'Wrong content type')
def setUp(self):
self.portal = self.layer["portal"]
self.request = self.portal.REQUEST
alsoProvides(self.request, NuPloneSkin)
z2.login(self.layer['app']['acl_users'], SITE_OWNER_NAME)
# Create two folders
self.portal.invokeFactory("Folder", "source_folder")
self.source_folder = self.portal['source_folder']
self.portal.invokeFactory("Folder", "dest_folder")
self.dest_folder = self.portal['dest_folder']
# Create an object to be copied
self.source_folder.invokeFactory("Document", "doc")
def setUpPloneSite(self, portal):
# base test fixture sets default chain to nothing
pwf = portal['portal_workflow']
pwf.setDefaultChain('simple_publication_workflow')
# use testing profile, to avoid trubles with collective.geo.mapwidget
self.applyProfile(portal, 'org.bccvl.site.tests:testing')
# FIXME: for testing we access the site via localhost,
# so we can't use the localscript extraction plugin
from Products.PluggableAuthService.interfaces.plugins import IAuthenticationPlugin
portal.acl_users.plugins.deactivatePlugin(IAuthenticationPlugin, 'localscript')
app = portal.getPhysicalRoot()
z2.login(app['acl_users'], SITE_OWNER_NAME)
self.addTestContent(portal)
# run all tests as our new test user
login(portal, TEST_USER_NAME)
def setUpPloneSite(self, portal):
applyProfile(portal, 'shuiwu.policy:default')
applyProfile(portal, 'shuiwu.baoshui: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)
# setRoles(portal, TEST_USER_ID, ('Manager',))
# login(portal, TEST_USER_NAME)
self.portal = portal
def setUpPloneSite(self, portal):
# Why the f...k do we need to run the standard workflow GS step?
setuptool = portal['portal_setup']
setuptool.runImportStepFromProfile('profile-Products.CMFPlone:plone',
'workflow',
run_dependencies=False)
applyProfile(portal, 'plone.app.contenttypes:default')
# Applying our default GS setup
applyProfile(portal, 'aws.authrss:default')
z2.login(portal.getParentNode().acl_users, SITE_OWNER_NAME)
# Enabling global site syndication
syntool = getToolByName(portal, 'portal_syndication')
syntool.editProperties(isAllowed=True)
z2.logout()
login(portal, TEST_USER_NAME)
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)
#We apply profile of addon which has no testing layer here
for profile in PROFILES:
self.applyProfile(portal, profile)
#portal.membrane_tool.user_adder = "rcse"
#portal.membrane_tool.membrane_types.append("collective.rcse.member")
#The setup unactivate source users to use CAS. because we are in test
#we just reactivate sources users
#portal.acl_users.source_users.manage_activateInterfaces([
# "IAuthenticationPlugin",
# "IUserAdderPlugin",
# "IUserEnumerationPlugin",
# "IUserIntrospection",
# "IUserManagement",
#])
# login(portal, SITE_OWNER_NAME)
self.regtool = getToolByName(portal, 'portal_registration')
self.mtool = getToolByName(portal, 'membrane_tool')
self.create_test_user(portal)
key = 'collective.rcse.security.ISecuritySettings.addGroupPermission'
portal.portal_registry[key] = "Member"
self.create_user(portal,
TEST_USER_ADMIN,
function="Admin",
first_name="admin",
last_name="rcse")
setRoles(portal, TEST_USER_ADMIN, ["Member", "Site Administrator"])
simplemember1 = self.create_user(portal,
TEST_USER_1,
first_name="User",
last_name="1")
self.create_user(portal, TEST_USER_2, first_name="User", last_name="2")
self.create_company(portal, simplemember1)
logout()
transaction.commit()
def setUp(self):
self.app = self.layer['app']
self.request = self.layer['request']
self.portal = self.layer['portal']
self.portal_url = self.portal.absolute_url()
self.browser = Browser(self.app)
self.browser.handleErrors = True
self.app.acl_users.userFolderAddUser('app', 'secret', ['Manager'], [])
from plone.testing import z2
z2.login(self.app['acl_users'], 'app')
import transaction
transaction.commit()
self.site_administrator_browser = Browser(self.app)
self.site_administrator_browser.handleErrors = False
self.site_administrator_browser.addHeader(
'Authorization', 'Basic %s:%s' % ('app', 'secret'))
def setup_profiles(self):
z2.login(self.app['acl_users'], SITE_OWNER_NAME)
self.userid1 = '*****@*****.**'
self.email1 = '*****@*****.**'
self.profile1 = api.content.create(
container=self.profiles,
type='ploneintranet.userprofile.userprofile',
id=self.userid1,
username=self.userid1,
email=self.email1,
first_name='John',
last_name='Doe',
password='******',
confirm_password='******',
)
api.content.transition(self.profile1, 'approve')
self.profile1.reindexObject()
self.member1 = api.user.get(userid=self.userid1)
self.member2 = api.user.get_current()
def test_workbook_import(self):
"""
Importing a whole workbook imports multiple sheets.
"""
self.assertNotIn(
'foo-document-title', self.portal,
'Content exists before importing')
self.assertNotIn(
'bar-news-item-title', self.portal,
'Content exists before importing')
self.assertNotIn(
'corge-document-title', self.portal,
'Content exists before importing')
from collective.excelimportexport.sheet import WorkbookForm
request = self.portal.REQUEST.clone()
interface.alsoProvides(request, z3cform_ifaces.IPloneFormLayer)
workbook_form = WorkbookForm(self.portal, request)
workbook_form.update()
# Stub out a file upload submittions
widget = workbook_form.widgets['workbook']
storage = browser.ZopeFieldStorage(environ={})
storage.file = open(self.workbook_path)
storage.filename = storage.file.name
workbook_form.request.form[
widget.name] = HTTPRequest.FileUpload(storage)
action = workbook_form.actions['import']
workbook_form.request.form[action.name] = True
z2.login(self.layer['app']['acl_users'], pa_testing.SITE_OWNER_NAME)
workbook_form()
self.assertIn(
'foo-document-title', self.portal,
'Content not created from import')
self.assertIn(
'bar-news-item-title', self.portal,
'Content not created from import')
self.assertIn(
'garply-folder-title', self.portal,
'Content not created from import')
def setUpDefaultContent_AdditionalPage(self, app, additional_page_id,
additional_page_title):
z2.login(app['acl_users'], SITE_OWNER_NAME)
from Products.CMFPlone.factory import addPloneSite
# Set up the second page with another ID here.
addPloneSite(
app,
additional_page_id,
title=additional_page_title,
setup_content=False,
default_language=DEFAULT_LANGUAGE,
extension_ids=self.extensionProfiles,
)
app[additional_page_id]['portal_workflow'].setDefaultChain('')
pas = app[additional_page_id]['acl_users']
pas.source_users.addUser(TEST_USER_ID, TEST_USER_NAME,
TEST_USER_PASSWORD)
for role in TEST_USER_ROLES:
pas.portal_role_manager.doAssignRoleToPrincipal(TEST_USER_ID, role)
z2.logout()
def assertRow(self):
row_form = self.getRowForm()
z2.login(self.layer['app']['acl_users'], pa_testing.SITE_OWNER_NAME)
data, errors = row_form.extractData()
self.assertFalse(errors, 'Validation errors in row')
self.assertIn(self.title_name, data, 'Row data missing title')
self.assertIsInstance(
data[self.title_name], self.title_type, 'Wrong imported title type')
self.assertIn(
self.description_name, data, 'Row data missing description')
self.assertIsInstance(
data[self.description_name], self.description_type,
'Wrong imported description type')
self.assertIn(
self.subjects_name, data, 'Row data missing subjects')
self.assertIsInstance(
data[self.subjects_name], (tuple, list),
'Wrong imported subjects type')
self.assertGreater(
len(data[self.subjects_name]), 1, 'Wrong imported subjects type')
self.assertIn('text', data, 'Row data missing text')
self.assertIsInstance(
data['text'], self.text_type, 'Wrong imported text type')
