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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 import_mimetypes_registry(registry, xml_filecontent):
""" Imports the given xml filecontent directly into the mimetypes registry
"""
portal = registry.portal_url.getPortalObject()
tool = portal.portal_setup
imp = DummyImportContext(portal, purge=True, tool=tool)
doc = parseString(xml_filecontent)
node = doc.firstChild
adapter = MimetypesRegistryNodeAdapter(registry, imp)
adapter._importNode(node)
return imp.getLogger(adapter._LOGGER_ID)._messages
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_importCatalogBlacklist(self):
context = DummyImportContext(self.portal, self.portal.portal_setup)
context._files[ CATALOGBLACKLIST_XML ] = _TEST1_XML
importCatalogBlacklist(context)
self.assertEqual(
self.catalogblacklist.getBlackListedIndexesForObject(
self.folder.doc),
[u'object_provides', u'Description'])
self.assertEqual(
self.catalogblacklist.getBlackListedIndexesForObject(
self.folder),
[u'object_provides'])
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_import_site_with_subitems_and_blanklines_dotobjects(self):
self._setUpAdapters()
ITEM_IDS = ('foo', 'bar', 'baz')
site = _makeFolder('site', site_folder=True)
context = DummyImportContext(site)
# We want to add 'baz' to 'foo', without losing 'bar'
correct = '\n'.join(['%s,%s' % (x, TEST_INI_AWARE) for x in ITEM_IDS])
broken = correct + '\n\n'
context._files['structure/.objects'] = broken
for index in range(len(ITEM_IDS)):
id = ITEM_IDS[index]
context._files['structure/%s.ini' % id] = KNOWN_INI % (
'Title: %s' % id,
'xyzzy',
)
importer = self._getImporter()
importer(context)
after = site.objectIds()
self.assertEqual(len(after), len(ITEM_IDS))
for found_id, expected_id in zip(after, ITEM_IDS):
self.assertEqual(found_id, expected_id)
def test_empty_skip_purge(self):
from Products.CMFCore.exportimport.skins import importSkinsTool
_IDS = ('one', 'two', 'three')
_PATHS = {'basic': 'one', 'fancy': 'three, two, one'}
site = self._initSite(selections=_PATHS, ids=_IDS)
skins_tool = site.portal_skins
self.failIf(site._skin_setup_called)
self.assertEqual(len(skins_tool.getSkinPaths()), 2)
self.assertEqual(len(skins_tool.objectItems()), 3)
context = DummyImportContext(site, False)
context._files['skins.xml'] = self._EMPTY_EXPORT
importSkinsTool(context)
self.assertEqual(skins_tool.default_skin, "default_skin")
self.assertEqual(skins_tool.request_varname, "request_varname")
self.failIf(skins_tool.allow_any)
self.failIf(skins_tool.cookie_persistence)
self.failUnless(site._skin_setup_called)
self.assertEqual(len(skins_tool.getSkinPaths()), 2)
self.assertEqual(len(skins_tool.objectItems()), 3)
def test_import_site_with_subfolders_and_preserve(self):
self._setUpAdapters()
site = _makeFolder('site', site_folder=True)
site._setObject('foo', _makeFolder('foo'))
site.foo._setObject('bar', _makeFolder('bar'))
context = DummyImportContext(site)
# We want to add 'baz' to 'foo', without losing 'bar'
context._files['structure/.objects'] = 'foo,%s' % TEST_FOLDER
context._files['structure/.preserve'] = '*'
context._files['structure/foo/.objects'] = 'baz,%s' % TEST_FOLDER
context._files['structure/foo/.preserve'] = '*'
context._files['structure/foo/baz/.objects'] = ''
importer = self._getImporter()
importer(context)
self.assertEqual(len(site.objectIds()), 1)
self.assertEqual(site.objectIds()[0], 'foo')
self.assertEqual(len(site.foo.objectIds()), 2, site.foo.objectIds())
self.assertEqual(site.foo.objectIds()[0], 'bar')
self.assertEqual(site.foo.objectIds()[1], 'baz')
def test_import_multiple_times_no_purge(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.assertEquals(1, 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)
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(Interface, roles['CopyEditor'].required_interface)
self.assertEquals('Can control', roles['Controller'].title)
self.assertEquals(None, roles['Controller'].required_permission)
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_syntax_error_reporting(self):
site = self.site
context = DummyImportContext(site, False)
context._files['viewlets.xml'] = """<?xml version="1.0"?>\n<"""
self.assertRaises(ExpatError, importViewletSettingsStorage, context)
def setUp(self):
super(TestSchema, self).setUp()
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="home_page" type="zope.schema.URI" users:forms="In User Profile">
<description i18n:translate="help_homepage">
The URL for your external home page, if you have one.
</description>
<required>False</required>
<title i18n:translate="label_homepage">Home Page</title>
</field>
<field name="description" type="zope.schema.Text" users:forms="In User Profile">
<description i18n:translate="help_biography">
A short overview of who you are and what you do. Will be displayed
on your author page, linked from the items you create.
</description>
<required>False</required>
<title i18n:translate="label_biography">Biography</title>
</field>
<field name="location" type="zope.schema.TextLine" users:forms="In User Profile">
<description i18n:translate="help_location">
Your location - either city and country - or in
a company setting, where your office is located.
</description>
<required>False</required>
<title i18n:translate="label_biography">Location</title>
</field>
<field name="portrait" type="plone.namedfile.field.NamedBlobImage" users:forms="In User Profile">
<description i18n:translate="help_portrait">
To add or change the portrait: click the "Browse" button; select a
picture of yourself. Recommended image size is 75 pixels wide by
100 pixels tall.
</description>
<required>False</required>
<title i18n:translate="label_portrait">Portrait</title>
</field>
<field name="birthdate" type="zope.schema.Date" users:forms="In User Profile">
<description/>
<required>False</required>
<title>Birthdate</title>
</field>
<field name="another_date" type="zope.schema.Datetime" users:forms="In User Profile">
<description/>
<required>False</required>
<title>Another date</title>
</field>
<field name="age" type="zope.schema.Int" users:forms="In User Profile">
<description/>
<required>False</required>
<title>Age</title>
</field>
<field name="department" type="zope.schema.Choice" users:forms="In User Profile">
<description/>
<required>False</required>
<title>Department</title>
<values>
<element>Marketing</element>
<element>Production</element>
<element>HR</element>
</values>
</field>
<field name="skills" type="zope.schema.Set" users:forms="In User Profile">
<description/>
<required>False</required>
<title>Skills</title>
<value_type type="zope.schema.Choice">
<values>
<element>Programming</element>
<element>Management</element>
</values>
</value_type>
</field>
<field name="pi" type="zope.schema.Float" users:forms="In User Profile">
<description/>
<required>False</required>
<title>Pi</title>
</field>
<field name="vegetarian" type="zope.schema.Bool" users:forms="In User Profile">
<description/>
<required>False</required>
<title>Vegetarian</title>
</field>
</schema>
</model>
"""
context = DummyImportContext(self.portal, purge=False)
context._files = {'userschema.xml': xml}
import_schema(context)
transaction.commit()
self.browser = Browser(self.layer['app'])
self.request = self.layer['request']
def test_normal(self):
from Products.GenericSetup.tests.common import DummyImportContext
from Products.LDAPUserFolder.exportimport import \
importLDAPUserFolder
site = self._initSite()
acl = site.acl_users
context = DummyImportContext(site)
context._files['ldapuserfolder.xml'] = _CHANGED_EXPORT
importLDAPUserFolder(context)
self.assertEqual(acl.title, 'changed title')
self.assertEqual(acl._login_attr, 'uid')
self.assertEqual(acl._uid_attr, 'cn')
self.assertEqual(acl.users_base, 'ou=users,dc=localhost')
self.assertEqual(acl.users_scope, 1)
self.assertEqual(acl._roles, ['Anonymous', 'Member'])
self.assertEqual(acl.groups_base, 'ou=groups,dc=localhost')
self.assertEqual(acl.groups_scope, 1)
self.assertEqual(acl._binduid, 'cn=Manager,dc=localhost')
self.assertEqual(acl._bindpwd, 'secret')
self.assertEqual(acl._binduid_usage, 2)
self.assertEqual(acl._rdnattr, 'uid')
self.assertEqual(acl._user_objclasses, ['top', 'inetOrgPerson'])
self.assertTrue(acl._local_groups)
self.assertTrue(acl._implicit_mapping)
self.assertEqual(acl._pwd_encryption, 'SSHA')
self.assertTrue(acl.read_only)
self.assertEqual(acl._extra_user_filter, '(usertype=privileged)')
group_mappings = acl.getGroupMappings()
self.assertEqual(len(group_mappings), 1)
self.assertEqual(group_mappings[0], ('posixAdmin', 'Manager'))
schema = acl.getSchemaConfig()
self.assertEqual(len(schema), 4)
self.assertEqual(
schema.get('mail'), {
'ldap_name': 'mail',
'friendly_name': 'Email Address',
'public_name': 'publicmail',
'multivalued': True,
'binary': True
})
servers = acl.getServers()
self.assertEqual(len(servers), 2)
svr1 = {
'host': 'localhost',
'port': 636,
'protocol': 'ldaps',
'conn_timeout': 10,
'op_timeout': 10
}
svr2 = {
'host': '/var/spool/ldapi',
'port': 0,
'protocol': 'ldapi',
'conn_timeout': 2,
'op_timeout': 2
}
self.assertTrue(svr1 in servers)
self.assertTrue(svr2 in servers)
local_groups = list(acl._groups_store.items())
self.assertEqual(len(local_groups), 2)
self.assertTrue(('user1', ['posixAdmin', 'foobar']) in local_groups)
self.assertTrue(('user2', ['baz']) in local_groups)
def testAssignmentPurging(self):
# initially there should be 3 assignments on the root
mapping = assignment_mapping_from_key(self.portal,
manager_name=u"test.testcolumn", category=CONTEXT_CATEGORY, key="/")
self.assertEqual(3, len(mapping))
context = DummyImportContext(self.portal, purge=False)
context._files['portlets.xml'] = """<?xml version="1.0"?>
<portlets>
<assignment
manager="test.testcolumn"
category="context"
key="/"
purge="True"
/>
</portlets>
"""
importPortlets(context)
# now they should be gone
mapping = assignment_mapping_from_key(self.portal,
manager_name=u"test.testcolumn", category=CONTEXT_CATEGORY, key="/")
self.assertEqual(0, len(mapping))
# group assignments should still be there
mapping = assignment_mapping_from_key(self.portal,
manager_name=u"test.testcolumn", category=GROUP_CATEGORY, key="Reviewers")
self.assertEqual(1, len(mapping))
# and be purgable
context = DummyImportContext(self.portal, purge=False)
context._files['portlets.xml'] = """<?xml version="1.0"?>
<portlets>
<assignment
manager="test.testcolumn"
category="group"
key="Reviewers"
purge="True"
/>
</portlets>
"""
importPortlets(context)
# now they should be gone
mapping = assignment_mapping_from_key(self.portal,
manager_name=u"test.testcolumn", category=GROUP_CATEGORY, key="Reviewers")
self.assertEqual(0, len(mapping))
# also content type assignments should still be there
mapping = assignment_mapping_from_key(self.portal,
manager_name=u"test.testcolumn", category=CONTENT_TYPE_CATEGORY, key="Folder")
self.assertEqual(2, len(mapping))
# and be purgable
context = DummyImportContext(self.portal, purge=False)
context._files['portlets.xml'] = """<?xml version="1.0"?>
<portlets>
<assignment
manager="test.testcolumn"
category="content_type"
key="Folder"
purge="True"
/>
</portlets>
"""
importPortlets(context)
# now they should be gone
mapping = assignment_mapping_from_key(self.portal,
manager_name=u"test.testcolumn", category=CONTENT_TYPE_CATEGORY, key="Folder")
self.assertEqual(0, len(mapping))
