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 = Mock(
wraps=PersistentComponents(bases=(getGlobalSiteManager(),)))
from zope.component.hooks import getSiteManager
self.patch_global(getSiteManager, return_value=site_manager_mock)
# 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.assertEqual(None, queryUtility(IDexterityFTI, name=portal_type))
self.assertEqual(None, queryUtility(IFactory, name=portal_type))
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_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 = Mock(wraps=PersistentComponents(
bases=(getGlobalSiteManager(), )))
from zope.component.hooks import getSiteManager
self.patch_global(getSiteManager, return_value=site_manager_mock)
# 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.assertEqual(None, queryUtility(IDexterityFTI, name=portal_type))
self.assertEqual(None, queryUtility(IFactory, name=portal_type))
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_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 test_fires_add_begun_event(self):
# Context and request
context_mock = self.create_dummy(
portal_type=u'testtype',
allowedContentTypes=lambda:
[self.create_dummy(getId=lambda: '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 = DefaultAddForm(context_mock, request_mock)
view.portal_type = fti_mock.getId()
view.update()
self.assertTrue(notify_mock.called)
self.assertTrue(IAddBegunEvent.providedBy(notify_mock.call_args[0][0]))
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.app.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_components_unregistered_on_delete_does_not_error_with_no_components(
self): # noqa
portal_type = '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, Interface)
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 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.assertNotEquals(None, queryUtility(IDexterityFTI,
name=portal_type))
self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))
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 = Mock(wraps=PersistentComponents(
bases=(getGlobalSiteManager(), )))
from zope.component.hooks import getSiteManager
self.patch_global(getSiteManager, return_value=site_manager_mock)
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
args1, kwargs1 = site_manager_mock.registerUtility.call_args_list[0]
self.assertEqual(args1, (fti, IDexterityFTI, portal_type))
self.assertEqual(kwargs1, {'info': 'plone.dexterity.dynamic'})
args2, kwargs2 = site_manager_mock.registerUtility.call_args_list[1]
self.assertIsInstance(args2[0], DexterityFactory)
self.assertEqual(args2[0].portal_type, portal_type)
self.assertEqual(args2[1:], (IFactory, portal_type))
self.assertEqual(kwargs2, {'info': 'plone.dexterity.dynamic'})
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_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 = 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 that all components are registered, so do not expect any
# registrations
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
self.assertFalse(site_manager_mock.registerUtility.called)
def test_fires_add_begun_event(self):
# Context and request
context_mock = self.create_dummy(
portal_type=u'testtype',
allowedContentTypes=lambda: [self.create_dummy(getId=lambda: '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 = DefaultAddForm(context_mock, request_mock)
view.portal_type = fti_mock.getId()
view.update()
self.assertTrue(notify_mock.called)
self.assertTrue(IAddBegunEvent.providedBy(notify_mock.call_args[0][0]))
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_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_dynamic_schema_refreshed_on_modify_model_source(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
class INew(Interface):
title = zope.schema.TextLine(title=u"title")
model_dummy = Model({u"": INew})
fti.lookupModel = Mock(return_value=model_dummy)
self.create_dummy()
site_dummy = self.create_dummy(getPhysicalPath=lambda: ('', 'siteid'))
self.mock_utility(site_dummy, ISiteRoot)
class IBlank(Interface):
pass
# Set source interface
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, IBlank)
# Sync this with schema
ftiModified(
fti,
ObjectModifiedEvent(
fti, DexterityFTIModificationDescription('model_source', '')))
self.assertTrue('title' in IBlank)
self.assertTrue(IBlank['title'].title == u"title")
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 = 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 that all components are registered, so do not expect any
# registrations
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
self.assertFalse(site_manager_mock.registerUtility.called)
def test_concrete_schema_not_refreshed_on_modify_schema(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
class IBlank(Interface):
pass
class INew(Interface):
title = zope.schema.TextLine(title=u"title")
model_dummy = Model({u"": INew})
fti.lookupModel = Mock(return_value=model_dummy)
site_dummy = self.create_dummy(getPhysicalPath=lambda: ('', 'siteid'))
self.mock_utility(site_dummy, ISiteRoot)
# Set schema to something so that hasDynamicSchema is false
fti.schema = IBlank.__identifier__
assert not fti.hasDynamicSchema
# Set source for dynamic FTI - should not be used
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, IBlank)
# Sync should not happen now
ftiModified(
fti,
ObjectModifiedEvent(
fti, DexterityFTIModificationDescription('schema', '')))
self.assertFalse('title' in IBlank)
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 = 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_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_components_reregistered_on_rename(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.app.component.hooks.getSiteManager')
self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1,None)
# First look for unregistration of all local components
self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()
# Then look for re-registration of global components
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.assertEquals('string:${folder_url}/++add++testtype', fti.add_view_expr)
self.replay()
ftiRenamed(fti, ObjectMovedEvent(fti, container_dummy, fti.getId(), container_dummy, u"newtype"))
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_dynamic_schema_refreshed_on_modify_model_source(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
class INew(Interface):
title = zope.schema.TextLine(title=u"title")
model_dummy = Model({u"": INew})
fti.lookupModel = Mock(return_value=model_dummy)
self.create_dummy()
site_dummy = self.create_dummy(
getPhysicalPath=lambda: ('', 'siteid')
)
self.mock_utility(site_dummy, ISiteRoot)
class IBlank(Interface):
pass
# Set source interface
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, IBlank)
# Sync this with schema
ftiModified(
fti,
ObjectModifiedEvent(
fti,
DexterityFTIModificationDescription('model_source', '')
)
)
self.assertTrue('title' in IBlank)
self.assertTrue(IBlank['title'].title == u"title")
def test_components_reregistered_on_rename(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)
# First look for unregistration of all local components
self.expect(
site_manager_mock.unregisterUtility(
provided=IDexterityFTI, name=portal_type)).passthrough()
# Then look for re-registration of global components
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.assertEqual('string:${folder_url}/++add++testtype',
fti.add_view_expr)
self.replay()
ftiRenamed(
fti,
ObjectMovedEvent(fti, container_dummy, fti.getId(),
container_dummy, u"newtype"))
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_components_unregistered_on_delete(self):
portal_type = '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, Interface)
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.assertEqual(None, queryUtility(IDexterityFTI, name=portal_type))
self.assertEqual(None, queryUtility(IFactory, name=portal_type))
def test_lookupSchema_with_nonexistant_schema(self):
""" Tests the case where a dexterity type is not removed cleanly
from the fti, but the code has been removed.
"""
fti = DexterityFTI(u"testtype")
fti.schema = 'model.wont.be.imported'
portal = self.create_dummy(getPhysicalPath=lambda: ('', 'site'))
self.mock_utility(portal, ISiteRoot)
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, ITestSchema)
self.assertEqual(ITestSchema, fti.lookupSchema())
delattr(plone.dexterity.schema.generated, schemaName)
def test_lookupSchema_with_nonexistant_schema(self):
''' Tests the case where a dexterity type is not removed cleanly
from the fti, but the code has been removed.
'''
fti = DexterityFTI('testtype')
fti.schema = 'model.wont.be.imported'
portal = self.create_dummy(getPhysicalPath=lambda: ('', 'site'))
self.mock_utility(portal, Interface)
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, ITestSchema)
self.assertEqual(ITestSchema, fti.lookupSchema())
delattr(plone.dexterity.schema.generated, schemaName)
def test_lookupSchema_with_dynamic_schema(self):
fti = DexterityFTI(u"testtype")
fti.schema = None # use dynamic schema
portal = self.create_dummy(getPhysicalPath=lambda: ('', 'site'))
self.mock_utility(portal, ISiteRoot)
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, ITestSchema)
self.assertEqual(ITestSchema, fti.lookupSchema())
# cleanup
delattr(plone.dexterity.schema.generated, schemaName)
def test_lookupSchema_with_dynamic_schema(self):
fti = DexterityFTI('testtype')
fti.schema = None # use dynamic schema
portal = self.create_dummy(getPhysicalPath=lambda: ('', 'site'))
self.mock_utility(portal, Interface)
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, ITestSchema)
self.assertEqual(ITestSchema, fti.lookupSchema())
# cleanup
delattr(plone.dexterity.schema.generated, schemaName)
def test_components_reregistered_on_rename(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)
self.assertEqual(
'string:${folder_url}/++add++testtype',
fti.add_view_expr
)
ftiRenamed(
fti,
ObjectMovedEvent(
fti,
container_dummy,
fti.getId(),
container_dummy,
u"newtype"
)
)
# First look for unregistration of all local components
site_manager_mock.unregisterUtility.assert_called_once_with(
provided=IDexterityFTI, name=portal_type
)
# Then look for re-registration of global components
self.assertEqual(site_manager_mock.registerUtility.call_count, 2)
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_components_reregistered_on_rename(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)
self.assertEqual(
'string:${folder_url}/++add++testtype',
fti.add_view_expr
)
ftiRenamed(
fti,
ObjectMovedEvent(
fti,
container_dummy,
fti.getId(),
container_dummy,
u"newtype"
)
)
# First look for unregistration of all local components
site_manager_mock.unregisterUtility.assert_called_once_with(
provided=IDexterityFTI, name=portal_type
)
# Then look for re-registration of global components
self.assertEquals(site_manager_mock.registerUtility.call_count, 2)
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_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 IBlank3(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 = portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, IBlank3)
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 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 test_deleted_factory_not_unregistered_if_not_unique(self):
portal_type = 'testtype'
fti = DexterityFTI(portal_type, factory='common-factory')
portal_type2 = '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, Interface)
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='testtype')).count(1)
self.replay()
ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
def test_components_registered_on_add(self):
portal_type = '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, Interface)
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 = '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, Interface)
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_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 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_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_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.assertNotEquals(
None,
queryUtility(IDexterityFTI, name=portal_type)
)
self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))
def test_dynamic_schema_refreshed_on_modify_model_source(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
class INew(Interface):
title = zope.schema.TextLine(title=u"title")
model_dummy = Model({u"": INew})
fti.lookupModel = Mock(return_value=model_dummy)
self.create_dummy()
site_dummy = self.create_dummy(
getPhysicalPath=lambda: ('', 'siteid')
)
self.mock_utility(site_dummy, ISiteRoot)
# b/c of zope.interface does not support hashing of the same class multiple times
# we need to postfix with a unique number
# see https://github.com/zopefoundation/zope.interface/issues/216#issuecomment-701332380
class IBlank2(Interface):
pass
# Set source interface
schemaName = portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, IBlank2)
# Sync this with schema
ftiModified(
fti,
ObjectModifiedEvent(
fti,
DexterityFTIModificationDescription('model_source', '')
)
)
self.assertTrue('title' in IBlank2)
self.assertTrue(IBlank2['title'].title == u"title")
def test_components_not_registered_on_add_if_exist(self):
portal_type = '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, Interface)
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_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 = Mock(
wraps=PersistentComponents(bases=(getGlobalSiteManager(),)))
from zope.component.hooks import getSiteManager
self.patch_global(getSiteManager, return_value=site_manager_mock)
ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
args1, kwargs1 = site_manager_mock.registerUtility.call_args_list[0]
self.assertEqual(args1, (fti, IDexterityFTI, portal_type))
self.assertEqual(kwargs1, {'info': 'plone.dexterity.dynamic'})
args2, kwargs2 = site_manager_mock.registerUtility.call_args_list[1]
self.assertIsInstance(args2[0], DexterityFactory)
self.assertEqual(args2[0].portal_type, portal_type)
self.assertEqual(args2[1:], (IFactory, portal_type))
self.assertEqual(kwargs2, {'info': 'plone.dexterity.dynamic'})
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_concrete_schema_not_refreshed_on_modify_schema(self):
portal_type = u"testtype"
fti = DexterityFTI(portal_type)
class IBlank(Interface):
pass
class INew(Interface):
title = zope.schema.TextLine(title=u"title")
model_dummy = Model({u"": INew})
fti.lookupModel = Mock(return_value=model_dummy)
site_dummy = self.create_dummy(
getPhysicalPath=lambda: ('', 'siteid')
)
self.mock_utility(site_dummy, ISiteRoot)
# Set schema to something so that hasDynamicSchema is false
fti.schema = IBlank.__identifier__
assert not fti.hasDynamicSchema
# Set source for dynamic FTI - should not be used
schemaName = utils.portalTypeToSchemaName(fti.getId())
setattr(plone.dexterity.schema.generated, schemaName, IBlank)
# Sync should not happen now
ftiModified(
fti,
ObjectModifiedEvent(
fti,
DexterityFTIModificationDescription('schema', '')
)
)
self.assertFalse('title' in IBlank)
def test_factory_name_is_fti_id(self):
fti = DexterityFTI(u"testtype")
self.assertEqual(u"testtype", fti.getId())
self.assertEqual(u"testtype", fti.factory)
def test_factory_name_is_fti_id(self):
fti = DexterityFTI(u"testtype")
self.assertEquals(u"testtype", fti.getId())
self.assertEquals(u"testtype", fti.factory)
def test_factory_name_is_fti_id(self):
fti = DexterityFTI('testtype')
self.assertEqual('testtype', fti.getId())
self.assertEqual('testtype', fti.factory)
