def test_version_cmp_python():
    """
    Test package version if falling back to python

    :return:
    """
    mock_log = MagicMock()
    patch_rpm = patch("salt.modules.rpm_lowpkg.HAS_RPM", False)
    patch_rpmutils = patch("salt.modules.rpm_lowpkg.HAS_RPMUTILS", False)
    mock_version_cmp = MagicMock(return_value=-1)
    patch_py_rpm = patch("salt.modules.rpm_lowpkg.HAS_PY_RPM", False)
    patch_cmp = patch("salt.utils.versions.version_cmp", mock_version_cmp)
    patch_which = patch("salt.utils.path.which", return_value=False)
    patch_log = patch("salt.modules.rpm_lowpkg.log", mock_log)

    with patch_rpm, patch_rpmutils, patch_py_rpm, patch_cmp, patch_which, patch_log:
        assert -1 == rpm.version_cmp("1", "2")
        assert mock_version_cmp.called
        assert mock_log.warning.called
        assert (
            mock_log.warning.mock_calls[0][1][0] ==
            "Please install a package that provides rpm.labelCompare for more accurate version comparisons."
        )
        assert (
            mock_log.warning.mock_calls[1][1][0] ==
            "Falling back on salt.utils.versions.version_cmp() for version comparisons"
        )
def test_version_cmp_rpmdev_vercmp():
    """
    Test package version if rpmdev-vercmp is installed

    :return:
    """
    mock__salt__ = MagicMock(return_value={"retcode": 12})
    mock_log = MagicMock()
    patch_rpm = patch("salt.modules.rpm_lowpkg.HAS_RPM", False)
    patch_rpmutils = patch("salt.modules.rpm_lowpkg.HAS_RPMUTILS", False)
    patch_py_rpm = patch("salt.modules.rpm_lowpkg.HAS_PY_RPM", False)
    patch_which = patch("salt.utils.path.which", return_value=True)
    patch_log = patch("salt.modules.rpm_lowpkg.log", mock_log)

    with patch_rpm, patch_rpmutils, patch_py_rpm, patch_which, patch_log:
        with patch.dict(rpm.__salt__, {"cmd.run_all": mock__salt__}):
            assert -1 == rpm.version_cmp("1", "2")
            assert mock__salt__.called
            assert mock_log.warning.called
            assert (
                mock_log.warning.mock_calls[0][1][0] ==
                "Please install a package that provides rpm.labelCompare for more accurate version comparisons."
            )
            assert (
                mock_log.warning.mock_calls[1][1][0] ==
                "Installing the rpmdevtools package may surface dev tools in production."
            )
Exemple #3
0
    def test_version_cmp_fallback(self):
        '''
        Test package version is called RPM version if RPM-Python is installed

        :return:
        '''
        with patch('salt.modules.rpm_lowpkg.rpm.labelCompare', MagicMock(return_value=0)), \
                patch('salt.modules.rpm_lowpkg.HAS_RPM', False):
            self.assertEqual(-1, rpm.version_cmp('1', '2'))  # mock returns -1, a python implementation was called
Exemple #4
0
    def test_version_cmp_rpm(self):
        '''
        Test package version is called RPM version if RPM-Python is installed

        :return:
        '''
        with patch('salt.modules.rpm_lowpkg.rpm.labelCompare', MagicMock(return_value=0)), \
                patch('salt.modules.rpm_lowpkg.HAS_RPM', True):
            self.assertEqual(0, rpm.version_cmp('1', '2'))  # mock returns 0, which means RPM was called
Exemple #5
0
    def test_version_cmp_rpm(self, mock_log, mock_labelCompare):
        """
        Test package version if RPM-Python is installed

        :return:
        """
        self.assertEqual(-1, rpm.version_cmp("1", "2"))
        self.assertEqual(mock_log.warning.called, False)
        self.assertEqual(mock_labelCompare.called, True)
Exemple #6
0
    def test_version_cmp_rpm(self):
        """
        Test package version is called RPM version if RPM-Python is installed

        :return:
        """
        with patch("salt.modules.rpm_lowpkg.rpm.labelCompare",
                   MagicMock(return_value=0)), patch(
                       "salt.modules.rpm_lowpkg.HAS_RPM", True):
            self.assertEqual(0, rpm.version_cmp(
                "1", "2"))  # mock returns 0, which means RPM was called
Exemple #7
0
    def test_version_cmp_fallback(self):
        """
        Test package version is called RPM version if RPM-Python is installed

        :return:
        """
        with patch(
            "salt.modules.rpm_lowpkg.rpm.labelCompare", MagicMock(return_value=0)
        ), patch("salt.modules.rpm_lowpkg.HAS_RPM", False):
            self.assertEqual(
                -1, rpm.version_cmp("1", "2")
            )  # mock returns -1, a python implementation was called
