def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Contributor'])
fti = DexterityFTI('leadimagefolder')
self.portal.portal_types._setObject('leadimagefolder', fti)
fti.klass = 'plone.dexterity.content.Container'
fti.behaviors = (
'plone.app.contenttypes.behaviors.leadimage.ILeadImage',
)
self.fti = fti
alsoProvides(self.portal.REQUEST, IPloneAppContenttypesLayer)
alsoProvides(self.request, IPloneAppContenttypesLayer)
from plone.app.contenttypes.behaviors.leadimage import ILeadImage
alsoProvides(self.request, ILeadImage)
self.portal.invokeFactory(
'leadimagefolder',
id='leadimagefolder',
title=u'Folder with a lead image'
)
import transaction
transaction.commit()
# Set up browser
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic %s:%s' % (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_fires_edit_begun_event(self):
# Context and request
context_mock = self.create_dummy(portal_type=u'testtype')
request_mock = TestRequest()
# FTI
fti_mock = DexterityFTI(u"testtype")
fti_mock.lookupSchema = Mock(return_value=ISchema)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.mock_adapter(
FieldWidgets,
IWidgets,
(Interface, Interface, Interface)
)
self.mock_adapter(Actions, IActions, (Interface, Interface, Interface))
# mock notify
from zope.event import notify
notify_mock = self.patch_global(notify)
# Form
view = DefaultEditForm(context_mock, request_mock)
view.update()
self.assertTrue(notify_mock.called)
self.assertTrue(
IEditBegunEvent.providedBy(notify_mock.call_args[0][0]))
def test_repeated_behavior_registration_lookup(self):
fti = DexterityFTI(u"testtype")
self.mock_utility(fti, IDexterityFTI, name=u"testtype")
# Mock a test behavior
class ITestBehavior(Interface):
pass
fti.behaviors = [ITestBehavior.__identifier__]
from plone.behavior.registration import BehaviorRegistration
registration = BehaviorRegistration(
title=u"Test Behavior",
description=u"Provides test behavior",
interface=Interface,
marker=ITestBehavior,
factory=None
)
from plone.behavior.interfaces import IBehavior
self.mock_utility(
registration,
IBehavior,
ITestBehavior.__identifier__
)
r1 = SCHEMA_CACHE.behavior_registrations(u'testtype')
r2 = SCHEMA_CACHE.behavior_registrations(u'testtype')
self.assertTrue(r1[0] is r2[0] is registration)
def test_clear_all_caches(self):
class ISchema1(Interface):
pass
fti1 = DexterityFTI(u"testtype")
fti1.lookupSchema = Mock(return_value=ISchema1)
self.mock_utility(fti1, IDexterityFTI, name=u"testtype1")
fti2 = DexterityFTI(u"testtype")
fti2.lookupSchema = Mock(return_value=ISchema1)
self.mock_utility(fti2, IDexterityFTI, name=u"testtype2")
# reset schemacache counter
SCHEMA_CACHE.invalidations = 0
# fill cache should call lookupschema one time
schema1 = SCHEMA_CACHE.get(u"testtype1")
schema2 = SCHEMA_CACHE.get(u"testtype2")
self.assertTrue(schema1 is schema2 is ISchema1)
# clear
SCHEMA_CACHE.clear()
self.assertEqual(SCHEMA_CACHE.invalidations, 2)
# check invalidations
# fill cache again should call lookupschema one time
schema1 = SCHEMA_CACHE.get(u"testtype1")
schema2 = SCHEMA_CACHE.get(u"testtype2")
self.assertTrue(schema1 is schema2 is ISchema1)
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 create(self, data):
id = data.pop('id')
fti = DexterityFTI(id)
fti.id = id
data['title'] = data['title'].encode('utf8')
if data['description']:
data['description'] = data['description'].encode('utf8')
data['i18n_domain'] = 'plone'
data['behaviors'] = '\n'.join([
'plone.dublincore',
'plone.namefromtitle',
])
data['model_source'] = """
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema>
</schema>
</model>
"""
data['klass'] = 'plone.dexterity.content.Container'
data['filter_content_types'] = True
data['icon_expr'] = 'string:${portal_url}/document_icon.png'
fti.manage_changeProperties(**data)
return fti
def test_global_components_not_unregistered_on_delete(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace("zope.component.hooks.getSiteManager")
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
# Register FTI utility and factory utility
self.mock_utility(fti, IDexterityFTI, name=portal_type)
self.mock_utility(DexterityFactory(portal_type), IFactory, name=portal_type)
# We expect to always be able to unregister without error, even if the
# component exists. The factory is only unregistered if it was registered
# with info='plone.dexterity.dynamic'.
self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()
self.replay()
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
site_dummy = self.create_dummy(getSiteManager=lambda: site_manager_mock)
setSite(site_dummy)
setHooks()
self.assertNotEquals(None, queryUtility(IDexterityFTI, name=portal_type))
self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))
def test_deleted_factory_not_unregistered_if_not_unique(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type, factory="common-factory")
portal_type2 = u"testtype2"
fti2 = DexterityFTI(portal_type2, factory="common-factory")
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace("zope.component.hooks.getSiteManager")
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1, None)
# Pretend two FTIs are registered, both using common-factory
# NB: Assuming that "testtype" was already removed when this gets called
self.expect(site_manager_mock.registeredUtilities()).result(
[
self.create_dummy(provided=IFactory, name="common-factory", info="plone.dexterity.dynamic"),
self.create_dummy(
component=fti2, provided=IDexterityFTI, name="testtype2", info="plone.dexterity.dynamic"
),
]
)
# We shouldn't remove this since fti2 still uses it
self.expect(site_manager_mock.unregisterUtility(provided=IFactory, name="common-factory")).count(0)
# The type itself should be removed though
self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=u"testtype")).count(1)
self.replay()
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
def setUpContentTypes(self, portal):
from plone.dexterity.fti import DexterityFTI
from plone.dexterity.fti import register
from plone.app.content.interfaces import INameFromTitle
from plone.app.dexterity.behaviors.metadata import IOwnership
from collective.multilingual.interfaces import IMultilingual
bs = (
dottedName(IMultilingual),
dottedName(IOwnership),
dottedName(INameFromTitle),
)
content_types = [
("Item", "Item", (), bs),
("Container", "Container", ("Item", "Container"), bs),
]
# Set up Dexterity-based content types.
for portal_type, klass, allowed_content_types, bs in content_types:
fti = DexterityFTI(portal_type)
fti.allowed_content_types = allowed_content_types
fti.behaviors = bs
fti.klass = "plone.dexterity.content." + klass
register(fti)
# There's got to be a better way :-)
portal.portal_types._setOb(portal_type, fti)
def test_components_not_registered_on_add_if_exist(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace("zope.component.hooks.getSiteManager")
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
# Register FTI utility and factory utility
self.mock_utility(fti, IDexterityFTI, name=portal_type)
self.mock_utility(DexterityFactory(portal_type), IFactory, name=portal_type)
# We expect that all components are registered, so do not expect any registrations
self.expect(site_manager_mock.registerUtility(fti, IDexterityFTI, portal_type)).passthrough().count(0)
self.expect(
site_manager_mock.registerUtility(
mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.portal_type == portal_type),
IFactory,
portal_type,
)
).passthrough().count(0)
self.replay()
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
def test_add_raises_value_error_if_type_not_addable(self):
# Container, new object, and request
container = Mock()
obj = Mock()
request = TestRequest()
obj.portal_type = 'testtype'
# New object's FTI
fti_mock = DexterityFTI(u"testtype")
fti_mock.isConstructionAllowed = Mock(return_value=True)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
# Container FTI
container_fti_mock = DexterityFTI(u"containertype")
container_fti_mock.allowType = Mock(return_value=False)
self.mock_utility(
container_fti_mock,
IDexterityFTI,
name=u"containertype"
)
container.getTypeInfo = Mock(return_value=container_fti_mock)
form = DefaultAddForm(container, request)
form.portal_type = u"testtype"
self.assertRaises(ValueError, form.add, obj)
def setUp(self):
# add IShortName behavior to Page
self.portal = self.layer['portal']
self.request = self.layer['request']
setRoles(self.portal, TEST_USER_ID, ['Manager'])
fti = DexterityFTI('LockableType',
factory='LockableType')
fti.behaviors = ('plone.app.lockingbehavior.behaviors.ILocking', )
fti.global_allow = True
self.portal.portal_types._setObject('LockableType', fti)
transaction.commit()
# prepare two browsers
self.foo_browser = z2.Browser(self.layer['app'])
self.foo_browser.addHeader(
'Authorization', 'Basic %s:%s'
% (SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
self.foo_browser.open('http://nohost/plone')
self.bar_browser = z2.Browser(self.layer['app'])
self.bar_browser.addHeader(
'Authorization', 'Basic %s:%s'
% (TEST_USER_NAME, TEST_USER_PASSWORD,)
)
self.bar_browser.open('http://nohost/plone')
def test_label(self):
# Add view should take its label from the FTI title
# Context and request
context_mock = Mock()
request_mock = TestRequest()
request_mock.form['disable_border'] = True
# FTI
fti_mock = DexterityFTI(u"testtype")
fti_mock.Title = Mock(return_value=u'Test title')
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
# Form
addform = DefaultAddForm(context_mock, request_mock)
addform.portal_type = u"testtype"
label = addform.label
self.assertEqual(u"Add ${name}", six.text_type(label))
self.assertEqual(u"Test title", label.mapping['name'])
def test_update_checks_allowed_types(self):
# Context and request
context_mock = self.create_dummy(
portal_type=u'testtype',
allowedContentTypes=lambda: [])
request_mock = TestRequest()
# FTI
fti_mock = DexterityFTI(u"testtype")
fti_mock.lookupSchema = Mock(return_value=ISchema)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.mock_adapter(
FieldWidgets,
IWidgets,
(Interface, Interface, Interface)
)
self.mock_adapter(Actions, IActions, (Interface, Interface, Interface))
# Form
view = DefaultAddForm(context_mock, request_mock)
view.portal_type = fti_mock.getId()
self.assertRaises(ValueError, view.update)
def test_update_ignores_type_check_if_security_check_deferred(self):
# Context and request
context_mock = self.create_dummy(
portal_type=u'testtype',
allowedContentTypes=lambda: [])
request_mock = TestRequest()
alsoProvides(request_mock, IDeferSecurityCheck)
# FTI
fti_mock = DexterityFTI(u"testtype")
fti_mock.lookupSchema = Mock(return_value=ISchema)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.mock_adapter(
FieldWidgets,
IWidgets,
(Interface, Interface, Interface)
)
self.mock_adapter(Actions, IActions, (Interface, Interface, Interface))
# Form
view = DefaultAddForm(context_mock, request_mock)
view.portal_type = fti_mock.getId()
try:
view.update()
except ValueError:
self.fail("Update raised Unauthorized with security checks "
"deferred")
def test_lookupModel_failure(self):
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = None
fti.model_file = None
self.assertRaises(ValueError, fti.lookupModel)
def setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Contributor'])
fti = DexterityFTI('tocdocument')
self.portal.portal_types._setObject('tocdocument', fti)
fti.klass = 'plone.dexterity.content.Item'
fti.behaviors = (
'plone.app.contenttypes.behaviors.tableofcontents.'
'ITableOfContents',
)
self.fti = fti
alsoProvides(self.portal.REQUEST, IPloneAppContenttypesLayer)
alsoProvides(self.request, IPloneAppContenttypesLayer)
from plone.app.contenttypes.behaviors.tableofcontents \
import ITableOfContents
alsoProvides(self.request, ITableOfContents)
self.portal.invokeFactory(
'tocdocument',
id='tocdoc',
title=u'Document with a table of contents'
)
import transaction
transaction.commit()
# Set up browser
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic {0}:{1}'.format(SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_renamed_factory_not_unregistered_if_not_unique(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type, factory='common-factory')
portal_type2 = u"testtype2"
fti2 = DexterityFTI(portal_type2, factory='common-factory')
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace('zope.app.component.hooks.getSiteManager')
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1,None)
# Pretend two FTIs are registered, both using common-factory
self.expect(site_manager_mock.registeredUtilities()).result([
self.create_dummy(provided=IFactory, name='common-factory', info='plone.dexterity.dynamic'),
self.create_dummy(component=fti, provided=IDexterityFTI, name='testtype', info='plone.dexterity.dynamic'),
self.create_dummy(component=fti2, provided=IDexterityFTI, name='testtype2', info='plone.dexterity.dynamic'),
])
# We shouldn't remove this since fti2 still uses it
self.expect(site_manager_mock.unregisterUtility(provided=IFactory, name='common-factory')).count(0)
# And a new one to be created with the new factory name
self.expect(site_manager_mock.registerUtility(
mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.portal_type == portal_type),
IFactory, 'new-factory', info='plone.dexterity.dynamic')).passthrough()
self.replay()
fti.factory = 'new-factory'
ftiModified(fti, ObjectModifiedEvent(fti, DexterityFTIModificationDescription('factory', 'common-factory')))
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
# TYPE 1
type1_fti = DexterityFTI('type1')
type1_fti.klass = 'plone.dexterity.content.Container'
type1_fti.filter_content_types = True
type1_fti.allowed_content_types = []
type1_fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IBasic',
)
self.portal.portal_types._setObject('type1', type1_fti)
self.type1_fti = type1_fti
# TYPE 2
type2_fti = DexterityFTI('type1')
type2_fti.klass = 'plone.dexterity.content.Item'
type2_fti.filter_content_types = True
type2_fti.allowed_content_types = []
type2_fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IBasic',
)
self.portal.portal_types._setObject('type2', type2_fti)
self.type2_fti = type2_fti
login(self.portal, TEST_USER_NAME)
setRoles(self.portal, TEST_USER_ID, ['Manager'])
self.portal.invokeFactory('type1', id='it1', title='Item 1')
self.portal.invokeFactory('type2', id='it2', title='Item 2')
def test_components_unregistered_on_delete(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace("zope.component.hooks.getSiteManager")
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1, None)
# We expect to always be able to unregister without error, even if the
# components do not exists (as here)
self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()
self.expect(site_manager_mock.unregisterUtility(provided=IFactory, name=portal_type)).passthrough()
self.replay()
# First add the components
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
# Then remove them again
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
site_dummy = self.create_dummy(getSiteManager=lambda: site_manager_mock)
setSite(site_dummy)
setHooks()
self.assertEquals(None, queryUtility(IDexterityFTI, name=portal_type))
self.assertEquals(None, queryUtility(IFactory, name=portal_type))
def test_repeated_subtypes_lookup(self):
fti = DexterityFTI(u"testtype")
self.mock_utility(fti, IDexterityFTI, name=u"testtype")
# Mock a test behavior
class ITestSchema(Interface):
pass
class ITestMarker(Interface):
pass
fti.behaviors = [ITestSchema.__identifier__]
from plone.behavior.registration import BehaviorRegistration
registration = BehaviorRegistration(
title=u"Test Behavior",
description=u"Provides test behavior",
interface=ITestSchema,
marker=ITestMarker,
factory=None
)
from plone.behavior.interfaces import IBehavior
self.mock_utility(
registration,
IBehavior,
ITestSchema.__identifier__
)
s1 = SCHEMA_CACHE.subtypes(u"testtype")
s2 = SCHEMA_CACHE.subtypes(u"testtype")
self.assertTrue(s1[0] is s2[0] is ITestMarker)
def test_new_factory_not_registered_after_name_changed_if_exists(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace("zope.component.hooks.getSiteManager")
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1, None)
# Create a global default for the new name
self.mock_utility(DexterityFactory(portal_type), IFactory, name="new-factory")
# Factory should not be registered again
self.expect(
site_manager_mock.registerUtility(
mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.portal_type == portal_type),
IFactory,
"new-factory",
info="plone.dexterity.dynamic",
)
).passthrough().count(0)
self.replay()
fti.factory = "new-factory"
ftiModified(fti, ObjectModifiedEvent(fti, DexterityFTIModificationDescription("factory", "old-factory")))
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 setUp(self):
app = self.layer['app']
self.portal = self.layer['portal']
self.wf = api.portal.get_tool('portal_workflow')
self.portal.acl_users._doAddUser('user_std', 'secret', ['Member'], [])
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Manager'])
fti = DexterityFTI(self.portal_type)
self.portal.portal_types._setObject(self.portal_type, fti)
fti.klass = 'plone.dexterity.content.Item'
fti.behaviors = self.behaviors
api.content.create(
container=self.portal,
type=self.portal_type,
id='doc1')
setRoles(self.portal, TEST_USER_ID, ['Member'])
import transaction
transaction.commit()
# Set up browser
self.browser = Browser(app)
self.browser.handleErrors = False
self.browser.addHeader(
'Authorization',
'Basic {0}:{1}'.format(SITE_OWNER_NAME, SITE_OWNER_PASSWORD,)
)
def test_old_factory_not_unregistered_if_not_created_by_dexterity(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
getSiteManager_mock = self.mocker.replace('zope.app.component.hooks.getSiteManager')
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1,None)
# Pretend like we have a utility registered
reg1 = self.create_dummy()
reg1.provided = IFactory
reg1.name = 'old-factory'
reg1.info = None
self.expect(site_manager_mock.registeredUtilities()).result([reg1])
# This should not be removed, since we didn't create it
self.expect(site_manager_mock.unregisterUtility(provided=IFactory, name='old-factory')).count(0)
# A new one may still be created, however
self.expect(site_manager_mock.registerUtility(
mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.portal_type == portal_type),
IFactory, 'new-factory', info='plone.dexterity.dynamic')).passthrough()
self.replay()
fti.factory = 'new-factory'
ftiModified(fti, ObjectModifiedEvent(fti, DexterityFTIModificationDescription('factory', 'old-factory')))
def test_checks_permission_in_is_construction_allowed_false(self):
fti = DexterityFTI(u"testtype")
fti.add_permission = "demo.Permission"
container_dummy = self.create_dummy()
permission_dummy = self.create_dummy()
permission_dummy.id = 'demo.Permission'
permission_dummy.title = 'Some add permission'
self.mock_utility(
permission_dummy,
IPermission,
name=u"demo.Permission"
)
security_manager_mock = self.mocker.mock()
self.expect(
security_manager_mock.checkPermission(
"Some add permission",
container_dummy
)
).result(False)
getSecurityManager_mock = self.mocker.replace(
'AccessControl.getSecurityManager'
)
self.expect(getSecurityManager_mock()).result(security_manager_mock)
self.replay()
self.assertEqual(False, fti.isConstructionAllowed(container_dummy))
def test_checks_permission_in_is_construction_allowed_false(self):
fti = DexterityFTI('testtype')
fti.add_permission = 'demo.Permission'
container_dummy = self.create_dummy()
permission_dummy = self.create_dummy()
permission_dummy.id = 'demo.Permission'
permission_dummy.title = 'Some add permission'
self.mock_utility(
permission_dummy,
IPermission,
name='demo.Permission'
)
security_manager_mock = self.mocker.mock()
self.expect(
security_manager_mock.checkPermission( # noqa
'Some add permission',
container_dummy
)
).result(False)
getSecurityManager_mock = self.mocker.replace(
'zopepolicy.ZopeSecurityPolicy.getSecurityManager'
)
self.expect(getSecurityManager_mock()).result(security_manager_mock)
self.replay()
self.assertEqual(False, fti.isConstructionAllowed(container_dummy))
def test_components_unregistered_on_delete_does_not_error_with_no_components(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(
PersistentComponents(bases=(getGlobalSiteManager(),))
)
getSiteManager_mock = self.mocker.replace(
'zope.component.hooks.getSiteManager'
)
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
# We expect to always be able to unregister without error, even if the
# components do not exists (as here)
self.expect(site_manager_mock.unregisterUtility(
provided=IDexterityFTI,
name=portal_type)
).passthrough()
self.replay()
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
self.portal_url = self.portal.absolute_url()
setRoles(self.portal, TEST_USER_ID, ['Manager'])
fti = DexterityFTI('collectioncontainer')
self.portal.portal_types._setObject('collectioncontainer', fti)
fti.klass = 'plone.dexterity.content.Container'
fti.behaviors = (
'plone.app.contenttypes.behaviors.collection.ICollection',
)
self.fti = fti
alsoProvides(self.portal.REQUEST, IPloneAppContenttypesLayer)
alsoProvides(self.request, IPloneAppContenttypesLayer)
from plone.app.contenttypes.behaviors.collection import ICollection
alsoProvides(self.request, ICollection)
self.portal.invokeFactory(
'collectioncontainer',
id='collectioncontainer',
title=u'Container with a collection',
customViewFields=['Title', 'portal_type'],
query=query,
)
self.portal.invokeFactory(
'Document',
id='doc',
title=u'Collection Test Page',
)
def test_supports(self):
# Context mock
context_dummy = self.create_dummy(portal_type=u"testtype")
# Behavior mock
behavior_dummy_1 = self.create_dummy(interface=IOne)
self.mock_utility(
behavior_dummy_1,
IBehavior,
name=IOne.__identifier__
)
behavior_dummy_4 = self.create_dummy(interface=IFour)
self.mock_utility(
behavior_dummy_4,
IBehavior,
name=IFour.__identifier__
)
# FTI mock
fti = DexterityFTI(u"testtype")
fti.behaviors = [IOne.__identifier__, IFour.__identifier__]
self.mock_utility(fti, IDexterityFTI, name=u"testtype")
assignable = DexterityBehaviorAssignable(context_dummy)
self.assertEqual(True, assignable.supports(IOne))
self.assertEqual(False, assignable.supports(ITwo))
self.assertEqual(True, assignable.supports(IThree))
self.assertEqual(True, assignable.supports(IFour))
def test_components_unregistered_on_delete(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(
PersistentComponents(bases=(getGlobalSiteManager(), )))
getSiteManager_mock = self.mocker.replace(
'zope.component.hooks.getSiteManager')
self.expect(
getSiteManager_mock(dummy_site)).result(site_manager_mock).count(
1, None)
# We expect to always be able to unregister without error, even if the
# components do not exists (as here)
self.expect(
site_manager_mock.unregisterUtility(
provided=IDexterityFTI, name=portal_type)).passthrough()
self.expect(
site_manager_mock.unregisterUtility(
provided=IFactory, name=portal_type)).passthrough()
self.replay()
# First add the components
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
# Then remove them again
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
site_dummy = self.create_dummy(
getSiteManager=lambda: site_manager_mock)
setSite(site_dummy)
setHooks()
self.assertEquals(None, queryUtility(IDexterityFTI, name=portal_type))
self.assertEquals(None, queryUtility(IFactory, name=portal_type))
def test_deleted_factory_not_unregistered_if_not_unique(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type, factory='common-factory')
portal_type2 = u"testtype2"
fti2 = DexterityFTI(portal_type2, factory='common-factory')
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(
PersistentComponents(bases=(getGlobalSiteManager(), )))
getSiteManager_mock = self.mocker.replace(
'zope.component.hooks.getSiteManager')
self.expect(
getSiteManager_mock(dummy_site)).result(site_manager_mock).count(
1, None)
# Pretend two FTIs are registered, both using common-factory
# NB: Assuming that "testtype" was already removed when this gets called
self.expect(site_manager_mock.registeredUtilities()).result([
self.create_dummy(provided=IFactory,
name='common-factory',
info='plone.dexterity.dynamic'),
self.create_dummy(component=fti2,
provided=IDexterityFTI,
name='testtype2',
info='plone.dexterity.dynamic'),
])
# We shouldn't remove this since fti2 still uses it
self.expect(
site_manager_mock.unregisterUtility(
provided=IFactory, name='common-factory')).count(0)
# The type itself should be removed though
self.expect(
site_manager_mock.unregisterUtility(provided=IDexterityFTI,
name=u"testtype")).count(1)
self.replay()
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
def test_components_registered_on_add(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(
PersistentComponents(bases=(getGlobalSiteManager(), )))
getSiteManager_mock = self.mocker.replace(
'zope.component.hooks.getSiteManager')
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
# We expect that no components are registered , so look for all registrations
self.expect(
site_manager_mock.registerUtility(
fti,
IDexterityFTI,
portal_type,
info='plone.dexterity.dynamic')).passthrough()
self.expect(
site_manager_mock.registerUtility(
mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.
portal_type == portal_type),
IFactory,
portal_type,
info='plone.dexterity.dynamic')).passthrough()
self.replay()
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
site_dummy = self.create_dummy(
getSiteManager=lambda: site_manager_mock)
setSite(site_dummy)
setHooks()
self.assertNotEquals(None, queryUtility(IDexterityFTI,
name=portal_type))
self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))
def test_global_components_not_unregistered_on_delete(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = self.mocker.proxy(
PersistentComponents(bases=(getGlobalSiteManager(), )))
getSiteManager_mock = self.mocker.replace(
'zope.component.hooks.getSiteManager')
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
# Register FTI utility and factory utility
self.mock_utility(fti, IDexterityFTI, name=portal_type)
self.mock_utility(DexterityFactory(portal_type),
IFactory,
name=portal_type)
# We expect to always be able to unregister without error, even if the
# component exists. The factory is only unregistered if it was registered
# with info='plone.dexterity.dynamic'.
self.expect(
site_manager_mock.unregisterUtility(
provided=IDexterityFTI, name=portal_type)).passthrough()
self.replay()
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
site_dummy = self.create_dummy(
getSiteManager=lambda: site_manager_mock)
setSite(site_dummy)
setHooks()
self.assertNotEquals(None, queryUtility(IDexterityFTI,
name=portal_type))
self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))
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.assertEquals(False, ISchema.implementedBy(Item))
self.assertEquals(False, 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.assertEquals(False, ISchema.implementedBy(Item))
# Schema as looked up in FTI is now provided by item ...
self.assertEquals(True, 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.assertEquals(True, 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.assertEquals(True, IMarker.providedBy(item))
self.assertEquals(True, ISchema.providedBy(item))
def setUpPloneSite(self, portal):
self.applyProfile(portal, 'plone.app.dexterity:default')
self.applyProfile(portal, 'plone.app.drafts:default')
if 'Folder' not in portal.portal_types.objectIds():
fti = DexterityFTI('Folder')
fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IDublinCore', )
fti.klass = 'plone.dexterity.content.Container'
fti.filter_content_types = False
fti.global_allow = True
portal.portal_types._setObject('Folder', fti)
fti = DexterityFTI('MyDocument')
fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IDublinCore',
'plone.app.drafts.interfaces.IDraftable',
)
fti.global_allow = True
portal.portal_types._setObject('MyDocument', fti)
def create_content_type(self, portal_type):
"""Create dummy content type with a single custom field"""
disableCSRFProtection()
fti = DexterityFTI(str(portal_type), title=portal_type)
fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IBasic',
'plone.app.multilingual.dx.interfaces.IDexterityTranslatable'
)
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema>
<field name="custom" type="zope.schema.TextLine">
<description />
<required>False</required>
<title>Custom field</title>
</field>
</schema>
</model>"""
fti.global_allow = True
self.portal_types._setObject(str(portal_type), fti)
def test_provided_by_subclass(self):
# Make sure the __providedBy__ descriptor lives in sub-classes
# Dummy type
class MyItem(Item):
pass
class FauxDataManager(object):
def setstate(self, obj):
pass
def oldstate(self, obj, tid):
pass
def register(self, obj):
pass
# Dummy instance
item = MyItem(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
# 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")
self.assertFalse(ISchema.implementedBy(MyItem))
# 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:
self.assertTrue(ISchema.providedBy(item))
self.assertEqual(fti_mock.lookupSchema.call_count, 1)
# 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_primary_field_info(self):
class ITest(Interface):
title = schema.TextLine()
body = schema.Text()
alsoProvides(ITest['body'], IPrimaryField)
fti = DexterityFTI(u"testtype")
fti.lookupSchema = Mock(return_value=ITest)
fti.behaviors = []
self.mock_utility(fti, IDexterityFTI, name=u"testtype")
item = Item('item')
item.portal_type = 'testtype'
item.body = u'body text'
info = PrimaryFieldInfo(item)
assert info.fieldname == 'body'
assert info.field == ITest['body']
assert info.value == 'body text'
def test_alias_dexterity_object(self):
tt = getToolByName(self.portal, 'portal_types')
fti = DexterityFTI('collective.alias.test')
fti.schema = ITest.__identifier__
tt._setObject('collective.alias.test', fti)
self.folder.invokeFactory('collective.alias.test', 't1')
self.folder['t1'].title = "Dummy title"
self.folder['t1'].foo = "Foo Bar"
relation = RelationValue(self.intids.getId(self.folder['t1']))
self.folder.invokeFactory('collective.alias',
'a2',
_aliasTarget=relation)
self.failUnless(ITest.providedBy(self.folder['a2']))
self.assertEquals("Dummy title", self.folder['a2'].title)
self.assertEquals("Foo Bar", self.folder['a2'].foo)
def test_readfile_mimetype_no_message_multiple_primary_fields(self):
class ITest(Interface):
title = schema.TextLine()
body = schema.Text()
stuff = schema.Bytes()
alsoProvides(ITest['body'], IPrimaryField)
alsoProvides(ITest['stuff'], IPrimaryField)
SCHEMA_CACHE.clear()
fti_mock = DexterityFTI(u'testtype')
fti_mock.lookupSchema = Mock(return_value=ITest)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
item = Item('item')
item.portal_type = 'testtype'
readfile = DefaultReadFile(item)
self.assertEqual('message/rfc822', readfile.mimeType)
def create(self, data):
type_id = data.pop('id')
props = dict(self.context.fti.propertyItems())
# make sure we don't share the factory
if props['factory'] == self.context.fti.getId():
del props['factory']
props['title'] = data['title']
props['add_view_expr'] = props['add_view_expr'].replace(self.context.fti.getId(), type_id)
fti = DexterityFTI(type_id, **props)
return fti
def test_invalidate_cache(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
SCHEMA_CACHE.get(portal_type)
SCHEMA_CACHE.behavior_schema_interfaces(fti)
self.assertIn('_v_schema_behavior_schema_interfaces',
fti.__dict__.keys())
invalidate_cache(fti)
self.assertNotIn('_v_schema_behavior_schema_interfaces',
fti.__dict__.keys())
def test_addview_and_factory_not_overridden_on_creation(self):
fti = DexterityFTI(
u"testtype",
add_view_expr="string:${folder_url}/@@my-addview",
factory="my.factory"
)
self.assertEqual(
'string:${folder_url}/@@my-addview',
fti.add_view_expr
)
self.assertEqual('my.factory', fti.factory)
def test_enumerate(self):
# Context mock
context_dummy = self.create_dummy(portal_type=u"testtype")
# Behavior mock
behavior_dummy = self.create_dummy()
self.mock_utility(behavior_dummy, IBehavior, name=IOne.__identifier__)
# FTI mock
fti = DexterityFTI(u"testtype")
fti.behaviors = [IOne.__identifier__]
self.mock_utility(fti, IDexterityFTI, name=u"testtype")
self.replay()
assignable = DexterityBehaviorAssignable(context_dummy)
self.assertEqual([behavior_dummy],
list(assignable.enumerateBehaviors()))
def test_none_not_cached(self):
class ISchema1(Interface):
pass
fti = DexterityFTI(u"testtype")
fti.lookupSchema = Mock(side_effect=[None, ISchema1, ISchema1])
self.mock_utility(fti, IDexterityFTI, name=u"testtype")
SCHEMA_CACHE.invalidate('testtype')
schema1 = SCHEMA_CACHE.get(u"testtype")
SCHEMA_CACHE.invalidate('testtype')
schema2 = SCHEMA_CACHE.get(u"testtype")
SCHEMA_CACHE.invalidate('testtype')
schema3 = SCHEMA_CACHE.get(u"testtype")
self.assertTrue(schema1 is None)
self.assertTrue(schema2 is schema3 is ISchema1)
def test_dynamic_schema_refreshed_on_modify_schema_policy(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
class INew(Interface):
title = zope.schema.TextLine(title=u"title")
class IBlank(Interface):
pass
class TestSchemaPolicy(DexteritySchemaPolicy):
def bases(self, schemaName, tree):
return (INew, )
gsm = getGlobalSiteManager()
policy = TestSchemaPolicy()
gsm.registerUtility(policy,
plone.supermodel.interfaces.ISchemaPolicy,
name=u"test")
site_dummy = self.create_dummy(getPhysicalPath=lambda: ('', 'siteid'))
self.mock_utility(site_dummy, ISiteRoot)
# Set source interface
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, IBlank)
original = getattr(plone.dexterity.schema.generated, schemaName)
self.assertNotIn(INew, original.__bases__)
self.assertNotIn('title', original)
# Set new schema_policy
fti.schema_policy = "test"
# Sync this with schema
ftiModified(
fti,
ObjectModifiedEvent(
fti, DexterityFTIModificationDescription('schema_policy', '')))
updated = getattr(plone.dexterity.schema.generated, schemaName)
self.assertIn('title', updated)
self.assertIn(INew, updated.__bases__)
def setUp(self):
super(DexterityContentTestCase, self).setUp()
self.portal.portal_types._setObject('test_type',
DexterityFTI('test_type'))
test_type = self.portal.portal_types.test_type
test_type.klass = 'plone.dexterity.content.Item'
test_type.behaviors = (
'plone.app.dexterity.behaviors.metadata.IDublinCore', )
self.portal.invokeFactory('test_type', 'test_content')
self.content = self.portal['test_content']
self.content.setSubject(u'Keyword1 Keyword2 Keyword3'.split())
self.content.reindexObject()
def testRelations(self):
rel_fti = DexterityFTI('RelationsType',
schema=IRelationsType.__identifier__)
self.portal.portal_types._setObject('RelationsType', rel_fti)
# Setup IIntIds utility which is required for relations to work
from five.intid import site
from zope.app.intid.interfaces import IIntIds
site.add_intids(self.portal)
intids = getUtility(IIntIds)
source = createContentInContainer(self.portal, 'RelationsType')
target = createContentInContainer(self.portal, 'RelationsType')
# Test modifier when no relations are set
modifier = SkipRelations('modifier', 'Modifier')
on_clone_modifiers = modifier.getOnCloneModifiers(source)
pers_id, pers_load, empty1, empty2 = on_clone_modifiers
self.assertTrue(pers_id(None) is None)
self.assertTrue(pers_id(None) is None)
self.assertTrue(pers_load(None) is None)
self.assertTrue(pers_load(None) is None)
self.assertTrue(empty1 == [])
self.assertTrue(empty2 == [])
repo_clone = createContent('RelationsType')
modifier.afterRetrieveModifier(source, repo_clone)
self.assertTrue(repo_clone.single is source.single)
self.assertTrue(repo_clone.multiple is source.multiple)
# Add some relations
source.single = RelationValue(intids.getId(target))
source.multiple = [RelationValue(intids.getId(target))]
# Update relations
from zope.lifecycleevent import ObjectModifiedEvent
from zope.event import notify
notify(ObjectModifiedEvent(source))
modifier = SkipRelations('modifier', 'Modifier')
on_clone_modifiers = modifier.getOnCloneModifiers(source)
pers_id, pers_load, empty1, empty2 = on_clone_modifiers
self.assertTrue(pers_id(source.single))
self.assertTrue(pers_id(source.multiple))
self.assertTrue(pers_load(source.single) is None)
self.assertTrue(pers_load(source.multiple) is None)
self.assertTrue(empty1 == [])
self.assertTrue(empty2 == [])
repo_clone = createContent('RelationsType')
modifier.afterRetrieveModifier(source, repo_clone)
self.assertTrue(repo_clone.single is source.single)
self.assertTrue(repo_clone.multiple is source.multiple)
def test_components_unregistered_on_delete_does_not_error_with_no_components(self): # noqa
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = Mock(
wraps=PersistentComponents(bases=(getGlobalSiteManager(),)))
from zope.component.hooks import getSiteManager
self.patch_global(getSiteManager, return_value=site_manager_mock)
# We expect to always be able to unregister without error, even if the
# components do not exist (as here)
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
site_manager_mock.unregisterUtility.assert_called_once_with(
provided=IDexterityFTI, name=portal_type)
def test_update_checks_allowed_types(self):
# Context and request
context_mock = self.create_dummy(portal_type=u'testtype',
allowedContentTypes=lambda: [])
request_mock = TestRequest()
# FTI
fti_mock = DexterityFTI(u"testtype")
fti_mock.lookupSchema = Mock(return_value=ISchema)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.mock_adapter(FieldWidgets, IWidgets,
(Interface, Interface, Interface))
self.mock_adapter(Actions, IActions, (Interface, Interface, Interface))
# Form
view = DefaultAddForm(context_mock, request_mock)
view.portal_type = fti_mock.getId()
self.assertRaises(ValueError, view.update)
def setUp(self):
super(TestSequenceBehavior, self).setUp()
self.grant('Manager')
fti = DexterityFTI(
'type1',
klass="plone.dexterity.content.Container",
global_allow=True,
allowed_content_types=['type1'],
behaviors=[
"opengever.base.behaviors.sequence.ISequenceNumberBehavior"
])
self.portal.portal_types._setObject('type1', fti)
fti = DexterityFTI('type2',
klass="plone.dexterity.content.Container",
global_allow=True,
allowed_content_types=['type2'])
self.portal.portal_types._setObject('type2', fti)
self.portal.invokeFactory('type1', 'n1')
self.portal.invokeFactory('type1', 'n2')
self.portal.invokeFactory('type2', 'f1')
def setUpPloneSite(self, portal):
'''Set up additional products and ZCML required to test
this product.
'''
# setup dexterity
types_tool = getToolByName(portal, 'portal_types')
sm = getSiteManager(portal)
sm.registerUtility(component=vocabulary_factory,
provided=IVocabularyFactory,
name=u'Products.CMFDiffTool.testing.VOCABULARY')
fti = DexterityFTI(
TEST_CONTENT_TYPE_ID,
factory=TEST_CONTENT_TYPE_ID,
global_allow=True,
behaviors=(
'plone.app.versioningbehavior.behaviors.IVersionable',
'plone.app.dexterity.behaviors.metadata.IBasic',
'plone.app.dexterity.behaviors.metadata.IRelatedItems',
'plone.app.contenttypes.behaviors.collection.ICollection',
),
model_source='''
<model xmlns='http://namespaces.plone.org/supermodel/schema'>
<schema>
<field name='text' type='zope.schema.Text'>
<title>Text</title>
<required>False</required>
</field>
<field name='file' type='plone.namedfile.field.NamedFile'>
<title>File</title>
<required>False</required>
</field>
<field name='date' type='zope.schema.Date'>
<title>Date</title>
<required>False</required>
</field>
<field name='files' type='zope.schema.List'>
<title>Date</title>
<required>False</required>
<value_type type='plone.namedfile.field.NamedFile'>
<title>Val</title>
</value_type>
</field>
<field name='choice' type='zope.schema.Choice'>
<title>Choice</title>
<required>False</required>
<vocabulary>Products.CMFDiffTool.testing.VOCABULARY</vocabulary>
</field>
</schema>
</model>
''')
types_tool._setObject(TEST_CONTENT_TYPE_ID, fti)
def test_clear_all_caches(self):
class ISchema1(Interface):
pass
fti1 = DexterityFTI(u"testtype")
fti1.lookupSchema = Mock(return_value=ISchema1)
self.mock_utility(fti1, IDexterityFTI, name=u"testtype1")
fti2 = DexterityFTI(u"testtype")
fti2.lookupSchema = Mock(return_value=ISchema1)
self.mock_utility(fti2, IDexterityFTI, name=u"testtype2")
# reset schemacache counter
SCHEMA_CACHE.invalidations = 0
# fill cache should call lookupschema one time
schema1 = SCHEMA_CACHE.get(u"testtype1")
schema2 = SCHEMA_CACHE.get(u"testtype2")
self.assertTrue(schema1 is schema2 is ISchema1)
# clear
SCHEMA_CACHE.clear()
self.assertEqual(SCHEMA_CACHE.invalidations, 2)
# check invalidations
# fill cache again should call lookupschema one time
schema1 = SCHEMA_CACHE.get(u"testtype1")
schema2 = SCHEMA_CACHE.get(u"testtype2")
self.assertTrue(schema1 is schema2 is ISchema1)
def setUpPloneSite(self, portal):
# Install into Plone site using portal_setup
# self.applyProfile(portal, 'plone.app.linkintegrity:default')
super(LinkintegrityFixture, self).setUpPloneSite(portal)
setRoles(portal, TEST_USER_ID, ['Manager'])
fti = DexterityFTI('My Dexterity Item')
portal.portal_types._setObject('My Dexterity Item', fti)
fti.klass = 'plone.dexterity.content.Item'
fti.schema = 'collective.cover.tests.test_linkintegrity.IMyDexterityItem'
fti.behaviors = ('plone.app.referenceablebehavior.referenceable.IReferenceable',)
fti = DexterityFTI('Non referenciable Dexterity Item')
portal.portal_types._setObject('Non referenciable Dexterity Item', fti)
fti.klass = 'plone.dexterity.content.Item'
fti.schema = 'collective.cover.tests.test_linkintegrity.IMyDexterityItem'
# Create some dexterity items to test with it
portal.invokeFactory(
'My Dexterity Item', id='dexterity_item1', title='Dexterity Item 1')
portal.invokeFactory(
'My Dexterity Item', id='dexterity_item2', title='Dexterity Item 2')
portal.invokeFactory(
'Non referenciable Dexterity Item',
id='nonreferenciable_dexterity_item1',
title='Non referenciable Dexterity Item 1'
)
portal.invokeFactory(
'Non referenciable Dexterity Item',
id='nonreferenciable_dexterity_item2',
title='Non referenciable Dexterity Item 2'
)
# Create an AT Image
image = generate_jpeg(50, 50)
portal.invokeFactory(
'Image', id='image1', title='Test Image 1', image=image)
portal.invokeFactory('collective.cover.content', 'cover1')
# Documents
text = '<html> <body> a test page </body> </html>'
portal.invokeFactory(
'Document', id='doc1', title='Test Page 1', text=text)
text = '<html> <body> another test page </body> </html>'
portal.invokeFactory(
'Document', id='doc2', title='Test Page 2', text=text)
text = '<html> <body> a test page in a subfolder </body> </html>'
portal.invokeFactory('Folder', id='folder1', title='Test Folder 1')
portal.folder1.invokeFactory(
'Document', id='doc3', title='Test Page 3', text=text)
def test_global_components_not_unregistered_on_delete(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = Mock(
wraps=PersistentComponents(bases=(getGlobalSiteManager(),)))
from zope.component.hooks import getSiteManager
self.patch_global(getSiteManager, return_value=site_manager_mock)
# Register FTI utility and factory utility
self.mock_utility(fti, IDexterityFTI, name=portal_type)
self.mock_utility(
DexterityFactory(portal_type),
IFactory,
name=portal_type
)
# We expect to always be able to unregister without error, even if the
# component exists. The factory is only unregistered if it was
# registered with info='plone.dexterity.dynamic'.
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
site_dummy = self.create_dummy(
getSiteManager=lambda: site_manager_mock
)
setSite(site_dummy)
setHooks()
self.assertNotEqual(
None,
queryUtility(IDexterityFTI, name=portal_type)
)
self.assertNotEqual(None, queryUtility(IFactory, name=portal_type))
def test_deleted_factory_not_unregistered_if_not_unique(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type, factory='common-factory')
portal_type2 = u"testtype2"
fti2 = DexterityFTI(portal_type2, factory='common-factory')
container_dummy = self.create_dummy()
# Mock the lookup of the site and the site manager at the site root
dummy_site = self.create_dummy()
self.mock_utility(dummy_site, ISiteRoot)
site_manager_mock = Mock(
wraps=PersistentComponents(bases=(getGlobalSiteManager(),)))
from zope.component.hooks import getSiteManager
self.patch_global(getSiteManager, return_value=site_manager_mock)
# Pretend two FTIs are registered, both using common-factory
# NB: Assuming that "testtype" was already removed when this gets
# called
site_manager_mock.registeredUtilities = Mock(return_value=[
self.create_dummy(
provided=IFactory,
name='common-factory',
info='plone.dexterity.dynamic'
),
self.create_dummy(
component=fti2,
provided=IDexterityFTI,
name='testtype2',
info='plone.dexterity.dynamic'
),
])
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
# We shouldn't remove this since fti2 still uses it
# The type itself should be removed though
site_manager_mock.unregisterUtility.assert_called_once_with(
provided=IDexterityFTI, name=u'testtype'
)
def test_readfile_mimetype_additional_schemata(self):
# This is mostly a test that utils.iterSchemata takes
# IBehaviorAssignable into account.
class ITest(Interface):
title = schema.TextLine()
class ITestAdditional(Interface):
# Additional behavior on an item
body = schema.Text()
stuff = schema.Bytes()
alsoProvides(ITestAdditional['body'], IPrimaryField)
alsoProvides(ITestAdditional['stuff'], IPrimaryField)
alsoProvides(ITestAdditional, IFormFieldProvider)
class MockBehavior(object):
def __init__(self, iface):
self.interface = iface
class MockBehaviorAssignable(object):
def __init__(self, context):
self.context = context
def enumerateBehaviors(self):
yield MockBehavior(ITestAdditional)
SCHEMA_CACHE.clear()
fti_mock = DexterityFTI(u'testtype')
fti_mock.lookupSchema = Mock(return_value=ITest)
self.mock_adapter(MockBehaviorAssignable, IBehaviorAssignable,
(Item, ))
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
item = Item('item')
item.portal_type = 'testtype'
readfile = DefaultReadFile(item)
self.assertEqual('message/rfc822', readfile.mimeType)
def test_add_raises_value_error_if_type_not_addable(self):
# Container, new object, and request
container = Mock()
obj = Mock()
request = TestRequest()
obj.portal_type = 'testtype'
# New object's FTI
fti_mock = DexterityFTI(u"testtype")
fti_mock.isConstructionAllowed = Mock(return_value=True)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
# Container FTI
container_fti_mock = DexterityFTI(u"containertype")
container_fti_mock.allowType = Mock(return_value=False)
self.mock_utility(container_fti_mock,
IDexterityFTI,
name=u"containertype")
container.getTypeInfo = Mock(return_value=container_fti_mock)
form = DefaultAddForm(container, request)
form.portal_type = u"testtype"
self.assertRaises(ValueError, form.add, obj)
def test_getAdditionalSchemata(self):
from plone.dexterity.interfaces import IDexterityFTI
from plone.behavior.interfaces import IBehavior
from plone.autoform.interfaces import IFormFieldProvider
from zope.interface import Interface
from zope.interface import providedBy
class IBehaviorInterface(Interface):
pass
class IBehaviorSchema(Interface):
pass
behavior_mock = Mock()
fti_mock = DexterityFTI(u'testtype')
portal_type = 'prefix_0_type_0_schema'
behavior_name = 'behavior_0'
fti_mock.behaviors = (behavior_name,)
behavior_mock.interface = IBehaviorInterface
provider_mock = Mock(return_value=IBehaviorSchema)
self.mock_utility(behavior_mock, IBehavior, behavior_name)
self.mock_utility(fti_mock, IDexterityFTI, portal_type)
self.mock_adapter(
provider_mock,
IFormFieldProvider,
(providedBy(IBehaviorInterface), )
)
generator = utils.getAdditionalSchemata(None, portal_type)
schematas = tuple(generator)
self.assertEqual(len(schematas), 1)
schemata = schematas[0]
self.assertTrue(schemata is IBehaviorSchema)
