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 _makeRoot( self ):
from OFS.Folder import Folder
root = Folder( 'root' )
tt = DummyTypesTool()
root._setObject( 'portal_types', tt )
return root
def _makeRoot( self ):
from OFS.Folder import Folder
root = Folder( 'root' )
tt = DummyTypesTool()
root._setObject( 'portal_types', tt )
return root
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 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 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_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 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 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_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 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 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_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 _make_composite(self):
from OFS.Folder import Folder
f = Folder()
f.getPhysicalPath = lambda: ()
f.getPhysicalRoot = lambda f=f: f
from ZPublisher.HTTPRequest import HTTPRequest
f.REQUEST = HTTPRequest('', dict(HTTP_HOST='localhost:8080'), {})
from Products.CompositePage.composite import Composite
f.composite = Composite()
f.composite._setId("composite")
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
t = ZopePageTemplate(id="template",
text=template_text,
content_type="text/html")
f.composite.template = t
from Products.CompositePage.slot import Slot
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)
from Products.CompositePage.element import CompositeElement
e1 = CompositeElement('e1', f.a1)
slot_a._setObject(e1.id, e1)
return f.composite
def _make_composite(self):
from OFS.Folder import Folder
f = Folder()
f.getPhysicalPath = lambda: ()
f.getPhysicalRoot = lambda f=f: f
from ZPublisher.HTTPRequest import HTTPRequest
f.REQUEST = HTTPRequest('', dict(HTTP_HOST='localhost:8080'), {})
from Products.CompositePage.composite import Composite
f.composite = Composite()
f.composite._setId("composite")
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
t = ZopePageTemplate(
id="template", text=template_text, content_type="text/html")
f.composite.template = t
from Products.CompositePage.slot import Slot
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)
from Products.CompositePage.element import CompositeElement
e1 = CompositeElement('e1', f.a1)
slot_a._setObject(e1.id, e1)
return f.composite
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 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)
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 = BTreeFolder2('inner')
old_f._setObject(inner_f.id, inner_f)
self.ff._populateFromFolder(old_f)
self.assertEqual(self.ff.objectCount(), 1)
self.assert_('inner' in self.ff)
self.assertEqual(self.getBase(self.ff._getOb('inner')), inner_f)
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 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 _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 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.root._setObject( 'site', site )
site = self.root._getOb( 'site' )
site._setObject('setup_tool', SetupTool('setup_tool'))
return site
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 _makeContext(self):
from OFS.Folder import Folder
root = Folder()
root.getPhysicalPath = lambda: ('', 'some_path',)
cm_id = 'http_cache'
manager = self._makeOne(cm_id)
root._setObject(cm_id, manager)
manager = root[cm_id]
return root, manager
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 _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 _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 _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 testAllowGroupsAttribute(self):
# Verify that __allow_groups__ gets set and removed
from OFS.Folder import Folder
f = Folder()
zcuf = self._makeOne()
f._setObject(zcuf.getId(), zcuf)
self.assert_(zcuf.getId() in f.objectIds())
self.assert_(aq_base(f.__allow_groups__) is aq_base(f.acl_users))
f._delObject(zcuf.getId())
self.assert_(not zcuf.getId() in f.objectIds())
def testAllowGroupsAttribute(self):
# Verify that __allow_groups__ gets set and removed
from OFS.Folder import Folder
f = Folder()
zcuf = self._makeOne()
f._setObject(zcuf.getId(), zcuf)
self.assert_(zcuf.getId() in f.objectIds())
self.assert_(aq_base(f.__allow_groups__) is aq_base(f.acl_users))
f._delObject(zcuf.getId())
self.assert_(not zcuf.getId() in f.objectIds())
def _makeContext(self):
from OFS.Folder import Folder
root = Folder()
root.getPhysicalPath = lambda: ("", "some_path")
cm_id = "http_cache"
manager = self._makeOne(cm_id)
root._setObject(cm_id, manager)
manager = root[cm_id]
return root, manager
def load_folder(subdir):
id = os.path.basename(subdir.rstrip(os.path.sep))
f = Folder(id)
for filename in os.listdir(subdir):
if filename.startswith('.'):
continue
full_name = os.path.join(subdir, filename)
obj = load_object(full_name)
if obj is not None:
f._setObject(filename, obj)
return f
def test_always_traverse_root(self):
from naaya.core.zope2util import ofs_walk
fol = Folder('fol').__of__(Folder('root'))
fol2 = Folder('fol2')
item = SimpleItem('item')
item2 = SimpleItem('item2')
fol._setObject('item', item)
fol._setObject('fol2', fol2)
fol2._setObject('item2', item2)
self.assertEqual(list(ofs_walk(fol, containers=[])), [item, fol2])
def test_always_traverse_root(self):
from naaya.core.zope2util import ofs_walk
fol = Folder('fol').__of__(Folder('root'))
fol2 = Folder('fol2')
item = SimpleItem('item')
item2 = SimpleItem('item2')
fol._setObject('item', item)
fol._setObject('fol2', fol2)
fol2._setObject('item2', item2)
self.assertEqual(list(ofs_walk(fol, containers=[])), [item, fol2])
def _makeSite(self):
import base64
from cStringIO import StringIO
import urllib
try:
from OFS.userfolder import UserFolder
except ImportError:
# BBB for Zope < 2.13
from AccessControl.User import UserFolder
from OFS.Folder import Folder
from OFS.DTMLMethod import DTMLMethod
root = Folder()
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 = self._makeOne()
cc.id = self._CC_ID
root._setObject(cc.id, cc)
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)
req = makerequest(root, StringIO())
self._finally = req.close
credentials = urllib.quote(
base64.encodestring('abraham:pass-w').rstrip())
return root, cc, req, credentials
def _makeSite(self):
import base64
from cStringIO import StringIO
import urllib
try:
from OFS.userfolder import UserFolder
except ImportError:
# BBB for Zope < 2.13
from AccessControl.User import UserFolder
from OFS.Folder import Folder
from OFS.DTMLMethod import DTMLMethod
root = Folder()
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 = self._makeOne()
cc.id = self._CC_ID
root._setObject(cc.id, cc)
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)
req = makerequest(root, StringIO())
self._finally = req.close
credentials = urllib.quote(
base64.encodestring('abraham:pass-w').rstrip())
return root, cc, req, credentials
def _setupCallTests(self, aliases):
# root
root = Folder('root')
# set up dummy type info with problematic double-default alias
ttool = DummyTool()
ttool._type_actions = aliases
getSiteManager().registerUtility(ttool, ITypesTool)
# dummy content and skin
root._setObject('dummycontent', DummyContent())
root._setObject('dummy_view', DummyObject())
return root.dummycontent
def _setupCallTests(self, aliases):
# root
root = Folder('root')
# set up dummy type info with problematic double-default alias
ttool = DummyTool()
ttool._type_actions = aliases
getSiteManager().registerUtility(ttool, ITypesTool)
# dummy content and skin
root._setObject('dummycontent', DummyContent())
root._setObject('dummy_view', DummyObject())
return root.dummycontent
def test_export_import(self):
import tempfile
from os import mkdir
from os import rmdir
from os import unlink
from os.path import join
from os.path import split
from OFS.Folder import Folder
from OFS.Image import File
from transaction import commit
from ZODB.DB import DB
from ZODB.DemoStorage import DemoStorage
try:
tf = None # temporary file required for export/import
# export/import needs the object manager in ZODB
s = DemoStorage()
db = DB(s)
c = db.open()
root = c.root()
top = Folder("top")
f = File("f", "", b"")
top._setObject(f.getId(), f)
root["top"] = top
tmp = Folder("tmp")
top._setObject(tmp.getId(), tmp)
commit()
exported = top.manage_exportObject("f", True)
tdir = tempfile.mkdtemp()
idir = join(tdir, "import")
mkdir(idir)
tf = tempfile.NamedTemporaryFile(dir=idir, delete=False)
tf.write(exported)
tf.close()
unused, tname = split(tf.name)
tmp._getImportPaths = _CallResult((tdir, ))
tmp.manage_importObject(tname,
set_owner=False,
suppress_events=True)
imp_f = tmp["f"] # exception if import unsuccessful
self.assertIsInstance(imp_f, File)
commit()
finally:
if tf is not None: # pragma: no cover
unlink(tf.name)
rmdir(idir)
rmdir(tdir)
c.close()
db.close()
s.close()
def _makeContext(self, obj_id, filename):
newSecurityManager(None, OmnipotentUser().__of__(self.app.acl_users))
stool = Folder('portal_skins')
getSiteManager().registerUtility(stool, ISkinsTool)
stool._setObject('custom', Folder('custom'))
custom = stool.custom
stool._setObject('fsdir', Folder('fsdir'))
fsdir = stool.fsdir
fsdir._setObject(obj_id, self._makeOne(obj_id, filename))
return stool, custom, fsdir, fsdir[obj_id]
def _makeContext(self, obj_id, filename):
newSecurityManager(None, OmnipotentUser().__of__(self.app.acl_users))
stool = Folder('portal_skins')
getSiteManager().registerUtility(stool, ISkinsTool)
stool._setObject('custom', Folder('custom'))
custom = stool.custom
stool._setObject('fsdir', Folder('fsdir'))
fsdir = stool.fsdir
fsdir._setObject(obj_id, self._makeOne(obj_id, filename))
return stool, custom, fsdir, fsdir[obj_id]
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 test_withTwoOnlyOneWired( self ):
parent = Folder()
parent._setObject( 'plugins', DummyPluginRegistry() )
scriptable_plugin = self._makeOne().__of__(parent)
faux_method = SimpleItem( 'faux_method' )
whatever = SimpleItem( 'whatever' )
scriptable_plugin._setObject( 'faux_method', faux_method )
scriptable_plugin._setObject( 'whatever', whatever )
scriptable_plugin.manage_updateInterfaces( ['IFaux',] )
self.assertTrue( IFaux in providedBy(scriptable_plugin) )
def test_withTwo(self):
parent = Folder()
parent._setObject('plugins', DummyPluginRegistry())
scriptable_plugin = self._makeOne().__of__(parent)
faux_method = SimpleItem('faux_method')
two_method = SimpleItem('two_method')
scriptable_plugin._setObject('faux_method', faux_method)
scriptable_plugin._setObject('two_method', two_method)
scriptable_plugin.manage_updateInterfaces(['IFaux', 'IFauxTwo'])
self.assertEqual(len(scriptable_plugin.__implements__), 4)
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
self._BODY = _COMPONENTS_BODY
def test_withTwoOnlyOneWired(self):
parent = Folder()
parent._setObject('plugins', DummyPluginRegistry())
scriptable_plugin = self._makeOne().__of__(parent)
faux_method = SimpleItem('faux_method')
whatever = SimpleItem('whatever')
scriptable_plugin._setObject('faux_method', faux_method)
scriptable_plugin._setObject('whatever', whatever)
scriptable_plugin.manage_updateInterfaces(['IFaux'])
self.assertTrue(IFaux in providedBy(scriptable_plugin))
def test_withTwo( self ):
parent = Folder()
parent._setObject( 'plugins', DummyPluginRegistry() )
scriptable_plugin = self._makeOne().__of__(parent)
faux_method = SimpleItem( 'faux_method' )
two_method = SimpleItem( 'two_method' )
scriptable_plugin._setObject( 'faux_method', faux_method )
scriptable_plugin._setObject( 'two_method', two_method )
scriptable_plugin.manage_updateInterfaces( ['IFaux', 'IFauxTwo'] )
self.assertEqual( len(scriptable_plugin.__implements__), 4 )
def test_withTwo( self ):
parent = Folder()
parent._setObject( 'plugins', DummyPluginRegistry() )
scriptable_plugin = self._makeOne().__of__(parent)
faux_method = SimpleItem( 'faux_method' )
two_method = SimpleItem( 'two_method' )
scriptable_plugin._setObject( 'faux_method', faux_method )
scriptable_plugin._setObject( 'two_method', two_method )
scriptable_plugin.manage_updateInterfaces( ['IFaux', 'IFauxTwo'] )
self.failUnless( IFaux in providedBy(scriptable_plugin) )
self.failUnless( IFauxTwo in providedBy(scriptable_plugin) )
def test_withTwo(self):
parent = Folder()
parent._setObject('plugins', DummyPluginRegistry())
scriptable_plugin = self._makeOne().__of__(parent)
faux_method = SimpleItem('faux_method')
two_method = SimpleItem('two_method')
scriptable_plugin._setObject('faux_method', faux_method)
scriptable_plugin._setObject('two_method', two_method)
scriptable_plugin.manage_updateInterfaces(['IFaux', 'IFauxTwo'])
self.failUnless(IFaux in providedBy(scriptable_plugin))
self.failUnless(IFauxTwo in providedBy(scriptable_plugin))
def test_managersExist(self):
from OFS.Cache import managersExist
from OFS.DTMLMethod import DTMLMethod
root = Folder('root')
root._setObject('root_cache', DummyCacheManager('root_cache'))
root._setObject('child', Folder('child'))
root.child._setObject('child_cache', DummyCacheManager('child_cache'))
root.child._setObject('child_content', DTMLMethod('child_content'))
# To begin with, cache managers will be found correctly
# using managersExist
self.assertTrue(managersExist(root.child.child_content))
# Now we delete the cache in the child folder
root.child.manage_delObjects(['child_cache'])
# The parent_cache should still trigger managersExist
self.assertTrue(managersExist(root.child.child_content))
def test_managersExist(self):
from OFS.Cache import managersExist
from OFS.DTMLMethod import DTMLMethod
root = Folder('root')
root._setObject('root_cache', DummyCacheManager('root_cache'))
root._setObject('child', Folder('child'))
root.child._setObject('child_cache', DummyCacheManager('child_cache'))
root.child._setObject('child_content', DTMLMethod('child_content'))
# To begin with, cache managers will be found correctly
# using managersExist
self.assertTrue(managersExist(root.child.child_content))
# Now we delete the cache in the child folder
root.child.manage_delObjects(['child_cache'])
# The parent_cache should still trigger managersExist
self.assertTrue(managersExist(root.child.child_content))
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 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 setUp(self):
CookieCrumblerTests.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', ), ())
users._doAddUser(
'abrahammmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm',
'pass-wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww',
('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').replace('\012', ''))
def setUp(self):
CookieCrumblerTests.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',), ())
users._doAddUser('abrahammmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmm',
'pass-wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww',
('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').replace('\012', ''))
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 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)