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 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)