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