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 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 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 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 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 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_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_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('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_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(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 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 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_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_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_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 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('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_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 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
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 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)
