def test_lookupModel_failure(self):
fti = DexterityFTI('testtype')
fti.schema = None
fti.model_source = None
fti.model_file = None
self.assertRaises(ValueError, fti.lookupModel)
def setUpImageType(self):
portal = self.portal
tt = portal.portal_types
del tt['Image']
fti = DexterityFTI('Image')
portal.portal_types._setObject('Image', fti)
fti.model_source = IMAGE_SCHEMA
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):
portal_types = getToolByName(self.layer['portal'], 'portal_types')
# Define new portal type without behavior
fti = DexterityFTI(str('without_behavior'), title='Without Behavior')
fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IBasic',
)
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>"""
portal_types._setObject(str('without_behavior'), fti)
# Define new portal type with behavior
fti = DexterityFTI(str('with_behavior'), title='With Behavior')
fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IBasic',
'collective.dexteritytextindexer.behavior.IDexterityTextIndexer'
)
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>"""
portal_types._setObject(str('with_behavior'), fti)
setRoles(self.layer['portal'], TEST_USER_ID, ['Manager'])
transaction.commit()
self.browser = Browser(self.layer['app'])
self.browser.addHeader(
'Authorization', 'Basic %s:%s' % (TEST_USER_NAME,
TEST_USER_PASSWORD,))
self.portal_url = self.layer['portal'].absolute_url()
def setUp(self):
portal_types = getToolByName(self.layer['portal'], 'portal_types')
# Define new portal type without behavior
fti = DexterityFTI(str('without_behavior'), title='Without Behavior')
fti.behaviors = ('plone.app.dexterity.behaviors.metadata.IBasic', )
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>"""
portal_types._setObject(str('without_behavior'), fti)
# Define new portal type with behavior
fti = DexterityFTI(str('with_behavior'), title='With Behavior')
fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IBasic',
'collective.dexteritytextindexer.behavior.IDexterityTextIndexer')
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>"""
portal_types._setObject(str('with_behavior'), fti)
setRoles(self.layer['portal'], TEST_USER_ID, ['Manager'])
transaction.commit()
self.browser = Browser(self.layer['app'])
self.browser.addHeader(
'Authorization', 'Basic %s:%s' % (
TEST_USER_NAME,
TEST_USER_PASSWORD,
))
self.portal_url = self.layer['portal'].absolute_url()
def test_lookupModel_with_schema_only(self):
fti = DexterityFTI(u"testtype")
fti.schema = u"plone.dexterity.tests.schemata.ITestSchema"
fti.model_source = None
fti.model_file = None
model = fti.lookupModel()
self.assertEqual(1, len(model.schemata))
self.assertEqual(ITestSchema, model.schema)
def test_lookupModel_with_schema_only(self):
fti = DexterityFTI('testtype')
fti.schema = 'plone.dexterity.tests.schemata.ITestSchema'
fti.model_source = None
fti.model_file = None
model = fti.lookupModel()
self.assertEqual(1, len(model.schemata))
self.assertEqual(ITestSchema, model.schema)
def test_lookupModel_without_schema_policy(self):
gsm = getGlobalSiteManager()
gsm.registerUtility(DexteritySchemaPolicy(), plone.supermodel.interfaces.ISchemaPolicy, name=u"dexterity")
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = '<model xmlns="http://namespaces.plone.org/supermodel/schema"><schema/></model>'
fti.model_file = None
model = fti.lookupModel()
self.assertEquals(False, ITestInterface in model.schemata[""].__bases__)
def test_lookupModel_without_schema_policy(self):
gsm = getGlobalSiteManager()
gsm.registerUtility(DexteritySchemaPolicy(),
plone.supermodel.interfaces.ISchemaPolicy,
name=u"dexterity")
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = '<model xmlns="http://namespaces.plone.org/supermodel/schema"><schema/></model>'
fti.model_file = None
model = fti.lookupModel()
self.assertEqual(False, ITestInterface in model.schemata[''].__bases__)
def test_lookupModel_from_string(self):
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = "<model />"
fti.model_file = None
model_dummy = Model()
from plone.supermodel import loadString
self.patch_global(loadString, return_value=model_dummy)
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def test_lookupModel_from_string(self):
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = "<model />"
fti.model_file = None
model_dummy = Model()
from plone.supermodel import loadString
self.patch_global(loadString, return_value=model_dummy)
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def givenA(self):
from plone.dexterity.fti import DexterityFTI
fti = DexterityFTI('Ticket')
fti.behaviors = ('plone.app.dexterity.behaviors.metadata.IBasic', )
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema>
<field name="duedate" type="zope.schema.Date">
<description />
<required>False</required>
<title>Due Date</title>
</field>
</schema>
</model>"""
self.portal.portal_types._setObject('Ticket', fti)
def test_lookupModel_from_string(self):
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = "<model />"
fti.model_file = None
model_dummy = Model()
loadString_mock = self.mocker.replace("plone.supermodel.loadString")
self.expect(loadString_mock(fti.model_source, policy=u"dexterity")).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def givenA(self):
from plone.dexterity.fti import DexterityFTI
fti = DexterityFTI('Ticket')
fti.behaviors = ('plone.app.dexterity.behaviors.metadata.IBasic',)
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema>
<field name="important" type="zope.schema.Bool">
<description />
<required>False</required>
<title>This is important</title>
</field>
</schema>
</model>"""
self.portal.portal_types._setObject('Ticket', fti)
def givenA(self):
from plone.dexterity.fti import DexterityFTI
fti = DexterityFTI("Ticket")
fti.behaviors = ("plone.app.dexterity.behaviors.metadata.IBasic",)
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema>
<field name="duedate" type="zope.schema.Date">
<description />
<required>False</required>
<title>Due Date</title>
</field>
</schema>
</model>"""
self.portal.portal_types._setObject("Ticket", fti)
def create_type_with_date_field(self, name):
from plone.dexterity.fti import DexterityFTI
fti = DexterityFTI(str(name), title=name)
fti.behaviors = ('plone.app.dexterity.behaviors.metadata.IBasic', )
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema>
<field name="duedate" type="zope.schema.Date">
<description />
<required>False</required>
<title>Due Date</title>
</field>
</schema>
</model>"""
fti.global_allow = True
self.portal_types._setObject(str(name), fti)
def test_lookupModel_from_string_with_schema(self):
fti = DexterityFTI(u"testtype")
fti.schema = u"plone.dexterity.tests.schemata.ITestSchema" # effectively ignored
fti.model_source = "<model />"
fti.model_file = None
model_dummy = Model()
loadString_mock = self.mocker.replace("plone.supermodel.loadString")
self.expect(loadString_mock(fti.model_source, policy=u"dexterity")).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
self.assertIs(ITestSchema, fti.lookupSchema())
def test_lookupModel_from_string(self):
fti = DexterityFTI('testtype')
fti.schema = None
fti.model_source = '<model />'
fti.model_file = None
model_dummy = Model()
loadString_mock = self.mocker.replace('plone.supermodel.loadString')
self.expect(loadString_mock(fti.model_source,
policy='dexterity')).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def create_type_with_date_field(self, name):
from plone.dexterity.fti import DexterityFTI
fti = DexterityFTI(str(name), title=name)
fti.behaviors = ('plone.app.dexterity.behaviors.metadata.IBasic',)
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema>
<field name="duedate" type="zope.schema.Date">
<description />
<required>False</required>
<title>Due Date</title>
</field>
</schema>
</model>"""
fti.global_allow = True
self.portal_types._setObject(str(name), fti)
def test_lookupModel_with_schema_policy(self):
class TestSchemaPolicy(DexteritySchemaPolicy):
def bases(self, schemaName, tree):
return (ITestInterface,)
gsm = getGlobalSiteManager()
policy = TestSchemaPolicy()
gsm.registerUtility(policy, plone.supermodel.interfaces.ISchemaPolicy, name=u"test")
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = '<model xmlns="http://namespaces.plone.org/supermodel/schema"><schema/></model>'
fti.model_file = None
fti.schema_policy = u"test"
model = fti.lookupModel()
self.assertEquals(True, ITestInterface in model.schemata[""].__bases__)
def test_lookupModel_from_string_with_schema(self):
fti = DexterityFTI(u"testtype")
fti.schema = u"plone.dexterity.tests.schemata.ITestSchema" # effectively ignored
fti.model_source = "<model />"
fti.model_file = None
model_dummy = Model()
loadString_mock = self.mocker.replace("plone.supermodel.loadString")
self.expect(loadString_mock(fti.model_source,
policy=u"dexterity")).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
self.assertIs(ITestSchema, fti.lookupSchema())
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
alsoProvides(self.request, IDefaultBrowserLayer)
alsoProvides(self.request, IPloneAppMultilingualInstalled)
fti = DexterityFTI('Feedback')
fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IBasic',
'plone.app.content.interfaces.INameFromTitle',
'plone.app.multilingual.dx.interfaces.IDexterityTranslatable',
)
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema"
xmlns:lingua="http://namespaces.plone.org/supermodel/lingua">
<schema>
<field name="mandatory_feedback" type="zope.schema.Text"
lingua:independent="true">
<description />
<required>True</required>
<title>Mandatory feedback</title>
</field>
</schema>
</model>"""
portal_types = getToolByName(self.portal, 'portal_types')
portal_types._setObject('Feedback', fti)
self.document = createContentInContainer(
self.portal['en'], 'Feedback', checkConstraints=False,
title=u'Test feedback', mandatory_feedback=u'This is a test')
# Call 'create_translation' to annotate request
self.request.form['language'] = 'ca'
self.redirect = getMultiAdapter(
(self.document, self.request),
name="create_translation"
)
self.redirect()
# Look up the ++addtranslation++ with annotated request in place
self.view = self.portal['ca'].restrictedTraverse(
'++addtranslation++Feedback'
)
self.view.update()
self.field = self.view.form_instance.fields['mandatory_feedback'].field
self.widget = self.view.form_instance.widgets['mandatory_feedback']
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
alsoProvides(self.request, IDefaultBrowserLayer)
alsoProvides(self.request, IPloneAppMultilingualInstalled)
fti = DexterityFTI('Feedback')
fti.behaviors = (
'plone.app.dexterity.behaviors.metadata.IBasic',
'plone.app.content.interfaces.INameFromTitle',
'plone.app.multilingual.dx.interfaces.IDexterityTranslatable',
)
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema"
xmlns:lingua="http://namespaces.plone.org/supermodel/lingua">
<schema>
<field name="mandatory_feedback" type="zope.schema.Text"
lingua:independent="true">
<description />
<required>True</required>
<title>Mandatory feedback</title>
</field>
</schema>
</model>"""
portal_types = getToolByName(self.portal, 'portal_types')
portal_types._setObject('Feedback', fti)
self.document = createContentInContainer(
self.portal['en'], 'Feedback', checkConstraints=False,
title=u'Test feedback', mandatory_feedback=u'This is a test')
# Call 'create_translation' to annotate request
self.request.form['language'] = 'ca'
self.redirect = getMultiAdapter(
(self.document, self.request),
name="create_translation"
)
self.redirect()
# Look up the ++addtranslation++ with annotated request in place
self.view = self.portal['ca'].restrictedTraverse(
'++addtranslation++' + IUUID(self.document)
)
self.view.update()
self.field = self.view.form_instance.fields['mandatory_feedback'].field
self.widget = self.view.form_instance.widgets['mandatory_feedback']
def test_lookupModel_from_string_with_schema(self):
fti = DexterityFTI(u"testtype")
# effectively ignored:
fti.schema = u"plone.dexterity.tests.schemata.ITestSchema"
fti.model_source = "<model />"
fti.model_file = None
model_dummy = Model()
from plone.supermodel import loadString
loadString_mock = self.patch_global(
loadString, return_value=model_dummy)
model = fti.lookupModel()
self.assertIs(model_dummy, model)
self.assertIs(ITestSchema, fti.lookupSchema())
loadString_mock.assert_called_once_with(
fti.model_source, policy=u'dexterity')
def test_lookupModel_from_string_with_schema(self):
fti = DexterityFTI('testtype')
# effectively ignored:
fti.schema = 'plone.dexterity.tests.schemata.ITestSchema'
fti.model_source = '<model />'
fti.model_file = None
model_dummy = Model()
loadString_mock = self.mocker.replace('plone.supermodel.loadString')
self.expect(loadString_mock(fti.model_source,
policy='dexterity')).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
self.assertIs(ITestSchema, fti.lookupSchema())
def create_content_type(self, portal_type):
"""Create dummy content type with a single custom field"""
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_lookupModel_from_string_with_schema(self):
fti = DexterityFTI(u"testtype")
# effectively ignored:
fti.schema = u"plone.dexterity.tests.schemata.ITestSchema"
fti.model_source = "<model />"
fti.model_file = None
model_dummy = Model()
from plone.supermodel import loadString
loadString_mock = self.patch_global(loadString,
return_value=model_dummy)
model = fti.lookupModel()
self.assertIs(model_dummy, model)
self.assertIs(ITestSchema, fti.lookupSchema())
loadString_mock.assert_called_once_with(fti.model_source,
policy=u'dexterity')
def test_lookupModel_from_string_with_schema(self):
fti = DexterityFTI('testtype')
# effectively ignored:
fti.schema = 'plone.dexterity.tests.schemata.ITestSchema'
fti.model_source = '<model />'
fti.model_file = None
model_dummy = Model()
loadString_mock = self.mocker.replace('plone.supermodel.loadString')
self.expect(
loadString_mock(fti.model_source, policy='dexterity')
).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
self.assertIs(ITestSchema, fti.lookupSchema())
def test_lookupModel_with_schema_policy(self):
class TestSchemaPolicy(DexteritySchemaPolicy):
def bases(self, schemaName, tree):
return (ITestInterface, )
gsm = getGlobalSiteManager()
policy = TestSchemaPolicy()
gsm.registerUtility(policy,
plone.supermodel.interfaces.ISchemaPolicy,
name=u"test")
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = '<model xmlns="http://namespaces.plone.org/supermodel/schema"><schema/></model>'
fti.model_file = None
fti.schema_policy = u"test"
model = fti.lookupModel()
self.assertEqual(True, ITestInterface in model.schemata[''].__bases__)
def test_lookupModel_from_file_with_absolute_path(self):
import plone.dexterity.tests
abs_file = os.path.join(os.path.split(plone.dexterity.tests.__file__)[0], "test.xml")
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = None
fti.model_file = abs_file
model_dummy = Model()
loadFile_mock = self.mocker.replace("plone.supermodel.loadFile")
self.expect(loadFile_mock(abs_file, reload=True, policy=u"dexterity")).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def create_content_type(self, portal_type):
"""Create dummy content type with a single custom field"""
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_lookupModel_from_file_with_win32_absolute_path(self):
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = None
fti.model_file = r"C:\models\testmodel.xml"
model_dummy = Model()
from os.path import isabs, isfile
self.patch_global(isabs, return_value=True)
self.patch_global(isfile, return_value=True)
from plone.supermodel import loadFile
loadFile_mock = self.patch_global(loadFile, return_value=model_dummy)
model = fti.lookupModel()
self.assertIs(model_dummy, model)
loadFile_mock.assert_called_once_with(
fti.model_file, reload=True, policy=u"dexterity")
def test_lookupModel_from_file_with_win32_absolute_path(self):
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = None
fti.model_file = r"C:\models\testmodel.xml"
model_dummy = Model()
from os.path import isabs, isfile
self.patch_global(isabs, return_value=True)
self.patch_global(isfile, return_value=True)
from plone.supermodel import loadFile
loadFile_mock = self.patch_global(loadFile, return_value=model_dummy)
model = fti.lookupModel()
self.assertIs(model_dummy, model)
loadFile_mock.assert_called_once_with(
fti.model_file, reload=True, policy=u"dexterity")
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.basic',
'plone.translatable',
)
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_lookupModel_from_file_with_absolute_path(self):
import plone.dexterity.tests
abs_file = os.path.join(
os.path.split(plone.dexterity.tests.__file__)[0], "test.xml")
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = None
fti.model_file = abs_file
model_dummy = Model()
from plone.supermodel import loadFile
loadFile_mock = self.patch_global(loadFile, return_value=model_dummy)
model = fti.lookupModel()
self.assertIs(model_dummy, model)
loadFile_mock.assert_called_once_with(abs_file,
reload=True,
policy=u"dexterity")
def test_lookupModel_from_file_with_package(self):
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = None
fti.model_file = u"plone.dexterity.tests:test.xml"
model_dummy = Model()
import plone.dexterity.tests
abs_file = os.path.join(
os.path.split(plone.dexterity.tests.__file__)[0], "test.xml")
loadFile_mock = self.mocker.replace("plone.supermodel.loadFile")
self.expect(loadFile_mock(abs_file, reload=True,
policy=u"dexterity")).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def test_lookupModel_from_file_with_absolute_path(self):
import plone.dexterity.tests
abs_file = os.path.join(
os.path.split(plone.dexterity.tests.__file__)[0], 'test.xml')
fti = DexterityFTI('testtype')
fti.schema = None
fti.model_source = None
fti.model_file = abs_file
model_dummy = Model()
loadFile_mock = self.mocker.replace('plone.supermodel.loadFile')
self.expect(loadFile_mock(abs_file, reload=True,
policy='dexterity')).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def test_lookupModel_from_file_with_absolute_path(self):
import plone.dexterity.tests
abs_file = os.path.join(
os.path.split(plone.dexterity.tests.__file__)[0],
"test.xml"
)
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = None
fti.model_file = abs_file
model_dummy = Model()
from plone.supermodel import loadFile
loadFile_mock = self.patch_global(loadFile, return_value=model_dummy)
model = fti.lookupModel()
self.assertIs(model_dummy, model)
loadFile_mock.assert_called_once_with(
abs_file, reload=True, policy=u"dexterity")
def test_lookupModel_from_file_with_win32_absolute_path(self):
fti = DexterityFTI(u"testtype")
fti.schema = None
fti.model_source = None
fti.model_file = r"C:\models\testmodel.xml"
model_dummy = Model()
isabs_mock = self.mocker.replace("os.path.isabs")
self.expect(isabs_mock(fti.model_file)).result(True)
isfile_mock = self.mocker.replace("os.path.isfile")
self.expect(isfile_mock(fti.model_file)).result(True)
loadFile_mock = self.mocker.replace("plone.supermodel.loadFile")
self.expect(loadFile_mock(fti.model_file, reload=True, policy=u"dexterity")).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def setUpPloneSite(self, portal):
portal.portal_workflow.setDefaultChain('simple_publication_workflow')
self.applyProfile(portal, 'example.uidattrbehavior:default')
# Define minimal buyable content type
fti = DexterityFTI('example')
fti.title = u'example'
fti.icon_expr = 'string:${portal_url}/document_icon.png'
fti.icon_expr_object = Expression(fti.icon_expr)
fti.model_source = u"""\
<model xmlns="http://namespaces.plone.org/supermodel/schema">
<schema />
</model>"""
fti.behaviors = (
'plone.app.content.interfaces.INameFromTitle',
'plone.app.dexterity.behaviors.metadata.IBasic',
'plone.app.dexterity.behaviors.metadata.ICategorization',
'example.uidattrbehavior.behaviors.IUIDAttrBehavior',
)
portal.portal_types._setObject('example', fti)
setRoles(portal, TEST_USER_ID, ['Manager'])
createContentInContainer(portal, 'example', title=u'Hello World')
def test_lookupModel_from_file_with_package(self):
fti = DexterityFTI('testtype')
fti.schema = None
fti.model_source = None
fti.model_file = 'plone.dexterity.tests:test.xml'
model_dummy = Model()
import plone.dexterity.tests
abs_file = os.path.join(
os.path.split(plone.dexterity.tests.__file__)[0],
'test.xml'
)
loadFile_mock = self.mocker.replace('plone.supermodel.loadFile')
self.expect(
loadFile_mock(abs_file, reload=True, policy='dexterity')
).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def test_lookupModel_from_file_with_win32_absolute_path(self):
fti = DexterityFTI('testtype')
fti.schema = None
fti.model_source = None
fti.model_file = r'C:\models\testmodel.xml'
model_dummy = Model()
isabs_mock = self.mocker.replace('os.path.isabs')
self.expect(isabs_mock(fti.model_file)).result(True)
isfile_mock = self.mocker.replace('os.path.isfile')
self.expect(isfile_mock(fti.model_file)).result(True)
loadFile_mock = self.mocker.replace('plone.supermodel.loadFile')
self.expect(
loadFile_mock(fti.model_file, reload=True,
policy='dexterity')).result(model_dummy)
self.replay()
model = fti.lookupModel()
self.assertIs(model_dummy, model)
def test_create_document_method(self):
# we need to register any plone.directives.form magic components
# from the module manually (they are not grokky):
for factory, name in document.__form_value_adapters__:
provideAdapter(factory, name=name)
class MockContext(object):
def __init__(self, fti, template):
self.fti = fti
self.template = template
def _setObject(self, id, obj):
self.obj = obj
def _getOb(self, id):
return self.obj
def restrictedTraverse(self, testpath):
return self.template
def getTypeInfo(self):
return self.fti
# 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)
# fti fake
fti = DexterityFTI(u'opengever.document.document')
fti.schema = 'opengever.document.document.IDocumentSchema'
fti.model_source = None
fti.model_file = None
fti.addable_types = ['opengever.document.document']
fti.isConstructionAllowed = lambda x: True
fti.allowType = lambda x: True
register(fti)
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(0 , None)
alsoProvides(IDocumentSchema.get('file'), IPrimaryField)
# Name chooser
class NameChooser(object):
implements(INameChooser)
def __init__(self, context):
pass
def chooseName(self, name, object):
return u"newid"
self.mock_adapter(NameChooser, INameChooser, (Interface,))
# template
namedfile = self.stub()
template_doc = self.stub()
self.expect(template_doc.file).result(namedfile)
self.expect(template_doc.portal_type).result(
'opengever.document.document')
self.expect(namedfile.data).result('data data data')
self.expect(namedfile.filename).result(u'test_filename.doc')
# context and request
context = MockContext(fti, template_doc)
request = self.stub_request()
testpath = 'testpath'
# registry
registry_mock = self.stub()
self.expect(registry_mock.forInterface(IDocumentSettings)).result(registry_mock)
self.expect(registry_mock.preserved_as_paper_default).result(False)
self.mock_utility(registry_mock, IRegistry)
self.replay()
view = TemplateDocumentFormView(context, request)
view.title = u'Test Title'
view.create_document(testpath)
self.assertEqual(context.obj.portal_type, u'opengever.document.document')
self.assertFalse(context.obj.file == namedfile)
self.assertEquals(context.obj.file.data, namedfile.data)
self.assertEqual(context.obj.document_date, datetime.now().date())
self.assertEqual(context.obj.preserved_as_paper, False)
def create1_0EventType(portal):
"""Recreate the old event type used in the 1.0 branch"""
fti = DexterityFTI("Event")
fti.title = "Event"
fti.description = "Events can be shown in calendars."
fti.factory = "Event"
fti.add_view_expr = "string:${folder_url}/++add++Event"
fti.link_target = ""
fti.link_target = ""
fti.immediate_view = "view"
fti.global_allow = True
fti.filter_content_types = True
fti.allowed_content_types = []
fti.allow_discussion = False
fti.default_view = "event_view"
fti.view_methods = ("event_view",)
fti.default_view_fallback = False
fti.add_permission = "plone.app.contenttypes.addEvent"
fti.klass = "plone.app.contenttypes.content.Event"
fti.behaviors = (
"plone.app.contenttypes.interfaces.IEvent",
"plone.app.dexterity.behaviors.metadata.IDublinCore",
"plone.app.content.interfaces.INameFromTitle",
"plone.app.dexterity.behaviors.discussion.IAllowDiscussion",
"plone.app.dexterity.behaviors.exclfromnav.IExcludeFromNavigation",
"plone.app.relationfield.behavior.IRelatedItems",
"plone.app.versioningbehavior.behaviors.IVersionable",
)
fti.schema = None
fti.model_source = """
<model xmlns="http://namespaces.plone.org/supermodel/schema"
xmlns:indexer="http://namespaces.plone.org/supermodel/indexer"
xmlns:i18n="http://xml.zope.org/namespaces/i18n"
i18n:domain="plone">
<schema>
<field name="location" type="zope.schema.TextLine"
indexer:searchable="true">
<description />
<required>False</required>
<title i18n:translate="label_event_location">Event Location</title>
</field>
<field name="start_date" type="zope.schema.Datetime">
<description />
<title i18n:translate="label_event_start">Event Starts</title>
</field>
<field name="end_date" type="zope.schema.Datetime">
<description />
<title i18n:translate="label_event_end">Event Ends</title>
</field>
<field name="text" type="plone.app.textfield.RichText"
indexer:searchable="true">
<description />
<required>False</required>
<title i18n:translate="">Text</title>
</field>
<field name="attendees" type="zope.schema.Text"
indexer:searchable="true">
<description />
<required>False</required>
<title i18n:translate="label_event_attendees">Attendees</title>
</field>
<field name="event_url" type="zope.schema.TextLine">
<description i18n:translate="help_url">
Web address with more info about the event. Add http:// for external
links.
</description>
<required>False</required>
<title i18n:translate="event_more_information">Event URL</title>
</field>
<field name="contact_name" type="zope.schema.TextLine"
indexer:searchable="true">
<description />
<required>False</required>
<title i18n:translate="label_contact_name">Contact Name</title>
</field>
<field name="contact_email" type="zope.schema.TextLine">
<description />
<required>False</required>
<title i18n:translate="label_contact_email">Contact E-mail</title>
</field>
<field name="contact_phone" type="zope.schema.TextLine">
<description />
<required>False</required>
<title i18n:translate="label_contact_phone">Contact Phone</title>
</field>
</schema>
</model>"""
fti.model_file = None # Was plone.app.contenttypes.schema:event.xml
if "Event" in portal.portal_types:
del portal.portal_types["Event"]
portal.portal_types._setObject("Event", fti)
return fti
def create1_0EventType(portal):
"""Recreate the old event type used in the 1.0 branch"""
fti = DexterityFTI('Event')
fti.title = 'Event'
fti.description = 'Events can be shown in calendars.'
fti.factory = 'Event'
fti.add_view_expr = 'string:${folder_url}/++add++Event'
fti.link_target = ''
fti.link_target = ''
fti.immediate_view = 'view'
fti.global_allow = True
fti.filter_content_types = True
fti.allowed_content_types = []
fti.allow_discussion = False
fti.default_view = 'event_view'
fti.view_methods = ('event_view', )
fti.default_view_fallback = False
fti.add_permission = 'plone.app.contenttypes.addEvent'
fti.klass = 'plone.app.contenttypes.tests.oldtypes.Event'
fti.behaviors = (
'plone.app.contenttypes.interfaces.IEvent',
'plone.app.dexterity.behaviors.metadata.IDublinCore',
'plone.app.content.interfaces.INameFromTitle',
'plone.app.dexterity.behaviors.discussion.IAllowDiscussion',
'plone.app.dexterity.behaviors.exclfromnav.IExcludeFromNavigation',
'plone.app.relationfield.behavior.IRelatedItems',
'plone.app.versioningbehavior.behaviors.IVersionable',
)
fti.schema = None
fti.model_source = """
<model xmlns="http://namespaces.plone.org/supermodel/schema"
xmlns:indexer="http://namespaces.plone.org/supermodel/indexer"
xmlns:i18n="http://xml.zope.org/namespaces/i18n"
i18n:domain="plone">
<schema>
<field name="location" type="zope.schema.TextLine"
indexer:searchable="true">
<description />
<required>False</required>
<title i18n:translate="label_event_location">Event Location</title>
</field>
<field name="start_date" type="zope.schema.Datetime">
<description />
<title i18n:translate="label_event_start">Event Starts</title>
</field>
<field name="end_date" type="zope.schema.Datetime">
<description />
<title i18n:translate="label_event_end">Event Ends</title>
</field>
<field name="text" type="plone.app.textfield.RichText"
indexer:searchable="true">
<description />
<required>False</required>
<title i18n:translate="">Text</title>
</field>
<field name="attendees" type="zope.schema.Text"
indexer:searchable="true">
<description />
<required>False</required>
<title i18n:translate="label_event_attendees">Attendees</title>
</field>
<field name="event_url" type="zope.schema.TextLine">
<description i18n:translate="help_url">
Web address with more info about the event. Add http:// for external
links.
</description>
<required>False</required>
<title i18n:translate="event_more_information">Event URL</title>
</field>
<field name="contact_name" type="zope.schema.TextLine"
indexer:searchable="true">
<description />
<required>False</required>
<title i18n:translate="label_contact_name">Contact Name</title>
</field>
<field name="contact_email" type="zope.schema.TextLine">
<description />
<required>False</required>
<title i18n:translate="label_contact_email">Contact E-mail</title>
</field>
<field name="contact_phone" type="zope.schema.TextLine">
<description />
<required>False</required>
<title i18n:translate="label_contact_phone">Contact Phone</title>
</field>
</schema>
</model>"""
fti.model_file = None # Was plone.app.contenttypes.schema:event.xml
if 'Event' in portal.portal_types:
del portal.portal_types['Event']
portal.portal_types._setObject('Event', fti)
return fti
