# Patch-overlapping Python context after the fix ## `src/Products/GenericSetup/context.py` — `class:SnapshotExportContext` (lines 472-572) ```python class SnapshotExportContext(BaseContext): security = ClassSecurityInfo() def __init__(self, tool, snapshot_id, encoding=None): BaseContext.__init__(self, tool, encoding) self._snapshot_id = snapshot_id @security.protected(ManagePortal) def writeDataFile(self, filename, text, content_type, subdir=None): """ See IExportContext. """ if subdir is not None: filename = '/'.join((subdir, filename)) sep = filename.rfind('/') if sep != -1: subdir = filename[:sep] filename = filename[sep+1:] if six.PY2 and isinstance(text, six.text_type): encoding = self.getEncoding() or 'utf-8' text = text.encode(encoding) folder = self._ensureSnapshotsFolder(subdir) # MISSING: switch on content_type ob = self._createObjectByType(filename, text, content_type) folder._setObject(str(filename), ob) # No Unicode IDs! # Tighten the View permission on the new object. # Only the owner and Manager users may view the log. # file_ob = self._getOb(name) ob.manage_permission(view, ('Manager', 'Owner'), 0) @security.protected(ManagePortal) def getSnapshotURL(self): """ See IExportContext. """ return '%s/%s' % (self._tool.absolute_url(), self._snapshot_id) @security.protected(ManagePortal) def getSnapshotFolder(self): """ See IExportContext. """ return self._ensureSnapshotsFolder() # # Helper methods # @security.private def _createObjectByType(self, name, body, content_type): encoding = self.getEncoding() or 'utf-8' if six.PY2 and isinstance(body, six.text_type): body = body.encode(encoding) if name.endswith('.py'): ob = PythonScript(name) ob.write(body) return ob if name.endswith('.dtml'): ob = DTMLDocument('', __name__=name) ob.munge(body) return ob if content_type in ('text/html', 'text/xml'): return ZopePageTemplate(name, body, content_type=content_type) if isinstance(body, six.text_type): body = body.encode(encoding) if content_type[:6] == 'image/': return Image(name, '', body, content_type=content_type) return File(name, '', body, content_type=content_type) @security.private def _ensureSnapshotsFolder(self, subdir=None): """ Ensure that the appropriate snapshot folder exists. """ path = ['snapshots', self._snapshot_id] if subdir is not None: path.extend(subdir.split('/')) current = self._tool for element in path: if element not in current.objectIds(): # No Unicode IDs! current._setObject(str(element), Folder(element)) current = current._getOb(element) current.manage_permission(view, ('Manager', 'Owner'), 0) else: current = current._getOb(element) return current ``` ## `src/Products/GenericSetup/context.py` — `function:SnapshotExportContext.writeDataFile` (lines 482-506) ```python def writeDataFile(self, filename, text, content_type, subdir=None): """ See IExportContext. """ if subdir is not None: filename = '/'.join((subdir, filename)) sep = filename.rfind('/') if sep != -1: subdir = filename[:sep] filename = filename[sep+1:] if six.PY2 and isinstance(text, six.text_type): encoding = self.getEncoding() or 'utf-8' text = text.encode(encoding) folder = self._ensureSnapshotsFolder(subdir) # MISSING: switch on content_type ob = self._createObjectByType(filename, text, content_type) folder._setObject(str(filename), ob) # No Unicode IDs! # Tighten the View permission on the new object. # Only the owner and Manager users may view the log. # file_ob = self._getOb(name) ob.manage_permission(view, ('Manager', 'Owner'), 0) ``` ## `src/Products/GenericSetup/context.py` — `function:SnapshotExportContext._ensureSnapshotsFolder` (lines 551-572) ```python def _ensureSnapshotsFolder(self, subdir=None): """ Ensure that the appropriate snapshot folder exists. """ path = ['snapshots', self._snapshot_id] if subdir is not None: path.extend(subdir.split('/')) current = self._tool for element in path: if element not in current.objectIds(): # No Unicode IDs! current._setObject(str(element), Folder(element)) current = current._getOb(element) current.manage_permission(view, ('Manager', 'Owner'), 0) else: current = current._getOb(element) return current ``` ## `src/Products/GenericSetup/context.py` — `module:@29` (lines 29-29) ```python from AccessControl.Permissions import view ``` ## `src/Products/GenericSetup/tests/test_tool.py` — `class:SetupToolTests` (lines 111-1786) ```python class SetupToolTests(FilesystemTestBase, TarballTester, ConformsToISetupTool): layer = ExportImportZCMLLayer _PROFILE_PATH = tempfile.mkdtemp(prefix='STT_test') _PROFILE_PATH2 = tempfile.mkdtemp(prefix='STT_test2') _PROFILE_PATH3 = tempfile.mkdtemp(prefix='STT_test3') def afterSetUp(self): from ..upgrade import _upgrade_registry _upgrade_registry.clear() profile_registry.clear() global _before_import_events global _after_import_events _before_import_events = [] provideHandler(handleBeforeProfileImportEvent) _after_import_events = [] provideHandler(handleProfileImportedEvent) def beforeTearDown(self): base_registry.unregisterHandler(handleBeforeProfileImportEvent) base_registry.unregisterHandler(handleProfileImportedEvent) FilesystemTestBase.beforeTearDown(self) from ..upgrade import _upgrade_registry profile_registry.clear() _upgrade_registry.clear() noSecurityManager() def _getTargetClass(self): from ..tool import SetupTool return SetupTool def _makeSite(self, title="Don't care"): site = Folder() site._setId('site') site.title = title self.app._setObject('site', site) self.app.acl_users.userFolderAddUser('admin', '', ['Manager'], []) newSecurityManager(None, self.app.acl_users.getUser('admin')) return self.app._getOb('site') def test_empty(self): tool = self._makeOne('setup_tool') self.assertEqual(tool.getBaselineContextID(), '') import_registry = tool.getImportStepRegistry() self.assertEqual(len(import_registry.listSteps()), 0) export_registry = tool.getExportStepRegistry() export_steps = export_registry.listSteps() self.assertEqual(len(export_steps), 0) toolset_registry = tool.getToolsetRegistry() self.assertEqual(len(toolset_registry.listForbiddenTools()), 0) self.assertEqual(len(toolset_registry.listRequiredTools()), 0) def test_getBaselineContextID(self): from ..tool import EXPORT_STEPS_XML from ..tool import IMPORT_STEPS_XML from ..tool import TOOLSET_XML tool = self._makeOne('setup_tool') self._makeFile(IMPORT_STEPS_XML, _EMPTY_IMPORT_XML) self._makeFile(EXPORT_STEPS_XML, _EMPTY_EXPORT_XML) self._makeFile(TOOLSET_XML, _EMPTY_TOOLSET_XML) profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH) tool.setBaselineContext('profile-other:foo') self.assertEqual(tool.getBaselineContextID(), 'profile-other:foo') def test_setBaselineContext_invalid(self): tool = self._makeOne('setup_tool') self.assertRaises(KeyError, tool.setBaselineContext, 'profile-foo') def test_setBaselineContext_empty_string(self): tool = self._makeOne('setup_tool') self.assertRaises(KeyError, tool.setBaselineContext, '') def test_setBaselineContext(self): from ..tool import EXPORT_STEPS_XML from ..tool import IMPORT_STEPS_XML from ..tool import TOOLSET_XML tool = self._makeOne('setup_tool') tool.getExportStepRegistry().clear() self._makeFile(IMPORT_STEPS_XML, _SINGLE_IMPORT_XML) self._makeFile(EXPORT_STEPS_XML, _SINGLE_EXPORT_XML) self._makeFile(TOOLSET_XML, _NORMAL_TOOLSET_XML) profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH) tool.setBaselineContext('profile-other:foo') self.assertEqual(tool.getBaselineContextID(), 'profile-other:foo') import_registry = tool.getImportStepRegistry() self.assertEqual(len(import_registry.listSteps()), 1) self.assertTrue('one' in import_registry.listSteps()) info = import_registry.getStepMetadata('one') self.assertEqual(info['id'], 'one') self.assertEqual(info['title'], 'One Step') self.assertEqual(info['version'], '1') self.assertTrue('One small step' in info['description']) self.assertEqual(info['handler'], 'Products.GenericSetup.tests.test_registry.ONE_FUNC') self.assertEqual(import_registry.getStep('one'), ONE_FUNC) export_registry = tool.getExportStepRegistry() self.assertEqual(len(export_registry.listSteps()), 1) self.assertTrue('one' in import_registry.listSteps()) info = export_registry.getStepMetadata('one') self.assertEqual(info['id'], 'one') self.assertEqual(info['title'], 'One Step') self.assertTrue('One small step' in info['description']) self.assertEqual(info['handler'], 'Products.GenericSetup.tests.test_registry.ONE_FUNC') self.assertEqual(export_registry.getStep('one'), ONE_FUNC) def test_runImportStepFromProfile_nonesuch(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) self.assertRaises(KeyError, tool.runImportStepFromProfile, '', 'nonesuch') def test_runImportStepFromProfile_simple(self): TITLE = 'original title' site = self._makeSite(TITLE) tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep('simple', '1', _uppercaseSiteTitle) result = tool.runImportStepFromProfile('snapshot-dummy', 'simple') self.assertEqual(len(result['steps']), 1) self.assertEqual(result['steps'][0], 'simple') self.assertEqual(result['messages']['simple'], 'Uppercased title') self.assertEqual(site.title, TITLE.upper()) global _before_import_events self.assertEqual(len(_before_import_events), 1) self.assertEqual(_before_import_events[0].profile_id, 'snapshot-dummy') self.assertEqual(_before_import_events[0].steps, ['simple']) self.assertEqual(_before_import_events[0].full_import, False) global _after_import_events self.assertEqual(len(_after_import_events), 1) self.assertEqual(_after_import_events[0].profile_id, 'snapshot-dummy') self.assertEqual(_after_import_events[0].steps, ['simple']) self.assertEqual(_after_import_events[0].full_import, False) def test_runImportStepFromProfile_dependencies(self): TITLE = 'original title' site = self._makeSite(TITLE) tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep('dependable', '1', _underscoreSiteTitle) registry.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('dependable', )) result = tool.runImportStepFromProfile('snapshot-dummy', 'dependent') self.assertEqual(len(result['steps']), 2) self.assertEqual(result['steps'][0], 'dependable') self.assertEqual(result['messages']['dependable'], 'Underscored title') self.assertEqual(result['steps'][1], 'dependent') self.assertEqual(result['messages']['dependent'], 'Uppercased title') self.assertEqual(site.title, TITLE.replace(' ', '_').upper()) global _before_import_events self.assertEqual(len(_before_import_events), 1) self.assertEqual(_before_import_events[0].profile_id, 'snapshot-dummy') self.assertEqual(_before_import_events[0].steps, ['dependable', 'dependent']) self.assertEqual(_before_import_events[0].full_import, False) global _after_import_events self.assertEqual(len(_after_import_events), 1) self.assertEqual(_after_import_events[0].profile_id, 'snapshot-dummy') self.assertEqual(_after_import_events[0].steps, ['dependable', 'dependent']) self.assertEqual(_after_import_events[0].full_import, False) def test_runImportStepFromProfile_skip_dependencies(self): TITLE = 'original title' site = self._makeSite(TITLE) tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep('dependable', '1', _underscoreSiteTitle) registry.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('dependable', )) result = tool.runImportStepFromProfile('snapshot-dummy', 'dependent', run_dependencies=False) self.assertEqual(len(result['steps']), 1) self.assertEqual(result['steps'][0], 'dependent') self.assertEqual(result['messages']['dependent'], 'Uppercased title') self.assertEqual(site.title, TITLE.upper()) global _before_import_events self.assertEqual(len(_before_import_events), 1) self.assertEqual(_before_import_events[0].profile_id, 'snapshot-dummy') self.assertEqual(_before_import_events[0].steps, ['dependent']) self.assertEqual(_before_import_events[0].full_import, False) global _after_import_events self.assertEqual(len(_after_import_events), 1) self.assertEqual(_after_import_events[0].profile_id, 'snapshot-dummy') self.assertEqual(_after_import_events[0].steps, ['dependent']) self.assertEqual(_after_import_events[0].full_import, False) def test_runImportStepFromProfile_default_purge(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep('purging', '1', _purgeIfRequired) result = tool.runImportStepFromProfile('snapshot-dummy', 'purging') self.assertEqual(len(result['steps']), 1) self.assertEqual(result['steps'][0], 'purging') self.assertEqual(result['messages']['purging'], 'Purged') self.assertTrue(site.purged) def test_runImportStepFromProfile_explicit_purge(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep('purging', '1', _purgeIfRequired) result = tool.runImportStepFromProfile('snapshot-dummy', 'purging', purge_old=True) self.assertEqual(len(result['steps']), 1) self.assertEqual(result['steps'][0], 'purging') self.assertEqual(result['messages']['purging'], 'Purged') self.assertTrue(site.purged) def test_runImportStepFromProfile_skip_purge(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep('purging', '1', _purgeIfRequired) result = tool.runImportStepFromProfile('snapshot-dummy', 'purging', purge_old=False) self.assertEqual(len(result['steps']), 1) self.assertEqual(result['steps'][0], 'purging') self.assertEqual(result['messages']['purging'], 'Unpurged') self.assertFalse(site.purged) def test_runImportStepFromProfile_consistent_context(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep('purging', '1', _purgeIfRequired) registry.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('purging', )) tool.runImportStepFromProfile('snapshot-dummy', 'dependent', purge_old=False) self.assertFalse(site.purged) def test_runAllImportStepsFromProfile_empty(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) result = tool.runAllImportStepsFromProfile('snapshot-dummy') self.assertEqual(len(result['steps']), 3) def test_runAllImportStepsFromProfile_inquicksuccession(self): """ This test provokes an issue that only appears in testing. There it can happen that profiles get run multiple times within a second. As of 1.6.3, genericsetup does not handle this. """ site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) tool.runAllImportStepsFromProfile('snapshot-dummy') tool.runAllImportStepsFromProfile('snapshot-dummy') # For good measurement tool.runAllImportStepsFromProfile('snapshot-dummy') self.assertTrue("No exception thrown") def test_runAllImportStepsFromProfile_sorted_default_purge(self): TITLE = 'original title' PROFILE_ID = 'snapshot-testing' site = self._makeSite(TITLE) tool = self._makeOne('setup_tool').__of__(site) tool._exclude_global_steps = True registry = tool.getImportStepRegistry() registry.registerStep( 'dependable', '1', _underscoreSiteTitle, ('purging', )) registry.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('dependable', )) registry.registerStep('purging', '1', _purgeIfRequired) result = tool.runAllImportStepsFromProfile(PROFILE_ID) self.assertEqual(len(result['steps']), 3) self.assertEqual(result['steps'][0], 'purging') self.assertEqual(result['messages']['purging'], 'Purged') self.assertEqual(result['steps'][1], 'dependable') self.assertEqual(result['messages']['dependable'], 'Underscored title') self.assertEqual(result['steps'][2], 'dependent') self.assertEqual(result['messages']['dependent'], 'Uppercased title') self.assertEqual(site.title, TITLE.replace(' ', '_').upper()) self.assertTrue(site.purged) prefix = 'import-all-%s' % PROFILE_ID logged = [x for x in tool.objectIds('File') if x.startswith(prefix)] self.assertEqual(len(logged), 1) def check_restricted_access(self, obj): # For most objects that we create, we do not want ordinary users to # see it, also not when they have View permission on a higher level. rop_info = obj.rolesOfPermission(view) allowed_roles = sorted([x['name'] for x in rop_info if x['selected']]) self.assertEqual(allowed_roles, ['Manager', 'Owner']) self.assertFalse(obj.acquiredRolesAreUsedBy(view)) def test_runAllImportStepsFromProfile_unicode_id_creates_reports(self): TITLE = 'original title' PROFILE_ID = u'snapshot-testing' site = self._makeSite(TITLE) tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep( 'dependable', '1', _underscoreSiteTitle, ('purging', )) registry.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('dependable', )) registry.registerStep('purging', '1', _purgeIfRequired) tool.runAllImportStepsFromProfile(PROFILE_ID) prefix = str('import-all-%s' % PROFILE_ID) logged = [x for x in tool.objectIds('File') if x.startswith(prefix)] self.assertEqual(len(logged), 1) # Check acess restriction on log files logged = [x for x in tool.objectIds('File')] for file_id in logged: file_ob = tool._getOb(file_id) self.check_restricted_access(file_ob) def test_runAllImportStepsFromProfile_sorted_explicit_purge(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) tool._exclude_global_steps = True registry = tool.getImportStepRegistry() registry.registerStep( 'dependable', '1', _underscoreSiteTitle, ('purging', )) registry.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('dependable', )) registry.registerStep('purging', '1', _purgeIfRequired) result = tool.runAllImportStepsFromProfile('snapshot-dummy', purge_old=True) self.assertEqual(len(result['steps']), 3) self.assertEqual(result['steps'][0], 'purging') self.assertEqual(result['messages']['purging'], 'Purged') self.assertEqual(result['steps'][1], 'dependable') self.assertEqual(result['steps'][2], 'dependent') self.assertTrue(site.purged) def test_runAllImportStepsFromProfile_sorted_skip_purge(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) tool._exclude_global_steps = True registry = tool.getImportStepRegistry() registry.registerStep( 'dependable', '1', _underscoreSiteTitle, ('purging', )) registry.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('dependable', )) registry.registerStep('purging', '1', _purgeIfRequired) result = tool.runAllImportStepsFromProfile('snapshot-dummy', purge_old=False) self.assertEqual(len(result['steps']), 3) self.assertEqual(result['steps'][0], 'purging') self.assertEqual(result['messages']['purging'], 'Unpurged') self.assertEqual(result['steps'][1], 'dependable') self.assertEqual(result['steps'][2], 'dependent') self.assertFalse(site.purged) def test_runAllImportStepsFromProfile_without_depends(self): from ..metadata import METADATA_XML self._makeFile(METADATA_XML, _METADATA_XML) site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH) _imported = [] def applyContext(context): _imported.append(context._profile_path) tool.applyContext = applyContext tool.runAllImportStepsFromProfile('profile-other:foo', ignore_dependencies=True) self.assertEqual(_imported, [self._PROFILE_PATH]) def test_runAllImportStepsFromProfile_with_depends(self): from ..metadata import METADATA_XML self._makeFile(METADATA_XML, _METADATA_XML) site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH) profile_registry.registerProfile('bar', 'Bar', '', self._PROFILE_PATH2) _imported = [] def applyContext(context): _imported.append(context._profile_path) tool.applyContext = applyContext tool.runAllImportStepsFromProfile('profile-other:foo', ignore_dependencies=False) self.assertEqual(_imported, [self._PROFILE_PATH2, self._PROFILE_PATH]) def _setup_dependency_strategy_test_tool(self): # If we add a dependency profile in our metadata.xml, and this # dependency was already applied, then we do not need to apply # it yet again. Once is quite enough, thank you. Running any # upgrade steps would be nice though. There are options. # Setup a tool and profiles for testing dependency strategies. from ..interfaces import EXTENSION from ..metadata import METADATA_XML self._makeFile(METADATA_XML, _DOUBLE_METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH2, _PLAIN_METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH3, _PLAIN_METADATA_XML) site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) # Register main profile and two dependency profiles. profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH, profile_type=EXTENSION) profile_registry.registerProfile('bar', 'Bar', '', self._PROFILE_PATH2, profile_type=EXTENSION) profile_registry.registerProfile('ham', 'Ham', '', self._PROFILE_PATH3, profile_type=EXTENSION) # Apply the second profile. tool.runAllImportStepsFromProfile('profile-other:bar') # Register an upgrade step. Note that applying this step will # set the profile version to 1.1, even though the metadata of # the profile really says 1.0. We will use this to check # whether the upgrade step has been applied (version is 1.1) # or the full profile has been applied (version is 1.0). step_bar = UpgradeStep( "Upgrade", "other:bar", '1.0', '1.1', '', dummy_upgrade, None, "1") _registerUpgradeStep(step_bar) # And another one. step_ham = UpgradeStep( "Upgrade", "other:ham", '1.0', '1.1', '', dummy_upgrade, None, "1") _registerUpgradeStep(step_ham) # Gather list of imported profiles. tool._imported = [] def applyContext(context): tool._imported.append(context._profile_path) tool.applyContext = applyContext return tool def test_runAllImportStepsFromProfile_with_default_strategy(self): # Default strategy: apply new profiles, upgrade old profiles. tool = self._setup_dependency_strategy_test_tool() # Run the main profile. tool.runAllImportStepsFromProfile('profile-other:foo') # The main and third profile have been applied. self.assertEqual(tool._imported, [self._PROFILE_PATH3, self._PROFILE_PATH]) # The upgrade step of the second profile has been applied, # pushing it to version 1.1. self.assertEqual(tool.getLastVersionForProfile('other:bar'), ('1', '1')) # Third profile is at 1.0. self.assertEqual(tool.getLastVersionForProfile('other:ham'), ('1', '0')) def test_runAllImportStepsFromProfile_with_reapply_strategy(self): # You can choose the old behavior of always applying the # dependencies. This ignores any upgrade steps. tool = self._setup_dependency_strategy_test_tool() # Run the main profile. from ..tool import DEPENDENCY_STRATEGY_REAPPLY tool.runAllImportStepsFromProfile( 'profile-other:foo', dependency_strategy=DEPENDENCY_STRATEGY_REAPPLY) # All three profiles have been applied. self.assertEqual(tool._imported, [self._PROFILE_PATH2, self._PROFILE_PATH3, self._PROFILE_PATH]) self.assertEqual(tool.getLastVersionForProfile('other:bar'), ('1', '0')) self.assertEqual(tool.getLastVersionForProfile('other:ham'), ('1', '0')) def test_runAllImportStepsFromProfile_with_new_strategy(self): # You can choose to be happy with any applied version and # ignore any upgrade steps. tool = self._setup_dependency_strategy_test_tool() # Run the main profile. from ..tool import DEPENDENCY_STRATEGY_NEW tool.runAllImportStepsFromProfile( 'profile-other:foo', dependency_strategy=DEPENDENCY_STRATEGY_NEW) # The main and third profile have been applied. self.assertEqual(tool._imported, [self._PROFILE_PATH3, self._PROFILE_PATH]) # Second profile stays at 1.0. self.assertEqual(tool.getLastVersionForProfile('other:bar'), ('1', '0')) self.assertEqual(tool.getLastVersionForProfile('other:ham'), ('1', '0')) def test_runAllImportStepsFromProfile_with_ignore_strategy(self): # You can choose to be ignore all dependency profiles. tool = self._setup_dependency_strategy_test_tool() # Run the main profile. from ..tool import DEPENDENCY_STRATEGY_IGNORE tool.runAllImportStepsFromProfile( 'profile-other:foo', dependency_strategy=DEPENDENCY_STRATEGY_IGNORE) # Only the main profile has been applied. self.assertEqual(tool._imported, [self._PROFILE_PATH]) # Second profile stays at 1.0. self.assertEqual(tool.getLastVersionForProfile('other:bar'), ('1', '0')) # Third profile is not applied. self.assertEqual(tool.getLastVersionForProfile('other:ham'), ('unknown')) def test_runAllImportStepsFromProfile_unknown_strategy(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH) self.assertRaises(ValueError, tool.runAllImportStepsFromProfile, 'profile-other:foo', dependency_strategy='random') def test_runAllImportStepsFromProfile_set_last_profile_version(self): from ..metadata import METADATA_XML self._makeFile(METADATA_XML, _METADATA_XML) site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH) # test initial states profile_id = "other:foo" self.assertEqual(tool.getVersionForProfile(profile_id), '1.0') self.assertEqual(tool.getLastVersionForProfile(profile_id), 'unknown') # run all imports steps tool.runAllImportStepsFromProfile('profile-other:foo', ignore_dependencies=True) # events.handleProfileImportedEvent should set last profile version self.assertEqual(tool.getLastVersionForProfile(profile_id), ('1', '0')) def test_runAllImportStepsFromProfile_step_registration_with_depends(self): from ..metadata import METADATA_XML self._makeFile(METADATA_XML, _METADATA_XML) _IMPORT_STEPS_XML = """ One small step """ self._makeFile('import_steps.xml', _IMPORT_STEPS_XML) site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH) profile_registry.registerProfile('bar', 'Bar', '', self._PROFILE_PATH2) result = tool.runAllImportStepsFromProfile('profile-other:foo', ignore_dependencies=False) # ensure the additional step on foo was imported self.assertTrue('one' in result['steps']) def test_runAllImportStepsFromProfile_skipStep(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) result = tool.runAllImportStepsFromProfile( 'snapshot-dummy', blacklisted_steps=['toolset'], ) self.assertEqual((result['messages']['toolset']), 'step skipped') def test_runAllImportStepsFromProfile_with_base_profile(self): # Applying a base profile should clear the profile upgrade # versions. from ..interfaces import BASE from ..interfaces import EXTENSION from ..metadata import METADATA_XML site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool self._makeFile(METADATA_XML, _METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH2, _PLAIN_METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH3, _PLAIN_METADATA_XML) # Register a base and two extension profile. The base profile # 'foo' has a dependency 'bar'. This might not make sense, # but it will serve to check that we clear the profile # versions right before we apply the base profile, which means # right after any dependency profiles. profile_registry.registerProfile( 'foo', 'Foo', '', self._PROFILE_PATH, profile_type=BASE) profile_registry.registerProfile( 'bar', 'Bar', '', self._PROFILE_PATH2, profile_type=EXTENSION) profile_registry.registerProfile( 'ham', 'Ham', '', self._PROFILE_PATH3, profile_type=EXTENSION) # Apply the extension profile. tool.runAllImportStepsFromProfile('profile-other:ham') self.assertEqual(tool._profile_upgrade_versions, {u'other:ham': (u'1', u'0')}) # Apply the base profile. tool.runAllImportStepsFromProfile('profile-other:foo') self.assertEqual(tool._profile_upgrade_versions, {u'other:foo': (u'1', u'0')}) def test_runAllImportStepsFromProfile_with_unknown_pre_handler(self): # Registering already fails. self.assertRaises( ValueError, profile_registry.registerProfile, 'foo', 'Foo', '', self._PROFILE_PATH, pre_handler='Products.GenericSetup.tests.test_tool.foo_handler') def test_runAllImportStepsFromProfile_with_unknown_post_handler(self): # Registering already fails. self.assertRaises( ValueError, profile_registry.registerProfile, 'foo', 'Foo', '', self._PROFILE_PATH, post_handler='Products.GenericSetup.tests.test_tool.foo_handler') def test_runAllImportStepsFromProfile_pre_post_handlers_dotted_names(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) profile_registry.registerProfile( 'foo', 'Foo', '', self._PROFILE_PATH, pre_handler='Products.GenericSetup.tests.test_tool.pre_handler', post_handler='Products.GenericSetup.tests.test_tool.post_handler') tool.runAllImportStepsFromProfile('profile-other:foo') self.assertEqual(tool.pre_handler_called, 1) self.assertEqual(tool.post_handler_called, 1) tool.runAllImportStepsFromProfile('profile-other:foo') self.assertEqual(tool.pre_handler_called, 2) self.assertEqual(tool.post_handler_called, 2) def test_runAllImportStepsFromProfile_pre_post_handlers_functions(self): # When you register a profile with pre/post handlers in zcml, you do # not get dotted names (strings) but an actual function. site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) profile_registry.registerProfile( 'foo', 'Foo', '', self._PROFILE_PATH, pre_handler=pre_handler, post_handler=post_handler) tool.runAllImportStepsFromProfile('profile-other:foo') self.assertEqual(tool.pre_handler_called, 1) self.assertEqual(tool.post_handler_called, 1) tool.runAllImportStepsFromProfile('profile-other:foo') self.assertEqual(tool.pre_handler_called, 2) self.assertEqual(tool.post_handler_called, 2) def test_runExportStep_nonesuch(self): site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) self.assertRaises(ValueError, tool.runExportStep, 'nonesuch') def test_runExportStep_step_registry_empty(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool result = tool.runExportStep('step_registries') self.assertEqual(len(result['steps']), 1) self.assertEqual(result['steps'][0], 'step_registries') self.assertEqual(result['messages']['step_registries'], None) def test_runExportStep_step_registry_default(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool._import_registry.registerStep('foo', handler='foo.bar') steps = 'Products.GenericSetup.tool.exportStepRegistries' tool._export_registry.registerStep('step_registries', steps, 'Export import / export steps.') result = tool.runExportStep('step_registries') self.assertEqual(len(result['steps']), 1) self.assertEqual(result['steps'][0], 'step_registries') self.assertEqual(result['messages']['step_registries'], None) fileish = BytesIO(result['tarball']) self._verifyTarballContents(fileish, ['import_steps.xml', 'export_steps.xml']) self._verifyTarballEntryXML( fileish, 'import_steps.xml', _DEFAULT_STEP_REGISTRIES_IMPORT_XML) self._verifyTarballEntryXML( fileish, 'export_steps.xml', _DEFAULT_STEP_REGISTRIES_EXPORT_XML) def test_runAllExportSteps_empty(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool result = tool.runAllExportSteps() self.assertEqual( sorted(result['steps']), ['componentregistry', 'rolemap', 'step_registries', 'toolset']) self.assertEqual(result['messages']['step_registries'], None) def test_runAllExportSteps_default(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool._import_registry.registerStep('foo', handler='foo.bar') steps = 'Products.GenericSetup.tool.exportStepRegistries' tool._export_registry.registerStep('step_registries', steps, 'Export import / export steps.') result = tool.runAllExportSteps() self.assertEqual(sorted(result['steps']), ['componentregistry', 'rolemap', 'step_registries', 'toolset']) self.assertEqual(result['messages']['step_registries'], None) fileish = BytesIO(result['tarball']) self._verifyTarballContents(fileish, ['import_steps.xml', 'export_steps.xml', 'rolemap.xml', 'toolset.xml']) self._verifyTarballEntryXML( fileish, 'import_steps.xml', _DEFAULT_STEP_REGISTRIES_IMPORT_XML) self._verifyTarballEntryXML( fileish, 'export_steps.xml', _DEFAULT_STEP_REGISTRIES_EXPORT_XML) def test_runAllExportSteps_extras(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool steps = 'Products.GenericSetup.tool.exportStepRegistries' tool._export_registry.registerStep('step_registries', steps, 'Export import / export steps.') import_reg = tool.getImportStepRegistry() import_reg.registerStep( 'dependable', '1', _underscoreSiteTitle, ('purging', )) import_reg.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('dependable', )) import_reg.registerStep('purging', '1', _purgeIfRequired) export_reg = tool.getExportStepRegistry() export_reg.registerStep('properties', _exportPropertiesINI) result = tool.runAllExportSteps() self.assertEqual(len(result['steps']), 5) self.assertEqual(sorted(result['steps']), ['componentregistry', 'properties', 'rolemap', 'step_registries', 'toolset']) self.assertEqual(result['messages']['properties'], 'Exported properties') self.assertEqual(result['messages']['step_registries'], None) fileish = BytesIO(result['tarball']) self._verifyTarballContents(fileish, ['import_steps.xml', 'export_steps.xml', 'properties.ini', 'rolemap.xml', 'toolset.xml']) self._verifyTarballEntryXML( fileish, 'import_steps.xml', _EXTRAS_STEP_REGISTRIES_IMPORT_XML) self._verifyTarballEntryXML( fileish, 'export_steps.xml', _EXTRAS_STEP_REGISTRIES_EXPORT_XML) ini_string = _PROPERTIES_INI % site.title self._verifyTarballEntry(fileish, 'properties.ini', ini_string.encode('utf-8')) def test_manage_importTarball(self): # Tests for importing a tarball with GenericSetup files. # We are especially interested to see if old settings get purged. site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool # We need to be Manager to see the result of calling # manage_importTarball. newSecurityManager(None, UnrestrictedUser('root', '', ['Manager'], '')) ROLEMAP_XML = """ """ def rolemap_tarball(name): # Create a tarball archive with rolemap.xml containing 'name' as # role. context = TarballExportContext(tool) contents = ROLEMAP_XML % name if isinstance(contents, six.text_type): contents = contents.encode('utf-8') context.writeDataFile('rolemap.xml', contents, 'text/xml') return context.getArchive() # Import first role. tool.manage_importTarball(rolemap_tarball('First')) self.assertTrue('First' in site.valid_roles()) # Import second role. tool.manage_importTarball(rolemap_tarball('Second')) self.assertTrue('Second' in site.valid_roles()) # The first role has been purged, because that is the default. self.assertFalse('First' in site.valid_roles()) # A few standard roles are never removed, probably because they are # defined one level higher. self.assertTrue('Anonymous' in site.valid_roles()) self.assertTrue('Authenticated' in site.valid_roles()) self.assertTrue('Manager' in site.valid_roles()) self.assertTrue('Owner' in site.valid_roles()) # Import third role in non-purge mode. tool.manage_importTarball(rolemap_tarball('Third'), purge_old=False) self.assertTrue('Third' in site.valid_roles()) # The second role is still there. self.assertTrue('Second' in site.valid_roles()) # When you use the form, and uncheck the purge_old checkbox, then the # browser does not send the purge_old parameter in the request. To # work around this, the form always passes a hidden 'submitted' # parameter. # Import fourth role in non-purge mode with a form submit. tool.manage_importTarball(rolemap_tarball('Fourth'), submitted='yes') self.assertTrue('Fourth' in site.valid_roles()) # The other roles are still there. self.assertTrue('Second' in site.valid_roles()) self.assertTrue('Third' in site.valid_roles()) self.assertTrue('Manager' in site.valid_roles()) def test_createSnapshot_default(self): _EXPECTED = [ ('import_steps.xml', _DEFAULT_STEP_REGISTRIES_IMPORT_XML), ('export_steps.xml', _DEFAULT_STEP_REGISTRIES_EXPORT_XML), ('rolemap.xml', 'dummy'), ('toolset.xml', 'dummy'), ] site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool._import_registry.registerStep('foo', handler='foo.bar') tool._export_registry.registerStep( 'step_registries', 'Products.GenericSetup.tool.exportStepRegistries', 'Export import / export steps.') self.assertEqual(len(tool.listSnapshotInfo()), 0) result = tool.createSnapshot('default') self.assertEqual( sorted(result['steps']), ['componentregistry', 'rolemap', 'step_registries', 'toolset']) self.assertEqual(result['messages']['step_registries'], None) snapshot = result['snapshot'] self.assertEqual(len(snapshot.objectIds()), len(_EXPECTED)) for id in [x[0] for x in _EXPECTED]: self.assertTrue(id in snapshot.objectIds()) def normalize_xml(xml): # using this might mask a real problem on windows, but so far the # different newlines just caused problems in this test lines = [line.strip() for line in xml.splitlines() if line.strip()] return ' '.join(lines) fileobj = snapshot._getOb('import_steps.xml') self.assertEqual(normalize_xml(fileobj.read()), normalize_xml(_DEFAULT_STEP_REGISTRIES_IMPORT_XML)) fileobj = snapshot._getOb('export_steps.xml') self.assertEqual(normalize_xml(fileobj.read()), normalize_xml(_DEFAULT_STEP_REGISTRIES_EXPORT_XML)) self.assertEqual(len(tool.listSnapshotInfo()), 1) info = tool.listSnapshotInfo()[0] self.assertEqual(info['id'], 'default') self.assertEqual(info['title'], 'default') # Check access restriction on snapshot files and folders self.check_restricted_access(tool.snapshots) self.check_restricted_access(snapshot) for obj in snapshot.objectValues(): self.check_restricted_access(obj) if hasattr(aq_base(obj), 'objectValues'): for child in obj.objectValues(): self.check_restricted_access(child) def test_applyContext(self): from ..tool import EXPORT_STEPS_XML from ..tool import IMPORT_STEPS_XML from ..tool import TOOLSET_XML site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) tool.getImportStepRegistry().clear() tool.getExportStepRegistry().clear() tool.getToolsetRegistry().clear() context = DummyImportContext(site, tool=tool) context._files[IMPORT_STEPS_XML] = _SINGLE_IMPORT_XML context._files[EXPORT_STEPS_XML] = _SINGLE_EXPORT_XML context._files[TOOLSET_XML] = _NORMAL_TOOLSET_XML tool.applyContext(context) import_registry = tool.getImportStepRegistry() self.assertEqual(len(import_registry.listSteps()), 1) self.assertTrue('one' in import_registry.listSteps()) info = import_registry.getStepMetadata('one') self.assertEqual(info['id'], 'one') self.assertEqual(info['title'], 'One Step') self.assertEqual(info['version'], '1') self.assertTrue('One small step' in info['description']) self.assertEqual(info['handler'], 'Products.GenericSetup.tests.test_registry.ONE_FUNC') self.assertEqual(import_registry.getStep('one'), ONE_FUNC) export_registry = tool.getExportStepRegistry() self.assertEqual(len(export_registry.listSteps()), 1) self.assertTrue('one' in import_registry.listSteps()) info = export_registry.getStepMetadata('one') self.assertEqual(info['id'], 'one') self.assertEqual(info['title'], 'One Step') self.assertTrue('One small step' in info['description']) self.assertEqual(info['handler'], 'Products.GenericSetup.tests.test_registry.ONE_FUNC') self.assertEqual(export_registry.getStep('one'), ONE_FUNC) def test_listContextInfos_empty(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool infos = tool.listContextInfos() self.assertEqual(len(infos), 0) def test_listContextInfos_with_snapshot(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool.createSnapshot('testing') infos = tool.listContextInfos() self.assertEqual(len(infos), 1) info = infos[0] self.assertEqual(info['id'], 'snapshot-testing') self.assertEqual(info['title'], 'testing') self.assertEqual(info['type'], 'snapshot') def test_listContextInfos_with_registered_base_profile(self): from ..interfaces import BASE profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH, 'Foo', BASE) site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool infos = tool.listContextInfos() self.assertEqual(len(infos), 1) info = infos[0] self.assertEqual(info['id'], 'profile-Foo:foo') self.assertEqual(info['title'], 'Foo') self.assertEqual(info['type'], 'base') def test_listContextInfos_with_registered_extension_profile(self): from ..interfaces import EXTENSION profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH, 'Foo', EXTENSION) site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool infos = tool.listContextInfos() self.assertEqual(len(infos), 1) info = infos[0] self.assertEqual(info['id'], 'profile-Foo:foo') self.assertEqual(info['title'], 'Foo') self.assertEqual(info['type'], 'extension') def test_listContextInfos_with_ordering(self): from ..interfaces import BASE from ..interfaces import EXTENSION # three extension profiles profile_registry.registerProfile( 'bar', 'bar', '', self._PROFILE_PATH, 'bar', EXTENSION) profile_registry.registerProfile( 'foo', 'foo', '', self._PROFILE_PATH, 'foo', EXTENSION) profile_registry.registerProfile( 'upper', 'UPPER', '', self._PROFILE_PATH, 'UPPER', EXTENSION) # one base profile profile_registry.registerProfile( 'base', 'base', '', self._PROFILE_PATH, 'base', BASE) site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool.createSnapshot('UPPER') tool.createSnapshot('lower') infos = tool.listContextInfos() self.assertEqual(len(infos), 6) # We sort case insensitively, so by lowercase. # First snapshots. self.assertEqual(infos[0]['id'], 'snapshot-lower') self.assertEqual(infos[1]['id'], 'snapshot-UPPER') # Then base and extension profiles self.assertEqual(infos[2]['id'], 'profile-bar:bar') self.assertEqual(infos[3]['id'], 'profile-base:base') self.assertEqual(infos[4]['id'], 'profile-foo:foo') self.assertEqual(infos[5]['id'], 'profile-UPPER:upper') def test_getProfileImportDate_nonesuch(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool self.assertEqual(tool.getProfileImportDate('nonesuch'), None) def test_getProfileImportDate_simple_id(self): from OFS.Image import File site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool filename = 'import-all-foo-20070315123456.log' tool._setObject(filename, File(filename, '', b'')) self.assertEqual(tool.getProfileImportDate('foo'), '2007-03-15T12:34:56Z') def test_getProfileImportDate_id_with_colon(self): from OFS.Image import File site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool filename = 'import-all-foo_bar-20070315123456.log' tool._setObject(filename, File(filename, '', b'')) self.assertEqual(tool.getProfileImportDate('foo:bar'), '2007-03-15T12:34:56Z') def test_getProfileImportDate_id_with_prefix(self): # Test if getProfileImportDate does not fail if there is another # item id with id with a longer id which starts with the same # prefix from OFS.Image import File site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool filename = 'import-all-foo_bar-20070315123456.log' tool._setObject(filename, File(filename, '', b'')) filename2 = 'import-all-foo_bar-boo-20070315123456.log' tool._setObject(filename2, File(filename2, '', b'')) self.assertEqual(tool.getProfileImportDate('foo:bar'), '2007-03-15T12:34:56Z') def test_profileVersioning(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool profile_id = 'dummy_profile' product_name = 'GenericSetup' directory = os.path.split(__file__)[0] path = os.path.join(directory, 'versioned_profile') # register profile profile_registry.registerProfile(profile_id, 'Dummy Profile', 'This is a dummy profile', path, product=product_name) # register upgrade step step = UpgradeStep("Upgrade", "GenericSetup:dummy_profile", '*', '1.1', '', dummy_upgrade, None, "1") _registerUpgradeStep(step) # test initial states profile_id = ':'.join((product_name, profile_id)) self.assertEqual(tool.getVersionForProfile(profile_id), '1.1') self.assertEqual(tool.getLastVersionForProfile(profile_id), 'unknown') # run upgrade steps request = site.REQUEST request.form['profile_id'] = profile_id steps = listUpgradeSteps(tool, profile_id, '1.0') step_id = steps[0]['id'] request.form['upgrades'] = [step_id] tool.manage_doUpgrades() self.assertEqual(tool.getLastVersionForProfile(profile_id), ('1', '1')) def test_get_and_setLastVersionForProfile(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool self.assertEqual(tool._profile_upgrade_versions, {}) # Any 'profile-' is stripped off in these calls. self.assertEqual(tool.getLastVersionForProfile('foo'), 'unknown') self.assertEqual(tool.getLastVersionForProfile( 'profile-foo'), 'unknown') tool.setLastVersionForProfile('foo', '1.0') self.assertEqual(tool.getLastVersionForProfile('foo'), ('1', '0')) self.assertEqual(tool.getLastVersionForProfile( 'profile-foo'), ('1', '0')) tool.setLastVersionForProfile('profile-foo', '2.0') self.assertEqual(tool.getLastVersionForProfile('foo'), ('2', '0')) self.assertEqual(tool.getLastVersionForProfile( 'profile-foo'), ('2', '0')) # Setting the profile to unknown, removes it from the versions. self.assertEqual(tool._profile_upgrade_versions, {'foo': ('2', '0')}) tool.setLastVersionForProfile('profile-foo', 'unknown') self.assertEqual(tool._profile_upgrade_versions, {}) def test_unsetLastVersionForProfile(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool.setLastVersionForProfile('foo', '1.0') tool.setLastVersionForProfile('bar', '2.0') self.assertEqual(tool._profile_upgrade_versions, {'foo': ('1', '0'), 'bar': ('2', '0')}) # Any 'profile-' is stripped off in these calls. tool.unsetLastVersionForProfile('profile-foo') self.assertEqual(tool._profile_upgrade_versions, {'bar': ('2', '0')}) tool.unsetLastVersionForProfile('bar') self.assertEqual(tool._profile_upgrade_versions, {}) def test_purgeProfileVersions(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool.setLastVersionForProfile('foo', '1.0') tool.setLastVersionForProfile('bar', '2.0') self.assertEqual(tool._profile_upgrade_versions, {'foo': ('1', '0'), 'bar': ('2', '0')}) tool.purgeProfileVersions() self.assertEqual(tool._profile_upgrade_versions, {}) def test_listProfilesWithUpgrades(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool self.assertEqual(tool.listProfilesWithUpgrades(), []) self.assertEqual(tool.listProfilesWithPendingUpgrades(), []) self.assertEqual(tool.listUptodateProfiles(), []) self.assertEqual(tool.hasPendingUpgrades(), False) profile_id = 'dummy_profile' product_name = 'GenericSetup' directory = os.path.split(__file__)[0] path = os.path.join(directory, 'versioned_profile') # register profile profile_registry.registerProfile(profile_id, 'Dummy Profile', 'This is a dummy profile', path, product=product_name) self.assertEqual(tool.listProfilesWithUpgrades(), []) self.assertEqual(tool.listProfilesWithPendingUpgrades(), []) self.assertEqual(tool.listUptodateProfiles(), []) self.assertEqual(tool.hasPendingUpgrades(), False) # register upgrade step step1 = UpgradeStep("Upgrade 1", "GenericSetup:dummy_profile", '*', '1.1', '', dummy_upgrade, None, "1") _registerUpgradeStep(step1) self.assertEqual(tool.listProfilesWithUpgrades(), [u'GenericSetup:dummy_profile']) self.assertEqual(tool.listProfilesWithPendingUpgrades(), []) self.assertEqual(tool.listUptodateProfiles(), []) self.assertEqual(tool.hasPendingUpgrades(), False) # register another upgrade step step2 = UpgradeStep("Upgrade 2", "GenericSetup:dummy_profile", '1.1', '1.2', '', dummy_upgrade, None, "1") _registerUpgradeStep(step2) self.assertEqual(tool.listProfilesWithUpgrades(), [u'GenericSetup:dummy_profile']) self.assertEqual(tool.listProfilesWithPendingUpgrades(), []) self.assertEqual(tool.listUptodateProfiles(), []) self.assertEqual(tool.hasPendingUpgrades(), False) # get full profile id profile_id = ':'.join((product_name, profile_id)) # Pretend the profile was installed tool.setLastVersionForProfile(profile_id, '1.0') self.assertEqual(tool.listProfilesWithUpgrades(), [u'GenericSetup:dummy_profile']) self.assertEqual(tool.listProfilesWithPendingUpgrades(), [u'GenericSetup:dummy_profile']) self.assertEqual(tool.listUptodateProfiles(), []) self.assertEqual(tool.hasPendingUpgrades(), True) # run first upgrade step request = site.REQUEST request.form['profile_id'] = profile_id steps = listUpgradeSteps(tool, profile_id, '1.0') step_id = steps[0]['id'] request.form['upgrades'] = [step_id] tool.manage_doUpgrades() self.assertEqual(tool.getLastVersionForProfile(profile_id), ('1', '1')) self.assertEqual(tool.listProfilesWithUpgrades(), [u'GenericSetup:dummy_profile']) self.assertEqual(tool.listProfilesWithPendingUpgrades(), [u'GenericSetup:dummy_profile']) self.assertEqual(tool.listUptodateProfiles(), []) self.assertEqual(tool.hasPendingUpgrades(), True) # run second upgrade step request = site.REQUEST request.form['profile_id'] = profile_id steps = listUpgradeSteps(tool, profile_id, '1.1') step_id = steps[0]['id'] request.form['upgrades'] = [step_id] tool.manage_doUpgrades() self.assertEqual(tool.getLastVersionForProfile(profile_id), ('1', '2')) self.assertEqual(tool.listProfilesWithUpgrades(), [u'GenericSetup:dummy_profile']) self.assertEqual(tool.listProfilesWithPendingUpgrades(), []) self.assertEqual(tool.listUptodateProfiles(), [u'GenericSetup:dummy_profile']) self.assertEqual(tool.hasPendingUpgrades(), False) # Pretend the profile was never installed. tool.unsetLastVersionForProfile(profile_id) self.assertEqual(tool.listProfilesWithPendingUpgrades(), []) self.assertEqual(tool.listUptodateProfiles(), []) self.assertEqual(tool.hasPendingUpgrades(), False) def test_hasPendingUpgrades(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool profile_id_1 = 'dummy_profile1' profile_id_2 = 'dummy_profile2' product_name = 'GenericSetup' directory = os.path.split(__file__)[0] path = os.path.join(directory, 'versioned_profile') # register profiles profile_registry.registerProfile(profile_id_1, 'Dummy Profile 1', 'This is dummy profile 1', path, product=product_name) profile_registry.registerProfile(profile_id_2, 'Dummy Profile 2', 'This is dummy profile 2', path, product=product_name) # get full profile ids profile_id_1 = ':'.join((product_name, profile_id_1)) profile_id_2 = ':'.join((product_name, profile_id_2)) # test self.assertEqual(tool.hasPendingUpgrades(), False) self.assertEqual(tool.hasPendingUpgrades(profile_id_1), False) self.assertEqual(tool.hasPendingUpgrades(profile_id_2), False) self.assertEqual(tool.hasPendingUpgrades('non-existing'), False) # register upgrade steps step1 = UpgradeStep("Upgrade 1", profile_id_1, '*', '1.1', '', dummy_upgrade, None, "1") _registerUpgradeStep(step1) step2 = UpgradeStep("Upgrade 2", profile_id_2, '*', '2.2', '', dummy_upgrade, None, "2") _registerUpgradeStep(step2) # No profile has been applied, so no upgrade is pending. self.assertEqual(tool.hasPendingUpgrades(), False) self.assertEqual(tool.hasPendingUpgrades(profile_id_1), False) self.assertEqual(tool.hasPendingUpgrades(profile_id_2), False) # Pretend profile 1 was installed to an earlier version. tool.setLastVersionForProfile(profile_id_1, '1.0') self.assertEqual(tool.hasPendingUpgrades(), True) self.assertEqual(tool.hasPendingUpgrades(profile_id_1), True) self.assertEqual(tool.hasPendingUpgrades(profile_id_2), False) # Pretend profile 2 was installed to an earlier version. tool.setLastVersionForProfile(profile_id_2, '2.0') self.assertEqual(tool.hasPendingUpgrades(), True) self.assertEqual(tool.hasPendingUpgrades(profile_id_1), True) self.assertEqual(tool.hasPendingUpgrades(profile_id_2), True) # Pretend profile 1 was installed to the final version. tool.setLastVersionForProfile(profile_id_1, '1.1') self.assertEqual(tool.hasPendingUpgrades(), True) self.assertEqual(tool.hasPendingUpgrades(profile_id_1), False) self.assertEqual(tool.hasPendingUpgrades(profile_id_2), True) # Pretend profile 2 was installed to the final version. tool.setLastVersionForProfile(profile_id_2, '2.2') self.assertEqual(tool.hasPendingUpgrades(), False) self.assertEqual(tool.hasPendingUpgrades(profile_id_1), False) self.assertEqual(tool.hasPendingUpgrades(profile_id_2), False) def test_manage_doUpgrades_no_profile_id_or_updates(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool.manage_doUpgrades() self.assertEqual(tool._profile_upgrade_versions, {}) def test_manage_doUpgrades_upgrade_w_no_target_version(self): def notool(): return None step = UpgradeStep('TITLE', 'foo', '*', '*', 'DESC', notool) _registerUpgradeStep(step) site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool request = site.REQUEST request['profile_id'] = ['foo'] request['upgrade'] = [step.id] tool.manage_doUpgrades() self.assertEqual(tool._profile_upgrade_versions, {}) def test_upgradeProfile_no_profile_id_or_updates(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool # Mostly this checks to see if we can call this without an # exception. tool.upgradeProfile('no.such.profile:default') self.assertEqual(tool._profile_upgrade_versions, {}) tool.upgradeProfile('no.such.profile:default', dest='42') self.assertEqual(tool._profile_upgrade_versions, {}) def test_persistent_profile_upgrade_versions(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool savepoint1 = transaction.savepoint() tool.setLastVersionForProfile('foo', '1.0') savepoint2 = transaction.savepoint() tool.setLastVersionForProfile('bar', '2.0') self.assertEqual(tool._profile_upgrade_versions, {'foo': ('1', '0'), 'bar': ('2', '0')}) savepoint2.rollback() self.assertEqual(tool._profile_upgrade_versions, {'foo': ('1', '0')}) savepoint1.rollback() self.assertEqual(tool._profile_upgrade_versions, {}) def test_separate_profile_upgrade_versions(self): # _profile_upgrade_versions used to be a class property. That is fine # as long as we only work on copies, otherwise state is shared between # two instances. We now create the property in the __init__ method, # but let's test it to avoid a regression. site = self._makeSite() site.setup_tool1 = self._makeOne('setup_tool1') tool1 = site.setup_tool1 site.setup_tool2 = self._makeOne('setup_tool2') tool2 = site.setup_tool2 tool1._profile_upgrade_versions['foo'] = '1.0' self.assertEqual(tool2._profile_upgrade_versions, {}) tool2.setLastVersionForProfile('bar', '2.0') self.assertEqual(self._makeOne('t')._profile_upgrade_versions, {}) def test_upgradeProfile(self): def dummy_handler(tool): return None def step3_handler(tool): tool._step3_applied = 'just a marker' def step3_checker(tool): # False means already applied or does not apply. # True means can be applied. return not hasattr(tool, '_step3_applied') step1 = UpgradeStep('Step 1', 'foo', '0', '1', 'DESC', dummy_handler) step2 = UpgradeStep('Step 2', 'foo', '1', '2', 'DESC', dummy_handler) step3 = UpgradeStep('Step 3', 'foo', '2', '3', 'DESC', step3_handler, checker=step3_checker) step4 = UpgradeStep('Step 4', 'foo', '3', '4', 'DESC', dummy_handler) _registerUpgradeStep(step1) _registerUpgradeStep(step2) _registerUpgradeStep(step3) _registerUpgradeStep(step4) site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool self.assertEqual(tool.getLastVersionForProfile('foo'), 'unknown') tool.setLastVersionForProfile('foo', '0') self.assertEqual(tool.getLastVersionForProfile('foo'), ('0',)) # Upgrade the profile one step to version 1. tool.upgradeProfile('foo', '1') self.assertEqual(tool.getLastVersionForProfile('foo'), ('1',)) # Upgrade the profile two steps to version 3. This one has a # checker. The profile version must be correctly updated. tool.upgradeProfile('foo', '3') self.assertEqual(tool.getLastVersionForProfile('foo'), ('3',)) # Upgrade the profile to a non existing version. Nothing # should happen. tool.upgradeProfile('foo', '5') self.assertEqual(tool.getLastVersionForProfile('foo'), ('3',)) # Upgrade the profile to the latest version. tool.upgradeProfile('foo') self.assertEqual(tool.getLastVersionForProfile('foo'), ('4',)) def test_listExportSteps(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool result = tool.listExportSteps() self.assertEqual(len(result), 4) self.assertTrue(u'componentregistry' in result) self.assertTrue(u'rolemap' in result) self.assertTrue(u'step_registries' in result) self.assertTrue(u'toolset' in result) tool._export_registry.registerStep(u'foo', handler='foo.export') tool._export_registry.registerStep(u'toolset', handler='toolset.export') result = tool.listExportSteps() self.assertEqual(len(result), 5) self.assertTrue(u'componentregistry' in result) self.assertTrue(u'foo' in result) self.assertTrue(u'rolemap' in result) self.assertTrue(u'step_registries' in result) self.assertTrue(u'toolset' in result) def test_getSortedImportSteps(self): site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool result = tool.getSortedImportSteps() self.assertEqual(len(result), 3) self.assertTrue(u'componentregistry' in result) self.assertTrue(u'rolemap' in result) self.assertTrue(u'toolset' in result) self.assertTrue(list(result).index(u'componentregistry') > list(result).index(u'toolset')) tool._import_registry.registerStep(u'foo', handler='foo.import') tool._import_registry.registerStep(u'toolset', handler='toolset.import') result = tool.getSortedImportSteps() self.assertEqual(len(result), 4) self.assertTrue(u'componentregistry' in result) self.assertTrue(u'foo' in result) self.assertTrue(u'rolemap' in result) self.assertTrue(u'toolset' in result) self.assertTrue(list(result).index(u'componentregistry') > list(result).index(u'toolset')) def test_listProfileInfo_for_parameter(self): from ..metadata import METADATA_XML self._makeFile(METADATA_XML, _METADATA_XML) site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) profile_registry.registerProfile('foo', 'Foo', '', self._PROFILE_PATH, for_=ISite) # tool.listProfileInfo should call registry.listProfileInfo # with the for_ parameter self.assertEqual(len(tool.listProfileInfo()), 1) self.assertEqual(len(tool.listProfileInfo(for_=ISite)), 1) self.assertEqual(len(tool.listProfileInfo(for_=IDerivedSite)), 1) self.assertEqual(len(tool.listProfileInfo(for_=IAnotherSite)), 0) def test_profileExists(self): from ..interfaces import EXTENSION from ..metadata import METADATA_XML site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) # Register two extension profiles. Profile 'foo' has a dependency # 'bar'. self._makeFile(METADATA_XML, _METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH2, _PLAIN_METADATA_XML) profile_registry.registerProfile( 'foo', 'Foo', '', self._PROFILE_PATH, profile_type=EXTENSION) profile_registry.registerProfile( 'bar', 'Bar', '', self._PROFILE_PATH2, profile_type=EXTENSION) self.assertTrue(tool.profileExists('other:foo')) self.assertTrue(tool.profileExists('other:bar')) self.assertFalse(tool.profileExists('snapshot-something')) self.assertFalse(tool.profileExists(None)) self.assertFalse(tool.profileExists('nonesuch')) def test_getDependenciesForProfile(self): from ..interfaces import EXTENSION from ..metadata import METADATA_XML site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) # Register three extension profiles. Profile 'foo' has a dependency # 'bar', and 'baz' contains non-existing dependency-profiles. self._makeFile(METADATA_XML, _METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH2, _PLAIN_METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH3, _BROKEN_METADATA_XML) profile_registry.registerProfile( 'foo', 'Foo', '', self._PROFILE_PATH, profile_type=EXTENSION) profile_registry.registerProfile( 'bar', 'Bar', '', self._PROFILE_PATH2, profile_type=EXTENSION) profile_registry.registerProfile( 'baz', 'Baz', '', self._PROFILE_PATH3, profile_type=EXTENSION) self.assertEqual(tool.getDependenciesForProfile('other:foo'), (u'profile-other:bar', )) self.assertEqual(tool.getDependenciesForProfile('other:bar'), ()) self.assertEqual(tool.getDependenciesForProfile('snapshot-some'), ()) self.assertEqual(tool.getDependenciesForProfile(None), ()) self.assertRaises(KeyError, tool.getDependenciesForProfile, 'nonesuch') def test_getBrokenDependencies(self): from ..interfaces import EXTENSION from ..metadata import METADATA_XML site = self._makeSite() tool = self._makeOne('setup_tool').__of__(site) # Register three extension profiles. Profile 'foo' has a dependency # 'bar' and 'baz' contains non-existing dependency-profiles. self._makeFile(METADATA_XML, _METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH2, _PLAIN_METADATA_XML) _makeTestFile(METADATA_XML, self._PROFILE_PATH3, _BROKEN_METADATA_XML) profile_registry.registerProfile( 'foo', 'Foo', '', self._PROFILE_PATH, profile_type=EXTENSION) profile_registry.registerProfile( 'bar', 'Bar', '', self._PROFILE_PATH2, profile_type=EXTENSION) profile_registry.registerProfile( 'baz', 'Baz', '', self._PROFILE_PATH3, profile_type=EXTENSION) # profile has dependencies and none of them is broken: self.assertFalse(tool.hasBrokenDependencies('other:foo')) # profile has no dependencies, therfore nothing can be broken: self.assertFalse(tool.hasBrokenDependencies('other:bar')) # profile has dependencies and at least one of them is broken: self.assertTrue(tool.hasBrokenDependencies('other:baz')) ``` ## `src/Products/GenericSetup/tests/test_tool.py` — `function:SetupToolTests.check_restricted_access` (lines 476-483) ```python def check_restricted_access(self, obj): # For most objects that we create, we do not want ordinary users to # see it, also not when they have View permission on a higher level. rop_info = obj.rolesOfPermission(view) allowed_roles = sorted([x['name'] for x in rop_info if x['selected']]) self.assertEqual(allowed_roles, ['Manager', 'Owner']) self.assertFalse(obj.acquiredRolesAreUsedBy(view)) ``` ## `src/Products/GenericSetup/tests/test_tool.py` — `function:SetupToolTests.test_runAllImportStepsFromProfile_unicode_id_creates_reports` (lines 485-509) ```python def test_runAllImportStepsFromProfile_unicode_id_creates_reports(self): TITLE = 'original title' PROFILE_ID = u'snapshot-testing' site = self._makeSite(TITLE) tool = self._makeOne('setup_tool').__of__(site) registry = tool.getImportStepRegistry() registry.registerStep( 'dependable', '1', _underscoreSiteTitle, ('purging', )) registry.registerStep( 'dependent', '1', _uppercaseSiteTitle, ('dependable', )) registry.registerStep('purging', '1', _purgeIfRequired) tool.runAllImportStepsFromProfile(PROFILE_ID) prefix = str('import-all-%s' % PROFILE_ID) logged = [x for x in tool.objectIds('File') if x.startswith(prefix)] self.assertEqual(len(logged), 1) # Check acess restriction on log files logged = [x for x in tool.objectIds('File')] for file_id in logged: file_ob = tool._getOb(file_id) self.check_restricted_access(file_ob) ``` ## `src/Products/GenericSetup/tests/test_tool.py` — `function:SetupToolTests.test_createSnapshot_default` (lines 1055-1116) ```python def test_createSnapshot_default(self): _EXPECTED = [ ('import_steps.xml', _DEFAULT_STEP_REGISTRIES_IMPORT_XML), ('export_steps.xml', _DEFAULT_STEP_REGISTRIES_EXPORT_XML), ('rolemap.xml', 'dummy'), ('toolset.xml', 'dummy'), ] site = self._makeSite() site.setup_tool = self._makeOne('setup_tool') tool = site.setup_tool tool._import_registry.registerStep('foo', handler='foo.bar') tool._export_registry.registerStep( 'step_registries', 'Products.GenericSetup.tool.exportStepRegistries', 'Export import / export steps.') self.assertEqual(len(tool.listSnapshotInfo()), 0) result = tool.createSnapshot('default') self.assertEqual( sorted(result['steps']), ['componentregistry', 'rolemap', 'step_registries', 'toolset']) self.assertEqual(result['messages']['step_registries'], None) snapshot = result['snapshot'] self.assertEqual(len(snapshot.objectIds()), len(_EXPECTED)) for id in [x[0] for x in _EXPECTED]: self.assertTrue(id in snapshot.objectIds()) def normalize_xml(xml): # using this might mask a real problem on windows, but so far the # different newlines just caused problems in this test lines = [line.strip() for line in xml.splitlines() if line.strip()] return ' '.join(lines) fileobj = snapshot._getOb('import_steps.xml') self.assertEqual(normalize_xml(fileobj.read()), normalize_xml(_DEFAULT_STEP_REGISTRIES_IMPORT_XML)) fileobj = snapshot._getOb('export_steps.xml') self.assertEqual(normalize_xml(fileobj.read()), normalize_xml(_DEFAULT_STEP_REGISTRIES_EXPORT_XML)) self.assertEqual(len(tool.listSnapshotInfo()), 1) info = tool.listSnapshotInfo()[0] self.assertEqual(info['id'], 'default') self.assertEqual(info['title'], 'default') # Check access restriction on snapshot files and folders self.check_restricted_access(tool.snapshots) self.check_restricted_access(snapshot) for obj in snapshot.objectValues(): self.check_restricted_access(obj) if hasattr(aq_base(obj), 'objectValues'): for child in obj.objectValues(): self.check_restricted_access(child) ```