def test_remove_one(self):
xml = """\
<sharing>
<role id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy' />
</sharing>
"""
context = DummyImportContext(self.sm, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEquals(1, len(roles))
self.assertEquals('Can copyedit', roles['CopyEditor'].title)
xml = """\
<sharing>
<role remove="True"
id='CopyEditor' />
</sharing>
"""
context = DummyImportContext(self.sm, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEquals(0, len(roles))
def test_import_records_remove_with_omit(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
delete_xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" remove="true">
<omit>name</omit>
</records>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': delete_xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless('plone.app.registry.tests.data.ITestSettings.name' in
self.registry)
self.failIf(
'plone.app.registry.tests.data.ITestSettings.age' in self.registry)
def test_import_records_remove_with_omit(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
delete_xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" remove="true">
<omit>name</omit>
</records>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': delete_xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless('plone.app.registry.tests.data.ITestSettings.name' in self.registry)
self.failIf('plone.app.registry.tests.data.ITestSettings.age' in self.registry)
def test_import_records_remove_with_value(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
delete_xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" remove="true">
<value key="name">Spam</value>
</records>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': delete_xml}
self.assertRaises(ValueError, importRegistry, context)
self.assertEquals(2, len(self.registry.records))
def test_remove_one(self):
xml = """\
<sharing>
<role id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy' />
</sharing>
"""
context = DummyImportContext(self.sm, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEqual(1, len(roles))
self.assertEqual('Can copyedit', roles['CopyEditor'].title)
xml = """\
<sharing>
<role remove="True"
id='CopyEditor' />
</sharing>
"""
context = DummyImportContext(self.sm, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEqual(0, len(roles))
def test_remove_multiple(self):
xml = """\
<sharing>
<role id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy' />
<role id='DoerOfStuff'
title='Can do stuff'
permission='Delegate doing stuff' />
</sharing>
"""
context = DummyImportContext(self.sm, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
xml = """\
<sharing>
<role id='Hacker'
title='Can hack'
permission='Hack the system' />
<role remove="True"
id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy' />
</sharing>
"""
context = DummyImportContext(self.sm, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEqual(2, len(roles))
self.assertEqual('Can do stuff', roles['DoerOfStuff'].title)
self.assertEqual('Can hack', roles['Hacker'].title)
def test_import_records_remove_with_value(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
delete_xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" remove="true">
<value key="name">Spam</value>
</records>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': delete_xml}
self.assertRaises(ValueError, importRegistry, context)
self.assertEquals(2, len(self.registry.records))
def test_import_multiple_times_no_purge(self):
xml = """\
<sharing>
<role id='CopyEditor' title='Can copyedit' permission='Delegate edit copy'/>
</sharing>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEquals(1, len(roles))
self.assertEquals('Can copyedit', roles['CopyEditor'].title)
self.assertEquals('Delegate edit copy', roles['CopyEditor'].required_permission)
xml = """\
<sharing>
<role id='Controller' title='Can control' />
</sharing>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEquals(2, len(roles))
self.assertEquals('Can copyedit', roles['CopyEditor'].title)
self.assertEquals('Delegate edit copy', roles['CopyEditor'].required_permission)
self.assertEquals('Can control', roles['Controller'].title)
self.assertEquals(None, roles['Controller'].required_permission)
def test_remove_multiple(self):
xml = """\
<sharing>
<role id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy' />
<role id='DoerOfStuff'
title='Can do stuff'
permission='Delegate doing stuff' />
</sharing>
"""
context = DummyImportContext(self.sm, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
xml = """\
<sharing>
<role id='Hacker'
title='Can hack'
permission='Hack the system' />
<role remove="True"
id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy' />
</sharing>
"""
context = DummyImportContext(self.sm, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEquals(2, len(roles))
self.assertEquals('Can do stuff', roles['DoerOfStuff'].title)
self.assertEquals('Can hack', roles['Hacker'].title)
def test_import_override_global(self):
provideUtility(PersistentSharingPageRole("Do stuff", "A permission"),
ISharingPageRole,
name="DoerOfStuff")
xml = """\
<sharing>
<role id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy' />
<role id='DoerOfStuff'
title='Can do stuff'
permission='Delegate doing stuff' />
</sharing>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEquals(2, len(roles))
self.assertEquals('Can copyedit', roles['CopyEditor'].title)
self.assertEquals('Delegate edit copy',
roles['CopyEditor'].required_permission)
self.assertEquals(None, roles['CopyEditor'].required_interface)
self.assertEquals('Can do stuff', roles['DoerOfStuff'].title)
self.assertEquals('Delegate doing stuff',
roles['DoerOfStuff'].required_permission)
def test_import_override_global(self):
provideUtility(PersistentSharingPageRole("Do stuff", "A permission"), ISharingPageRole, name="DoerOfStuff")
xml = """\
<sharing>
<role id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy' />
<role id='DoerOfStuff'
title='Can do stuff'
permission='Delegate doing stuff' />
</sharing>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEqual(2, len(roles))
self.assertEqual('Can copyedit', roles['CopyEditor'].title)
self.assertEqual('Delegate edit copy', roles['CopyEditor'].required_permission)
self.assertEqual(None, roles['CopyEditor'].required_interface)
self.assertEqual('Can do stuff', roles['DoerOfStuff'].title)
self.assertEqual('Delegate doing stuff', roles['DoerOfStuff'].required_permission)
def test_import_collection_frozenset_append(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element>4</element>
<element>6</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = Record(
field.FrozenSet(title=u"Simple record",
value_type=field.Int(title=u"Val")),
value=frozenset([2, 4]))
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals(frozenset([2, 4, 6]),
self.registry['test.registry.field'])
def afterSetUp(self):
xml = """<model xmlns:lingua="http://namespaces.plone.org/supermodel/lingua" xmlns:users="http://namespaces.plone.org/supermodel/users" xmlns:form="http://namespaces.plone.org/supermodel/form" xmlns:i18n="http://xml.zope.org/namespaces/i18n" xmlns:security="http://namespaces.plone.org/supermodel/security" xmlns:marshal="http://namespaces.plone.org/supermodel/marshal" xmlns="http://namespaces.plone.org/supermodel/schema" i18n:domain="plone">
<schema name="member-fields">
<field name="id_number" type="zope.schema.TextLine"
users:forms="In User Profile">
<description i18n:translate="help_idnumber">
The number of user's personal identifier .
</description>
<required>True</required>
<title i18n:translate="">Identifier Number</title>
</field>
<field name="safe_level" type="zope.schema.Choice" users:forms="In User Profile">
<description/>
<required>False</required>
<title i18n:translate="">safe level</title>
<values>
<element>height</element>
<element>mid</element>
<element>low</element>
</values>
</field>
</schema>
</model>
"""
context = DummyImportContext(self.portal, purge=False)
context._files = {'userschema.xml': xml}
import_schema(context)
def test_import_multiple_no_purge(self):
xml = """\
<sharing>
<role id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy'
interface='zope.interface.Interface' />
<role id='Controller'
title='Can control' />
</sharing>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEquals(2, len(roles))
self.assertEquals('Can copyedit', roles['CopyEditor'].title)
self.assertEquals('Delegate edit copy',
roles['CopyEditor'].required_permission)
self.assertEquals(Interface, roles['CopyEditor'].required_interface)
self.assertEquals('Can control', roles['Controller'].title)
self.assertEquals(None, roles['Controller'].required_permission)
def test_export_multiple(self):
sm = self.site.getSiteManager()
# Will not be exported, as it's global
provideUtility(PersistentSharingPageRole("Do stuff", "A permission"), ISharingPageRole, name="DoerOfStuff")
# Will not be exported, as it wasn't imported with this handler
sm.registerUtility(PersistentSharingPageRole("Do other Stuff"), ISharingPageRole, "DoerOfOtherStuff")
import_xml = """\
<sharing>
<role id='CopyEditor' title='Can copyedit' permission='Delegate edit copy'/>
<role id='Controller' title='Can control' />
</sharing>
"""
export_xml = """\
<?xml version="1.0"?>
<sharing>
<role title="Can control" id="Controller"/>
<role title="Can copyedit" id="CopyEditor" permission="Delegate edit copy"/>
</sharing>
"""
import_context = DummyImportContext(self.site, purge=False)
import_context._files = {'sharing.xml': import_xml}
import_sharing(import_context)
export_context = DummyExportContext(self.site)
export_sharing(export_context)
self.assertEquals('sharing.xml', export_context._wrote[0][0])
self.assertEquals(export_xml, export_context._wrote[0][1])
def test_import_collection_frozenset_append(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element>4</element>
<element>6</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = Record(
field.FrozenSet(
title=u"Simple record",
value_type=field.Int(title=u"Val")
),
value=frozenset([2, 4])
)
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals(
frozenset([2, 4, 6]),
self.registry['test.registry.field']
)
def test_import_choice_field(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.Choice">
<title>Simple record</title>
<values>
<element>One</element>
<element>Two</element>
</values>
</field>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Old value")
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(isinstance(self.registry.records['test.registry.field'].field, field.Choice))
self.assertEquals(u"Simple record", self.registry.records['test.registry.field'].field.title)
self.assertEquals([u'One', u'Two'], [t.value for t in self.registry.records['test.registry.field'].field.vocabulary])
self.assertEquals(None, self.registry['test.registry.field'])
def test_import_collection_tuple_append(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element>b</element>
<element>c</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = Record(
field.Tuple(
title=u"Simple record",
value_type=field.TextLine(title=u"Val")
),
value=(u"a", u"b", )
)
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals(
(u"a", u"b", u"c", ),
self.registry['test.registry.field']
)
def test_import_collection_tuple_append(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element>b</element>
<element>c</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = Record(field.Tuple(
title=u"Simple record", value_type=field.TextLine(title=u"Val")),
value=(
u"a",
u"b",
))
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals((
u"a",
u"b",
u"c",
), self.registry['test.registry.field'])
def test_import_field_only(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.TextLine">
<default>N/A</default>
<title>Simple record</title>
</field>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(
self.registry.records['test.registry.field'].field,
field.TextLine)
)
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title
)
self.assertEquals(
u"value",
self.registry.records['test.registry.field'].field.__name__
)
self.assertEquals(
u"N/A",
self.registry['test.registry.field']
)
def test_import_dict_nopurge(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element key="x">4</element>
<element key="y">6</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.Dict(title=u"Simple record",
key_type=field.ASCIILine(title=u"Key"),
value_type=field.Int(title=u"Val")),
value={'a': 1})
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.Dict))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals({
'a': 1,
'x': 4,
'y': 6
}, self.registry['test.registry.field'])
def test_import_collection_nopurge(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element>4</element>
<element>6</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.Set(title=u"Simple record", value_type=field.Int(title=u"Val")),
value=set([1]))
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(isinstance(self.registry.records['test.registry.field'].field, field.Set))
self.assertEquals(u"Simple record", self.registry.records['test.registry.field'].field.title)
self.assertEquals(frozenset([1, 4, 6]), self.registry['test.registry.field'])
def test_import_overwrite_field_with_interface(self):
xml = """\
<registry>
<record name="test.registry.field" interface="plone.app.registry.tests.data.ITestSettingsDisallowed" field="age" />
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Old value")
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(
self.registry.records['test.registry.field'].field,
field.Int
)
)
self.assertEquals(
u"Age",
self.registry.records['test.registry.field'].field.title
)
self.assertEquals(
None,
self.registry['test.registry.field']
)
def test_import_overwrite_field_with_field(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.ASCIILine">
<default>Nada</default>
<title>Simple record</title>
</field>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Old value")
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(isinstance(self.registry.records['test.registry.field'].field, field.ASCIILine))
self.assertEquals(u"Simple record", self.registry.records['test.registry.field'].field.title)
self.assertEquals("Nada", self.registry['test.registry.field'])
def test_import_field_ref(self):
xml = """\
<registry>
<record name="test.registry.field.override">
<field ref="test.registry.field" />
<value>Another value</value>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.registry.field'] = Record(
field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
self.failUnless(
IFieldRef.providedBy(
self.registry.records['test.registry.field.override'].field)
)
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field.override'].field.title
)
self.assertEquals(
u"value",
self.registry.records['test.registry.field.override'].field.__name__ # noqa
)
self.assertEquals(
u"Another value",
self.registry['test.registry.field.override']
)
def test_import_field_and_interface(self):
xml = """\
<registry>
<record name="test.registry.field" interface="plone.app.registry.tests.data.ITestSettingsDisallowed" field="age">
<field type="plone.registry.field.ASCIILine">
<default>N/A</default>
<title>Simple record</title>
</field>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(
self.registry.records['test.registry.field'].field,
field.ASCIILine
)
)
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title
)
self.assertEquals(
"N/A",
self.registry['test.registry.field']
)
def test_import_overwrite_field_with_field(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.ASCIILine">
<default>Nada</default>
<title>Simple record</title>
</field>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Old value")
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.ASCIILine))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals("Nada", self.registry['test.registry.field'])
def test_import_collection_nopurge(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element>4</element>
<element>6</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = Record(field.Set(
title=u"Simple record", value_type=field.Int(title=u"Val")),
value=set([1]))
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.Set))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals(frozenset([1, 4, 6]),
self.registry['test.registry.field'])
def test_import_field_only(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.TextLine">
<default>N/A</default>
<title>Simple record</title>
</field>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.TextLine))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals(
u"value",
self.registry.records['test.registry.field'].field.__name__)
self.assertEquals(u"N/A", self.registry['test.registry.field'])
def test_import_field_ref(self):
xml = """\
<registry>
<record name="test.registry.field.override">
<field ref="test.registry.field" />
<value>Another value</value>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.registry.field'] = Record(
field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
self.failUnless(
IFieldRef.providedBy(
self.registry.records['test.registry.field.override'].field))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field.override'].field.title)
self.assertEquals(
u"value",
self.registry.records['test.registry.field.override'].field.
__name__ # noqa
)
self.assertEquals(u"Another value",
self.registry['test.registry.field.override'])
def test_import_interface_and_value(self):
xml = """\
<registry>
<record interface="plone.app.registry.tests.data.ITestSettingsDisallowed" field="age">
<value>2</value>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals(
u"Age",
self.registry.records[
'plone.app.registry.tests.data.ITestSettingsDisallowed.age'].
field.title # noqa
)
self.assertEquals(
2,
self.registry[
'plone.app.registry.tests.data.ITestSettingsDisallowed.age'] # noqa
)
def test_import_dict_nopurge(self):
xml = """\
<registry>
<record name="test.registry.field">
<value purge="false">
<element key="x">4</element>
<element key="y">6</element>
</value>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.Dict(title=u"Simple record",
key_type=field.ASCIILine(title=u"Key"),
value_type=field.Int(title=u"Val")),
value={'a': 1})
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(isinstance(self.registry.records['test.registry.field'].field, field.Dict))
self.assertEquals(u"Simple record", self.registry.records['test.registry.field'].field.title)
self.assertEquals({'a': 1, 'x': 4, 'y': 6}, self.registry['test.registry.field'])
def test_import_records_with_values(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" prefix="plone.app.registry.tests.data.SomethingElse">
<value key="name">Magic</value>
<value key="age">42</value>
</records>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
self.failUnless('plone.app.registry.tests.data.SomethingElse.name' in
self.registry)
self.failUnless(
'plone.app.registry.tests.data.SomethingElse.age' in self.registry)
self.assertEqual(
self.registry['plone.app.registry.tests.data.SomethingElse.name'],
'Magic')
self.assertEqual(
self.registry['plone.app.registry.tests.data.SomethingElse.age'],
42)
def test_import_collection_field(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.FrozenSet">
<title>Simple record</title>
<default>
<element>1</element>
<element>3</element>
</default>
<value_type type="plone.registry.field.Int">
<title>Value</title>
</value_type>
</field>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Old value")
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(isinstance(self.registry.records['test.registry.field'].field, field.FrozenSet))
self.assertEquals(u"Simple record", self.registry.records['test.registry.field'].field.title)
self.assertEquals(frozenset([1, 3]), self.registry['test.registry.field'])
def test_import_with_comments(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" prefix="plone.app.registry.tests.data.SomethingElse">
<!-- set values in this interface -->
<value key="name">Magic</value>
<value key="age">42</value>
</records>
<record name="test.registry.field">
<!-- comment on this field or value -->
<field type="plone.registry.field.TextLine">
<default>N/A</default>
<!-- comment here too -->
<title>Simple record</title>
</field>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(3, len(self.registry.records))
self.failUnless(isinstance(self.registry.records['test.registry.field'].field, field.TextLine))
self.assertEquals(u"Simple record", self.registry.records['test.registry.field'].field.title)
self.assertEquals(u"value", self.registry.records['test.registry.field'].field.__name__)
self.assertEquals(u"N/A", self.registry['test.registry.field'])
self.failUnless('plone.app.registry.tests.data.SomethingElse.name' in self.registry)
self.failUnless('plone.app.registry.tests.data.SomethingElse.age' in self.registry)
self.assertEqual(self.registry['plone.app.registry.tests.data.SomethingElse.name'], 'Magic')
self.assertEqual(self.registry['plone.app.registry.tests.data.SomethingElse.age'], 42)
def test_import_dict_field(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.Dict">
<title>Simple record</title>
<default>
<element key="a">1</element>
<element key="b">3</element>
</default>
<key_type type="plone.registry.field.ASCIILine">
<title>Key</title>
</key_type>
<value_type type="plone.registry.field.Int">
<title>Value</title>
</value_type>
</field>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Old value")
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(isinstance(self.registry.records['test.registry.field'].field, field.Dict))
self.assertEquals(u"Simple record", self.registry.records['test.registry.field'].field.title)
self.assertEquals({'a': 1, 'b': 3}, self.registry['test.registry.field'])
def test_import_value_only(self):
xml = """\
<registry>
<record name="test.export.simple">
<value>Imported value</value>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals(
u"Simple record",
self.registry.records['test.export.simple'].field.title
)
self.assertEquals(
u"Imported value",
self.registry['test.export.simple']
)
def test_import_records_with_values(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" prefix="plone.app.registry.tests.data.SomethingElse">
<value key="name">Magic</value>
<value key="age">42</value>
</records>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
self.failUnless(
'plone.app.registry.tests.data.SomethingElse.name' in self.registry
)
self.failUnless(
'plone.app.registry.tests.data.SomethingElse.age' in self.registry
)
self.assertEqual(
self.registry['plone.app.registry.tests.data.SomethingElse.name'],
'Magic'
)
self.assertEqual(
self.registry['plone.app.registry.tests.data.SomethingElse.age'],
42
)
def test_import_records_omit(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettingsDisallowed">
<omit>blob</omit>
</records>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(3, len(self.registry.records))
self.failUnless(
'plone.app.registry.tests.data.ITestSettingsDisallowed.name' in
self.registry
)
self.failUnless(
'plone.app.registry.tests.data.ITestSettingsDisallowed.age' in
self.registry
)
def test_empty_import_no_purge(self):
xml = "<sharing />"
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
self.assertEqual(0, len(self.roles()))
def test_empty_import_no_purge(self):
xml = "<sharing />"
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
self.assertEquals(0, len(self.roles()))
def test_import_records_nonexistant_interface(self):
xml = """\
<registry>
<records interface="non.existant.ISchema" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.assertRaises(ImportError, importRegistry, context)
def test_import_purge(self):
xml = "<registry/>"
context = DummyImportContext(self.site, purge=True)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(0, len(self.registry.records))
def test_import_purge(self):
xml = "<registry/>"
context = DummyImportContext(self.site, purge=True)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(0, len(self.registry.records))
def test_import_multiples_times_no_purge_overwrite(self):
xml = """\
<sharing>
<role id='CopyEditor'
title='Can copyedit'
permission='Delegate edit copy'
interface='zope.interface.Interface' />
</sharing>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEqual(1, len(roles))
self.assertEqual('Can copyedit', roles['CopyEditor'].title)
self.assertEqual('Delegate edit copy', roles['CopyEditor'].required_permission)
self.assertEqual(Interface, roles['CopyEditor'].required_interface)
xml = """\
<sharing>
<role id='CopyEditor'
title='Can edit copy'
permission='Delegate: CopyEditor' />
</sharing>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'sharing.xml': xml}
import_sharing(context)
roles = self.roles()
self.assertEqual(1, len(roles))
self.assertEqual('Can edit copy', roles['CopyEditor'].title)
self.assertEqual('Delegate: CopyEditor', roles['CopyEditor'].required_permission)
self.assertEqual(None, roles['CopyEditor'].required_interface)
def test_import_records_delete_deprecated(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
delete_xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" delete="true"/>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': delete_xml}
importRegistry(context)
self.assertEquals(0, len(self.registry.records))
def test_import_records_delete_deprecated(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
delete_xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" delete="true"/>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': delete_xml}
importRegistry(context)
self.assertEquals(0, len(self.registry.records))
def test_import_interface_no_value(self):
xml = """\
<registry>
<record interface="plone.app.registry.tests.data.ITestSettingsDisallowed" field="name" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals(u"Name", self.registry.records['plone.app.registry.tests.data.ITestSettingsDisallowed.name'].field.title)
self.assertEquals(u"Mr. Registry", self.registry['plone.app.registry.tests.data.ITestSettingsDisallowed.name'])
def test_delete_deprecated(self):
xml = """\
<registry>
<record name="test.export.simple" delete="true" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(0, len(self.registry.records))
def test_delete_deprecated(self):
xml = """\
<registry>
<record name="test.export.simple" delete="true" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(0, len(self.registry.records))
def test_import_records_with_prefix(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" prefix="plone.app.registry.tests.data.SomethingElse" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(2, len(self.registry.records))
self.failUnless('plone.app.registry.tests.data.SomethingElse.name' in
self.registry)
self.failUnless(
'plone.app.registry.tests.data.SomethingElse.age' in self.registry)
def test_import_with_comments(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" prefix="plone.app.registry.tests.data.SomethingElse">
<!-- set values in this interface -->
<value key="name">Magic</value>
<value key="age">42</value>
</records>
<record name="test.registry.field">
<!-- comment on this field or value -->
<field type="plone.registry.field.TextLine">
<default>N/A</default>
<!-- comment here too -->
<title>Simple record</title>
</field>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(3, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.TextLine))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals(
u"value",
self.registry.records['test.registry.field'].field.__name__)
self.assertEquals(u"N/A", self.registry['test.registry.field'])
self.failUnless('plone.app.registry.tests.data.SomethingElse.name' in
self.registry)
self.failUnless(
'plone.app.registry.tests.data.SomethingElse.age' in self.registry)
self.assertEqual(
self.registry['plone.app.registry.tests.data.SomethingElse.name'],
'Magic')
self.assertEqual(
self.registry['plone.app.registry.tests.data.SomethingElse.age'],
42)
def test_import_records_disallowed(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettingsDisallowed" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
try:
importRegistry(context)
except TypeError:
pass
else:
self.fail()
def test_import_export(self):
# This module takes care of exporting and importing settings of TinyMCE. Let's
# create a dummy import context. And a dummy file.
xml = """\
<object>
<resourcetypes>
<link_using_uids value="True"/>
<customplugins purge="True">
<element value="testplugin"/>
</customplugins>
<linkable purge="False">
<element value="Topic"/>
</linkable>
<customplugins purge="True">
<element value="testplugin"/>
</customplugins>
</resourcetypes>
</object>
"""
context = DummyImportContext(self.portal, purge=True)
context._files = {'tinymce.xml': xml}
# Now import the file.
importTinyMCESettings(context)
# Our specified plugin should now be stored in the utility.
tinymce_utility = getUtility(ITinyMCE)
self.assertIn('testplugin', tinymce_utility.customplugins)
# Let's create a dummy export context.
context = DummyExportContext(self.portal)
# And export the current settings.
exportTinyMCESettings(context)
# Check if tinymce.xml is exported.
self.assertEqual(context._wrote[0][0], 'tinymce.xml')
# Check the contents of the export.
self.assertIn('testplugin', context._wrote[0][1])
def test_import_interface_no_value(self):
xml = """\
<registry>
<record interface="plone.app.registry.tests.data.ITestSettingsDisallowed" field="name" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals(
u"Name", self.registry.records[
'plone.app.registry.tests.data.ITestSettingsDisallowed.name'].
field.title)
self.assertEquals(
u"Mr. Registry", self.registry[
'plone.app.registry.tests.data.ITestSettingsDisallowed.name'])
def test_import_records(self):
xml = """\
<registry>
<records interface="plone.app.registry.tests.data.ITestSettings" />
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(3, len(self.registry.records))
self.failUnless('plone.app.registry.tests.data.ITestSettings.name' in
self.registry)
self.failUnless(
'plone.app.registry.tests.data.ITestSettings.age' in self.registry)
def test_import_dict_field(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.Dict">
<title>Simple record</title>
<default>
<element key="a">1</element>
<element key="b">3</element>
</default>
<key_type type="plone.registry.field.ASCIILine">
<title>Key</title>
</key_type>
<value_type type="plone.registry.field.Int">
<title>Value</title>
</value_type>
</field>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = Record(
field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Old value")
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.Dict))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals({
'a': 1,
'b': 3
}, self.registry['test.registry.field'])
def test_export_multiple(self):
sm = self.site.getSiteManager()
# Will not be exported, as it's global
provideUtility(PersistentSharingPageRole("Do stuff", "A permission"),
ISharingPageRole,
name="DoerOfStuff")
# Will not be exported, as it wasn't imported with this handler
sm.registerUtility(PersistentSharingPageRole("Do other Stuff"),
ISharingPageRole, "DoerOfOtherStuff")
import_xml = """\
<sharing>
<role title="Can control" id="Controller"/>
<role title="Can copyedit" id="CopyEditor"
interface="zope.interface.Interface" permission="Delegate edit copy"/>
</sharing>
"""
export_xml = """\
<?xml version="1.0"?>
<sharing>
<role title="Can control" id="Controller"/>
<role title="Can copyedit" id="CopyEditor"
interface="zope.interface.Interface" permission="Delegate edit copy"/>
</sharing>
"""
import_context = DummyImportContext(self.site, purge=False)
import_context._files = {'sharing.xml': import_xml}
import_sharing(import_context)
export_context = DummyExportContext(self.site)
export_sharing(export_context)
self.assertEquals('sharing.xml', export_context._wrote[0][0])
self.assertEquals(export_xml, export_context._wrote[0][1])
def test_import_value_only(self):
xml = """\
<registry>
<record name="test.export.simple">
<value>Imported value</value>
</record>
</registry>
"""
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
self.registry.records['test.export.simple'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Sample value")
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.assertEquals(
u"Simple record",
self.registry.records['test.export.simple'].field.title)
self.assertEquals(u"Imported value",
self.registry['test.export.simple'])
def test_import_choice_field(self):
xml = """\
<registry>
<record name="test.registry.field">
<field type="plone.registry.field.Choice">
<title>Simple record</title>
<values>
<element>One</element>
<element>Two</element>
</values>
</field>
</record>
</registry>
"""
self.registry.records['test.registry.field'] = \
Record(field.TextLine(title=u"Simple record", default=u"N/A"),
value=u"Old value")
context = DummyImportContext(self.site, purge=False)
context._files = {'registry.xml': xml}
importRegistry(context)
self.assertEquals(1, len(self.registry.records))
self.failUnless(
isinstance(self.registry.records['test.registry.field'].field,
field.Choice))
self.assertEquals(
u"Simple record",
self.registry.records['test.registry.field'].field.title)
self.assertEquals(
[u'One', u'Two'],
[
t.value for t in
self.registry.records['test.registry.field'].field.vocabulary
] # noqa
)
self.assertEquals(None, self.registry['test.registry.field'])
