def test_get_minimal_adapter(self):
class ReadFileAdapter(object):
def __init__(self, context):
self.context = context
mimeType = None
encoding = None
def size(self):
return None
def read(self, size=None):
return "1234567890"
self.mock_adapter(ReadFileAdapter, IRawReadFile, (Item,))
request = DAVTestRequest()
item = Item("item")
item.REQUEST = request
self.replay()
self.assertEqual("1234567890", item.manage_DAVget())
self.assertEqual(None, request.response.getHeader("Content-Type"))
self.assertEqual(None, request.response.getHeader("Content-Length"))
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_Subject_handles_None(self):
i = Item()
i.subject = None
self.assertEqual((), i.Subject())
c = Container()
c.subject = None
self.assertEqual((), c.Subject())
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_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_get_minimal_adapter(self):
class ReadFileAdapter(object):
def __init__(self, context):
self.context = context
mimeType = None
encoding = None
def size(self):
return None
def read(self, size=None):
return '1234567890'
self.mock_adapter(ReadFileAdapter, IRawReadFile, (Item, ))
request = DAVTestRequest()
item = Item('item')
item.REQUEST = request
self.replay()
self.assertEqual('1234567890', item.manage_DAVget())
self.assertEqual(None, request.response.getHeader('Content-Type'))
self.assertEqual(None, request.response.getHeader('Content-Length'))
def test_put_no_content_type_header(self):
class WriteFile(object):
def __init__(self, context):
self.context = context
self._written = ''
self._closed = False
mimeType = None
encoding = None
def write(self, data):
self._written += data
def close(self):
self._closed = True
adapterInstance = WriteFile(None)
def factory(context):
return adapterInstance
self.mock_adapter(factory, IRawWriteFile, (Item, ))
request = DAVTestRequest(environ={'BODYFILE': StringIO('data')})
item = Item('item')
item.REQUEST = request
self.replay()
item.PUT()
self.assertEqual(None, adapterInstance.mimeType)
self.assertEqual(None, adapterInstance.encoding)
self.assertEqual('data', adapterInstance._written)
self.assertEqual(True, adapterInstance._closed)
def test_getattr_consults_schema_item_default_factory_with_context(self):
content = Item()
content.id = u"id"
content.portal_type = u"testtype"
from zope.interface import provider
from zope.schema.interfaces import IContextAwareDefaultFactory
@provider(IContextAwareDefaultFactory)
def defaultFactory(context):
return u"{0:s}_{1:s}".format(context.id, context.portal_type)
class ISchema(Interface):
foo = zope.schema.TextLine(title=u"foo",
defaultFactory=defaultFactory)
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')
self.assertEqual(u"id_testtype", content.foo)
self.assertEqual(None, content.bar)
self.assertEqual(u"id", content.id)
self.assertRaises(AttributeError, getattr, content, 'baz')
def test_content_type_no_adapter(self):
item = Item('test')
self.replay()
self.assertEqual(None, item.content_type())
self.assertEqual(None, item.Format())
def test_get_simple_adapter(self):
class ReadFileAdapter(object):
def __init__(self, context):
self.context = context
mimeType = 'text/foo'
encoding = 'latin1'
def size(self):
return 10
def read(self, size=None):
return '1234567890'
self.mock_adapter(ReadFileAdapter, IRawReadFile, (Item,))
request = DAVTestRequest()
item = Item('item')
item.REQUEST = request
self.replay()
self.assertEqual('1234567890', item.manage_DAVget())
self.assertEqual(
'text/foo; charset="latin1"',
request.response.getHeader('Content-Type')
)
self.assertEqual('10', request.response.getHeader('Content-Length'))
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_put_no_content_type_header(self):
class WriteFile(object):
def __init__(self, context):
self.context = context
self._written = ''
self._closed = False
mimeType = None
encoding = None
def write(self, data):
self._written += data
def close(self):
self._closed = True
adapterInstance = WriteFile(None)
def factory(context):
return adapterInstance
self.mock_adapter(factory, IRawWriteFile, (Item,))
request = DAVTestRequest(environ={'BODYFILE': StringIO('data')})
item = Item('item')
item.REQUEST = request
self.replay()
item.PUT()
self.assertEqual(None, adapterInstance.mimeType)
self.assertEqual(None, adapterInstance.encoding)
self.assertEqual('data', adapterInstance._written)
self.assertEqual(True, adapterInstance._closed)
def test_get_streaming(self):
class ReadFileAdapter(object):
implements(IStreamIterator)
def __init__(self, context):
self.context = context
mimeType = None
encoding = None
def size(self):
return 10
def read(self, size=None):
return '1234567890'
adapterInstance = ReadFileAdapter(None)
def factory(context):
return adapterInstance
self.mock_adapter(factory, IRawReadFile, (Item,))
request = DAVTestRequest()
item = Item('item')
item.REQUEST = request
self.replay()
self.assertEqual(adapterInstance, item.manage_DAVget())
def test_dexterity_item(self):
# prepare a fti
portal_type = 'testtype'
fti = DexterityFTI(portal_type)
fti.klass = 'plone.dexterity.content.Item'
fti.schema = Interface.__identifier__
self.portal.portal_types._setObject(portal_type, fti)
register(fti)
# prepare an item
item = Item('testitem')
item.portal_type = portal_type
self.portal._setObject(item.id, item)
item = self.portal[item.id]
john = create(Builder('user').with_roles('Reader', on=item))
item.reindexObject()
catalog = getToolByName(self.portal, 'portal_catalog')
result = catalog(principal_with_local_roles=[john.getId()])
self.assertEquals(1,
len(result),
'Expect one entry')
self.assertEquals(result[0].getPath(),
'/'.join(item.getPhysicalPath()))
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_getattr_consults_schema_item_default_factory_with_context(self):
content = Item()
content.id = u"id"
content.portal_type = u"testtype"
from zope.interface import provider
from zope.schema.interfaces import IContextAwareDefaultFactory
@provider(IContextAwareDefaultFactory)
def defaultFactory(context):
return u"{0:s}_{1:s}".format(context.id, context.portal_type)
class ISchema(Interface):
foo = zope.schema.TextLine(title=u"foo",
defaultFactory=defaultFactory)
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')
self.assertEqual(u"id_testtype", content.foo)
self.assertEqual(None, content.bar)
self.assertEqual(u"id", content.id)
self.assertRaises(AttributeError, getattr, content, 'baz')
def test_put_no_adapter(self):
request = DAVTestRequest(environ={'BODYFILE': StringIO('')})
item = Item('item')
item.REQUEST = request
self.assertRaises(MethodNotAllowed, item.PUT)
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 test_put_no_body(self):
request = DAVTestRequest()
item = Item('item')
item.REQUEST = request
self.assertRaises(MethodNotAllowed, item.PUT)
def test_content_type_no_adapter(self):
item = Item('test')
self.replay()
self.assertEqual(None, item.content_type())
self.assertEqual(None, item.Format())
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_put_no_body(self):
request = DAVTestRequest()
item = Item('item')
item.REQUEST = request
self.assertRaises(MethodNotAllowed, item.PUT)
def test_item_dublincore_datetime(self):
from DateTime.DateTime import DateTime
i = Item(
title=u"Emperor Penguin",
description=u'One of the most magnificent birds.',
subject=u'Penguins',
contributors=u'admin',
effective_date=datetime(2010, 8, 20, 12, 59, 59, 0, timezone('US/Eastern')),
expiration_date=datetime(2013, 7, 9, 12, 59, 59, 0, timezone('US/Eastern')),
format='text/plain',
language='de',
rights='CC',
)
summer_timezone=DateTime('2010/08/20').timezone()
self.assertEqual(i.effective_date, DateTime('08/20/2010 12:59:59 GMT-5'))
self.assertEqual(i.EffectiveDate(zone=summer_timezone),
DateTime('2010-08-20 12:59:59 GMT-5').toZone(summer_timezone).ISO())
self.assertEqual(i.effective(), DateTime('08/20/2010 12:59:59 GMT-5'))
self.assertEqual(i.expiration_date, DateTime('07/09/2013 12:59:59 GMT-5'))
self.assertEqual(i.ExpirationDate(zone=summer_timezone),
DateTime('2013-07-09 12:59:59 GMT-5').toZone(summer_timezone).ISO())
self.assertEqual(i.expires(), DateTime('2013/07/09 12:59:59 GMT-5'))
self.assertEqual(i.creation_date, i.created())
self.assertEqual(i.CreationDate(), i.creation_date.ISO())
self.assertEqual(i.modification_date, i.creation_date)
self.assertEqual(i.modification_date, i.modified())
self.assertEqual(i.ModificationDate(), i.modification_date.ISO())
self.assertEqual(i.Date(), i.EffectiveDate())
def test_Creators_handles_None(self):
i = Item()
i.creators = None
self.assertEqual((), i.Creators())
c = Container()
c.creators = None
self.assertEqual((), c.Creators())
def test_get_simple_adapter(self):
class ReadFileAdapter(object):
def __init__(self, context):
self.context = context
mimeType = 'text/foo'
encoding = 'latin1'
def size(self):
return 10
def read(self, size=None):
return '1234567890'
self.mock_adapter(ReadFileAdapter, IRawReadFile, (Item, ))
request = DAVTestRequest()
item = Item('item')
item.REQUEST = request
self.replay()
self.assertEqual('1234567890', item.manage_DAVget())
self.assertEqual('text/foo; charset="latin1"',
request.response.getHeader('Content-Type'))
self.assertEqual('10', request.response.getHeader('Content-Length'))
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_get_streaming(self):
class ReadFileAdapter(object):
implements(IStreamIterator)
def __init__(self, context):
self.context = context
mimeType = None
encoding = None
def size(self):
return 10
def read(self, size=None):
return '1234567890'
adapterInstance = ReadFileAdapter(None)
def factory(context):
return adapterInstance
self.mock_adapter(factory, IRawReadFile, (Item, ))
request = DAVTestRequest()
item = Item('item')
item.REQUEST = request
self.replay()
self.assertEqual(adapterInstance, item.manage_DAVget())
def test_put_no_adapter(self):
request = DAVTestRequest(environ={'BODYFILE': StringIO('')})
item = Item('item')
item.REQUEST = request
self.assertRaises(MethodNotAllowed, item.PUT)
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"é")
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 = self.mocker.mock()
self.expect(fti.isConstructionAllowed(container)).result(False)
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()
self.assertRaises(
ValueError,
container._verifyObjectPaste,
content,
True
)
def test_put_no_adapter(self):
request = DAVTestRequest(environ={"BODYFILE": StringIO("")})
item = Item("item")
item.REQUEST = request
self.replay()
self.assertRaises(MethodNotAllowed, item.PUT)
def test_item_notifyModified(self):
i = Item()
def mock_addCreator():
mock_addCreator.called = True
i.addCreator = mock_addCreator
i.notifyModified()
self.assertNotEqual(i.modification_date, i.creation_date)
self.assertTrue(mock_addCreator.called)
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_uuid_assigned_on_creation(self):
from plone.dexterity.content import Item
from plone.uuid.interfaces import IUUID
from zope.event import notify
from zope.lifecycleevent import ObjectCreatedEvent
item = Item()
notify(ObjectCreatedEvent(item))
self.assertTrue(IUUID(item) is not None)
self.assertEqual(IUUID(item), item.UID())
def test_item_notifyModified(self):
i = Item()
def mock_addCreator():
mock_addCreator.called = True
i.addCreator = mock_addCreator
i.notifyModified()
self.assertNotEqual(i.modification_date, i.creation_date)
self.assertTrue(mock_addCreator.called)
def test_provided_by_item(self):
class FauxDataManager(object):
def setstate(self, obj):
pass
def oldstate(self, obj, tid):
pass
def register(self, obj):
pass
# Dummy instance
item = Item(id=u'id')
item.portal_type = 'testtype'
item._p_jar = FauxDataManager()
# Dummy schema
class ISchema(Interface):
foo = zope.schema.TextLine(title=u"foo", default=u"foo_default")
bar = zope.schema.TextLine(title=u"bar")
class IMarker(Interface):
pass
# Schema is not implemented by class or provided by instance
self.assertFalse(ISchema.implementedBy(Item))
self.assertFalse(ISchema.providedBy(item))
# FTI mock
fti_mock = self.mocker.proxy(DexterityFTI(u"testtype"))
self.expect(fti_mock.lookupSchema()).result(ISchema).count(1)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
self.assertFalse(ISchema.implementedBy(Item))
# Schema as looked up in FTI is now provided by item ...
self.assertTrue(ISchema.providedBy(item))
# If the _v_ attribute cache does not work, then we'd expect to have
# to look up the schema more than once (since we invalidated)
# the cache. This is not the case, as evidenced by .count(1) above.
self.assertTrue(ISchema.providedBy(item))
# We also need to ensure that the _v_ attribute doesn't hide any
# interface set directly on the instance with alsoProvides() or
# directlyProvides(). This is done by clearing the cache when these
# are invoked.
alsoProvides(item, IMarker)
self.assertTrue(IMarker.providedBy(item))
self.assertTrue(ISchema.providedBy(item))
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_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_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_content_type_simple_adapter(self):
class ReadFileAdapter(object):
def __init__(self, context):
self.context = context
mimeType = 'text/foo'
# others omitted
self.mock_adapter(ReadFileAdapter, IRawReadFile, (Item,))
item = Item('test')
self.assertEqual('text/foo', item.content_type())
self.assertEqual('text/foo', item.Format())
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_setCreators_converts_to_unicode(self):
i = Item()
i.setCreators(("é",))
self.assertEqual(i.creators, (u"é",))
i.setCreators((u"é",))
self.assertEqual(i.creators, (u"é",))
c = Container()
c.setCreators(("é",))
self.assertEqual(c.creators, (u"é",))
c.setCreators((u"é",))
self.assertEqual(c.creators, (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_item_Type(self):
i = Item()
def mock_getTypeInfo():
class TypeInfo(object):
def Title(self):
return 'Foo'
return TypeInfo()
i.getTypeInfo = mock_getTypeInfo
self.assertEqual(i.Type(), 'Foo')
def test_item_Type(self):
i = Item()
def mock_getTypeInfo():
class TypeInfo(object):
def Title(self):
return 'Foo'
return TypeInfo()
i.getTypeInfo = mock_getTypeInfo
self.assertEqual(i.Type(), 'Foo')
def test_content_type_simple_adapter(self):
class ReadFileAdapter(object):
def __init__(self, context):
self.context = context
mimeType = 'text/foo'
# others omitted
self.mock_adapter(ReadFileAdapter, IRawReadFile, (Item, ))
item = Item('test')
self.assertEqual('text/foo', item.content_type())
self.assertEqual('text/foo', item.Format())
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_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_container_manage_delObjects(self):
# OFS does not check the delete permission for each object being
# deleted. We want to.
item = Item(id='test')
container = Container(id='container')
container['test'] = item
from zExceptions import Unauthorized
self.assertRaises(Unauthorized, container.manage_delObjects, ['test'])
# Now permit it and try again.
from Products.CMFCore.permissions import DeleteObjects
item.manage_permission(DeleteObjects, ('Anonymous', ))
container.manage_delObjects(['test'])
self.assertFalse('test' in container)
def test_no_tagged_value(self):
# Mock schema model
class ITestSchema(Interface):
test = zope.schema.TextLine(title=u"Test")
# Mock FTI
fti_mock = self.mocker.proxy(DexterityFTI(u"testtype"))
self.expect(fti_mock.lookupSchema()).result(ITestSchema)
self.expect(fti_mock.behaviors).result(tuple())
self.mock_utility(fti_mock, IDexterityFTI, u'testtype')
# Content item
item = Item('test')
item.portal_type = u"testtype"
item.test = u"foo"
item.foo = u"bar"
self.mocker.replay()
SCHEMA_CACHE.clear()
# Everything allowed
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__('test', u"foo"))
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__('foo', u"bar"))
# Unknown attributes are allowed
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__(
'random', u"stuff"))
def test_no_schema(self):
# Mock FTI
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(
fti_mock.lookupSchema()
).result(None).count(3) # not cached this time
self.mock_utility(fti_mock, IDexterityFTI, u'testtype')
# Content item
item = Item('test')
item.portal_type = u"testtype"
item.test = u"foo"
item.foo = u"bar"
self.mocker.replay()
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__('test', u"foo")
)
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__('foo', u"bar")
)
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__('random', u"stuff")
)
def test_schema_exception(self):
# Mock FTI
fti_mock = self.mocker.proxy(DexterityFTI(u"testtype"))
self.expect(fti_mock.lookupSchema()).throw(AttributeError)
self.expect(fti_mock.behaviors).result(tuple())
self.mock_utility(fti_mock, IDexterityFTI, u'testtype')
# Content item
item = Item('test')
item.portal_type = u"testtype"
item.test = u"foo"
item.foo = u"bar"
self.mocker.replay()
SCHEMA_CACHE.clear()
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__('test', u"foo"))
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__('foo', u"bar"))
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__(
'random', u"stuff"))
def test_empty_name(self):
# Mock FTI
fti_mock = DexterityFTI(u"testtype")
self.mock_utility(fti_mock, IDexterityFTI, u'testtype')
# Content item
item = Item('test')
item.portal_type = u"testtype"
SCHEMA_CACHE.clear()
self.assertTrue(
item.__allow_access_to_unprotected_subobjects__('', u"foo"))
def test_no_read_permission(self):
# Mock schema model
class ITestSchema(Interface):
test = zope.schema.TextLine(title=u"Test")
ITestSchema.setTaggedValue(READ_PERMISSIONS_KEY, dict(foo='foo.View'))
# Mock FTI
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.lookupSchema()).result(ITestSchema)
self.mock_utility(fti_mock, IDexterityFTI, u'testtype')
# Mock permissions
self.mock_utility(Permission(u'foo.View', u"View foo"), IPermission, u'foo.View')
# Content item
item = Item('test')
item.portal_type = u"testtype"
item.test = u"foo"
item.foo = u"bar"
# Check permission
securityManager_mock = self.mocker.mock()
self.expect(securityManager_mock.checkPermission("View foo", item)).result(True)
getSecurityManager_mock = self.mocker.replace('AccessControl.getSecurityManager')
self.expect(getSecurityManager_mock()).result(securityManager_mock).count(1)
self.mocker.replay()
self.assertTrue(item.__allow_access_to_unprotected_subobjects__('test', u"foo"))
self.assertTrue(item.__allow_access_to_unprotected_subobjects__('foo', u"bar"))
# Unknown attributes are allowed
self.assertTrue(item.__allow_access_to_unprotected_subobjects__('random', u"stuff"))
def test_empty_name(self):
# Mock FTI
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.lookupSchema()).count(0)
self.mock_utility(fti_mock, IDexterityFTI, u'testtype')
# Content item
item = Item('test')
item.portal_type = u"testtype"
self.mocker.replay()
self.assertTrue(item.__allow_access_to_unprotected_subobjects__('', u"foo"))
def test_get_size_right_adapter(self):
class SizedAdapter(object):
def __init__(self, context):
self.context = context
def sizeForSorting(self):
return 'bytes', 10
def sizeForDisplay(self):
'10 bytes'
self.mock_adapter(SizedAdapter, ISized, (Item, ))
item = Item('test')
self.assertEqual(10, item.get_size())
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_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_tags(self):
item = Item(id='dummy_a')
storage = self.backend.acquire(item)
self.assertEqual(storage.tags(), (
('initial', '0'),
('release', '3'),
))