def test_version_cmp_rpm_all_libraries(rpm_lib):
    """
    Test package version when each library is installed
    """
    rpmdev = salt.utils.path.which("rpmdev-vercmp")
    patch_cmd = patch.dict(rpm.__salt__,
                           {"cmd.run_all": salt.modules.cmdmod.run_all})
    if rpm_lib == "rpmdev-vercmp":
        if rpmdev:
            patch_rpm = patch("salt.modules.rpm_lowpkg.HAS_RPM", False)
            patch_py_rpm = patch("salt.modules.rpm_lowpkg.HAS_PY_RPM", False)
        else:
            pytest.skip("The rpmdev-vercmp binary is not installed")
    elif rpm_lib == "HAS_RPM":
        if HAS_RPM:
            patch_rpm = patch("salt.modules.rpm_lowpkg.HAS_RPM", True)
            patch_py_rpm = patch("salt.modules.rpm_lowpkg.HAS_PY_RPM", False)
        else:
            pytest.skip("The RPM lib is not installed, skipping")
    elif rpm_lib == "HAS_PY_RPM":
        if HAS_PY_RPM:
            patch_rpm = patch("salt.modules.rpm_lowpkg.HAS_RPM", False)
            patch_py_rpm = patch("salt.modules.rpm_lowpkg.HAS_PY_RPM", True)
        else:
            pytest.skip("The Python RPM lib is not installed, skipping")

    with patch_rpm, patch_py_rpm, patch_cmd:
        assert -1 == rpm.version_cmp("1", "2")
        assert -1 == rpm.version_cmp("2.9.1-6.el7_2.3", "2.9.1-6.el7.4")
        assert 1 == rpm.version_cmp("3.2", "3.0")
        assert 0 == rpm.version_cmp("3.0", "3.0")
        assert 1 == rpm.version_cmp("1:2.9.1-6.el7_2.3", "2.9.1-6.el7.4")
        assert -1 == rpm.version_cmp("1:2.9.1-6.el7_2.3", "1:2.9.1-6.el7.4")
        assert 1 == rpm.version_cmp("2:2.9.1-6.el7_2.3", "1:2.9.1-6.el7.4")
        assert 0 == rpm.version_cmp("3:2.9.1-6.el7.4", "3:2.9.1-6.el7.4")
        assert -1 == rpm.version_cmp("3:2.9.1-6.el7.4", "3:2.9.1-7.el7.4")
        assert 1 == rpm.version_cmp("3:2.9.1-8.el7.4", "3:2.9.1-7.el7.4")
Exemple #9
0
    def test_version_cmp_rpmutils(self, mock_log, mock_rpmUtils):
        """
        Test package version if rpmUtils.miscutils called

        :return:
        """
        mock_rpmUtils.miscutils = MagicMock()
        mock_rpmUtils.miscutils.compareEVR = MagicMock(return_value=-1)
        self.assertEqual(-1, rpm.version_cmp("1", "2"))
        self.assertEqual(mock_log.warning.called, True)
        self.assertEqual(mock_rpmUtils.miscutils.compareEVR.called, True)
        self.assertEqual(
            mock_log.warning.mock_calls[0][1][0],
            "Please install a package that provides rpm.labelCompare for more accurate version comparisons.",
        )
def test_version_cmp_rpm():
    """
    Test package version if RPM-Python is installed

    :return:
    """
    mock_label = MagicMock(return_value=-1)
    mock_log = MagicMock()
    patch_label = patch("salt.modules.rpm_lowpkg.rpm.labelCompare", mock_label)
    patch_log = patch("salt.modules.rpm_lowpkg.log", mock_log)
    patch_rpm = patch("salt.modules.rpm_lowpkg.HAS_RPM", True)
    with patch_label, patch_rpm, patch_log:
        assert -1 == rpm.version_cmp("1", "2")
        assert not mock_log.warning.called
        assert mock_label.called
Exemple #11
0
    def test_version_cmp_python(self, mock_log, mock_which, mock_version_cmp):
        """
        Test package version if falling back to python

        :return:
        """
        self.assertEqual(-1, rpm.version_cmp("1", "2"))
        self.assertEqual(mock_version_cmp.called, True)
        self.assertEqual(mock_log.warning.called, True)
        self.assertEqual(
            mock_log.warning.mock_calls[0][1][0],
            "Please install a package that provides rpm.labelCompare for more accurate version comparisons.",
        )
        self.assertEqual(
            mock_log.warning.mock_calls[1][1][0],
            "Falling back on salt.utils.versions.version_cmp() for version comparisons",
        )
Exemple #12
0
    def test_version_cmp_rpmdev_vercmp(self, mock_log, mock_which):
        """
        Test package version if rpmdev-vercmp is installed

        :return:
        """
        mock__salt__ = MagicMock(return_value={"retcode": 12})
        with patch.dict(rpm.__salt__, {"cmd.run_all": mock__salt__}):
            self.assertEqual(-1, rpm.version_cmp("1", "2"))
            self.assertEqual(mock__salt__.called, True)
            self.assertEqual(mock_log.warning.called, True)
            self.assertEqual(
                mock_log.warning.mock_calls[0][1][0],
                "Please install a package that provides rpm.labelCompare for more accurate version comparisons.",
            )
            self.assertEqual(
                mock_log.warning.mock_calls[1][1][0],
                "Installing the rpmdevtools package may surface dev tools in production.",
            )
def test_version_cmp_rpmutils():
    """
    Test package version if rpmUtils.miscutils called

    :return:
    """
    mock_log = MagicMock()
    mock_rpmUtils = MagicMock()
    mock_rpmUtils.miscutils = MagicMock()
    mock_rpmUtils.miscutils.compareEVR = MagicMock(return_value=-1)
    patch_utils = patch("salt.modules.rpm_lowpkg.rpmUtils",
                        mock_rpmUtils,
                        create=True)
    patch_rpm = patch("salt.modules.rpm_lowpkg.HAS_RPM", False)
    patch_utils_lib = patch("salt.modules.rpm_lowpkg.HAS_RPMUTILS", True)
    patch_py_rpm = patch("salt.modules.rpm_lowpkg.HAS_PY_RPM", False)
    patch_log = patch("salt.modules.rpm_lowpkg.log", mock_log)

    with patch_utils, patch_rpm, patch_py_rpm, patch_utils_lib, patch_log:
        assert -1 == rpm.version_cmp("1", "2")
        assert mock_log.warning.called
        assert mock_rpmUtils.miscutils.compareEVR.called