def test_exportXML(self):
from OFS.Folder import Folder
from OFS.Image import Image
from OFS.XMLExportImport import exportXML
connection, app = self._makeJarAndRoot()
data = open(imagedata, 'rb')
sub = Folder('sub')
app._setObject('sub', sub)
img = Image('image', '', data, 'image/gif')
sub._setObject('image', img)
img._setProperty('prop1', 3.14159265359, 'float')
img._setProperty('prop2', 1, 'int')
img._setProperty('prop3', 2L**31-1, 'long')
img._setProperty('prop4', 'xxx', 'string')
img._setProperty('prop5', ['xxx', 'zzz'], 'lines')
img._setProperty('prop6', u'xxx', 'unicode')
img._setProperty('prop7', [u'xxx', u'zzz'], 'ulines')
img._setProperty('prop8', '<&>', 'string')
img._setProperty('prop9', u'<&>', 'unicode')
img._setProperty('prop10', '<]]>', 'string')
img._setProperty('prop11', u'<]]>', 'unicode')
img._setProperty('prop12', u'£', 'unicode')
transaction.savepoint(optimistic=True)
oid = sub._p_oid
handle, path = tempfile.mkstemp(suffix='.xml')
try:
ostream = os.fdopen(handle,'wb')
data = exportXML(connection, oid, ostream)
ostream.close()
finally:
os.remove(path)
def __init__(self, id, respondent, draft, creation_date):
Folder.__init__(self, id)
NyProperties.__init__(self)
self.respondent = respondent
self.draft = bool(draft)
self.modification_time = DateTime()
self.creation_date = creation_date
def test_OFS_ObjectManager__importObjectFromFile_xml(self):
from OFS.DTMLMethod import DTMLMethod
from OFS.Folder import Folder
from OFS.XMLExportImport import exportXML
connection, app = self._makeJarAndRoot()
dm = DTMLMethod('test')
dm._setId('test')
dm.munge(_LONG_DTML)
app._setObject('test', dm)
sub = Folder('sub')
app._setObject('sub', sub)
transaction.savepoint(optimistic=True) # need an OID!
oid = dm._p_oid
sub = app._getOb('sub')
handle, path = tempfile.mkstemp(suffix='.xml')
try:
ostream = os.fdopen(handle,'wb')
data = exportXML(connection, oid, ostream)
ostream.close()
sub._importObjectFromFile(path, 0, 0)
finally:
# if this operaiton fails with a 'Permission Denied' error,
# then comment it out as it's probably masking a failure in
# the block above.
os.remove(path)
def __init__(self, *args, **kw):
Folder.__init__(self, *args, **kw)
SilvaService.__init__(self, *args, **kw)
self._config_declarations = {}
self._per_tag_allowed_attr = set(DEFAULT_PER_TAG_WHITELISTS)
self._allowed_html_attributes = set(DEFAULT_HTML_ATTR_WHITELIST)
self._allowed_css_attributes = set(DEFAULT_CSS_PROP_WHITELIST)
def test_foreign_line_endings(self):
# Load the various line ending files and get their output
container = Folder("container_for_execution")
for fformat in ("unix", "dos", "mac"):
container._setObject(fformat, self._makeOne(fformat, "test_%s.py" % fformat))
script = getattr(container, fformat)
self.assertEqual(script(), fformat)
def manage_addMounts(dispatcher, paths=(), create_mount_points=True,
REQUEST=None):
"""Adds MountedObjects at the requested paths.
"""
count = 0
app = dispatcher.getPhysicalRoot()
for path in paths:
mo = MountedObject(path)
mo._create_mount_points = not not create_mount_points
# Raise an error now if there is any problem.
mo._test(app)
blazer = SimpleTrailblazer(app)
container = blazer.traverseOrConstruct(path, omit_final=1)
container._p_jar.add(mo)
loaded = mo.__of__(container)
# Add a faux object to avoid generating manage_afterAdd() events
# while appeasing OFS.ObjectManager._setObject(), then discreetly
# replace the faux object with a MountedObject.
faux = Folder()
faux.id = mo.id
faux.meta_type = loaded.meta_type
container._setObject(faux.id, faux)
# DM 2005-05-17: we want to keep our decision about automatic
# mount point creation
#del mo._create_mount_points
container._setOb(faux.id, mo)
setMountPoint(container, faux.id, mo)
count += 1
if REQUEST is not None:
REQUEST['RESPONSE'].redirect(
REQUEST['URL1'] + ('/manage_main?manage_tabs_message='
'Added %d mount points.' % count))
def test_pruneMemberData(self):
# This needs a tad more setup
from OFS.Folder import Folder
from ..MembershipTool import MembershipTool
folder = Folder('test')
folder._setObject('portal_memberdata', self._makeOne())
sm = getSiteManager()
sm.registerUtility(MembershipTool().__of__(folder), IMembershipTool)
folder._setObject('acl_users', DummyUserFolder())
tool = folder.portal_memberdata
# Create some members
for i in range(20):
tool.registerMemberData('Dummy_%i' % i, 'user_foo_%i' % i)
# None of these fake members are in the user folder, which means
# there are 20 members and 20 "orphans"
contents = tool.getMemberDataContents()
info_dict = contents[0]
self.assertEqual(info_dict['member_count'], 20)
self.assertEqual(info_dict['orphan_count'], 20)
# Calling the prune method should delete all orphans, so we end
# up with no members in the tool.
tool.pruneMemberDataContents()
contents = tool.getMemberDataContents()
info_dict = contents[0]
self.assertEqual(info_dict['member_count'], 0)
self.assertEqual(info_dict['orphan_count'], 0)
def test_upo_state_after_deactivate(self):
# An unmanaged persistent object that gets deactivated
# and reactivated should have the most recent state.
self.db.setCacheSize(10) # Don't flush the objects at commit
conn = self.db.open()
try:
app = conn.root()['Application']
f = Folder()
f.id = 'Holidays'
f.stowaway = Folder()
f.stowaway.id = 'stowaway'
f.stowaway._prop = 'value1'
app._setObject(f.id, f, set_owner=0)
transaction.commit()
self.assertEqual(f._p_changed, 0)
self.assertEqual(f.stowaway._p_oid, 'unmanaged')
f.stowaway._prop = 'value2'
transaction.commit()
self.assertEqual(f._p_changed, 0)
del f.stowaway._p_changed
self.assertEqual(f.stowaway._p_changed, None)
self.assertEqual(f.stowaway._prop, 'value2')
finally:
conn.close()
def test_btreefolder2(self):
from Products.BTreeFolder2.BTreeFolder2 import BTreeFolder2
conn = self.db.open()
try:
app = conn.root()['Application']
f = BTreeFolder2('Holidays')
f.id = 'Holidays'
app._setObject(f.id, f, set_owner=0)
f2 = Folder()
f2.id = 'Easter'
app.Holidays._setObject(f2.id, f2)
transaction.commit()
# Verify serialize() found the unmanaged subobjects.
self.assertEqual(app.Holidays._tree._p_oid, 'unmanaged')
# Sanity check
self.assertEqual(app.Holidays.objectCount(), 1)
conn2 = self.db.open()
try:
app2 = conn2.root()['Application']
self.assert_(app2.Holidays._tree.has_key('Easter'))
self.assert_(not app2.Holidays.__dict__.has_key('Easter'))
# Verify deserialize() found the unmanaged subobjects.
self.assertEqual(app2.Holidays._tree._p_oid, 'unmanaged')
app2.Holidays._delObject('Easter')
transaction.commit()
finally:
conn2.close()
# The deletion should be seen by both connections.
conn.sync()
self.assertEqual(app.Holidays.objectCount(), 0)
finally:
conn.close()
def test_anyfolder_storage(self):
# Try to store a folderish object of an otherwise unknown class
conn = self.db.open()
try:
app = conn.root()['Application']
f = Folder()
f.id = 'Holidays'
app._setObject(f.id, f, set_owner=0)
transaction.commit()
f2 = TestFolder("New Year's Eve")
f2.id = 'NewYear'
f._setObject(f2.id, f2, set_owner=0)
transaction.commit()
# Verify the object is in its own database record
self.assertNotEqual(f2._p_oid, None)
f2._p_changed = None
self.assert_(f2._p_changed is None)
# Verify the ability to load it
conn2 = self.db.open()
try:
app2 = conn2.root()['Application']
ff = app2.Holidays.NewYear
self.assertEqual(ff.title, "New Year's Eve")
self.assertEqual(ff.__class__, TestFolder)
finally:
conn2.close()
finally:
conn.close()
def test_rename(self):
conn = self.db.open()
try:
app = conn.root()['Application']
f = Folder()
f.id = 'Holidays'
app._setObject(f.id, f, set_owner=0)
transaction.commit()
# Do what manage_rename does, without the security checks
ob = app.Holidays.aq_base
app._delObject('Holidays')
ob._setId('HolidayCalendar')
app._setObject(ob.id, ob, set_owner=0)
transaction.commit()
self.assert_(hasattr(app, 'HolidayCalendar'))
self.assert_(not hasattr(app, 'Holidays'))
conn2 = self.db.open()
try:
app = conn2.root()['Application']
self.assert_(hasattr(app, 'HolidayCalendar'))
self.assert_(not hasattr(app, 'Holidays'))
finally:
conn2.close()
finally:
conn.close()
def test_required_tools_missing_acquired_nofail( self ):
from Products.GenericSetup.tool import TOOLSET_XML
from Products.GenericSetup.tool import importToolset
site = self._initSite()
parent_site = Folder()
mandatory = AnotherDummyTool()
mandatory._setId( 'mandatory' )
parent_site._setObject( 'mandatory', mandatory )
obligatory = AnotherDummyTool()
obligatory._setId( 'obligatory' )
parent_site._setObject( 'obligatory', obligatory )
site = site.__of__(parent_site)
# acquiring subobjects of a different class during import
# should not prevent new objects from being created if they
# don't exist in the site
context = DummyImportContext( site, tool=site.setup_tool )
context._files[ TOOLSET_XML ] = _REQUIRED_TOOLSET_XML
importToolset( context )
self.failIf( aq_base( site._getOb( 'mandatory' ) ) is mandatory )
self.failUnless( isinstance( aq_base( site._getOb( 'mandatory' ) )
, DummyTool ) )
self.failIf( aq_base( site._getOb( 'obligatory' ) ) is obligatory )
self.failUnless( isinstance( aq_base( site._getOb( 'obligatory' ) )
, DummyTool ) )
def _makeRoot( self ):
from OFS.Folder import Folder
root = Folder( 'root' )
tt = DummyTypesTool()
root._setObject( 'portal_types', tt )
return root
def test_store(self):
conn = self.db.open()
try:
app = conn.root()['Application']
f = Folder()
f.id = 'Holidays'
app._setObject(f.id, f, set_owner=0)
transaction.commit()
f2 = Folder()
f2.id = 'Christmas'
f._setObject(f2.id, f2, set_owner=0)
transaction.commit()
f3 = Folder()
f3.id = 'Eve'
f2._setObject(f3.id, f3, set_owner=0)
transaction.commit()
conn2 = self.db.open()
try:
app = conn2.root()['Application']
self.assert_(hasattr(app, 'Holidays'))
self.assert_(hasattr(app.Holidays, 'Christmas'))
self.assert_(hasattr(app.Holidays.Christmas, 'Eve'))
# Verify the same OID is seen in both connections.
self.assertEqual(app.Holidays._p_oid, f._p_oid)
finally:
conn2.close()
finally:
conn.close()
def testGenerateIdDenialOfServicePrevention(self):
for n in range(10):
item = Folder()
item.id = "item%d" % n
self.f._setOb(item.id, item)
self.f.generateId("item", rand_ceiling=20) # Shouldn't be a problem
self.assertRaises(ExhaustedUniqueIdsError, self.f.generateId, "item", rand_ceiling=9)
def test_forbidden_tools( self ):
from Products.GenericSetup.tool import TOOLSET_XML
from Products.GenericSetup.tool import importToolset
TOOL_IDS = ( 'doomed', 'blasted', 'saved' )
site = self._initSite()
for tool_id in TOOL_IDS:
pseudo = Folder()
pseudo._setId( tool_id )
site._setObject( tool_id, pseudo )
self.assertEqual( len( site.objectIds() ), len( TOOL_IDS ) + 1 )
for tool_id in TOOL_IDS:
self.failUnless( tool_id in site.objectIds() )
context = DummyImportContext( site, tool=site.setup_tool )
context._files[ TOOLSET_XML ] = _FORBIDDEN_TOOLSET_XML
importToolset( context )
self.assertEqual( len( site.objectIds() ), 2 )
self.failUnless( 'setup_tool' in site.objectIds() )
self.failUnless( 'saved' in site.objectIds() )
def test_foreign_line_endings( self ):
# Load the various line ending files and get their output
container = Folder('container_for_execution')
for fformat in ('unix', 'dos', 'mac'):
container._setObject(fformat,
self._makeOne(fformat, 'test_%s.py' % fformat))
script = getattr(container, fformat)
self.assertEqual(script(), fformat)
def _makeSite( self, title="Don't care" ):
site = Folder()
site._setId( 'site' )
site.title = title
self.app._setObject( 'site', site )
return self.app._getOb( 'site' )
def manage_renameObject(self, id, new_id, REQUEST=None):
"""
wrap manage_renameObject to deal with registration
"""
catalog = self._getOb(id)
self._unregisterMessageCatalog(catalog)
Folder.manage_renameObject(self, id, new_id, REQUEST=None)
self._registerMessageCatalog(catalog)
def __init__(self, id, title, forum, creator=None, commenttext=''):
Folder.__init__(self, id)
ContentMock.__init__(self, id, title, creator)
self.forum = forum
self.comments = []
comment = CommentMock(id, title, self, creator, commenttext)
self.comments.append(comment)
comment = comment.__of__(self)
self._setObject(id, comment)
def _initSite( self ):
from Products.CMFSetup.tool import SetupTool
site = Folder()
site._setId( 'site' )
self.root._setObject( 'site', site )
site = self.root._getOb( 'site' )
site._setObject( 'portal_setup', SetupTool() )
return site
def backupACLUserFolder(context):
timestamp = datetime.now().strftime('%Y.%d.%m-%H%M%S')
randomBit = int(random() * 10000)
backupFolderName = 'backup_acl_users_%s-%d' % (timestamp, randomBit)
backupFolder = Folder(backupFolderName)
backupFolder._setObject('acl_users', context.acl_users)
context._setObject(backupFolder.getId(), backupFolder)
context._delObject('acl_users')
return backupFolderName
def _initSite( self ):
from Products.GenericSetup.tool import SetupTool
site = Folder()
site._setId( 'site' )
self.app._setObject( 'site', site )
site = self.app._getOb( 'site' )
site._setObject('setup_tool', SetupTool('setup_tool'))
return site
def __init__(self, id, title, description, coverage, keywords, sortorder,
file, precondition, releasedate, lang):
"""
Constructor.
"""
self.save_properties(title, description, coverage, keywords, sortorder,
releasedate, lang)
Folder.__init__(self, id)
NyProperties.__dict__['__init__'](self)
class VHMAddingTests(unittest.TestCase):
def setUp(self):
from OFS.Folder import Folder
super(VHMAddingTests, self).setUp()
self.root = Folder('root')
def _makeOne(self):
from Products.SiteAccess.VirtualHostMonster import VirtualHostMonster
return VirtualHostMonster()
def test_add_with_existing_vhm(self):
from Products.SiteAccess.VirtualHostMonster import \
manage_addVirtualHostMonster
from zExceptions import BadRequest
vhm1 = self._makeOne()
vhm1.manage_addToContainer(self.root)
vhm2 = self._makeOne()
self.assertRaises(BadRequest, vhm2.manage_addToContainer, self.root)
self.assertRaises( BadRequest
, manage_addVirtualHostMonster
, self.root
)
def test_add_id_collision(self):
from OFS.Folder import Folder
from Products.SiteAccess.VirtualHostMonster import \
manage_addVirtualHostMonster
from zExceptions import BadRequest
self.root._setObject('VHM', Folder('VHM'))
vhm1 = self._makeOne()
self.assertRaises(BadRequest, vhm1.manage_addToContainer, self.root)
self.assertRaises( BadRequest
, manage_addVirtualHostMonster
, self.root
)
def test_add_addToContainer(self):
from ZPublisher.BeforeTraverse import queryBeforeTraverse
vhm1 = self._makeOne()
vhm1.manage_addToContainer(self.root)
self.assertTrue(vhm1.getId() in self.root.objectIds())
self.assertTrue(queryBeforeTraverse(self.root, vhm1.meta_type))
def test_add_manage_addVirtualHostMonster(self):
from Products.SiteAccess.VirtualHostMonster import \
manage_addVirtualHostMonster
from Products.SiteAccess.VirtualHostMonster import VirtualHostMonster
from ZPublisher.BeforeTraverse import queryBeforeTraverse
manage_addVirtualHostMonster(self.root)
self.assertTrue(VirtualHostMonster.id in self.root.objectIds())
hook = queryBeforeTraverse(self.root, VirtualHostMonster.meta_type)
self.assertTrue(hook)
def testReplace(self):
old_f = Folder()
old_f.id = 'item'
inner_f = HBTreeFolder2('inner')
old_f._setObject(inner_f.id, inner_f)
self.ff._populateFromFolder(old_f)
self.assertEqual(self.ff.objectCount(), 1)
self.assert_(self.ff.has_key('inner'))
self.assertEqual(self.getBase(self.ff._getOb('inner')), inner_f)
def cancelCheckout(self):
baseline = self._getBaseline()
notify(event.CancelCheckoutEvent(self.context, baseline))
wc_container = aq_parent(aq_inner(self.context))
Folder.manage_delObjects(wc_container, [self.context.getId()])
if getSecurityManager().checkPermission(permissions.View, baseline):
return baseline
else:
return aq_parent(baseline)
def _makeRoot( self ):
from OFS.Folder import Folder
sm = getSiteManager()
root = Folder( 'root' )
tt = DummyTypesTool()
root._setObject( 'portal_types', tt )
sm.registerUtility(root.portal_types, ITypesTool)
return root
def test_generateEXML_unacquired_perm_added_role( self ):
ACI = 'Access contents information'
ROLES = [ 'Manager', 'Owner' ]
site = Folder(id='site').__of__(self.app)
site.manage_permission( ACI, ROLES )
configurator = self._makeOne( site ).__of__( site )
self._compareDOM( configurator.generateXML(), _UNACQUIRED_EXPORT )
def manage_afterAdd(self, item, container):
""" overload manage_afterAdd to finish initialization when the
transform tool is added
"""
Folder.manage_afterAdd(self, item, container)
try:
initialize(self)
except TransformException:
# may fail on copy or zexp import
pass
def setUp(self):
# Create and enable a local component registry
site = Folder()
createComponentRegistry(site)
setHooks()
setSite(site)
sm = getSiteManager()
tool = DummyTool()
site._setObject(tool.id, tool)
tool2 = DummyTool2()
site._setObject(tool2.id, tool2)
self._obj = sm
def setUp(self):
f = Folder()
f.getPhysicalPath = lambda: ()
f.getPhysicalRoot = lambda f=f: f
f.composite = Composite()
f.composite._setId("composite")
t = ZopePageTemplate(
id="template", text=template_text, content_type="text/html")
if t.pt_errors():
raise SyntaxError(t.pt_errors())
f.composite.template = t
f.composite.filled_slots.slot_a = slot_a = Slot("slot_a")
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)
self.composite = f.composite
self.old_policy = setSecurityPolicy(PermissiveSecurityPolicy())
noSecurityManager()
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 _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 _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)
current.manage_permission(view, ('Manager', 'Owner'), 0)
else:
current = current._getOb(element)
return current
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_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 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 = FSPythonScript('test1',
join(self.skin_path_name,
'test1.py')).__of__(f)
res = []
def call_script(script=script, res=res):
try:
res.append(script())
except:
res.append('%s: %s' % sys.exc_info()[:2])
start_new_thread(call_script, ())
call_script()
while len(res) < 2:
time.sleep(0.05)
self.assertEqual(res, ['test1', 'test1'], res)
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 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 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 _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 _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.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
def setUpZope(self, app, configurationContext):
"""Set up the additional products required for the collective.js) 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
# ---------------------------------------------------------------------
# -----------------------------------------------------------------------
# Load our own chosen
# -----------------------------------------------------------------------
import collective.js.chosen
self.loadZCML('configure.zcml', package=collective.js.chosen)
# ------------------------------------------------------------------------
# - Load the python packages that are registered as Zope2 Products
# which can't happen until we have loaded the package ZCML.
# ------------------------------------------------------------------------
z2.installProduct(app, 'collective.js.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, foo=2):
site = self.root.site = Folder(id='site')
ctool = site.portal_catalog = CatalogTool()
for obj_id in ctool.objectIds():
ctool._delObject(obj_id)
for idx_id in ctool.indexes():
ctool.delIndex(idx_id)
for col in ctool.schema()[:]:
ctool.delColumn(col)
if foo > 0:
ctool._setObject('foo_plexicon', PLexicon('foo_plexicon'))
lex = ctool.foo_plexicon
lex._pipeline = (Splitter(), CaseNormalizer(), StopWordRemover())
extra = _extra()
extra.lexicon_id = 'foo_plexicon'
extra.index_type = 'Okapi BM25 Rank'
ctool.addIndex('foo_zctext', 'ZCTextIndex', extra)
ctool.addColumn('foo_zctext')
return site
def testMetadataOnce(self):
# this behavior is important to reduce conflict errors.
app = self.app
app.queue_cat.setImmediateMetadataUpdate(True)
app.queue_cat.setProcessAllIndexes(False)
app.real_cat.addColumn('title')
app.f1 = Folder()
app.f1.id = 'f1'
app.f1.title = 'Joe'
app.queue_cat.catalog_object(app.f1) # metadata should change
res = app.queue_cat.searchResults(id='f1')[0]
self.assertEqual(res.title, 'Joe')
app.f1.title = 'Betty'
app.queue_cat.process() # metadata should not change
res = app.queue_cat.searchResults(id='f1')[0]
self.assertEqual(res.title, 'Joe')
# now we'll change the policy
app.queue_cat.setImmediateMetadataUpdate(False)
app.queue_cat.catalog_object(app.f1) # metadata should not change
res = app.queue_cat.searchResults(id='f1')[0]
self.assertEqual(res.title, 'Joe')
app.queue_cat.process() # metadata should change
res = app.queue_cat.searchResults(id='f1')[0]
self.assertEqual(res.title, 'Betty')
def registerUtility(self, interface, utility, name=''):
# I think you are *really* supposed to:
# 1. Check if there is a "registrations" object for utilities.
# 2. If not create one.
# 3. Get it.
# 4. Create a registration object for the utility.
# 5. Rgister the registration object in the registrations.
# But that is quite complex, and Jim sais he wants to change that
# anyway, and in any case the way you would normally do this in Zope3
# and Five would probably differ anyway, so, here is this new
# Five-only, easy to use method!
utilities = getattr(self.context, 'utilities', None)
if utilities is None:
from OFS.Folder import Folder
self.context._setObject('utilities', Folder('utilities'))
utilities = self.context.utilities
if name == '':
# Singletons. Only one per interface allowed, so, let's call it
# by the interface.
name = interface.getName()
utilities._setObject(name, utility)
def test_unacquired_permission_added_role_skip_purge_encode_ascii(self):
ACI = 'Access contents information'
VIEW = 'View'
self.app.site = Folder(id='site')
site = self.app.site
site.manage_permission(VIEW, ())
existing_allowed = [
x['name'] for x in site.rolesOfPermission(ACI) if x['selected']
]
self.assertEqual(existing_allowed, ['Manager'])
self.failUnless(site.acquiredRolesAreUsedBy(ACI))
self.failIf(site.acquiredRolesAreUsedBy(VIEW))
self.failIf(site._has_user_defined_role('ZZZ'))
context = DummyImportContext(site, False, encoding='ascii')
context._files['rolemap.xml'] = _COMBINED_EXPORT
from Products.GenericSetup.rolemap import importRolemap
importRolemap(context)
self.failUnless(site._has_user_defined_role('ZZZ'))
new_allowed = [
x['name'] for x in site.rolesOfPermission(ACI) if x['selected']
]
self.assertEqual(new_allowed, ['Manager', 'Owner', 'ZZZ'])
self.failIf(site.acquiredRolesAreUsedBy(ACI))
self.failIf(site.acquiredRolesAreUsedBy(VIEW))
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)
r = traversal.publishTraverse(request, 'item')
self.assertEqual(r.aq_base, outer['item'].aq_base)
self.assertEqual(container, r.aq_parent)
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)
class SQLConnectionIdsTests(unittest.TestCase):
def setUp(self):
from OFS.Folder import Folder
from Products.ZSQLMethods.tests.dummy import DummySQLConnection
super(SQLConnectionIdsTests, self).setUp()
self.root = Folder('root')
conn1 = DummySQLConnection('conn1', 'Title1')
self.root._setObject('conn1', conn1)
self.root._setObject('child1', Folder('child1'))
conn2 = DummySQLConnection('conn2', 'Title2')
self.root.child1._setObject('conn2', conn2)
self.root._setObject('child2', Folder('child2'))
conn3 = DummySQLConnection('conn3')
self.root.child2._setObject('conn3', conn3)
self.root.child1._setObject('grandchild1', Folder('grandchild1'))
conn4 = DummySQLConnection('conn4')
self.root.child1.grandchild1._setObject('conn4', conn4)
def test_SQLConnectionIDs(self):
from Products.ZSQLMethods.SQL import SQLConnectionIDs
self.assertEqual( SQLConnectionIDs(self.root)
, [('Title1 (conn1)', 'conn1')]
)
self.assertEqual( SQLConnectionIDs(self.root.child1)
, [ ('Title1 (conn1)', 'conn1')
, ('Title2 (conn2)', 'conn2')
]
)
self.assertEqual( SQLConnectionIDs(self.root.child1.grandchild1)
, [ ('Title1 (conn1)', 'conn1')
, ('Title2 (conn2)', 'conn2')
, ('conn4', 'conn4')
]
)
self.assertEqual( SQLConnectionIDs(self.root.child2)
, [ ('Title1 (conn1)', 'conn1')
, ('conn3', 'conn3')
]
)
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 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 test_restrict_output(self):
from naaya.core.zope2util import ofs_walk
fol = Folder('fol').__of__(Folder('root'))
fol2 = Folder('fol2')
item = SimpleItem('item')
fol._setObject('item', item)
fol._setObject('fol2', fol2)
class IMyItem(interface.Interface):
pass
class IMyItem2(interface.Interface):
pass
# we call with 2 interfaces to make sure "OR" logic is applied
walk = lambda: list(ofs_walk(fol, [IMyItem, IMyItem2]))
self.assertEqual(walk(), [])
interface.alsoProvides(item, IMyItem)
self.assertEqual(walk(), [item])
interface.alsoProvides(fol2, IMyItem)
self.assertEqual(walk(), [item, fol2])
def test_listPermissions_nooverrides(self):
site = Folder(id='site').__of__(self.app)
configurator = self._makeOne(site)
self.assertEqual(len(configurator.listPermissions()), 0)
def setUp(self):
from Products.CMFCore.DirectoryView import DirectoryView
_DVRegistrySetup.setUp(self)
self._obj = DirectoryView('foo_directoryview').__of__(Folder())
self._XML = _DIRECTORYVIEW_XML
