File allow-vendor-change-option-with-zypper.patch of Package salt

Overview Repositories Revisions Requests Users Attributes Meta

File allow-vendor-change-option-with-zypper.patch of Package salt (Revision c0a8c8bf8ca50436255c651c6057120d)

Currently displaying revision c0a8c8bf8ca50436255c651c6057120d , Show latest

From a36d6524e530eca32966f46597c88dbfd4b90e78 Mon Sep 17 00:00:00 2001
From: Martin Seidl <mseidl@suse.de>
Date: Tue, 27 Oct 2020 16:12:29 +0100
Subject: [PATCH] Allow vendor change option with zypper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix novendorchange option (#284)

* Fixed novendorchange handling in zypperpkg

* refactor handling of novendorchange and fix tests

add patch support for allow vendor change option with zypper

Revert "add patch support for allow vendor change option with zypper"

This reverts commit cee4cc182b4740c912861c712dea7bc44eb70ffb.

Allow vendor change option with zypper (#313)

* add patch support for allow vendor change option with zypper

* adjust unit tests vendor change refactor, dropping cli arg

* Fix pr issues

Co-authored-by: Pablo Suárez Hernández <psuarezhernandez@suse.com>

* Fix unit test for allow vendor change on upgrade

* Add unit test with unsupported zypper version

Co-authored-by: Pablo Suárez Hernández <psuarezhernandez@suse.com>

Move vendor change logic to zypper class (#355)

* move vendor change logic to zypper class

* fix thing in zypperkg

* refactor unit tests

* Fix for syntax error

* Fix mocking issue in unit test

* fix issues with pr

* Fix for zypperpkg unit test after refactor of vendorchangeflags

Co-authored-by: Pablo Suárez Hernández <psuarezhernandez@suse.com>

* fix docs for vendor change options

* Fix doc strings, and clean up tests

Co-authored-by: Jochen Breuer <jbreuer@suse.de>
Co-authored-by: Pablo Suárez Hernández <psuarezhernandez@suse.com>
---
 salt/modules/zypperpkg.py            | 105 ++++--
 tests/unit/modules/test_zypperpkg.py | 532 ++++++++++++++++++++++++++-
 2 files changed, 612 insertions(+), 25 deletions(-)

diff --git a/salt/modules/zypperpkg.py b/salt/modules/zypperpkg.py
index 4bb10f445a..2da470bea3 100644
--- a/salt/modules/zypperpkg.py
+++ b/salt/modules/zypperpkg.py
@@ -36,6 +36,8 @@ import salt.utils.stringutils
 import salt.utils.systemd
 import salt.utils.versions
 from salt.exceptions import CommandExecutionError, MinionError, SaltInvocationError
+
+# pylint: disable=import-error,redefined-builtin,no-name-in-module
 from salt.utils.versions import LooseVersion
 
 if salt.utils.files.is_fcntl_available():
@@ -140,6 +142,13 @@ class _Zypper:
         self.__systemd_scope = False
         self.__root = None
 
+        # Dist upgrade vendor change support (SLE12+)
+        self.dup_avc = False
+        # Install/Patch/Upgrade vendor change support (SLE15+)
+        self.inst_avc = False
+        # Flag if allow vendor change should be allowed
+        self.avc = False
+
         # Call status
         self.__called = False
 
@@ -184,6 +193,8 @@ class _Zypper:
             self.__no_raise = True
         elif item == "refreshable":
             self.__refresh = True
+        elif item == "allow_vendor_change":
+            return self.__allow_vendor_change
         elif item == "call":
             return self.__call
         else:
@@ -224,6 +235,33 @@ class _Zypper:
     def pid(self):
         return self.__call_result.get("pid", "")
 
+    def __allow_vendor_change(self, allowvendorchange, novendorchange):
+        if allowvendorchange or not novendorchange:
+            self.refresh_zypper_flags()
+            if self.dup_avc or self.inst_avc:
+                log.info("Enabling vendor change")
+                self.avc = True
+            else:
+                log.warning(
+                    "Enabling/Disabling vendor changes is not supported on this Zypper version"
+                )
+        return self
+
+    def refresh_zypper_flags(self):
+        try:
+            zypp_version = version("zypper")
+            # zypper version 1.11.34 in SLE12 update supports vendor change for only dist upgrade
+            if version_cmp(zypp_version, "1.11.34") >= 0:
+                # zypper version supports vendor change for dist upgrade
+                self.dup_avc = True
+            # zypper version 1.14.8 in SLE15 update supports vendor change in install/patch/upgrading
+            if version_cmp(zypp_version, "1.14.8") >= 0:
+                self.inst_avc = True
+            else:
+                log.error("Failed to compare Zypper version")
+        except Exception as ex:
+            log.error("Unable to get Zypper version: {}".format(ex))
+
     def _is_error(self):
         """
         Is this is an error code?
@@ -362,6 +400,15 @@ class _Zypper:
             if self.__systemd_scope:
                 cmd.extend(["systemd-run", "--scope"])
             cmd.extend(self.__cmd)
+
+            if self.avc:
+                for i in ["install", "upgrade", "dist-upgrade"]:
+                    if i in cmd:
+                        if i == "install" and self.inst_avc:
+                            cmd.insert(cmd.index(i) + 1, "--allow-vendor-change")
+                        elif i in ["upgrade", "dist-upgrade"] and self.dup_avc:
+                            cmd.insert(cmd.index(i) + 1, "--allow-vendor-change")
+
             log.debug("Calling Zypper: %s", " ".join(cmd))
             self.__call_result = __salt__["cmd.run_all"](cmd, **kwargs)
             if self._check_result():
@@ -1490,6 +1537,8 @@ def install(
     no_recommends=False,
     root=None,
     inclusion_detection=False,
+    novendorchange=True,
+    allowvendorchange=False,
     **kwargs
 ):
     """
@@ -1537,6 +1586,13 @@ def install(
     skip_verify
         Skip the GPG verification check (e.g., ``--no-gpg-checks``)
 
+    novendorchange
+        DEPRECATED(use allowvendorchange): If set to True, do not allow vendor changes. Default: True
+
+    allowvendorchange
+        If set to True, vendor change is allowed. Default: False
+        If both allowvendorchange and novendorchange are passed, only allowvendorchange is used.
+
     version
         Can be either a version number, or the combination of a comparison
         operator (<, >, <=, >=, =) and a version number (ex. '>1.2.3-4').
@@ -1702,6 +1758,7 @@ def install(
     cmd_install.append(
         kwargs.get("resolve_capabilities") and "--capability" or "--name"
     )
+    # Install / patching / upgrade with vendor change support is only in SLE 15+  opensuse Leap 15+
 
     if not refresh:
         cmd_install.insert(0, "--no-refresh")
@@ -1738,6 +1795,7 @@ def install(
                 systemd_scope=systemd_scope,
                 root=root,
             )
+            .allow_vendor_change(allowvendorchange, novendorchange)
             .call(*cmd)
             .splitlines()
         ):
@@ -1750,7 +1808,9 @@ def install(
     while downgrades:
         cmd = cmd_install + ["--force"] + downgrades[:500]
         downgrades = downgrades[500:]
-        __zypper__(no_repo_failure=ignore_repo_failure, root=root).call(*cmd)
+        __zypper__(no_repo_failure=ignore_repo_failure, root=root).allow_vendor_change(
+            allowvendorchange, novendorchange
+        ).call(*cmd)
 
     _clean_cache()
     new = (
@@ -1783,7 +1843,8 @@ def upgrade(
     dryrun=False,
     dist_upgrade=False,
     fromrepo=None,
-    novendorchange=False,
+    novendorchange=True,
+    allowvendorchange=False,
     skip_verify=False,
     no_recommends=False,
     root=None,
@@ -1844,7 +1905,11 @@ def upgrade(
         Specify a list of package repositories to upgrade from. Default: None
 
     novendorchange
-        If set to True, no allow vendor changes. Default: False
+        DEPRECATED(use allowvendorchange): If set to True, do not allow vendor changes. Default: True
+
+    allowvendorchange
+        If set to True, vendor change is allowed. Default: False
+        If both allowvendorchange and novendorchange are passed, only allowvendorchange is used.
 
     skip_verify
         Skip the GPG verification check (e.g., ``--no-gpg-checks``)
@@ -1927,28 +1992,18 @@ def upgrade(
             cmd_update.extend(["--from" if dist_upgrade else "--repo", repo])
         log.info("Targeting repos: %s", fromrepo)
 
-    if dist_upgrade:
-        if novendorchange:
-            # TODO: Grains validation should be moved to Zypper class
-            if __grains__["osrelease_info"][0] > 11:
-                cmd_update.append("--no-allow-vendor-change")
-                log.info("Disabling vendor changes")
-            else:
-                log.warning(
-                    "Disabling vendor changes is not supported on this Zypper version"
-                )
+    if no_recommends:
+        cmd_update.append("--no-recommends")
+        log.info("Disabling recommendations")
 
-        if no_recommends:
-            cmd_update.append("--no-recommends")
-            log.info("Disabling recommendations")
+    if dryrun:
+        # Creates a solver test case for debugging.
+        log.info("Executing debugsolver and performing a dry-run dist-upgrade")
+        __zypper__(systemd_scope=_systemd_scope(), root=root).allow_vendor_change(
+            allowvendorchange, novendorchange
+        ).noraise.call(*cmd_update + ["--debug-solver"])
 
-        if dryrun:
-            # Creates a solver test case for debugging.
-            log.info("Executing debugsolver and performing a dry-run dist-upgrade")
-            __zypper__(systemd_scope=_systemd_scope(), root=root).noraise.call(
-                *cmd_update + ["--debug-solver"]
-            )
-    else:
+    if not dist_upgrade:
         if name or pkgs:
             try:
                 (pkg_params, _) = __salt__["pkg_resource.parse_targets"](
@@ -1962,7 +2017,9 @@ def upgrade(
 
     old = list_pkgs(root=root, attr=diff_attr)
 
-    __zypper__(systemd_scope=_systemd_scope(), root=root).noraise.call(*cmd_update)
+    __zypper__(systemd_scope=_systemd_scope(), root=root).allow_vendor_change(
+        allowvendorchange, novendorchange
+    ).noraise.call(*cmd_update)
     _clean_cache()
     new = list_pkgs(root=root, attr=diff_attr)
     ret = salt.utils.data.compare_dicts(old, new)
diff --git a/tests/unit/modules/test_zypperpkg.py b/tests/unit/modules/test_zypperpkg.py
index 5e4c967520..e85c93da3b 100644
--- a/tests/unit/modules/test_zypperpkg.py
+++ b/tests/unit/modules/test_zypperpkg.py
@@ -137,6 +137,7 @@ class ZypperTestCase(TestCase, LoaderModuleMockMixin):
 
         stdout_xml_snippet = '<?xml version="1.0"?><test foo="bar"/>'
         sniffer = RunSniffer(stdout=stdout_xml_snippet)
+        zypper.__zypper__._reset()
         with patch.dict("salt.modules.zypperpkg.__salt__", {"cmd.run_all": sniffer}):
             self.assertEqual(zypper.__zypper__.call("foo"), stdout_xml_snippet)
             self.assertEqual(len(sniffer.calls), 1)
@@ -628,13 +629,495 @@ class ZypperTestCase(TestCase, LoaderModuleMockMixin):
                 {"vim": "7.4.326-2.62", "fakepkg": ""},
             )
 
+    def test_upgrade_without_vendor_change(self):
+        """
+        Dist-upgrade without vendor change option.
+        """
+        with patch(
+            "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
+        ), patch(
+            "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
+        ):
+            with patch(
+                "salt.modules.zypperpkg.__zypper__.noraise.call", MagicMock()
+            ) as zypper_mock:
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.2"}]),
+                ):
+                    ret = zypper.upgrade(dist_upgrade=True)
+                    self.assertDictEqual(ret, {"vim": {"old": "1.1", "new": "1.2"}})
+                    zypper_mock.assert_any_call(
+                        "dist-upgrade", "--auto-agree-with-licenses",
+                    )
+
+    def test_refresh_zypper_flags(self):
+        zypper.__zypper__._reset()
+        with patch(
+            "salt.modules.zypperpkg.version", MagicMock(return_value="0.5")
+        ), patch.dict(
+            zypper.__salt__, {"lowpkg.version_cmp": MagicMock(side_effect=[-1, -1])}
+        ):
+            zypper.__zypper__.refresh_zypper_flags()
+            assert zypper.__zypper__.inst_avc == False
+            assert zypper.__zypper__.dup_avc == False
+        with patch(
+            "salt.modules.zypperpkg.version", MagicMock(return_value="1.11.34")
+        ), patch.dict(
+            zypper.__salt__, {"lowpkg.version_cmp": MagicMock(side_effect=[0, -1])}
+        ):
+            zypper.__zypper__.refresh_zypper_flags()
+            assert zypper.__zypper__.inst_avc == False
+            assert zypper.__zypper__.dup_avc == True
+        with patch(
+            "salt.modules.zypperpkg.version", MagicMock(return_value="1.14.8")
+        ), patch.dict(
+            zypper.__salt__, {"lowpkg.version_cmp": MagicMock(side_effect=[0, 0])}
+        ):
+            zypper.__zypper__.refresh_zypper_flags()
+            assert zypper.__zypper__.inst_avc == True
+            assert zypper.__zypper__.dup_avc == True
+
+    @patch("salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock())
+    def test_allow_vendor_change_function(self):
+        zypper.__zypper__._reset()
+        zypper.__zypper__.inst_avc = True
+        zypper.__zypper__.dup_avc = True
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(False, False)
+        assert zypper.__zypper__.avc == True
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(True, False)
+        assert zypper.__zypper__.avc == True
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(False, True)
+        assert zypper.__zypper__.avc == False
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(True, True)
+        assert zypper.__zypper__.avc == True
+
+        zypper.__zypper__._reset()
+        zypper.__zypper__.inst_avc = False
+        zypper.__zypper__.dup_avc = True
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(False, False)
+        assert zypper.__zypper__.avc == True
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(True, False)
+        assert zypper.__zypper__.avc == True
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(False, True)
+        assert zypper.__zypper__.avc == False
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(True, True)
+        assert zypper.__zypper__.avc == True
+
+        zypper.__zypper__._reset()
+        zypper.__zypper__.inst_avc = False
+        zypper.__zypper__.dup_avc = False
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(False, False)
+        assert zypper.__zypper__.avc == False
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(True, False)
+        assert zypper.__zypper__.avc == False
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(False, True)
+        assert zypper.__zypper__.avc == False
+        zypper.__zypper__.avc = False
+        zypper.__zypper__.allow_vendor_change(True, True)
+        assert zypper.__zypper__.avc == False
+
+    @patch(
+        "salt.utils.environment.get_module_environment",
+        MagicMock(return_value={"SALT_RUNNING": "1"}),
+    )
+    def test_zypper_call_dist_upgrade_with_avc_true(self):
+        cmd_run_mock = MagicMock(return_value={"retcode": 0, "stdout": None})
+        zypper.__zypper__._reset()
+        with patch.dict(zypper.__salt__, {"cmd.run_all": cmd_run_mock}), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ), patch("salt.modules.zypperpkg.__zypper__._reset", MagicMock()):
+            zypper.__zypper__.dup_avc = True
+            zypper.__zypper__.avc = True
+            zypper.__zypper__.call("dist-upgrade")
+            cmd_run_mock.assert_any_call(
+                [
+                    "zypper",
+                    "--non-interactive",
+                    "--no-refresh",
+                    "dist-upgrade",
+                    "--allow-vendor-change",
+                ],
+                output_loglevel="trace",
+                python_shell=False,
+                env={"SALT_RUNNING": "1"},
+            )
+
+    @patch(
+        "salt.utils.environment.get_module_environment",
+        MagicMock(return_value={"SALT_RUNNING": "1"}),
+    )
+    def test_zypper_call_dist_upgrade_with_avc_false(self):
+        cmd_run_mock = MagicMock(return_value={"retcode": 0, "stdout": None})
+        zypper.__zypper__._reset()
+        with patch.dict(zypper.__salt__, {"cmd.run_all": cmd_run_mock}), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ), patch("salt.modules.zypperpkg.__zypper__._reset", MagicMock()):
+            zypper.__zypper__.dup_avc = False
+            zypper.__zypper__.avc = False
+            zypper.__zypper__.call("dist-upgrade")
+            cmd_run_mock.assert_any_call(
+                ["zypper", "--non-interactive", "--no-refresh", "dist-upgrade",],
+                output_loglevel="trace",
+                python_shell=False,
+                env={"SALT_RUNNING": "1"},
+            )
+
+    @patch(
+        "salt.utils.environment.get_module_environment",
+        MagicMock(return_value={"SALT_RUNNING": "1"}),
+    )
+    def test_zypper_call_install_with_avc_true(self):
+        cmd_run_mock = MagicMock(return_value={"retcode": 0, "stdout": None})
+        zypper.__zypper__._reset()
+        with patch.dict(zypper.__salt__, {"cmd.run_all": cmd_run_mock}), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ), patch("salt.modules.zypperpkg.__zypper__._reset", MagicMock()):
+            zypper.__zypper__.inst_avc = True
+            zypper.__zypper__.avc = True
+            zypper.__zypper__.call("install")
+            cmd_run_mock.assert_any_call(
+                [
+                    "zypper",
+                    "--non-interactive",
+                    "--no-refresh",
+                    "install",
+                    "--allow-vendor-change",
+                ],
+                output_loglevel="trace",
+                python_shell=False,
+                env={"SALT_RUNNING": "1"},
+            )
+
+    @patch(
+        "salt.utils.environment.get_module_environment",
+        MagicMock(return_value={"SALT_RUNNING": "1"}),
+    )
+    def test_zypper_call_install_with_avc_false(self):
+        cmd_run_mock = MagicMock(return_value={"retcode": 0, "stdout": None})
+        zypper.__zypper__._reset()
+        with patch.dict(zypper.__salt__, {"cmd.run_all": cmd_run_mock}), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ), patch("salt.modules.zypperpkg.__zypper__._reset", MagicMock()):
+            zypper.__zypper__.inst_avc = False
+            zypper.__zypper__.dup_avc = True
+            zypper.__zypper__.avc = True
+            zypper.__zypper__.call("install")
+            cmd_run_mock.assert_any_call(
+                ["zypper", "--non-interactive", "--no-refresh", "install",],
+                output_loglevel="trace",
+                python_shell=False,
+                env={"SALT_RUNNING": "1"},
+            )
+
+    def test_upgrade_with_novendorchange_true(self):
+        """
+        Dist-upgrade without vendor change option.
+        """
+        zypper.__zypper__._reset()
+        with patch(
+            "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
+        ), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ) as refresh_flags_mock, patch(
+            "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
+        ):
+            with patch(
+                "salt.modules.zypperpkg.__zypper__.noraise.call", MagicMock()
+            ) as zypper_mock:
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.2"}]),
+                ):
+                    ret = zypper.upgrade(dist_upgrade=True, novendorchange=True)
+                    refresh_flags_mock.assert_not_called()
+                    zypper_mock.assert_any_call(
+                        "dist-upgrade", "--auto-agree-with-licenses",
+                    )
+
+    def test_upgrade_with_novendorchange_false(self):
+        """
+        Perform dist-upgrade with novendorchange set to False.
+        """
+        zypper.__zypper__._reset()
+        with patch(
+            "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
+        ), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ), patch(
+            "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
+        ):
+            with patch(
+                "salt.modules.zypperpkg.__zypper__.noraise.call", MagicMock()
+            ) as zypper_mock:
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+                ):
+                    zypper.__zypper__.inst_avc = True
+                    zypper.__zypper__.dup_avc = True
+                    with patch.dict(
+                        zypper.__salt__,
+                        {
+                            "pkg_resource.version": MagicMock(return_value="1.15"),
+                            "lowpkg.version_cmp": MagicMock(return_value=1),
+                        },
+                    ):
+                        ret = zypper.upgrade(
+                            dist_upgrade=True,
+                            dryrun=True,
+                            fromrepo=["Dummy", "Dummy2"],
+                            novendorchange=False,
+                        )
+                        assert zypper.__zypper__.avc == True
+
+    def test_upgrade_with_allowvendorchange_true(self):
+        """
+        Perform dist-upgrade with allowvendorchange set to True.
+        """
+        zypper.__zypper__._reset()
+        with patch(
+            "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
+        ), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ), patch(
+            "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
+        ):
+            with patch(
+                "salt.modules.zypperpkg.__zypper__.noraise.call", MagicMock()
+            ) as zypper_mock:
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+                ):
+                    with patch.dict(
+                        zypper.__salt__,
+                        {
+                            "pkg_resource.version": MagicMock(return_value="1.15"),
+                            "lowpkg.version_cmp": MagicMock(return_value=1),
+                        },
+                    ):
+
+                        zypper.__zypper__.inst_avc = True
+                        zypper.__zypper__.dup_avc = True
+                        ret = zypper.upgrade(
+                            dist_upgrade=True,
+                            dryrun=True,
+                            fromrepo=["Dummy", "Dummy2"],
+                            allowvendorchange=True,
+                        )
+                        assert zypper.__zypper__.avc == True
+
+    def test_upgrade_with_allowvendorchange_false(self):
+        """
+        Perform dist-upgrade with allowvendorchange set to False.
+        """
+        zypper.__zypper__._reset()
+        with patch(
+            "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
+        ), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ), patch(
+            "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
+        ):
+            with patch(
+                "salt.modules.zypperpkg.__zypper__.noraise.call", MagicMock()
+            ) as zypper_mock:
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+                ):
+                    with patch.dict(
+                        zypper.__salt__,
+                        {
+                            "pkg_resource.version": MagicMock(return_value="1.15"),
+                            "lowpkg.version_cmp": MagicMock(return_value=1),
+                        },
+                    ):
+
+                        zypper.__zypper__.inst_avc = True
+                        zypper.__zypper__.dup_avc = True
+                        ret = zypper.upgrade(
+                            dist_upgrade=True,
+                            dryrun=True,
+                            fromrepo=["Dummy", "Dummy2"],
+                            allowvendorchange=False,
+                        )
+                        assert zypper.__zypper__.avc == False
+
+    def test_upgrade_old_zypper(self):
+        zypper.__zypper__._reset()
+        with patch(
+            "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
+        ), patch(
+            "salt.modules.zypperpkg.__zypper__.refresh_zypper_flags", MagicMock()
+        ) as refresh_flags_mock, patch(
+            "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
+        ):
+            with patch(
+                "salt.modules.zypperpkg.__zypper__.noraise.call", MagicMock()
+            ) as zypper_mock:
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+                ):
+                    with patch.dict(
+                        zypper.__salt__,
+                        {
+                            "pkg_resource.version": MagicMock(return_value="1.11"),
+                            "lowpkg.version_cmp": MagicMock(return_value=-1),
+                        },
+                    ):
+                        zypper.__zypper__.inst_avc = False
+                        zypper.__zypper__.dup_avc = False
+                        ret = zypper.upgrade(
+                            dist_upgrade=True,
+                            dryrun=True,
+                            fromrepo=["Dummy", "Dummy2"],
+                            novendorchange=False,
+                        )
+                        zypper.__zypper__.avc = False
+
+    def test_upgrade_success(self):
+        """
+        Test system upgrade and dist-upgrade success.
+
+        :return:
+        """
+        with patch(
+            "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
+        ), patch(
+            "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
+        ):
+            with patch(
+                "salt.modules.zypperpkg.__zypper__.noraise.call", MagicMock()
+            ) as zypper_mock:
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.2"}]),
+                ):
+                    ret = zypper.upgrade()
+                    self.assertDictEqual(ret, {"vim": {"old": "1.1", "new": "1.2"}})
+                    zypper_mock.assert_any_call("update", "--auto-agree-with-licenses")
+
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(
+                        side_effect=[
+                            {"kernel-default": "1.1"},
+                            {"kernel-default": "1.1,1.2"},
+                        ]
+                    ),
+                ):
+                    ret = zypper.upgrade()
+                    self.assertDictEqual(
+                        ret, {"kernel-default": {"old": "1.1", "new": "1.1,1.2"}}
+                    )
+                    zypper_mock.assert_any_call("update", "--auto-agree-with-licenses")
+
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1,1.2"}]),
+                ):
+                    ret = zypper.upgrade()
+                    self.assertDictEqual(ret, {"vim": {"old": "1.1", "new": "1.1,1.2"}})
+                    zypper_mock.assert_any_call("update", "--auto-agree-with-licenses")
+
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+                ):
+                    ret = zypper.upgrade(dist_upgrade=True, dryrun=True)
+                    zypper_mock.assert_any_call(
+                        "dist-upgrade", "--auto-agree-with-licenses", "--dry-run"
+                    )
+                    zypper_mock.assert_any_call(
+                        "dist-upgrade",
+                        "--auto-agree-with-licenses",
+                        "--dry-run",
+                        "--debug-solver",
+                    )
+
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+                ):
+                    ret = zypper.upgrade(
+                        dist_upgrade=False, fromrepo=["Dummy", "Dummy2"], dryrun=False
+                    )
+                    zypper_mock.assert_any_call(
+                        "update",
+                        "--auto-agree-with-licenses",
+                        "--repo",
+                        "Dummy",
+                        "--repo",
+                        "Dummy2",
+                    )
+
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+                ):
+                    ret = zypper.upgrade(
+                        dist_upgrade=True,
+                        dryrun=True,
+                        fromrepo=["Dummy", "Dummy2"],
+                        novendorchange=True,
+                    )
+                    zypper_mock.assert_any_call(
+                        "dist-upgrade",
+                        "--auto-agree-with-licenses",
+                        "--dry-run",
+                        "--from",
+                        "Dummy",
+                        "--from",
+                        "Dummy2",
+                    )
+                    zypper_mock.assert_any_call(
+                        "dist-upgrade",
+                        "--auto-agree-with-licenses",
+                        "--dry-run",
+                        "--from",
+                        "Dummy",
+                        "--from",
+                        "Dummy2",
+                        "--debug-solver",
+                    )
+
+                with patch(
+                    "salt.modules.zypperpkg.list_pkgs",
+                    MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+                ):
+                    ret = zypper.upgrade(
+                        dist_upgrade=False, fromrepo=["Dummy", "Dummy2"], dryrun=False
+                    )
+                    zypper_mock.assert_any_call(
+                        "update",
+                        "--auto-agree-with-licenses",
+                        "--repo",
+                        "Dummy",
+                        "--repo",
+                        "Dummy2",
+                    )
+
     def test_upgrade_kernel(self):
         """
         Test kernel package upgrade success.
 
         :return:
         """
