def test_get_interfaces(self):
fti_mock = Mock(spec=DexterityFTI)
fti_mock.lookupSchema = Mock(return_value=IDummy)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
factory = DexterityFactory(portal_type=u"testtype")
spec = factory.getInterfaces()
self.assertEqual(u"testtype", spec.__name__)
self.assertEqual([IDummy, Interface], list(spec.flattened()))
def test_get_interfaces(self):
fti_mock = Mock(spec=DexterityFTI)
fti_mock.lookupSchema = Mock(return_value=IDummy)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
factory = DexterityFactory(portal_type=u"testtype")
spec = factory.getInterfaces()
self.assertEqual(u"testtype", spec.__name__)
self.assertEqual([IDummy, Interface], list(spec.flattened()))
def test_get_interfaces(self):
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.lookupSchema()).result(IDummy)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
factory = DexterityFactory(portal_type=u"testtype")
spec = factory.getInterfaces()
self.assertEqual(u"testtype", spec.__name__)
self.assertEqual([IDummy, Interface], list(spec.flattened()))
def test_get_interfaces(self):
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.lookupSchema()).result(IDummy)
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
factory = DexterityFactory(portal_type=u"testtype")
spec = factory.getInterfaces()
self.assertEqual(u"testtype", spec.__name__)
self.assertEqual([IDummy, Interface], list(spec.flattened()))
def register(fti):
"""Helper method to:
- register an FTI as a local utility
- register a local factory utility
- register an add view
"""
site_manager = getGlobalSiteManager()
portal_type = fti.getId()
fti_utility = queryUtility(IDexterityFTI, name=portal_type)
if fti_utility is None:
site_manager.registerUtility(fti,
IDexterityFTI,
portal_type,
info='plone.dexterity.dynamic')
factory_utility = queryUtility(IFactory, name=fti.factory)
if factory_utility is None:
site_manager.registerUtility(DexterityFactory(portal_type),
IFactory,
fti.factory,
info='plone.dexterity.dynamic')
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 = Mock(wraps=PersistentComponents(
bases=(getGlobalSiteManager(), )))
from zope.component.hooks import getSiteManager
self.patch_global(getSiteManager, return_value=site_manager_mock)
# Create a global default for the new name
self.mock_utility(DexterityFactory(portal_type),
IFactory,
name='new-factory')
fti.factory = 'new-factory'
ftiModified(
fti,
ObjectModifiedEvent(
fti,
DexterityFTIModificationDescription('factory', 'old-factory')))
# Factory should not be registered again
self.assertFalse(site_manager_mock.registerUtility.called)
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_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 remove_defaultfactories(context):
"""
Remove Custom DefaultFactories because they are not used.
Add Dexterity DefaultFactory instead
:param context:
:return:
"""
site = queryUtility(ISiteRoot)
if site is None:
return
sm = getSiteManager(site)
names = DCAT_CTs + [CT_HARVESTER, CT_HARVESTER_FOLDER]
for name in names:
sm.unregisterUtility(name=name, provided=IDexterityFactory)
fti = getUtility(IDexterityFTI, name=name)
factory_utility = queryUtility(IFactory, name=fti.factory)
if factory_utility is None:
sm.registerUtility(
DexterityFactory(name),
IFactory,
fti.factory,
info='plone.dexterity.dynamic',
)
transaction.commit()
def test_create_sets_portal_type_if_not_set(self):
# Object returned by class
obj_mock = self.mocker.mock()
self.expect(obj_mock.portal_type).throw(
AttributeError) # -> need to set portal_type
obj_mock.portal_type = u"testtype"
# Class set by factory
klass_mock = self.mocker.mock()
self.expect(klass_mock()).result(obj_mock)
# Resolver
resolver_mock = self.mocker.replace(
"plone.dexterity.utils.resolveDottedName")
self.expect(
resolver_mock("my.mocked.ContentTypeClass")).result(klass_mock)
# FTI
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.klass).result("my.mocked.ContentTypeClass")
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual(obj_mock, factory())
def test_create_sets_portal_type_if_wrong(self):
# Object returned by class
obj_mock = self.mocker.mock()
self.expect(obj_mock.portal_type).result(
'othertype') # -> need to fix portal_type
obj_mock.portal_type = 'testtype'
# Class set by factory
klass_mock = self.mocker.mock()
self.expect(klass_mock()).result(obj_mock)
# Resolver
resolver_mock = self.mocker.replace(
'plone.dexterity.utils.resolveDottedName')
self.expect(
resolver_mock('my.mocked.ContentTypeClass')).result(klass_mock)
# FTI
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.klass).result('my.mocked.ContentTypeClass')
self.mock_utility(fti_mock, IDexterityFTI, name='testtype')
self.replay()
factory = DexterityFactory(portal_type='testtype')
self.assertEqual(obj_mock, factory())
def test_factory_passes_args_and_kwargs(self):
# Object returned by class
obj_mock = self.mocker.mock()
self.expect(obj_mock.portal_type).result(u"testtype")
# Class set by factory
klass_mock = self.mocker.mock()
self.expect(klass_mock(u"id", title=u"title")).result(obj_mock)
# Resolver
resolver_mock = self.mocker.replace(
"plone.dexterity.utils.resolveDottedName")
self.expect(
resolver_mock("my.mocked.ContentTypeClass")).result(klass_mock)
# FTI
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.klass).result("my.mocked.ContentTypeClass")
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual(obj_mock, factory(u"id", title=u"title"))
def test_create_with_schema_already_provided_and_portal_type_set(self):
# Object returned by class
obj_mock = self.mocker.mock()
self.expect(obj_mock.portal_type).result(u"testtype")
# Class set by factory
klass_mock = self.mocker.mock()
self.expect(klass_mock()).result(obj_mock)
# Resolver
resolver_mock = self.mocker.replace(
"plone.dexterity.utils.resolveDottedName")
self.expect(
resolver_mock("my.mocked.ContentTypeClass")).result(klass_mock)
# FTI
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.klass).result("my.mocked.ContentTypeClass")
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual(obj_mock, factory())
def test_create_initialises_schema_if_not_provided(self):
# Object returned by class
obj_mock = self.mocker.mock()
self.expect(obj_mock.portal_type).result('testtype')
# Class set by factory
klass_mock = self.mocker.mock()
self.expect(klass_mock()).result(obj_mock)
# Resolver
resolver_mock = self.mocker.replace(
'plone.dexterity.utils.resolveDottedName')
self.expect(
resolver_mock('my.mocked.ContentTypeClass')).result(klass_mock)
# FTI
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.klass).result('my.mocked.ContentTypeClass')
self.mock_utility(fti_mock, IDexterityFTI, name='testtype')
self.replay()
factory = DexterityFactory(portal_type='testtype')
self.assertEqual(obj_mock, factory())
def register(fti):
"""Helper method to:
- register an FTI as a local utility
- register a local factory utility
- register an add view
"""
fti = aq_base(fti) # remove acquisition wrapper
site = getUtility(ISiteRoot)
site_manager = getSiteManager(site)
portal_type = fti.getId()
fti_utility = queryUtility(IDexterityFTI, name=portal_type)
if fti_utility is None:
site_manager.registerUtility(fti,
IDexterityFTI,
portal_type,
info='plone.dexterity.dynamic')
factory_utility = queryUtility(IFactory, name=fti.factory)
if factory_utility is None:
site_manager.registerUtility(DexterityFactory(portal_type),
IFactory,
fti.factory,
info='plone.dexterity.dynamic')
def ftiModified(object, event):
"""When an FTI is modified, re-sync and invalidate the schema, if
necessary.
"""
if not IDexterityFTI.providedBy(event.object):
return
fti = event.object
portal_type = fti.getId()
mod = {}
for desc in event.descriptions:
if IDexterityFTIModificationDescription.providedBy(desc):
mod[desc.attribute] = desc.oldValue
# If the factory utility name was modified, we may get an orphan if one
# was registered as a local utility to begin with. If so, remove the
# orphan.
if 'factory' in mod:
old_factory = mod['factory']
site_manager = getGlobalSiteManager()
# Remove previously registered factory, if no other type uses it.
unregister_factory(old_factory, site_manager)
# Register a new local factory if one doesn't exist already
new_factory_utility = queryUtility(IFactory, name=fti.factory)
if new_factory_utility is None:
site_manager.registerUtility(DexterityFactory(portal_type),
IFactory,
fti.factory,
info='plone.dexterity.dynamic')
# Determine if we need to invalidate the schema at all
if 'behaviors' in mod \
or 'schema' in mod \
or 'model_source' in mod \
or 'model_file' in mod \
or 'schema_policy' in mod:
# Determine if we need to re-sync a dynamic schema
if ((fti.model_source or fti.model_file)
and ('model_source' in mod or 'model_file' in mod
or 'schema_policy' in mod)):
schemaName = portalTypeToSchemaName(portal_type)
schema = getattr(plone.dexterity.schema.generated, schemaName)
model = fti.lookupModel()
sync_bases = 'schema_policy' in mod
syncSchema(model.schema,
schema,
overwrite=True,
sync_bases=sync_bases)
notify(SchemaInvalidatedEvent(portal_type))
def test_title(self):
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.title).result('Mock type')
self.mock_utility(fti_mock, IDexterityFTI, name='testtype')
self.replay()
factory = DexterityFactory(portal_type='testtype')
self.assertEqual('Mock type', factory.title)
def test_description(self):
fti_mock = self.mocker.mock(DexterityFTI)
self.expect(fti_mock.description).result("Mock type description")
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
self.replay()
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual("Mock type description", factory.description)
def test_create_with_schema_already_provided_and_portal_type_set(self):
# Object returned by class
obj_mock = Mock(portal_type=u'testtype')
# Class set by factory
klass_mock = Mock(return_value=obj_mock)
# Resolver
from plone.dexterity.utils import resolveDottedName
self.patch_global(resolveDottedName, return_value=klass_mock)
# FTI
fti_mock = Mock(spec=DexterityFTI, klass='my.mocked.ContentTypeClass')
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual(obj_mock, factory())
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_create_sets_portal_type_if_wrong(self):
# Object returned by class
obj_mock = Mock(portal_type='othertype')
# Class set by factory
klass_mock = Mock(return_value=obj_mock)
# Resolver
from plone.dexterity.utils import resolveDottedName
self.patch_global(resolveDottedName, return_value=klass_mock)
# FTI
fti_mock = Mock(spec=DexterityFTI)
fti_mock.klass = "my.mocked.ContentTypeClass"
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual(obj_mock, factory())
self.assertEqual(obj_mock.portal_type, u'testtype')
def test_factory_passes_args_and_kwargs(self):
# Object returned by class
obj_mock = Mock(portal_type=u'testtype')
# Class set by factory
klass_mock = Mock(return_value=obj_mock)
# Resolver
from plone.dexterity.utils import resolveDottedName
self.patch_global(resolveDottedName, return_value=klass_mock)
# FTI
fti_mock = Mock(spec=DexterityFTI)
fti_mock.klass = "my.mocked.ContentTypeClass"
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual(obj_mock, factory(u"id", title=u"title"))
klass_mock.assert_called_once_with(u'id', title=u'title')
def test_new_factory_not_registered_after_name_changed_if_exists(self):
portal_type = '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, 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)
# 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_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_description(self):
fti_mock = Mock(spec=DexterityFTI, description='Mock type description')
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual("Mock type description", factory.description)
def test_title(self):
fti_mock = Mock(spec=DexterityFTI, title='Mock type')
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
factory = DexterityFactory(portal_type=u"testtype")
self.assertEqual("Mock type", factory.title)
