def _initSite(self, foo=0):
self.root.site = Folder(id='site')
site = self.root.site
ttool = site.portal_types = TypesTool()
sm = getSiteManager()
sm.registerUtility(ttool, ITypesTool)
if foo == 1:
fti = _TI_LIST[0].copy()
ttool._setObject(fti['id'], FactoryTypeInformation(**fti))
sti = _TI_LIST[1].copy()
ttool._setObject(sti['id'], ScriptableTypeInformation(**sti))
elif foo == 2:
fti = _TI_LIST_WITH_FILENAME[0].copy()
ttool._setObject(fti['id'], FactoryTypeInformation(**fti))
sti = _TI_LIST_WITH_FILENAME[1].copy()
ttool._setObject(sti['id'], ScriptableTypeInformation(**sti))
return site
def test_parseXML_acquired_permission(self):
ACI = 'Access contents information'
self.app.site = Folder(id='site')
site = self.app.site
configurator = self._makeOne(site)
rolemap_info = configurator.parseXML(_ACQUIRED_EXPORT)
self.assertEqual(len(rolemap_info['permissions']), 1)
permission = rolemap_info['permissions'][0]
self.assertEqual(permission['name'], ACI)
self.failUnless(permission['acquire'])
p_roles = permission['roles']
self.assertEqual(len(p_roles), 2)
self.failUnless('Manager' in p_roles)
self.failUnless('Owner' in p_roles)
def _initSite(self, mit_predikat=False):
from Products.CMFCore.ContentTypeRegistry import ContentTypeRegistry
self.root.site = Folder(id='site')
site = self.root.site
ctr = ContentTypeRegistry()
site._setObject(ctr.getId(), ctr)
sm = getSiteManager(site)
sm.registerUtility(site.content_type_registry, IContentTypeRegistry)
if mit_predikat:
for (predicate_id, predicate_type, edit_args,
content_type_name) in _TEST_PREDICATES:
ctr.addPredicate(predicate_id, predicate_type)
predicate = ctr.getPredicate(predicate_id)
predicate.edit(*edit_args)
ctr.assignTypeName(predicate_id, content_type_name)
return site
def setUpZope(self, app, configurationContext):
import plone.uuid
import plone.multilingual
# load ZCML
xmlconfig.file('testing.zcml',
plone.multilingual,
context=configurationContext)
xmlconfig.file('configure.zcml',
plone.multilingual.tests,
context=configurationContext)
# Support sessionstorage in tests
app.REQUEST['SESSION'] = self.Session()
if not hasattr(app, 'temp_folder'):
tf = Folder('temp_folder')
app._setObject('temp_folder', tf)
transaction.commit()
ztc.utils.setupCoreSessions(app)
def test_acquire_without_dav(self):
container = Container('container')
outer = Folder('outer')
outer._setObject('item', SimpleItem('item'))
outer._setOb('container', container)
request = DAVTestRequest(
environ={'URL': 'http://site/test', 'REQUEST_METHOD': 'GET'}
)
request.maybe_webdav_client = False
traversal = DexterityPublishTraverse(container.__of__(outer), request)
self.replay()
r = traversal.publishTraverse(request, 'item')
self.assertEqual(r.aq_base, outer['item'].aq_base)
self.assertEqual(container, r.aq_parent)
def _ensureSnapshotsFolder( self, subdir=None ):
""" Ensure that the appropriate snapshot folder exists.
"""
path = [ 'snapshots', self._snapshot_id ]
if subdir is not None:
path.extend( subdir.split( '/' ) )
current = self._tool
for element in path:
if element not in current.objectIds():
# No Unicode IDs!
current._setObject( str( element ), Folder( element ) )
current = current._getOb( element )
return current
def testInitializationRaceCondition(self):
# Tries to exercise a former race condition where
# FSObject._updateFromFS() set self._parsed before the
# object was really parsed.
for n in range(10):
f = Folder()
script = self._makeOne('test1', 'test1.py').__of__(f)
res = []
def call_script(script=script, res=res):
try:
res.append(script())
except:
res.append('%s: %s' % exc_info()[:2])
start_new_thread(call_script, ())
call_script()
while len(res) < 2:
sleep(0.05)
self.assertEqual(res, ['test1', 'test1'], res)
def test_no_acquire_dav(self):
container = Container('container')
outer = Folder('outer')
outer._setOb('item', SimpleItem('item'))
outer._setOb('container', container)
request = DAVTestRequest(environ={
'URL': 'http://site/test',
'REQUEST_METHOD': 'PUT'
})
request.maybe_webdav_client = True
traversal = DexterityPublishTraverse(container.__of__(outer),
request)
r = traversal.publishTraverse(request, 'item')
self.assertTrue(isinstance(r, NullResource))
self.assertEqual(container, r.aq_parent)
def test_store_property_types(self):
# Test that Ape restores properties to the correct types.
from DateTime import DateTime
now = DateTime()
conn = self.db.open()
try:
app = conn.root()['Application']
f = Folder()
f.id = 'Holidays'
app._setObject(f.id, f, set_owner=0)
transaction.commit()
f._setProperty('string1', 's', 'string')
f._setProperty('float1', 3.14, 'float')
f._setProperty('int1', 5, 'int')
f._setProperty('long1', 2L**33, 'long')
f._setProperty('date1', now, 'date')
f._setProperty('date2', now, 'date_international')
f._setProperty('text1', 'abc\ndef', 'text')
f._setProperty('boolean0', 0, 'boolean')
f._setProperty('boolean1', 1, 'boolean')
transaction.commit()
conn2 = self.db.open()
try:
app2 = conn2.root()['Application']
f2 = app2.Holidays
self.assertEqual(f2.string1, 's')
self.assertEqual(f2.float1, 3.14)
self.assertEqual(f2.int1, 5)
self.assertEqual(f2.long1, 2L**33)
self.assertEqual(f2.date1.ISO(), now.ISO())
self.assertEqual(f2.date2.ISO(), now.ISO())
self.assertEqual(f2.text1, 'abc\ndef')
self.assertEqual(f2.boolean0, 0)
self.assertEqual(f2.boolean1, 1)
finally:
conn2.close()
finally:
conn.close()
def setUpZope(self, app, configurationContext):
"""Set up the additional products required for the collective.z3cform) site chosen.
until the setup of the Plone site testing layer.
"""
self.app = app
self.browser = Browser(app)
# old zope2 style products
for product in TESTED_PRODUCTS:
z2.installProduct(product)
# ----------------------------------------------------------------------
# Import all our python modules required by our packages
# ---------------------------------------------------------------------
#with_ploneproduct_jschosen
import collective.js.chosen
self.loadZCML('configure.zcml', package=collective.js.chosen)
# -----------------------------------------------------------------------
# Load our own chosen
# -----------------------------------------------------------------------
import collective.z3cform.chosen
self.loadZCML('configure.zcml', package=collective.z3cform.chosen)
# ------------------------------------------------------------------------
# - Load the python packages that are registered as Zope2 Products
# which can't happen until we have loaded the package ZCML.
# ------------------------------------------------------------------------
#with_ploneproduct_jschosen
z2.installProduct(app, 'collective.js.chosen')
z2.installProduct(app, 'collective.z3cform.chosen')
# -------------------------------------------------------------------------
# support for sessions without invalidreferences if using zeo temp storage
# -------------------------------------------------------------------------
app.REQUEST['SESSION'] = self.Session()
if not hasattr(app, 'temp_folder'):
tf = Folder('temp_folder')
app._setObject('temp_folder', tf)
transaction.commit()
ztc.utils.setupCoreSessions(app)
def _initSite(self, use_changed=False):
self.root.site = Folder(id='site')
site = self.root.site
cc = site.cookie_authentication = CookieCrumbler('foo_cookiecrumbler')
sm = getSiteManager()
sm.registerUtility(site.cookie_authentication, ICookieCrumbler)
if use_changed:
cc.auth_cookie = 'value1'
cc.cache_header_value = 'value2'
cc.name_cookie = 'value3'
cc.log_username = 0
cc.persist_cookie = 'value4'
cc.pw_cookie = 'value5'
cc.local_cookie_path = 1
cc.auto_login_page = 'value6'
cc.unauth_page = 'value7'
cc.logout_page = 'value8'
return site
def test_write_with_ghosts(self):
# It should be possible to write a container even if one
# or more of its subobjects are ghosts.
conn = self.db.open()
try:
root = conn.root()
root['foo'] = 1
f = Folder()
f.id = 'bar'
root['bar'] = f
transaction.commit()
conn2 = self.db.open()
try:
root2 = conn2.root()
root2['foo'] = 2
self.assertEqual(root2['bar']._p_changed, None)
transaction.commit()
finally:
conn2.close()
finally:
conn.close()
def _initRegistry(self, plugin_type_info=(), plugins={}):
from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from Products.PluginRegistry.PluginRegistry import PluginRegistry
app = Folder()
app.getPhysicalPath = lambda: ()
app.getPhysicalRoot = lambda: app
app._setObject('foo_plugin_1', SimpleItem())
app._setObject('foo_plugin_2', SimpleItem())
registry = PluginRegistry(plugin_type_info)
registry._plugins = {} # it is usually lazy
for plugin_type, registered in plugins.items():
registry._plugins[plugin_type] = registered
app._setObject('plugin_registry', registry)
registry = app._getOb('plugin_registry')
return app, registry
def test_before_traverse_hooks(self):
from OFS.Folder import Folder
container = Folder()
cc = self._makeOne()
marker = []
bt_before = getattr(container, '__before_traverse__', marker)
self.failUnless(bt_before is marker)
container._setObject(cc.id, cc)
bt_added = getattr(container, '__before_traverse__')
self.assertEqual(len(bt_added.items()), 1)
k, v = bt_added.items()[0]
self.failUnless(k[1].startswith(self._getTargetClass().meta_type))
self.assertEqual(v.name, cc.id)
container._delObject(cc.id)
bt_removed = getattr(container, '__before_traverse__')
self.assertEqual(len(bt_removed.items()), 0)
def addClient(zmscontext, id):
"""
Add ZMS client.
"""
request = zmscontext.REQUEST
home = zmscontext.getHome()
folder = Folder(id)
home._setObject(folder.id, folder)
folder_inst = getattr(home, id)
request.set('lang_label', zmscontext.getLanguageLabel(request['lang']))
zms_inst = zmscontext.initZMS(folder_inst, 'content', 'Title of %s' % id,
'Titlealt of %s' % id, request['lang'],
request['lang'], request)
print("home.id", home.id)
zms_inst.setConfProperty('Portal.Master', home.id)
for metaObjId in zmscontext.getMetaobjIds():
zms_inst.metaobj_manager.acquireMetaobj(metaObjId)
zmscontext.setConfProperty(
'Portal.Clients',
zmscontext.getConfProperty('Portal.Clients', []) + [id])
return zms_inst
def test_getMemberById_chained(self):
LOCAL_USER_ID = 'user_foo'
NONLOCAL_USER_ID = 'user_bar'
self.root._setObject('folder', Folder('folder'))
site = self._makeSite(self.root.folder)
tool = site.portal_membership
local_uf = DummyUserFolder()
delattr(local_uf, NONLOCAL_USER_ID)
site._setObject('acl_users', local_uf)
nonlocal_uf = DummyUserFolder()
delattr(nonlocal_uf, LOCAL_USER_ID)
self.root.folder._setObject('acl_users', nonlocal_uf)
local_member = tool.getMemberById(LOCAL_USER_ID)
self.assertEqual(local_member.getId(), LOCAL_USER_ID)
nonlocal_member = tool.getMemberById(NONLOCAL_USER_ID)
self.assertEqual(nonlocal_member.getId(), NONLOCAL_USER_ID)
def test_empty_skip_purge(self):
self.app.site = Folder(id='site')
site = self.app.site
original_roles = list(getattr(site, '__ac_roles__', []))[:]
modified_roles = original_roles[:]
modified_roles.append('ZZZ')
site.__ac_roles__ = modified_roles
context = DummyImportContext(site, False)
context._files['rolemap.xml'] = _EMPTY_EXPORT
from Products.GenericSetup.rolemap import importRolemap
importRolemap(context)
new_roles = list(getattr(site, '__ac_roles__', []))[:]
modified_roles.sort()
new_roles.sort()
self.assertEqual(modified_roles, new_roles)
def test_setSecurityProfile(self):
from Products.LDAPUserFolder.LDAPMemberDataTool import LDAPMemberDataTool
folder = Folder('test')
folder._setOb('portal_memberdata', LDAPMemberDataTool())
folder._setOb('acl_users', LDAPDummyUserFolder())
user = LDAPDummyUser('bob', 'pw', ['Role'], ['domain'])
folder.acl_users._addUser(user)
user = folder.acl_users.getUser(user.getId())
member = folder.portal_memberdata.wrapUser(user)
member.setSecurityProfile(password='******')
self.assertEqual(user.__, 'newpw')
self.assertEqual(list(user.roles), ['Role'])
self.assertEqual(list(user.domains), ['domain'])
member.setSecurityProfile(roles=['NewRole'])
self.assertEqual(user.__, 'newpw')
self.assertEqual(list(user.roles), ['NewRole'])
self.assertEqual(list(user.domains), ['domain'])
member.setSecurityProfile(domains=['newdomain'])
self.assertEqual(user.__, 'newpw')
self.assertEqual(list(user.roles), ['NewRole'])
self.assertEqual(list(user.domains), ['newdomain'])
def _initSite(self, with_icon=False):
from OFS.Folder import Folder
from Products.CMFActionIcons.ActionIconsTool import ActionIconsTool
_setUpDefaultTraversable()
self.root.site = Folder(id='site')
site = self.root.site
tool = ActionIconsTool()
site._setObject(tool.getId(), tool)
sm = getSiteManager()
sm.registerUtility(site.portal_actionicons, IActionIconsTool)
if with_icon:
tool.addActionIcon(category=self.CATEGORY,
action_id=self.ACTION_ID,
title=self.TITLE,
priority=self.PRIORITY,
icon_expr=self.ICON_EXPR)
return site
def _make_composite(self):
from OFS.Folder import Folder
from ZPublisher.HTTPRequest import HTTPRequest
from ZPublisher.HTTPRequest import HTTPResponse
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Products.CompositePage.composite import Composite
from Products.CompositePage.element import CompositeElement
from Products.CompositePage.slot import Slot
TEMPLATE_TEXT = '\n'.join((
'<html>',
'<body>',
"""<div tal:replace="structure slot: slot_a (top) """
"""'Top News Stories'">slot_a</div>""",
"""<span tal:replace="structure slot: slot_b """
"""'Other News'">slot_b</span>""",
'<div tal:replace="structure context/slots/slot_c">slot_c</div>',
'</body>',
'</html>',
))
f = Folder()
f.getPhysicalPath = lambda: ()
f.getPhysicalRoot = lambda f=f: f
req = f.REQUEST = HTTPRequest('', dict(HTTP_HOST='localhost:8080'), {})
req.response = HTTPResponse()
f.composite = Composite()
f.composite._setId("composite")
t = ZopePageTemplate(id="template",
text=TEMPLATE_TEXT,
content_type="text/html")
f.composite.template = t
f.composite.filled_slots.slot_a = slot_a = Slot("slot_a")
t = f.composite.template
if t.pt_errors():
raise SyntaxError(t.pt_errors())
a1 = ZopePageTemplate(id="a1", text="<b>Slot A</b>")
f._setObject(a1.id, a1)
e1 = CompositeElement('e1', f.a1)
slot_a._setObject(e1.id, e1)
return f.composite
def test_createMemberArea_chained(self):
LOCAL_USER_ID = 'user_foo'
NONLOCAL_USER_ID = 'user_bar'
self.app._setObject('folder', Folder('folder'))
site = self._makeSite(self.app.folder)
mtool = site.portal_membership
members = site._setObject('Members', PortalFolder('Members'))
local_uf = DummyUserFolder()
delattr(local_uf, NONLOCAL_USER_ID)
acl_users = site._setObject('acl_users', local_uf)
nonlocal_uf = DummyUserFolder()
delattr(nonlocal_uf, LOCAL_USER_ID)
self.app.folder._setObject('acl_users', nonlocal_uf)
newSecurityManager(None, acl_users.all_powerful_Oz)
mtool.createMemberArea(NONLOCAL_USER_ID)
self.assertTrue(hasattr(members.aq_self, NONLOCAL_USER_ID))
mtool.createMemberArea(LOCAL_USER_ID)
self.assertTrue(hasattr(members.aq_self, LOCAL_USER_ID))
def test_existing_roles_missing_xml_doesnt_purge(self):
# LP # 279294
ACI = 'Access contents information'
VIEW = 'View'
self.app.site = Folder(id='site')
site = self.app.site # wrap
original_roles = list(getattr(site, '__ac_roles__', []))[:]
modified_roles = original_roles[:]
modified_roles.append('ZZZ')
site.__ac_roles__ = modified_roles
site.manage_permission(VIEW, ())
site.manage_permission(ACI, ('Manager', 'ZZZ'))
existing_allowed = [
x['name'] for x in site.rolesOfPermission(ACI) if x['selected']
]
self.assertEqual(existing_allowed, ['Manager', 'ZZZ'])
context = DummyImportContext(site, True)
#context._files[ 'rolemap.xml' ] = _EMPTY_EXPORT # no file!
from Products.GenericSetup.rolemap import importRolemap
importRolemap(context)
new_roles = list(getattr(site, '__ac_roles__', []))[:]
modified_roles.sort()
new_roles.sort()
self.assertEqual(modified_roles, new_roles)
new_allowed = [
x['name'] for x in site.rolesOfPermission(ACI) if x['selected']
]
self.assertEqual(new_allowed, existing_allowed)
def _initSite( self, foo=2, bar=2 ):
self.root.site = Folder( id='site' )
site = self.root.site
site.portal_membership = DummyMembershipTool()
site.portal_actions = DummyActionsTool()
site.portal_actions.addActionProvider( 'portal_actions' )
if foo > 0:
site.portal_foo = DummyTool()
if foo > 1:
site.portal_foo.addAction( id='foo'
, name='Foo'
, action='foo'
, condition='python:1'
, permission=()
, category='dummy'
, visible=1
)
site.portal_actions.addActionProvider( 'portal_foo' )
if bar > 0:
site.portal_bar = DummyTool()
if bar > 1:
site.portal_bar.addAction( id='bar'
, name='Bar'
, action='bar'
, condition='python:0'
, permission=( 'Manage portal', )
, category='dummy'
, visible=0
)
site.portal_actions.addActionProvider( 'portal_bar' )
return site
def test_unacquired_perm(self):
ACI = 'Access contents information'
ROLES = ['Manager', 'Owner', 'ZZZ']
self.app.site = Folder('site')
site = self.app.site
existing_roles = list(getattr(site, '__ac_roles__', []))[:]
existing_roles.append('ZZZ')
site.__ac_roles__ = existing_roles
site.manage_permission(ACI, ROLES)
context = DummyExportContext(site)
from Products.GenericSetup.rolemap import exportRolemap
exportRolemap(context)
self.assertEqual(len(context._wrote), 1)
filename, text, content_type = context._wrote[0]
self.assertEqual(filename, 'rolemap.xml')
self._compareDOM(text, _COMBINED_EXPORT)
self.assertEqual(content_type, 'text/xml')
def setUp(self):
root = Folder()
self.root = root
root.isTopLevelPrincipiaApplicationObject = 1 # User folder needs this
root.getPhysicalPath = lambda: () # hack
root._View_Permission = ('Anonymous', )
users = UserFolder()
users._setId('acl_users')
users._doAddUser('abraham', 'pass-w', ('Patriarch', ), ())
users._doAddUser('isaac', 'pass-w', ('Son', ), ())
root._setObject(users.id, users)
cc = CookieCrumbler()
cc.id = 'cookie_authentication'
root._setObject(cc.id, cc)
self.cc = getattr(root, cc.id)
index = DTMLMethod()
index.munge('This is the default view')
index._setId('index_html')
root._setObject(index.getId(), index)
login = DTMLMethod()
login.munge('Please log in first.')
login._setId('login_form')
root._setObject(login.getId(), login)
protected = DTMLMethod()
protected._View_Permission = ('Manager', )
protected.munge('This is the protected view')
protected._setId('protected')
root._setObject(protected.getId(), protected)
self.responseOut = StringIO()
self.req = makerequest(root, self.responseOut)
self.credentials = urllib.quote(
base64.encodestring('abraham:pass-w').rstrip())
def test_store_selection_properties(self):
conn = self.db.open()
try:
app = conn.root()['Application']
f = Folder()
f.id = 'Holidays'
f.title = 'Holiday Calendar'
app._setObject(f.id, f, set_owner=0)
transaction.commit()
f._setProperty('choices', ['alpha', 'omega', 'delta'], 'lines')
f._setProperty('greek', 'choices', 'multiple selection')
f._setProperty('hebrew', 'choices', 'selection')
f.greek = ['alpha', 'omega']
f.hebrew = 'alpha'
transaction.commit()
conn2 = self.db.open()
try:
app = conn2.root()['Application']
self.assert_(hasattr(app, 'Holidays'))
got = 0
for k, v in app.Holidays.propertyItems():
if k == 'greek':
got += 1
self.assertEqual(tuple(v), ('alpha', 'omega'))
if k == 'hebrew':
got += 1
self.assertEqual(v, 'alpha')
self.assertEqual(got, 2)
# Be sure the select_variable got restored.
dict = app.Holidays.propdict()
self.assertEqual(dict['greek']['select_variable'], 'choices')
self.assertEqual(dict['hebrew']['select_variable'], 'choices')
finally:
conn2.close()
finally:
conn.close()
def test_manage_propertiesForm_allows_adding(self):
from OFS.Folder import Folder
def _header(*args, **kw):
return 'HEADER'
def _footer(*args, **kw):
return 'HEADER'
def _main(*args, **kw):
return 'MAIN'
container = Folder('folder')
# Mocking out a bit of the ZMI
container.ZopeVersion = lambda **kw: '4.99'
container.REQUEST = request = DummyRequest()
request.set('manage_page_header', _header)
request.set('manage_page_footer', _footer)
request.set('manage_main', _main)
request.set('RESPONSE', None)
request.set('BASEPATH1', '/one/two')
request.set('URL', '/one/two/manage_propertiesForm')
request.set('URL0', '/one')
request.set('URL1', '/one/two')
setattr(request, 'URL1', '/one/two')
request._steps = ['one', 'two']
prd = {'ac_permissions': ('a', 'b')}
container._getProductRegistryData = prd.get
a = self._makeOne('extensible').__of__(container)
# EEK short-term solution until a new Zope release is out
from App.special_dtml import DTMLFile
DTMLFile.encoding = None
form_html = a.manage_propertiesForm(request)
self.assertIn('value="Add"', form_html)
def _initSite(self, foo=2):
self.root.site = Folder(id='site')
site = self.root.site
site.dummy = DummyObject(id='dummy')
site.dummy.foobarbaz = ('Foo', 'Bar', 'Baz')
if foo > 0:
site.dummy._setProperty('foo_boolean', '', 'boolean')
site.dummy._setProperty('foo_date', '', 'date')
site.dummy._setProperty('foo_float', '', 'float')
site.dummy._setProperty('foo_int', '', 'int')
site.dummy._setProperty('foo_lines', '', 'lines')
site.dummy._setProperty('foo_long', '', 'long')
site.dummy._setProperty('foo_string', '', 'string')
site.dummy._setProperty('foo_text', '', 'text')
site.dummy._setProperty('foo_tokens', (), 'tokens')
site.dummy._setProperty('foo_selection', 'foobarbaz', 'selection')
site.dummy._setProperty('foo_mselection', 'foobarbaz',
'multiple selection')
site.dummy._setProperty('foo_boolean0', '', 'boolean')
if foo > 1:
site.dummy._updateProperty('foo_boolean', 'True')
site.dummy._updateProperty('foo_date', '2000/01/01')
site.dummy._updateProperty('foo_float', '1.1')
site.dummy._updateProperty('foo_int', '1')
site.dummy._updateProperty('foo_lines', 'Foo\nLines')
site.dummy._updateProperty('foo_long', '1')
site.dummy._updateProperty('foo_string', 'Foo String')
site.dummy._updateProperty('foo_text', 'Foo\nText')
site.dummy._updateProperty('foo_tokens', ('Foo', 'Tokens'))
site.dummy._updateProperty('foo_selection', 'Foo')
site.dummy._updateProperty('foo_mselection', ('Foo', 'Baz'))
site.dummy.foo_boolean0 = 0
return site
def test_createMemberArea_chained(self):
LOCAL_USER_ID = 'user_foo'
NONLOCAL_USER_ID = 'user_bar'
self.root._setObject('folder', Folder('folder'))
site = self._makeSite(self.root.folder)
mtool = site.portal_membership
members = site._setObject('Members', PortalFolder('Members'))
getSiteManager().registerUtility(DummyTool(), IWorkflowTool)
local_uf = DummyUserFolder()
delattr(local_uf, NONLOCAL_USER_ID)
acl_users = site._setObject('acl_users', local_uf)
nonlocal_uf = DummyUserFolder()
delattr(nonlocal_uf, LOCAL_USER_ID)
self.root.folder._setObject('acl_users', nonlocal_uf)
newSecurityManager(None, acl_users.all_powerful_Oz)
mtool.createMemberArea(NONLOCAL_USER_ID)
self.failUnless(hasattr(members.aq_self, NONLOCAL_USER_ID))
mtool.createMemberArea(LOCAL_USER_ID)
self.failUnless(hasattr(members.aq_self, LOCAL_USER_ID))
def testLogCatalogErrors(self):
# Mutilate the logger so we can capture output silently
from Products.QueueCatalog.QueueCatalog import logger
logger.propagate = 0
fake_file = cStringIO.StringIO()
fake_log_handler = logging.StreamHandler(fake_file)
logger.addHandler(fake_log_handler)
# Now do our bidding
app = self.app
app.f1 = Folder()
app.f1.id = 'f1'
app.queue_cat.catalog_object(app.f1)
app.real_cat.catalog_object = lambda: None # raises TypeError
app.queue_cat.process()
del app.real_cat.catalog_object
# See what the fake file contains, and then rewind for reuse
output = fake_file.getvalue()
self.failUnless(output.startswith('error cataloging object'))
fake_file.seek(0)
app.queue_cat.setImmediateRemoval(False)
app.queue_cat.uncatalog_object(app.queue_cat.uidForObject(app.f1))
app.real_cat.uncatalog_object = lambda: None # raises TypeError
app.queue_cat.process()
del app.real_cat.uncatalog_object
# See what the fake file contains, and then rewind for reuse
output = fake_file.getvalue()
self.failUnless(output.startswith('error uncataloging object'))
fake_file.close()
# cleanup the logger
fake_log_handler.close()
logger.removeHandler(fake_log_handler)
logger.propagate = 1