-        with patch.dict(zypper.__grains__, {"osrelease_info": [12, 1]}), patch(
+        with patch(
             "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
         ), patch(
             "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
@@ -672,6 +1155,53 @@ class ZypperTestCase(TestCase, LoaderModuleMockMixin):
                             },
                         )
 
+    def test_upgrade_failure(self):
+        """
+        Test system upgrade failure.
+
+        :return:
+        """
+        zypper_out = """
+Loading repository data...
+Reading installed packages...
+Computing distribution upgrade...
+Use 'zypper repos' to get the list of defined repositories.
+Repository 'DUMMY' not found by its alias, number, or URI.
+"""
+
+        class FailingZypperDummy:
+            def __init__(self):
+                self.stdout = zypper_out
+                self.stderr = ""
+                self.pid = 1234
+                self.exit_code = 555
+                self.noraise = MagicMock()
+                self.allow_vendor_change = self
+                self.SUCCESS_EXIT_CODES = [0]
+
+            def __call__(self, *args, **kwargs):
+                return self
+
+        with patch(
+            "salt.modules.zypperpkg.__zypper__", FailingZypperDummy()
+        ) as zypper_mock, patch(
+            "salt.modules.zypperpkg.refresh_db", MagicMock(return_value=True)
+        ), patch(
+            "salt.modules.zypperpkg._systemd_scope", MagicMock(return_value=False)
+        ):
+            zypper_mock.noraise.call = MagicMock()
+            with patch(
+                "salt.modules.zypperpkg.list_pkgs",
+                MagicMock(side_effect=[{"vim": "1.1"}, {"vim": "1.1"}]),
+            ):
+                with self.assertRaises(CommandExecutionError) as cmd_exc:
+                    ret = zypper.upgrade(dist_upgrade=True, fromrepo=["DUMMY"])
+                self.assertEqual(cmd_exc.exception.info["changes"], {})
+                self.assertEqual(cmd_exc.exception.info["result"]["stdout"], zypper_out)
+                zypper_mock.noraise.call.assert_called_with(
+                    "dist-upgrade", "--auto-agree-with-licenses", "--from", "DUMMY",
+                )
+
     def test_upgrade_available(self):
         """
         Test whether or not an upgrade is available for a given package.
-- 
2.39.2

Places

File allow-vendor-change-option-with-zypper.patch of Package salt (Revision c0a8c8bf8ca50436255c651c6057120d)

Places