# -*- coding: utf-8 -*- ''' tests for pkg state ''' # Import Python libs from __future__ import absolute_import, print_function, unicode_literals import functools import logging import os import time # Import Salt Testing libs from tests.support.case import ModuleCase from tests.support.mixins import SaltReturnAssertsMixin from tests.support.unit import skipIf from tests.support.helpers import ( destructiveTest, requires_salt_modules, ) # Import Salt libs import salt.utils.files import salt.utils.path import salt.utils.pkg.rpm import salt.utils.platform # Import 3rd-party libs from salt.ext import six from salt.ext.six.moves import range # pylint: disable=import-error,redefined-builtin try: from distro import LinuxDistribution pre_grains = LinuxDistribution() except ImportError: pre_grains = None log = logging.getLogger(__name__) _PKG_EPOCH_TARGETS = [] _PKG_TARGETS = ['figlet', 'sl'] _PKG_32_TARGETS = [] _PKG_CAP_TARGETS = [] _PKG_DOT_TARGETS = [] _WILDCARDS_SUPPORTED = False _VERSION_SPEC_SUPPORTED = True if salt.utils.platform.is_windows(): _PKG_TARGETS = ['7zip', 'putty'] elif salt.utils.platform.is_freebsd: _VERSION_SPEC_SUPPORTED = False elif pre_grains: if any(arch in pre_grains.like() for arch in ('arch', 'archlinux')): _WILDCARDS_SUPPORTED = True elif 'debian' in pre_grains.like(): _WILDCARDS_SUPPORTED = True elif 'rhel' in pre_grains.like(): _PKG_TARGETS = ['units', 'zsh-html'] _WILDCARDS_SUPPORTED = True if pre_grains.id() == 'centos': if pre_grains.major_version() == 5: _PKG_32_TARGETS = ['xz-devel.i386'] else: _PKG_32_TARGETS.append('xz-devel.i686') if pre_grains.major_version() == 5: _PKG_DOT_TARGETS = ['python-migrate0.5'] elif pre_grains.major_version() == 6: _PKG_DOT_TARGETS = ['tomcat6-el-2.1-api'] elif pre_grains.major_version() == 7: _PKG_DOT_TARGETS = ['tomcat-el-2.2-api'] _PKG_EPOCH_TARGETS = ['comps-extras'] elif pre_grains.id() in ('sles', 'opensuse'): _PKG_TARGETS = ['figlet', 'htop'] _PKG_CAP_TARGETS = [('perl(ZNC)', 'znc-perl')] def runs_on(platforms=None, os_like=None, reason=''): def decorator(caller): @functools.wraps(caller) def wrapper(cls): if platforms: if not any(getattr(salt.utils.platform, 'is_' + platform)() for platform in platforms): cls.skipTest(reason if reason else 'OS not in [{}]'.format(', '.join(platforms))) if pre_grains and os_like: if not any(x in pre_grains.like() for x in os_like): cls.skipTest(reason if reason else 'OS not similar to [{}]'.format(', '.join(os_like))) return caller(cls) return wrapper return decorator @destructiveTest class PkgTest(ModuleCase, SaltReturnAssertsMixin): @classmethod def setUpClass(cls): cls.ctx = {} @classmethod def tearDownClass(cls): del cls.ctx def latest_version(self, *names): ''' Helper function which ensures that we don't make any unnecessary calls to pkg.latest_version to figure out what version we need to install. This won't stop pkg.latest_version from being run in a pkg.latest state, but it will reduce the amount of times we check the latest version here in the test suite. ''' key = 'latest_version' if key not in self.ctx: self.ctx[key] = dict() targets = [x for x in names if x not in self.ctx[key]] if targets: result = self.run_function('pkg.latest_version', targets, refresh=False) try: self.ctx[key].update(result) except ValueError: # Only a single target, pkg.latest_version returned a string self.ctx[key][targets[0]] = result ret = dict([(x, self.ctx[key].get(x, '')) for x in names]) if len(names) == 1: return ret[names[0]] return ret def setUp(self): super(PkgTest, self).setUp() if 'refresh' not in self.ctx: self.run_function('pkg.refresh_db') self.ctx['refresh'] = True @requires_salt_modules('pkg.version', 'pkg.installed', 'pkg.removed') def test_pkg_001_installed(self): ''' This is a destructive test as it installs and then removes a package ''' target = _PKG_TARGETS[0] version = self.run_function('pkg.version', [target]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) ret = self.run_state('pkg.installed', name=target, refresh=False) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @skipIf(not _VERSION_SPEC_SUPPORTED, 'Version specification not supported') @requires_salt_modules('pkg.installed', 'pkg.removed') def test_pkg_002_installed_with_version(self): ''' This is a destructive test as it installs and then removes a package ''' if pre_grains and 'arch' in pre_grains.like(): for idx in range(13): if idx == 12: raise Exception('Package database locked after 60 seconds, ' 'bailing out') if not os.path.isfile('/var/lib/pacman/db.lck'): break time.sleep(5) target = _PKG_TARGETS[0] version = self.latest_version(target) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertTrue(version) ret = self.run_state('pkg.installed', name=target, version=version, refresh=False) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @requires_salt_modules('pkg.installed', 'pkg.removed') def test_pkg_003_installed_multipkg(self): ''' This is a destructive test as it installs and then removes two packages ''' version = self.run_function('pkg.version', _PKG_TARGETS) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so these # packages need to not be installed before we run the states below self.assertFalse(any(version.values())) self.assertSaltTrueReturn(self.run_state('pkg.removed', name=None, pkgs=_PKG_TARGETS)) try: ret = self.run_state('pkg.installed', name=None, pkgs=_PKG_TARGETS, refresh=False) self.assertSaltTrueReturn(ret) finally: ret = self.run_state('pkg.removed', name=None, pkgs=_PKG_TARGETS) self.assertSaltTrueReturn(ret) @skipIf(not _VERSION_SPEC_SUPPORTED, 'Version specification not supported') @requires_salt_modules('pkg.installed', 'pkg.removed') def test_pkg_004_installed_multipkg_with_version(self): ''' This is a destructive test as it installs and then removes two packages ''' if pre_grains and 'arch' in pre_grains.like(): for idx in range(13): if idx == 12: raise Exception('Package database locked after 60 seconds, ' 'bailing out') if not os.path.isfile('/var/lib/pacman/db.lck'): break time.sleep(5) version = self.latest_version(_PKG_TARGETS[0]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so these # packages need to not be installed before we run the states below self.assertTrue(bool(version)) pkgs = [{_PKG_TARGETS[0]: version}, _PKG_TARGETS[1]] try: ret = self.run_state('pkg.installed', name=None, pkgs=pkgs, refresh=False) self.assertSaltTrueReturn(ret) finally: ret = self.run_state('pkg.removed', name=None, pkgs=_PKG_TARGETS) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_32_TARGETS, 'No 32 bit packages have been specified for testing') @requires_salt_modules('pkg.version', 'pkg.installed', 'pkg.removed') def test_pkg_005_installed_32bit(self): ''' This is a destructive test as it installs and then removes a package ''' target = _PKG_32_TARGETS[0] # _PKG_TARGETS_32 is only populated for platforms for which Salt has to # munge package names for 32-bit-on-x86_64 (Currently only Ubuntu and # RHEL-based). Don't actually perform this test on other platforms. version = self.run_function('pkg.version', [target]) # If this assert fails, we need to find a new target. This test # needs to be able to test successful installation of packages, so # the target needs to not be installed before we run the states # below self.assertFalse(version) ret = self.run_state('pkg.installed', name=target, refresh=False) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_32_TARGETS, 'No 32 bit packages have been specified for testing') @requires_salt_modules('pkg.installed', 'pkg.removed') def test_pkg_006_installed_32bit_with_version(self): ''' This is a destructive test as it installs and then removes a package ''' target = _PKG_32_TARGETS[0] # _PKG_TARGETS_32 is only populated for platforms for which Salt has to # munge package names for 32-bit-on-x86_64 (Currently only Ubuntu and # RHEL-based). Don't actually perform this test on other platforms. if pre_grains and 'arch' in pre_grains.like(): for idx in range(13): if idx == 12: raise Exception('Package database locked after 60 seconds, ' 'bailing out') if not os.path.isfile('/var/lib/pacman/db.lck'): break time.sleep(5) version = self.latest_version(target) # If this assert fails, we need to find a new target. This test # needs to be able to test successful installation of the package, so # the target needs to not be installed before we run the states # below self.assertTrue(version) ret = self.run_state('pkg.installed', name=target, version=version, refresh=False) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_DOT_TARGETS, 'No packages with "." in their name have been configured for') @requires_salt_modules('pkg.installed', 'pkg.removed') def test_pkg_007_with_dot_in_pkgname(self=None): ''' This tests for the regression found in the following issue: https://github.com/saltstack/salt/issues/8614 This is a destructive test as it installs a package ''' target = _PKG_DOT_TARGETS[0] version = self.latest_version(target) # If this assert fails, we need to find a new target. This test # needs to be able to test successful installation of the package, so # the target needs to not be installed before we run the # pkg.installed state below self.assertTrue(bool(version)) ret = self.run_state('pkg.installed', name=target, refresh=False) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_EPOCH_TARGETS, 'No targets have been configured with "epoch" in the version') @requires_salt_modules('pkg.installed', 'pkg.removed') def test_pkg_008_epoch_in_version(self): ''' This tests for the regression found in the following issue: https://github.com/saltstack/salt/issues/8614 This is a destructive test as it installs a package ''' target = _PKG_EPOCH_TARGETS[0] version = self.latest_version(target) # If this assert fails, we need to find a new target. This test # needs to be able to test successful installation of the package, so # the target needs to not be installed before we run the # pkg.installed state below self.assertTrue(version) ret = self.run_state('pkg.installed', name=target, version=version, refresh=False) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @requires_salt_modules('pkg.version', 'pkg.info_installed', 'pkg.installed', 'pkg.removed') @runs_on(platforms=['linux'], reason='This test only runs on linux') def test_pkg_009_latest_with_epoch(self): ''' This tests for the following issue: https://github.com/saltstack/salt/issues/31014 This is a destructive test as it installs a package ''' package = 'bash-completion' pkgquery = 'version' ret = self.run_state('pkg.installed', name=package, refresh=False) self.assertSaltTrueReturn(ret) ret = self.run_function('pkg.info_installed', [package]) self.assertTrue(pkgquery in six.text_type(ret)) @requires_salt_modules('pkg.latest', 'pkg.removed') def test_pkg_010_latest(self): ''' This tests pkg.latest with a package that has no epoch (or a zero epoch). ''' target = _PKG_TARGETS[0] version = self.latest_version(target) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertTrue(version) ret = self.run_state('pkg.latest', name=target, refresh=False) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @requires_salt_modules('pkg.latest', 'pkg.list_pkgs', 'pkg.list_upgrades', 'pkg.version') @runs_on(platforms=['linux'], os_like=['debian'], reason='This test only runs on Debian based linux distributions') def test_pkg_011_latest_only_upgrade(self): ''' WARNING: This test will pick a package with an available upgrade (if there is one) and upgrade it to the latest version. ''' target = _PKG_TARGETS[0] # If this assert fails, we need to find new targets, this test needs to # be able to test that the state fails when you try to run the state # with only_upgrade=True on a package which is not already installed, # so the targeted package needs to not be installed before we run the # state below. version = self.latest_version(target) self.assertTrue(version) ret = self.run_state('pkg.latest', name=target, refresh=False, only_upgrade=True) self.assertSaltFalseReturn(ret) # Now look for updates and try to run the state on a package which is already up-to-date. installed_pkgs = self.run_function('pkg.list_pkgs') updates = self.run_function('pkg.list_upgrades', refresh=False) for pkgname in updates: if pkgname in installed_pkgs: target = pkgname break else: target = '' log.warning( 'No available upgrades to installed packages, skipping ' 'only_upgrade=True test with already-installed package. For ' 'best results run this test on a machine with upgrades ' 'available.' ) if target: ret = self.run_state('pkg.latest', name=target, refresh=False, only_upgrade=True) self.assertSaltTrueReturn(ret) new_version = self.run_function('pkg.version', [target]) self.assertEqual(new_version, updates[target]) ret = self.run_state('pkg.latest', name=target, refresh=False, only_upgrade=True) self.assertEqual( ret['pkg_|-{0}_|-{0}_|-latest'.format(target)]['comment'], 'Package {0} is already up-to-date'.format(target) ) @skipIf(not _WILDCARDS_SUPPORTED, 'Wildcards in pkg.install are not supported') @requires_salt_modules('pkg.version', 'pkg.installed', 'pkg.removed') def test_pkg_012_installed_with_wildcard_version(self): ''' This is a destructive test as it installs and then removes a package ''' target = _PKG_TARGETS[0] version = self.run_function('pkg.version', [target]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) ret = self.run_state( 'pkg.installed', name=target, version='*', refresh=False, ) self.assertSaltTrueReturn(ret) # Repeat state, should pass ret = self.run_state( 'pkg.installed', name=target, version='*', refresh=False, ) expected_comment = ( 'All specified packages are already installed and are at the ' 'desired version' ) self.assertSaltTrueReturn(ret) self.assertEqual(ret[next(iter(ret))]['comment'], expected_comment) # Repeat one more time with unavailable version, test should fail ret = self.run_state( 'pkg.installed', name=target, version='93413*', refresh=False, ) self.assertSaltFalseReturn(ret) # Clean up ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @requires_salt_modules('pkg.version', 'pkg.latest_version', 'pkg.installed', 'pkg.removed') @runs_on(platforms=['linux'], os_like=['debian', 'redhat'], reason='Comparison operator not specially implemented') def test_pkg_013_installed_with_comparison_operator(self): ''' This is a destructive test as it installs and then removes a package ''' target = _PKG_TARGETS[0] version = self.run_function('pkg.version', [target]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) latest_version = self.run_function( 'pkg.latest_version', [target], refresh=False) try: ret = self.run_state( 'pkg.installed', name=target, version='<9999999', refresh=False, ) self.assertSaltTrueReturn(ret) # The version that was installed should be the latest available version = self.run_function('pkg.version', [target]) self.assertTrue(version, latest_version) finally: # Clean up ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @requires_salt_modules('pkg.version', 'pkg.installed', 'pkg.removed') @runs_on(platforms=['linux'], os_like=['redhat'], reason='Comparison operator not specially implemented') def test_pkg_014_installed_missing_release(self): ''' Tests that a version number missing the release portion still resolves as correctly installed. For example, version 2.0.2 instead of 2.0.2-1.el7 ''' target = _PKG_TARGETS[0] version = self.run_function('pkg.version', [target]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) ret = self.run_state( 'pkg.installed', name=target, version=salt.utils.pkg.rpm.version_to_evr(version)[1], refresh=False, ) self.assertSaltTrueReturn(ret) # Clean up ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) @requires_salt_modules('pkg.hold', 'pkg.unhold', 'pkg.installed', 'pkg.removed') def test_pkg_015_installed_held(self): ''' Tests that a package can be held even when the package is already installed. ''' if pre_grains and 'redhat' in pre_grains.like(): # If we're in the Red Hat family first we ensure that # the yum-plugin-versionlock package is installed ret = self.run_state( 'pkg.installed', name='yum-plugin-versionlock', refresh=False, ) self.assertSaltTrueReturn(ret) target = _PKG_TARGETS[0] # First we ensure that the package is installed ret = self.run_state( 'pkg.installed', name=target, refresh=False, ) self.assertSaltTrueReturn(ret) # Then we check that the package is now held ret = self.run_state( 'pkg.installed', name=target, hold=True, refresh=False, ) # changes from pkg.hold for Red Hat family are different if pre_grains: if 'redhat' in pre_grains.like(): target_changes = {'new': 'hold', 'old': ''} elif 'debian' in pre_grains.like(): target_changes = {'new': 'hold', 'old': 'install'} try: tag = 'pkg_|-{0}_|-{0}_|-installed'.format(target) self.assertSaltTrueReturn(ret) self.assertIn(tag, ret) self.assertIn('changes', ret[tag]) self.assertIn(target, ret[tag]['changes']) self.assertEqual(ret[tag]['changes'][target], target_changes) finally: # Clean up, unhold package and remove self.run_function('pkg.unhold', name=target) ret = self.run_state('pkg.removed', name=target) self.assertSaltTrueReturn(ret) if pre_grains and 'redhat' in pre_grains.like(): ret = self.run_state('pkg.removed', name='yum-plugin-versionlock') self.assertSaltTrueReturn(ret) @skipIf(not _PKG_CAP_TARGETS, 'Capability not provided') @requires_salt_modules('pkg.version', 'pkg.installed', 'pkg.removed') def test_pkg_cap_001_installed(self): ''' This is a destructive test as it installs and then removes a package ''' target, realpkg = _PKG_CAP_TARGETS[0] version = self.run_function('pkg.version', [target]) realver = self.run_function('pkg.version', [realpkg]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) self.assertFalse(realver) try: ret = self.run_state('pkg.installed', name=target, refresh=False, resolve_capabilities=True, test=True) self.assertInSaltComment("The following packages would be installed/updated: {0}".format(realpkg), ret) ret = self.run_state('pkg.installed', name=target, refresh=False, resolve_capabilities=True) self.assertSaltTrueReturn(ret) finally: ret = self.run_state('pkg.removed', name=realpkg) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_CAP_TARGETS, 'Capability not available') @requires_salt_modules('pkg.installed', 'pkg.removed') def test_pkg_cap_002_already_installed(self): ''' This is a destructive test as it installs and then removes a package ''' target, realpkg = _PKG_CAP_TARGETS[0] version = self.run_function('pkg.version', [target]) realver = self.run_function('pkg.version', [realpkg]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) self.assertFalse(realver) try: # install the package ret = self.run_state('pkg.installed', name=realpkg, refresh=False) self.assertSaltTrueReturn(ret) # Try to install again. Nothing should be installed this time. ret = self.run_state('pkg.installed', name=target, refresh=False, resolve_capabilities=True, test=True) self.assertInSaltComment("All specified packages are already installed", ret) ret = self.run_state('pkg.installed', name=target, refresh=False, resolve_capabilities=True) self.assertSaltTrueReturn(ret) self.assertInSaltComment("packages are already installed", ret) finally: ret = self.run_state('pkg.removed', name=realpkg) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_CAP_TARGETS, 'Capability not available') @skipIf(not _VERSION_SPEC_SUPPORTED, 'Version specification not supported') @requires_salt_modules('pkg.installed', 'pkg.removed') def test_pkg_cap_003_installed_multipkg_with_version(self): ''' This is a destructive test as it installs and then removes two packages ''' if pre_grains and ('arch' in pre_grains.like() or 'archlinux' in pre_grains.like()): for idx in range(13): if idx == 12: raise Exception('Package database locked after 60 seconds, ' 'bailing out') if not os.path.isfile('/var/lib/pacman/db.lck'): break time.sleep(5) target, realpkg = _PKG_CAP_TARGETS[0] version = self.latest_version(target) realver = self.latest_version(realpkg) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so these # packages need to not be installed before we run the states below self.assertTrue(version, 'new pkg cap targets required') self.assertTrue(realver, 'new pkg cap targets required') try: pkgs = [{_PKG_TARGETS[0]: version}, _PKG_TARGETS[1], {target: realver}] ret = self.run_state('pkg.installed', name='test_pkg_cap_003_installed_multipkg_with_version-install', pkgs=pkgs, refresh=False) self.assertSaltFalseReturn(ret) ret = self.run_state('pkg.installed', name='test_pkg_cap_003_installed_multipkg_with_version-install-capability', pkgs=pkgs, refresh=False, resolve_capabilities=True, test=True) self.assertInSaltComment("packages would be installed/updated", ret) self.assertInSaltComment("{0}={1}".format(realpkg, realver), ret) ret = self.run_state('pkg.installed', name='test_pkg_cap_003_installed_multipkg_with_version-install-capability', pkgs=pkgs, refresh=False, resolve_capabilities=True) self.assertSaltTrueReturn(ret) cleanup_pkgs = _PKG_TARGETS cleanup_pkgs.append(realpkg) finally: ret = self.run_state('pkg.removed', name='test_pkg_cap_003_installed_multipkg_with_version-remove', pkgs=cleanup_pkgs) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_CAP_TARGETS, 'Capability not available') @requires_salt_modules('pkg.version', 'pkg.latest', 'pkg.removed') def test_pkg_cap_004_latest(self): ''' This tests pkg.latest with a package that has no epoch (or a zero epoch). ''' target, realpkg = _PKG_CAP_TARGETS[0] version = self.run_function('pkg.version', [target]) realver = self.run_function('pkg.version', [realpkg]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) self.assertFalse(realver) try: ret = self.run_state('pkg.latest', name=target, refresh=False, resolve_capabilities=True, test=True) self.assertInSaltComment("The following packages would be installed/upgraded: {0}".format(realpkg), ret) ret = self.run_state('pkg.latest', name=target, refresh=False, resolve_capabilities=True) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.latest', name=target, refresh=False, resolve_capabilities=True) self.assertSaltTrueReturn(ret) self.assertInSaltComment("is already up-to-date", ret) finally: ret = self.run_state('pkg.removed', name=realpkg) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_CAP_TARGETS, 'Capability not available') @requires_salt_modules('pkg.version', 'pkg.installed', 'pkg.removed', 'pkg.downloaded') def test_pkg_cap_005_downloaded(self): ''' This is a destructive test as it installs and then removes a package ''' target, realpkg = _PKG_CAP_TARGETS[0] version = self.run_function('pkg.version', [target]) realver = self.run_function('pkg.version', [realpkg]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) self.assertFalse(realver) ret = self.run_state('pkg.downloaded', name=target, refresh=False) self.assertSaltFalseReturn(ret) ret = self.run_state('pkg.downloaded', name=target, refresh=False, resolve_capabilities=True, test=True) self.assertInSaltComment("The following packages would be downloaded: {0}".format(realpkg), ret) ret = self.run_state('pkg.downloaded', name=target, refresh=False, resolve_capabilities=True) self.assertSaltTrueReturn(ret) @skipIf(not _PKG_CAP_TARGETS, 'Capability not available') @requires_salt_modules('pkg.version', 'pkg.installed', 'pkg.removed', 'pkg.uptodate') def test_pkg_cap_006_uptodate(self): ''' This is a destructive test as it installs and then removes a package ''' target, realpkg = _PKG_CAP_TARGETS[0] version = self.run_function('pkg.version', [target]) realver = self.run_function('pkg.version', [realpkg]) # If this assert fails, we need to find new targets, this test needs to # be able to test successful installation of packages, so this package # needs to not be installed before we run the states below self.assertFalse(version) self.assertFalse(realver) try: ret = self.run_state('pkg.installed', name=target, refresh=False, resolve_capabilities=True) self.assertSaltTrueReturn(ret) ret = self.run_state('pkg.uptodate', name='test_pkg_cap_006_uptodate', pkgs=[target], refresh=False, resolve_capabilities=True) self.assertSaltTrueReturn(ret) self.assertInSaltComment("System is already up-to-date", ret) finally: ret = self.run_state('pkg.removed', name=realpkg) self.assertSaltTrueReturn(ret)