def testScheduleNodeUpgrade(tconf, nodeSet): """ Tests that upgrade scheduling works. For that it starts mock control service, schedules upgrade for near future and then checks that service received notification. """ loop = asyncio.get_event_loop() server, indicator = loop.run_until_complete( _createServer(host=tconf.controlServiceHost, port=tconf.controlServicePort)) indicator.add_done_callback(_stopServer(server)) node = nodeSet[0] # ATTENTION! nodeId and ledger must not be None, but there # we do not call methods that use them, so we can pass None # We do it because node from nodeSet is some testable object, not real # node, so it has no nodeId and ledger that we can use upgrader = Upgrader(nodeId=None, nodeName=None, dataDir=node.dataLocation, config=tconf, ledger=None) upgrader._callUpgradeAgent(time.time(), "1.2", 1000, None, tconf.UPGRADE_ENTRY) result = loop.run_until_complete(eventuallySoon(_checkFuture(indicator))) expectedResult = UpgradeMessage(version, tconf.UPGRADE_ENTRY) assert result == expectedResult.toJson()
def testScheduleNodeUpgrade(tconf, nodeSet): """ Tests that upgrade scheduling works. For that it starts mock control service, schedules upgrade for near future and then checks that service received notification. """ loop = asyncio.get_event_loop() server, indicator = loop.run_until_complete( _createServer( host=tconf.controlServiceHost, port=tconf.controlServicePort ) ) indicator.add_done_callback(_stopServer(server)) node = nodeSet[0] # ATTENTION! nodeId and ledger must not be None, but there # we do not call methods that use them, so we can pass None # We do it because node from nodeSet is some testable object, not real # node, so it has no nodeId and ledger that we can use upgrader = Upgrader(nodeId=None, nodeName=None, dataDir=node.dataLocation, config=tconf, ledger=None) upgrader._callUpgradeAgent( time.time(), "1.2", failTimeout=1000, upgrade_id=None) result = loop.run_until_complete(eventuallySoon(_checkFuture(indicator))) expectedResult = UpgradeMessage(version) assert result == expectedResult.toJson()
def _do_upgrade( self, pkg_name: str, curr_pkg_ver: PackageVersion, new_pkg_ver: PackageVersion, rollback: bool ): from indy_node.server.upgrader import Upgrader cur_node_src_ver = Upgrader.get_src_version() logger.info( "Trying to upgrade from {}={} to {}" .format(pkg_name, curr_pkg_ver, new_pkg_ver) ) try: self._call_upgrade_script(pkg_name, new_pkg_ver) if migrate: # TODO test for migration, should fail if nocache is False !!! new_node_src_ver = Upgrader.get_src_version(nocache=True) # assumption: migrations are anchored to release versions only self._migrate(cur_node_src_ver.release, new_node_src_ver.release) self._call_restart_node_script() except Exception as ex: logger.error( "Upgrade from {} to {} failed: {}" .format(curr_pkg_ver, new_pkg_ver, ex) ) if rollback: logger.error("Trying to rollback to the previous version {}" .format(ex, curr_pkg_ver)) self._do_upgrade( pkg_name, new_pkg_ver, curr_pkg_ver, rollback=False)
def validate(self, req: Request): status = None operation = req.operation typ = operation.get(TXN_TYPE) if typ not in [POOL_UPGRADE, POOL_CONFIG]: return origin = req.identifier try: originRole = self.idrCache.getRole(origin, isCommitted=False) except BaseException: raise UnauthorizedClientRequest( req.identifier, req.reqId, "Nym {} not added to the ledger yet".format(origin)) if typ == POOL_UPGRADE: currentVersion = Upgrader.getVersion() targetVersion = req.operation[VERSION] if Upgrader.compareVersions(currentVersion, targetVersion) < 0: # currentVersion > targetVersion raise InvalidClientRequest( req.identifier, req.reqId, "Upgrade to lower version is not allowed") trname = IndyTransactions.POOL_UPGRADE.name action = operation.get(ACTION) # TODO: Some validation needed for making sure name and version # present txn = self.upgrader.get_upgrade_txn( lambda txn: txn.get( NAME, None) == req.operation.get( NAME, None) and txn.get(VERSION) == req.operation.get(VERSION), reverse=True) if txn: status = txn.get(ACTION, None) if status == START and action == START: raise InvalidClientRequest( req.identifier, req.reqId, "Upgrade '{}' is already scheduled".format( req.operation.get(NAME))) elif typ == POOL_CONFIG: trname = IndyTransactions.POOL_CONFIG.name action = None status = None r, msg = Authoriser.authorised( typ, originRole, field=ACTION, oldVal=status, newVal=action) if not r: raise UnauthorizedClientRequest( req.identifier, req.reqId, "{} cannot do {}".format( Roles.nameFromValue(originRole), trname))
def validate(self, req: Request): status = None operation = req.operation typ = operation.get(TXN_TYPE) if typ not in [POOL_UPGRADE, POOL_CONFIG]: return origin = req.identifier try: originRole = self.idrCache.getRole(origin, isCommitted=False) except BaseException: raise UnauthorizedClientRequest( req.identifier, req.reqId, "Nym {} not added to the ledger yet".format(origin)) if typ == POOL_UPGRADE: currentVersion = Upgrader.getVersion() targetVersion = req.operation[VERSION] if Upgrader.compareVersions(currentVersion, targetVersion) < 0: # currentVersion > targetVersion raise InvalidClientRequest( req.identifier, req.reqId, "Upgrade to lower version is not allowed") trname = IndyTransactions.POOL_UPGRADE.name action = operation.get(ACTION) # TODO: Some validation needed for making sure name and version # present txn = self.upgrader.get_upgrade_txn( lambda txn: txn.get( NAME, None) == req.operation.get( NAME, None) and txn.get(VERSION) == req.operation.get(VERSION), reverse=True) if txn: status = txn.get(ACTION, None) if status == START and action == START: raise InvalidClientRequest( req.identifier, req.reqId, "Upgrade '{}' is already scheduled".format( req.operation.get(NAME))) elif typ == POOL_CONFIG: trname = IndyTransactions.POOL_CONFIG.name action = None status = None r, msg = Authoriser.authorised( typ, ACTION, originRole, oldVal=status, newVal=action) if not r: raise UnauthorizedClientRequest( req.identifier, req.reqId, "{} cannot do {}".format( Roles.nameFromValue(originRole), trname))
def _compare_migration_scripts(migration1, migration2): migration_original_version1, migration_new_version1 = _get_migration_versions( migration1) migration_original_version2, migration_new_version2 = _get_migration_versions( migration2) if Upgrader.compareVersions(migration_original_version2, migration_original_version1) == 0: return Upgrader.compareVersions(migration_new_version2, migration_new_version1) return Upgrader.compareVersions(migration_original_version2, migration_original_version1)
def _compare_migration_scripts(migration1, migration2): migration_original_version1, migration_new_version1 = _get_migration_versions( migration1) migration_original_version2, migration_new_version2 = _get_migration_versions( migration2) if Upgrader.compareVersions( migration_original_version2, migration_original_version1) == 0: return Upgrader.compareVersions( migration_new_version2, migration_new_version1) return Upgrader.compareVersions( migration_original_version2, migration_original_version1)
def test_get_src_version_for_app(monkeypatch): called = 0 def _f(*args, **kwargs): nonlocal called called += 1 return (None, []) monkeypatch.setattr(NodeControlUtil, 'curr_pkg_info', _f) assert Upgrader.get_src_version(APP_NAME) assert not called Upgrader.get_src_version(APP_NAME, nocache=True) assert called
def testNodeControlCreatesBackups(monkeypatch, tdir, looper, tconf): version = bumpedVersion() stdout = 'teststdout' curr_src_ver = Upgrader.get_src_version() def transform(tool): nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout) monkeypatch.setattr(tool, '_remove_old_backups', lambda *x: None) def checkBackup(tool): assert os.path.isfile('{}.{}'.format( tool._backup_name(curr_src_ver.release), tool.backup_format)) monkeypatch.setattr( NodeControlUtil, 'get_latest_pkg_version', lambda *x, **y: DebianVersion( version, upstream_cls=src_version_cls()) ) nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform, config=tconf) try: sendUpgradeMessage(version) looper.run(eventually(checkBackup, nct.tool)) finally: clean_dir(nct.tool.base_dir) nct.stop()
def getUpgrader(self): return Upgrader(self.id, self.name, self.dataLocation, self.config, self.configLedger, upgradeFailedCallback=self.postConfigLedgerCaughtUp, upgrade_start_callback=self.notify_upgrade_start)
def init_upgrader(self): return Upgrader(self.node.id, self.node.name, self.node.dataLocation, self.node.config, self.node.configLedger, actionFailedCallback=self.node.postConfigLedgerCaughtUp, action_start_callback=self.node.notify_upgrade_start)
def _get_relevant_migrations(migration_scripts, current_version, new_version): relevant_migrations = [] for migration in migration_scripts: migration_original_version, migration_new_version = _get_migration_versions( migration) if not migration_original_version or not migration_new_version: continue if Upgrader.compareVersions(current_version, new_version) >= 0: if Upgrader.compareVersions( migration_new_version, migration_original_version) > 0: continue if Upgrader.compareVersions(migration_original_version, current_version) <= 0 \ and Upgrader.compareVersions(migration_new_version, new_version) >= 0: relevant_migrations.append(migration) else: if Upgrader.compareVersions( migration_original_version, migration_new_version) > 0: continue if Upgrader.compareVersions(migration_original_version, current_version) >= 0 \ and Upgrader.compareVersions(migration_new_version, new_version) <= 0: relevant_migrations.append(migration) relevant_migrations = sorted( relevant_migrations, key=cmp_to_key(_compare_migration_scripts)) return relevant_migrations
def _get_relevant_migrations(migration_scripts, current_version, new_version): relevant_migrations = [] for migration in migration_scripts: migration_original_version, migration_new_version = _get_migration_versions( migration) if not migration_original_version or not migration_new_version: continue if Upgrader.compareVersions(current_version, new_version) >= 0: if Upgrader.compareVersions(migration_new_version, migration_original_version) > 0: continue if Upgrader.compareVersions(migration_original_version, current_version) <= 0 \ and Upgrader.compareVersions(migration_new_version, new_version) >= 0: relevant_migrations.append(migration) else: if Upgrader.compareVersions(migration_original_version, migration_new_version) > 0: continue if Upgrader.compareVersions(migration_original_version, current_version) >= 0 \ and Upgrader.compareVersions(migration_new_version, new_version) <= 0: relevant_migrations.append(migration) relevant_migrations = sorted( relevant_migrations, key=cmp_to_key(_compare_migration_scripts)) return relevant_migrations
def _upgrade(self, new_version, pkg_name, migrate=True, rollback=True): current_version, _ = NodeControlUtil.curr_pkt_info(pkg_name) try: from indy_node.server.upgrader import Upgrader node_cur_version = Upgrader.getVersion() logger.info('Trying to upgrade from {}={} to {}'.format(pkg_name, current_version, new_version)) self._call_upgrade_script(pkg_name, new_version) if migrate: node_new_version = Upgrader.getVersion() self._do_migration(node_cur_version, node_new_version) self._call_restart_node_script() except Exception as ex: self._declare_upgrade_failed(from_version=current_version, to_version=new_version, reason=str(ex)) logger.error("Trying to rollback to the previous version {}" .format(ex, current_version)) if rollback: self._upgrade(current_version, pkg_name, rollback=False)
def comparator_test(lower_versrion, higher_version): assert Upgrader.compareVersions(lower_versrion, higher_version) == 1 assert Upgrader.compareVersions(higher_version, lower_versrion) == -1 assert Upgrader.compareVersions(higher_version, higher_version) == 0 assert not Upgrader.is_version_upgradable(higher_version, higher_version) assert Upgrader.is_version_upgradable( higher_version, higher_version, reinstall=True) assert Upgrader.is_version_upgradable(lower_versrion, higher_version) assert Upgrader.is_version_upgradable(higher_version, lower_versrion)
def comparator_test(lower_versrion, higher_version): assert Upgrader.compareVersions(lower_versrion, higher_version) == 1 assert Upgrader.compareVersions(higher_version, lower_versrion) == -1 assert Upgrader.compareVersions(higher_version, higher_version) == 0 assert not Upgrader.is_version_upgradable(higher_version, higher_version) assert Upgrader.is_version_upgradable( higher_version, higher_version, reinstall=True) assert Upgrader.is_version_upgradable(lower_versrion, higher_version) assert not Upgrader.is_version_upgradable(higher_version, lower_versrion)
def _upgrade(self, new_version, migrate=True, rollback=True): current_version = self.ext_ver if self.ext_ver else Upgrader.getVersion( ) try: logger.info('Trying to upgrade from {} to {}'.format( current_version, new_version)) self._call_upgrade_script(new_version) if migrate: # migration should only be called with current version from Upgrader! self._do_migration(Upgrader.getVersion(), new_version) self._call_restart_node_script() except Exception as ex: self._declare_upgrade_failed(from_version=current_version, to_version=new_version, reason=str(ex)) logger.error( "Trying to rollback to the previous version {}".format( ex, current_version)) if rollback: self._upgrade(current_version, rollback=False)
def dynamic_validation(self, request: Request): self._validate_request_type(request) identifier, req_id, operation = get_request_data(request) status = '*' pkt_to_upgrade = operation.get(PACKAGE, getConfig().UPGRADE_ENTRY) if pkt_to_upgrade: currentVersion, cur_deps = self.curr_pkt_info(pkt_to_upgrade) if not currentVersion: raise InvalidClientRequest( identifier, req_id, "Packet {} is not installed and cannot be upgraded".format( pkt_to_upgrade)) if all([APP_NAME not in d for d in cur_deps]): raise InvalidClientRequest( identifier, req_id, "Packet {} doesn't belong to pool".format(pkt_to_upgrade)) else: raise InvalidClientRequest(identifier, req_id, "Upgrade packet name is empty") targetVersion = operation[VERSION] reinstall = operation.get(REINSTALL, False) if not Upgrader.is_version_upgradable(currentVersion, targetVersion, reinstall): # currentVersion > targetVersion raise InvalidClientRequest(identifier, req_id, "Version is not upgradable") action = operation.get(ACTION) # TODO: Some validation needed for making sure name and version # present txn = self.upgrader.get_upgrade_txn( lambda txn: get_payload_data(txn).get(NAME, None) == operation.get( NAME, None) and get_payload_data(txn).get( VERSION) == operation.get(VERSION), reverse=True) if txn: status = get_payload_data(txn).get(ACTION, '*') if status == START and action == START: raise InvalidClientRequest( identifier, req_id, "Upgrade '{}' is already scheduled".format( operation.get(NAME))) if status == '*': auth_action = AuthActionAdd(txn_type=POOL_UPGRADE, field=ACTION, value=action) else: auth_action = AuthActionEdit(txn_type=POOL_UPGRADE, field=ACTION, old_value=status, new_value=action) self.write_request_validator.validate(request, [auth_action])
def _upgrade(self, new_version, migrate=True, rollback=True): try: current_version = Upgrader.getVersion() logger.info('Trying to upgrade from {} to {}'.format( current_version, new_version)) self._call_upgrade_script(new_version) if migrate: self._do_migration(current_version, new_version) self._call_restart_node_script() except Exception as e: logger.error( "Unexpected error in _upgrade {}, trying to rollback to the previous version {}" .format(e, current_version)) if rollback: self._upgrade(current_version, rollback=False)
def test_versions_comparison(lower_version, higher_version): assert Upgrader.compareVersions(higher_version, lower_version) == 1 assert Upgrader.compareVersions(lower_version, higher_version) == -1 assert Upgrader.compareVersions(higher_version, higher_version) == 0 version_cls = src_version_cls(APP_NAME) lower_version = version_cls(lower_version) higher_version = version_cls(higher_version) assert not Upgrader.is_version_upgradable(higher_version, higher_version) assert Upgrader.is_version_upgradable(higher_version, higher_version, reinstall=True) assert Upgrader.is_version_upgradable(lower_version, higher_version) assert not Upgrader.is_version_upgradable(higher_version, lower_version)
def testNodeControlRemovesBackups(monkeypatch, tdir, looper, tconf): version = bumpedVersion() stdout = 'teststdout' curr_src_ver = Upgrader.get_src_version() backupsWereRemoved = m.Value('b', False) def testRemoveOldBackups(tool): assert len(tool._get_backups()) == (tool.backup_num + 1) #looper = Looper(debug=True) tool._remove_old_backups_test() backupsWereRemoved.value = True def transform(tool): nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout) tool._remove_old_backups_test = tool._remove_old_backups monkeypatch.setattr(tool, '_remove_old_backups', functools.partial(testRemoveOldBackups, tool)) def checkOldBackupsRemoved(): assert backupsWereRemoved.value def check_backups_files_exists(): assert os.path.exists('{}.{}'.format( nct.tool._backup_name(curr_src_ver.release), nct.tool.backup_format)) monkeypatch.setattr( NodeControlUtil, 'get_latest_pkg_version', lambda *x, **y: DebianVersion(version, upstream_cls=src_version_cls())) nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform) try: assert len(nct.tool._get_backups()) == 0 for i in range(nct.tool.backup_num): file = os.path.join(nct.tool.base_dir, '{}{}'.format(nct.tool.backup_name_prefix, i)) with open(file, 'w') as f: f.write('random') assert len(nct.tool._get_backups()) == nct.tool.backup_num sendUpgradeMessage(version) looper.run(eventually(checkOldBackupsRemoved)) looper.run(eventually(check_backups_files_exists)) assert len(nct.tool._get_backups()) == nct.tool.backup_num finally: clean_dir(nct.tool.base_dir) nct.stop()
def _upgrade(self, new_version, migrate=True, rollback=True): current_version = Upgrader.getVersion() try: logger.info('Trying to upgrade from {} to {}' .format(current_version, new_version)) self._call_upgrade_script(new_version) if migrate: self._do_migration(current_version, new_version) self._call_restart_node_script() except Exception as ex: self._declare_upgrade_failed(from_version=current_version, to_version=new_version, reason=str(ex)) logger.error("Trying to rollback to the previous version {}" .format(ex, current_version)) if rollback: self._upgrade(current_version, rollback=False)
def testNodeControlCreatesBackups(monkeypatch, tdir, looper, tconf): msg = 'test' stdout = 'teststdout' currentVersion = Upgrader.getVersion() def transform(tool): nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout) monkeypatch.setattr(tool, '_remove_old_backups', lambda *x: None) def checkBackup(tool): assert os.path.isfile('{}.{}'.format( tool._backup_name(currentVersion), tool.backup_format)) nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform) try: sendUpgradeMessage(msg) looper.run(eventually(checkBackup, nct.tool)) finally: clean_dir(nct.tool.base_dir) nct.stop()
def testNodeControlCreatesBackups(monkeypatch, tdir, looper): msg = 'test' stdout = 'teststdout' currentVersion = Upgrader.getVersion() def transform(tool): nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout) monkeypatch.setattr(tool, '_remove_old_backups', lambda *x: None) def checkBackup(tool): assert os.path.isfile('{}.{}'.format( tool._backup_name(currentVersion), tool.backup_format)) nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform) try: sendUpgradeMessage(msg) looper.run(eventually(checkBackup, nct.tool)) finally: clean_dir(nct.tool.base_dir) nct.stop()
def testNodeControlRestoresFromBackups(monkeypatch, tdir, looper, tconf): msg = 'test' stdout = 'teststdout' currentVersion = Upgrader.getVersion() backupWasRestored = m.Value('b', False) testFile = 'testFile' original_text = '1' new_text = '2' def testRestoreBackup(tool, version): tool._restore_from_backup_test(version) backupWasRestored.value = True def mockMigrate(tool, *args): monkeypatch.setattr(tool, '_migrate', lambda *args: None) with open(os.path.join(tool.indy_dir, testFile), 'w') as f: f.write(new_text) raise Exception('test') def transform(tool): nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout) tool._restore_from_backup_test = tool._restore_from_backup monkeypatch.setattr( tool, '_migrate', functools.partial(mockMigrate, tool)) monkeypatch.setattr(tool, '_restore_from_backup', functools.partial(testRestoreBackup, tool)) def checkBackupRestored(tool): assert backupWasRestored.value nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform) try: with open(os.path.join(nct.tool.indy_dir, testFile), 'w') as f: f.write(original_text) sendUpgradeMessage(msg) looper.run(eventually(checkBackupRestored, nct.tool)) with open(os.path.join(nct.tool.indy_dir, testFile)) as f: assert original_text == f.read() finally: clean_dir(nct.tool.base_dir) nct.stop()
def testNodeControlRestoresFromBackups(monkeypatch, tdir, looper, tconf): msg = 'test' stdout = 'teststdout' currentVersion = Upgrader.getVersion() backupWasRestored = m.Value('b', False) testFile = 'testFile' original_text = '1' new_text = '2' def testRestoreBackup(tool, version): tool._restore_from_backup_test(version) backupWasRestored.value = True def mockMigrate(tool, *args): monkeypatch.setattr(tool, '_migrate', lambda *args: None) with open(os.path.join(tool.indy_dir, testFile), 'w') as f: f.write(new_text) raise Exception('test') def transform(tool): nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout) tool._restore_from_backup_test = tool._restore_from_backup monkeypatch.setattr(tool, '_migrate', functools.partial(mockMigrate, tool)) monkeypatch.setattr(tool, '_restore_from_backup', functools.partial(testRestoreBackup, tool)) def checkBackupRestored(tool): assert backupWasRestored.value nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform) try: with open(os.path.join(nct.tool.indy_dir, testFile), 'w') as f: f.write(original_text) sendUpgradeMessage(msg) looper.run(eventually(checkBackupRestored, nct.tool)) with open(os.path.join(nct.tool.indy_dir, testFile)) as f: assert original_text == f.read() finally: clean_dir(nct.tool.base_dir) nct.stop()
def testNodeControlRemovesBackups(monkeypatch, tdir, looper): msg = 'test' stdout = 'teststdout' currentVersion = Upgrader.getVersion() backupsWereRemoved = m.Value('b', False) def testRemoveOldBackups(tool): assert len(tool._get_backups()) == (tool.backup_num + 1) #looper = Looper(debug=True) tool._remove_old_backups_test() backupsWereRemoved.value = True def transform(tool): nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout) tool._remove_old_backups_test = tool._remove_old_backups monkeypatch.setattr(tool, '_remove_old_backups', functools.partial(testRemoveOldBackups, tool)) def checkOldBackupsRemoved(): assert backupsWereRemoved.value def check_backups_files_exists(): assert os.path.exists('{}.{}'.format( nct.tool._backup_name(currentVersion), nct.tool.backup_format)) nct = NCT(backup_dir=tdir, backup_target=tdir, transform=transform) try: assert len(nct.tool._get_backups()) == 0 for i in range(nct.tool.backup_num): file = os.path.join(nct.tool.base_dir, '{}{}'.format( nct.tool.backup_name_prefix, i)) with open(file, 'w') as f: f.write('random') assert len(nct.tool._get_backups()) == nct.tool.backup_num sendUpgradeMessage(msg) looper.run(eventually(checkOldBackupsRemoved)) looper.run(eventually(check_backups_files_exists)) assert len(nct.tool._get_backups()) == nct.tool.backup_num finally: clean_dir(nct.tool.base_dir) nct.stop()
def testNodeControlRemovesBackups(monkeypatch, tdir, looper): msg = 'test' stdout = 'teststdout' currentVersion = Upgrader.getVersion() backupsWereRemoved = m.Value('b', False) def testRemoveOldBackups(tool): assert len(tool._get_backups()) == (tool.backup_num + 1) tool._remove_old_backups_test() backupsWereRemoved.value = True def transform(tool): nodeControlGeneralMonkeypatching(tool, monkeypatch, tdir, stdout) tool._remove_old_backups_test = tool._remove_old_backups monkeypatch.setattr(tool, '_remove_old_backups', functools.partial(testRemoveOldBackups, tool)) def checkOldBackupsRemoved(): assert backupsWereRemoved.value nct = NCT(transform=transform) try: assert len(nct.tool._get_backups()) == 0 for i in range(nct.tool.backup_num): file = os.path.join(nct.tool.base_dir, '{}{}'.format(nct.tool.backup_name_prefix, i)) with open(file, 'w') as f: f.write('random') assert len(nct.tool._get_backups()) == nct.tool.backup_num sendUpgradeMessage(msg) looper.run(eventually(checkOldBackupsRemoved)) assert os.path.exists('{}.{}'.format( nct.tool._backup_name(currentVersion), nct.tool.backup_format)) assert len(nct.tool._get_backups()) == nct.tool.backup_num finally: clean_dir(nct.tool.base_dir) nct.stop()
def test_check_upgrade_possible_invalid_top_level_pkg(): assert ("doesn't belong to pool" in Upgrader.check_upgrade_possible(some_pkg_name, '1.2.3'))
def test_check_upgrade_possible_reinstall_succeeded_for_app_pkg(): assert not Upgrader.check_upgrade_possible( APP_NAME, '1.2.2', reinstall=True)
def test_check_upgrade_possible_not_ge_version_reinstall(): assert ("is not upgradable" in Upgrader.check_upgrade_possible(some_pkg_name, '1.2.1', reinstall=True))
def test_check_upgrade_possible_not_gt_version(): assert ("is not upgradable" in Upgrader.check_upgrade_possible(some_pkg_name, '1.2.2'))
def test_check_upgrade_possible_no_pkg_with_target_version(): target_ver = '1.2.3' assert ("for target version {} is not found".format(target_ver) in Upgrader.check_upgrade_possible(some_pkg_name, target_ver))
def curr_pkt_info(self, pkg_name): if pkg_name == APP_NAME: return Upgrader.getVersion(), [APP_NAME] return NodeControlUtil.curr_pkt_info(pkg_name)
def test_check_upgrade_possible_succeeded(): target_ver = '1.2.3' assert not Upgrader.check_upgrade_possible(some_pkg_name, target_ver) assert not Upgrader.check_upgrade_possible( some_pkg_name, target_ver, reinstall=True)
def test_check_upgrade_possible_succeeded_for_app_pkg(): target_ver = '1.2.3' assert not Upgrader.check_upgrade_possible(APP_NAME, target_ver) assert not Upgrader.check_upgrade_possible( APP_NAME, target_ver, reinstall=True)
def test_check_upgrade_possible_reinstall_succeeded(): assert not Upgrader.check_upgrade_possible( some_pkg_name, '1.2.2', reinstall=True)
def test_get_src_version_for(monkeypatch): assert (Upgrader.get_src_version(some_pkg_name) == src_version_cls( some_pkg_name)('1.2.2'))
def codeVersion(): return Upgrader.getVersion()