def test_verifyObjectPaste_fti_does_not_allow_content(self):
from Products.CMFCore.interfaces import ITypeInformation
original_container = Container(id='parent')
original_container.manage_permission('View', ('Anonymous', ))
content = Item(id='test')
content.__factory_meta_type__ = 'document'
content.portal_type = 'document'
container = Container(id='container')
container.all_meta_types = [{
'name': 'document',
'action': None,
'permission': 'View'
}]
container.manage_permission('View', ('Anonymous', ))
container['test'] = content
content = container['test']
fti_mock = Mock()
fti_mock.isConstructionAllowed = Mock(return_value=False)
self.mock_utility(fti_mock, ITypeInformation, name='document')
mock_pt = Mock()
mock_pt.getTypeInfo = Mock(return_value=None)
self.mock_tool(mock_pt, 'portal_types')
self.mock_utility(mock_pt, ITypesTool)
self.assertRaises(ValueError, container._verifyObjectPaste, content,
True)
def test_verifyObjectPaste_fti_does_allow_content(self):
from Products.CMFCore.interfaces import ITypeInformation
original_container = Container(id='parent')
original_container.manage_permission('View', ('Anonymous', ))
content = Item(id='test')
content.__factory_meta_type__ = 'document'
content.portal_type = 'document'
container = Container(id='container')
container.all_meta_types = [{
'name': 'document',
'action': None,
'permission': 'View'
}]
container.manage_permission('View', ('Anonymous', ))
container['test'] = content
content = container['test']
fti = self.mocker.mock()
self.expect(fti.isConstructionAllowed(container)).result(True)
self.mock_utility(fti, ITypeInformation, name='document')
pt = self.mocker.mock()
self.expect(pt.getTypeInfo('document')).result(None)
self.expect(pt.getTypeInfo(container)).result(None)
self.mock_tool(pt, 'portal_types')
self.replay()
container._verifyObjectPaste(content, True)
def test_verifyObjectPaste_paste_without_portal_type(self):
original_container = Container(id='parent')
original_container.manage_permission('View', ('Anonymous',))
content = Item(id='test')
content.__factory_meta_type__ = 'document'
container = Container(id='container')
container.all_meta_types = [{'name': 'document',
'action': None,
'permission': 'View'}]
container.manage_permission('View', ('Anonymous',))
container['test'] = content
content = container['test']
container._verifyObjectPaste(content, True)
def test_put_factory_no_adapter(self):
container = Container('container')
self.replay()
self.assertEqual(
None,
container.PUT_factory('test', 'text/foo', 'body')
)
def testAddContentToContainer_preserves_existing_id(self):
from plone.dexterity.content import Item
from plone.dexterity.content import Container
container = Container()
container._ordering = u'unordered'
from zope.component import provideAdapter, provideUtility
from zope.container.interfaces import INameChooser
from zope.interface import Interface
from plone.app.content.namechooser import NormalizingNameChooser
from plone.folder.interfaces import IOrdering
from plone.folder.unordered import UnorderedOrdering
from plone.i18n.normalizer.interfaces import IURLNormalizer
from plone.i18n.normalizer import URLNormalizer
provideAdapter(NormalizingNameChooser, [Interface], INameChooser)
provideUtility(URLNormalizer(), IURLNormalizer)
provideAdapter(UnorderedOrdering, [Interface], IOrdering)
# if the item has an id already, use it
from plone.dexterity.utils import addContentToContainer
item = Item()
item.id = 'foo'
item = addContentToContainer(container, item, checkConstraints=False)
self.assertEqual(item.id, 'foo')
# unless it's a duplicate
item = Item()
item.id = 'foo'
item = addContentToContainer(container, item, checkConstraints=False)
self.assertEqual(item.id, 'foo-1')
def __getattr__(self, name):
try:
return Container.__getattr__(self, name)
except AttributeError:
# Check if it's on shared folder
# Search for the content on the shared folder
portal = getSite()
if portal is not None and name in portal and not name.startswith('_'):
# XXX Check that is content
if (name != 'portal_catalog'
and (name not in _languagelist
and name not in _combinedlanguagelist
and name != 'id-id')):
new_object = aq_base(getattr(portal, name)).__of__(self)
new_object._v_is_shared_content = True
return new_object
else:
raise
#if IBaseObject.providedBy(new_object) or IDexterityContent.providedBy(new_object):
# new_object._v_is_shared_content = True
# return new_object
#else:
# raise
else:
raise
def test_listDAVObjects(self):
container = Container('container')
r = FolderDataResource('fdata', container).__of__(container)
self.replay()
self.assertEqual([], r.listDAVObjects())
def testAddContentToContainer_preserves_existing_id(self):
from plone.dexterity.content import Item
from plone.dexterity.content import Container
container = Container()
container._ordering = u'unordered'
# Allow anyone to access the contents information on the container.
# This allows to check for existing content with the same id.
container.manage_permission(
'Access contents information', ['Anonymous'], acquire=1)
from zope.component import provideAdapter, provideUtility
from zope.container.interfaces import INameChooser
from zope.interface import Interface
from plone.app.content.namechooser import NormalizingNameChooser
from plone.folder.interfaces import IOrdering
from plone.folder.unordered import UnorderedOrdering
from plone.i18n.normalizer.interfaces import IURLNormalizer
from plone.i18n.normalizer import URLNormalizer
provideAdapter(NormalizingNameChooser, [Interface], INameChooser)
provideUtility(URLNormalizer(), IURLNormalizer)
provideAdapter(UnorderedOrdering, [Interface], IOrdering)
# if the item has an id already, use it
from plone.dexterity.utils import addContentToContainer
item = Item()
item.id = 'foo'
item = addContentToContainer(container, item, checkConstraints=False)
self.assertEqual(item.id, 'foo')
# unless it's a duplicate
item = Item()
item.id = 'foo'
item = addContentToContainer(container, item, checkConstraints=False)
self.assertEqual(item.id, 'foo-1')
def test_iconstraintypes_adapter(self):
class DummyConstrainTypes(object):
def __init__(self, context):
self.context = context
def allowedContentTypes(self):
fti = getUtility(IDexterityFTI, name=u"testtype")
return [fti]
self.mock_adapter(DummyConstrainTypes, IConstrainTypes,
(IDexterityContainer, ))
# FTI mock
fti_mock = self.mocker.proxy(DexterityFTI(u"testtype"))
self.expect(fti_mock.getId()).result(u"testtype")
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
folder = Container(id="testfolder")
self.assertEquals(folder.allowedContentTypes(), [fti_mock])
self.assertRaises(ValueError,
folder.invokeFactory,
u"disallowed_type",
id="test")
def test_file_factory_construction_not_allowed(self):
container = Container('container')
container.portal_type = 'containertype'
child_fti_mock = self.mocker.mock()
container_fti_mock = self.mocker.mock()
ctr_mock = self.mocker.mock()
pt_mock = self.mocker.mock()
getToolByName_mock = self.mocker.replace(
'Products.CMFCore.utils.getToolByName')
self.expect(
getToolByName_mock(container, 'content_type_registry',
None)).result(ctr_mock)
self.expect(getToolByName_mock(container,
'portal_types')).result(pt_mock)
self.expect(ctr_mock.findTypeName('test.html', 'text/html',
'<html />')).result('childtype')
self.expect(pt_mock.getTypeInfo('childtype')).result(child_fti_mock)
self.expect(pt_mock.getTypeInfo(container)).result(container_fti_mock)
self.expect(child_fti_mock.product).result(None)
self.expect(container_fti_mock.allowType('childtype')).result(True)
self.expect(
child_fti_mock.isConstructionAllowed(container)).result(False)
factory = DefaultFileFactory(container)
self.replay()
self.assertRaises(Unauthorized, factory, 'test.html', 'text/html',
'<html />')
def test_getattr_on_container_returns_children(self):
content = Container()
content.id = u"id"
content.portal_type = u"testtype"
content['foo'] = Item('foo')
content['quux'] = Item('quux')
class ISchema(Interface):
foo = zope.schema.TextLine(title=u"foo", default=u"foo_default")
bar = zope.schema.TextLine(title=u"bar")
# FTI mock
fti_mock = self.mocker.proxy(DexterityFTI(u"testtype"))
self.expect(fti_mock.lookupSchema()).result(ISchema)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
# Schema field masks contained item
self.assertEquals(u"foo_default", content.foo)
# But we can still obtain an item
self.failUnless(isinstance(content['foo'], Item))
self.assertEquals('foo', content['foo'].id)
# And if the item isn't masked by an attribute, we can still getattr it
self.failUnless(isinstance(content['quux'], Item))
self.assertEquals('quux', content['quux'].id)
self.failUnless(isinstance(getattr(content, 'quux'), Item))
self.assertEquals('quux', getattr(content, 'quux').id)
def test_form_create(self):
# Context and request
context = Container(u"container")
request = TestRequest()
# FTI - returns dummy factory name
fti_mock = self.mocker.proxy(DexterityFTI(u"testtype"))
self.expect(fti_mock.factory).result(u"testfactory")
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
# The form we're testing
form = DefaultAddForm(context, request)
form.portal_type = u"testtype"
# createObject and applyChanges
obj_dummy = Item(id="dummy")
data_dummy = {u"foo": u"bar"}
createObject_mock = self.mocker.replace('zope.component.createObject')
self.expect(createObject_mock(u"testfactory")).result(obj_dummy)
applyChanges_mock = self.mocker.replace('z3c.form.form.applyChanges')
self.expect(applyChanges_mock(form, obj_dummy, data_dummy))
self.replay()
self.assertEqual(obj_dummy, form.create(data_dummy))
self.assertEqual("testtype", obj_dummy.portal_type)
def test_Subject_handles_None(self):
i = Item()
i.subject = None
self.assertEqual((), i.Subject())
c = Container()
c.subject = None
self.assertEqual((), c.Subject())
def test_form_create(self):
# Context and request
context = Container(u"container")
request = TestRequest()
# FTI - returns dummy factory name
fti_mock = DexterityFTI(u"testtype")
fti_mock.factory = u'testfactory'
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
# The form we're testing
form = DefaultAddForm(context, request)
form.portal_type = u"testtype"
class ISchema(Interface):
foo = schema.TextLine()
form.fields = Fields(ISchema)
# createObject and applyChanges
obj_dummy = Item(id="dummy")
alsoProvides(obj_dummy, ISchema)
data_dummy = {u"foo": u"bar"}
from zope.component import createObject
self.patch_global(createObject, return_value=obj_dummy)
provideAdapter(AttributeField)
self.assertEqual(obj_dummy, form.create(data_dummy))
self.assertEqual("testtype", obj_dummy.portal_type)
def test_getattr_on_container_returns_children(self):
content = Container()
content.id = u"id"
content.portal_type = u"testtype"
content['foo'] = Item('foo')
content['quux'] = Item('quux')
class ISchema(Interface):
foo = zope.schema.TextLine(title=u"foo", default=u"foo_default")
bar = zope.schema.TextLine(title=u"bar")
# FTI mock
fti_mock = Mock(wraps=DexterityFTI(u"testtype"))
fti_mock.lookupSchema = Mock(return_value=ISchema)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
SCHEMA_CACHE.invalidate('testtype')
# Schema field masks contained item
self.assertEqual(u"foo_default", content.foo)
# But we can still obtain an item
self.assertTrue(isinstance(content['foo'], Item))
self.assertEqual('foo', content['foo'].id)
# And if the item isn't masked by an attribute, we can still getattr it
self.assertTrue(isinstance(content['quux'], Item))
self.assertEqual('quux', content['quux'].id)
self.assertTrue(isinstance(getattr(content, 'quux'), Item))
self.assertEqual('quux', getattr(content, 'quux').id)
def test_container_init_dublincore(self):
from DateTime.DateTime import DateTime
c = Container(title=u"Test title",
language="en",
effective_date="2010-08-20")
self.assertEqual(c.title, u"Test title")
self.assertEqual(c.language, "en")
self.assertTrue(isinstance(c.effective_date, DateTime))
def test_getId(self):
container = Container('container')
r = FolderDataResource('fdata', container)
self.replay()
self.assertEqual('fdata', r.getId())
self.assertEqual(container, r.__parent__)
def test_file_factory_finder_cruft(self):
container = Container('container')
factory = DefaultFileFactory(container)
self.assertRaises(Unauthorized, factory, '.DS_Store',
'application/octet-stream', 'xxx')
self.assertRaises(Unauthorized, factory, '._test',
'application/octet-stream', 'xxx')
def test_folder_data_traversal_without_dav(self):
container = Container('test')
request = DAVTestRequest(environ={'URL': 'http://site/test'})
request.maybe_webdav_client = False
traversal = DexterityPublishTraverse(container, request)
self.assertRaises(Forbidden, traversal.publishTraverse, request,
DAV_FOLDER_DATA_ID)
def test_addview_sets_form_portal_type(self):
context = Container(u"container")
request = TestRequest()
fti = DexterityFTI(u"testtype")
addview = DefaultAddView(context, request, fti)
self.assertEqual(u"testtype", addview.form_instance.portal_type)
def test_MOVE(self):
container = Container('container')
r = FolderDataResource('fdata', container).__of__(container)
request = DAVTestRequest(
environ={'URL': 'http://example.org/site/container'})
response = request.response
self.assertRaises(MethodNotAllowed, r.MOVE, request, response)
def test_file_factory_no_ctr(self):
container = Container('container')
from Products.CMFCore.utils import getToolByName
self.patch_global(getToolByName, return_value=None)
factory = DefaultFileFactory(container)
self.assertEqual(None, factory('test.html', 'text/html', '<html />'))
def test_Creator_converts_to_utf8(self):
i = Item()
i.creators = (u"é", )
self.assertEqual("é", i.Creator())
i.creators = ("é", )
self.assertEqual("é", i.Creator())
c = Container()
c.creators = (u"é", )
self.assertEqual("é", c.Creator())
self.assertEqual((u"é", ), c.creators)
def test_file_factory_no_fti(self):
container = Container('container')
ctr_mock = Mock()
ctr_mock.findTypeName = Mock(return_value=None)
self.mock_tool(ctr_mock, 'content_type_registry')
factory = DefaultFileFactory(container)
self.assertEqual(None, factory('test.html', 'text/html', '<html />'))
def test_setSubject_converts_to_unicode(self):
i = Item()
i.setSubject(("é", ))
self.assertEqual(i.subject, (u"é", ))
i.setSubject((u"é", ))
self.assertEqual(i.subject, (u"é", ))
c = Container()
c.setSubject(("é", ))
self.assertEqual(c.subject, (u"é", ))
c.setSubject((u"é", ))
self.assertEqual(c.subject, (u"é", ))
def test_Subject_converts_to_utf8(self):
i = Item()
i.subject = (u"é", )
self.assertEqual(("é", ), i.Subject())
i.subject = ("é", )
self.assertEqual(("é", ), i.Subject())
c = Container()
c.subject = (u"é", )
self.assertEqual(("é", ), c.Subject())
c.subject = ("é", )
self.assertEqual(("é", ), c.Subject())
def test_setDescription_converts_to_unicode(self):
i = Item()
i.setDescription("é")
self.assertEqual(i.description, u"é")
i.setDescription(u"é")
self.assertEqual(i.description, u"é")
c = Container()
c.setDescription("é")
self.assertEqual(c.description, u"é")
c.setDescription(u"é")
self.assertEqual(c.description, u"é")
def test_Description_converts_to_utf8(self):
i = Item()
i.description = u"é"
self.assertEqual("é", i.Description())
i.description = "é"
self.assertEqual("é", i.Description())
c = Container()
c.description = u"é"
self.assertEqual("é", c.Description())
c.description = "é"
self.assertEqual("é", c.Description())
def test_Title_converts_to_utf8(self):
i = Item()
i.title = u"é"
self.assertEqual("é", i.Title())
i.title = "é"
self.assertEqual("é", i.Title())
c = Container()
c.title = u"é"
self.assertEqual("é", c.Title())
c.title = "é"
self.assertEqual("é", c.Title())
def test_setTitle_converts_to_unicode(self):
# fix http://code.google.com/p/dexterity/issues/detail?id=145
i = Item()
i.setTitle("é")
self.assertEqual(i.title, u"é")
i.setTitle(u"é")
self.assertEqual(i.title, u"é")
c = Container()
c.setTitle("é")
self.assertEqual(c.title, u"é")
c.setTitle(u"é")
self.assertEqual(c.title, u"é")
def test_folder_data_traversal_dav(self):
container = Container('test')
request = DAVTestRequest(environ={'URL': 'http://site/test'})
request.maybe_webdav_client = True
traversal = DexterityPublishTraverse(container, request)
r = traversal.publishTraverse(request, DAV_FOLDER_DATA_ID)
self.assertEqual(DAV_FOLDER_DATA_ID, r.__name__)
self.assertEqual(container, r.__parent__)
self.assertEqual(container, r.aq_parent)
def __init__(self):
Container.__init__(self)
def __init__(self, id=None, *args, **kwargs):
Container.__init__(self, id, *args, **kwargs)
DefinitionBase.__init__(self, content_base=Container)
self.definition_history = PersistentList()
def __getitem__(self, name):
if name in self.objectIds():
return Container.__getitem__(self, name)
return DefinitionBase.__getitem__(self, name) # traversal hook
def __init__(self):
Container.__init__(self)
manage_addCMFBTreeFolder(self, id='resources')
manage_addCMFBTreeFolder(self, id='dtcolumns')
