Example #1
0
def test_pkg_install_rollback():
    """
    test pkg.install rolling back to a previous version
    """
    ret_reg = {"Nullsoft Install System": "3.03"}
    # The 2nd time it's run, pkg.list_pkgs uses with stringify
    se_list_pkgs = [{"nsis": ["3.03"]}, {"nsis": "3.02"}]
    with patch.object(
            win_pkg, "list_pkgs", side_effect=se_list_pkgs), patch.object(
                win_pkg, "_get_reg_software",
                return_value=ret_reg), patch.dict(win_pkg.__salt__, {
                    "cp.is_cached":
                    MagicMock(return_value=False)
                }), patch.dict(
                    win_pkg.__salt__,
                    {
                        "cp.cache_file":
                        MagicMock(return_value="C:\\fake\\path.exe")
                    },
                ), patch.dict(
                    win_pkg.__salt__,
                    {"cmd.run_all": MagicMock(return_value={"retcode": 0})}):
        expected = {"nsis": {"new": "3.02", "old": "3.03"}}
        result = win_pkg.install(name="nsis", version="3.02")
        assert expected == result
Example #2
0
def test_pkg_install_existing_with_version():
    """
    test pkg.install when the package is already installed
    A version is passed
    """
    ret_reg = {"Nullsoft Install System": "3.03"}
    # The 2nd time it's run, pkg.list_pkgs uses with stringify
    se_list_pkgs = {"nsis": ["3.03"]}
    with patch.object(
            win_pkg, "list_pkgs", return_value=se_list_pkgs), patch.object(
                win_pkg, "_get_reg_software",
                return_value=ret_reg), patch.dict(win_pkg.__salt__, {
                    "cp.is_cached":
                    MagicMock(return_value=False)
                }), patch.dict(
                    win_pkg.__salt__,
                    {
                        "cp.cache_file":
                        MagicMock(return_value="C:\\fake\\path.exe")
                    },
                ), patch.dict(
                    win_pkg.__salt__,
                    {"cmd.run_all": MagicMock(return_value={"retcode": 0})}):
        expected = {}
        result = win_pkg.install(name="nsis", version="3.03")
        assert expected == result
Example #3
0
 def test_pkg_install_rollback(self):
     '''
     test pkg.install rolling back to a previous version
     '''
     ret_reg = {'Nullsoft Install System': '3.03'}
     # The 2nd time it's run, pkg.list_pkgs uses with stringify
     se_list_pkgs = [{'nsis': ['3.03']},
                     {'nsis': '3.02'}]
     with patch.object(win_pkg, 'list_pkgs', side_effect=se_list_pkgs), \
             patch.object(
                 win_pkg, '_get_reg_software', return_value=ret_reg), \
             patch.dict(
                 win_pkg.__salt__,
                 {'cp.is_cached': MagicMock(return_value=False)}), \
             patch.dict(
                 win_pkg.__salt__,
                 {'cp.cache_file':
                      MagicMock(return_value='C:\\fake\\path.exe')}), \
             patch.dict(
                 win_pkg.__salt__,
                 {'cmd.run_all':
                      MagicMock(return_value={'retcode': 0})}):
         expected = {'nsis': {'new': '3.02', 'old': '3.03'}}
         result = win_pkg.install(name='nsis', version='3.02')
         self.assertDictEqual(expected, result)
Example #4
0
 def test_pkg_install_existing_with_version(self):
     '''
     test pkg.install when the package is already installed
     A version is passed
     '''
     ret_reg = {'Nullsoft Install System': '3.03'}
     # The 2nd time it's run, pkg.list_pkgs uses with stringify
     se_list_pkgs = {'nsis': ['3.03']}
     with patch.object(win_pkg, 'list_pkgs', return_value=se_list_pkgs), \
             patch.object(
                 win_pkg, '_get_reg_software', return_value=ret_reg), \
             patch.dict(
                 win_pkg.__salt__,
                 {'cp.is_cached': MagicMock(return_value=False)}), \
             patch.dict(
                 win_pkg.__salt__,
                 {'cp.cache_file':
                      MagicMock(return_value='C:\\fake\\path.exe')}), \
             patch.dict(
                 win_pkg.__salt__,
                 {'cmd.run_all':
                      MagicMock(return_value={'retcode': 0})}):
         expected = {}
         result = win_pkg.install(name='nsis', version='3.03')
         self.assertDictEqual(expected, result)
Example #5
0
    def test_pkg_install_multiple_pkgs(self):
        '''
        test pkg.install pkg with extra_install_flags
        '''
        ret__get_package_info = {
            '3.03': {
                'uninstaller': '%program.exe',
                'reboot': False,
                'msiexec': False,
                'installer': 'runme.exe',
                'uninstall_flags': '/S',
                'locale': 'en_US',
                'install_flags': '/s',
                'full_name': 'Firebox 3.03 (x86 en-US)'
            }
        }

        mock_cmd_run_all = MagicMock(return_value={'retcode': 0})
        with patch.object(salt.utils.data, 'is_true', MagicMock(return_value=True)), \
             patch.object(win_pkg, '_get_package_info', MagicMock(return_value=ret__get_package_info)), \
             patch.dict(win_pkg.__salt__, {'pkg_resource.parse_targets':
                                               MagicMock(return_value=[{'firebox': '3.03', 'got': '3.03'}, None]),
                                           'cp.is_cached':
                                               MagicMock(return_value='C:\\fake\\path.exe'),
                                           'cmd.run_all': mock_cmd_run_all}):
            ret = win_pkg.install(
                pkgs=['firebox', 'got'],
                extra_install_flags='-e True -test_flag True')
            self.assertFalse('-e True -test_flag True' in str(
                mock_cmd_run_all.call_args[0]))
Example #6
0
 def test_pkg_install_not_found(self):
     '''
     Test pkg.install when the Version is NOT FOUND in the Software
     Definition
     '''
     ret_reg = {'Nullsoft Install System': '3.03'}
     # The 2nd time it's run with stringify
     se_list_pkgs = {'nsis': ['3.03']}
     with patch.object(win_pkg, 'list_pkgs', return_value=se_list_pkgs), \
             patch.object(win_pkg, '_get_reg_software', return_value=ret_reg):
         expected = {'nsis': {'not found': '3.01'}}
         result = win_pkg.install(name='nsis', version='3.01')
         self.assertDictEqual(expected, result)
Example #7
0
def test_pkg_install_not_found():
    """
    Test pkg.install when the Version is NOT FOUND in the Software
    Definition
    """
    ret_reg = {"Nullsoft Install System": "3.03"}
    # The 2nd time it's run with stringify
    se_list_pkgs = {"nsis": ["3.03"]}
    with patch.object(win_pkg, "list_pkgs",
                      return_value=se_list_pkgs), patch.object(
                          win_pkg, "_get_reg_software", return_value=ret_reg):
        expected = {"nsis": {"not found": "3.01"}}
        result = win_pkg.install(name="nsis", version="3.01")
        assert expected == result
Example #8
0
def test_pkg_install_minion_error_https():
    """
    Test pkg.install when cp.cache_file encounters a minion error
    """
    ret__get_package_info = {
        "3.03": {
            "uninstaller": "%program.exe",
            "reboot": False,
            "msiexec": False,
            "installer": "https://repo.test.com/runme.exe",
            "uninstall_flags": "/S",
            "locale": "en_US",
            "install_flags": "/s",
            "full_name": "Firebox 3.03 (x86 en-US)",
        }
    }

    err_msg = ("Error: [Errno 11001] getaddrinfo failed reading"
               " https://repo.test.com/runme.exe")
    mock_none = MagicMock(return_value=None)
    mock_minion_error = MagicMock(side_effect=MinionError(err_msg))
    mock_parse = MagicMock(return_value=[{"firebox": "3.03"}, None])
    with patch.object(
            salt.utils.data, "is_true",
            MagicMock(return_value=True)), patch.object(
                win_pkg, "_get_package_info",
                MagicMock(return_value=ret__get_package_info)), patch.dict(
                    win_pkg.__salt__,
                    {
                        "pkg_resource.parse_targets": mock_parse,
                        "cp.is_cached": mock_none,
                        "cp.cache_file": mock_minion_error,
                    },
                ):
        ret = win_pkg.install(
            name="firebox",
            version="3.03",
        )
        expected = (
            "Failed to cache https://repo.test.com/runme.exe\nError: [Errno 11001]"
            " getaddrinfo failed reading https://repo.test.com/runme.exe")

        assert ret == expected
Example #9
0
    def test_pkg_install_name(self):
        """
        test pkg.install name extra_install_flags
        """

        ret__get_package_info = {
            "3.03": {
                "uninstaller": "%program.exe",
                "reboot": False,
                "msiexec": False,
                "installer": "runme.exe",
                "uninstall_flags": "/S",
                "locale": "en_US",
                "install_flags": "/s",
                "full_name": "Firebox 3.03 (x86 en-US)",
            }
        }

        mock_cmd_run_all = MagicMock(return_value={"retcode": 0})
        with patch.object(
                salt.utils.data, "is_true",
                MagicMock(return_value=True)), patch.object(
                    win_pkg, "_get_package_info",
                    MagicMock(return_value=ret__get_package_info)), patch.dict(
                        win_pkg.__salt__,
                        {
                            "pkg_resource.parse_targets":
                            MagicMock(return_value=[{
                                "firebox": "3.03"
                            }, None]),
                            "cp.is_cached":
                            MagicMock(return_value="C:\\fake\\path.exe"),
                            "cmd.run_all":
                            mock_cmd_run_all,
                        },
                    ):
            ret = win_pkg.install(
                name="firebox",
                version="3.03",
                extra_install_flags="-e True -test_flag True",
            )
            self.assertTrue("-e True -test_flag True" in str(
                mock_cmd_run_all.call_args[0]))
Example #10
0
def test_pkg_install_minion_error_salt_cache_dir():
    """
    Test pkg.install when cp.cache_dir encounters a minion error
    """
    ret__get_package_info = {
        "3.03": {
            "uninstaller": "%program.exe",
            "reboot": False,
            "msiexec": False,
            "installer": "salt://software/runme.exe",
            "cache_dir": True,
            "uninstall_flags": "/S",
            "locale": "en_US",
            "install_flags": "/s",
            "full_name": "Firebox 3.03 (x86 en-US)",
        }
    }

    err_msg = "Error: [Errno 1] failed reading salt://software"
    mock_none = MagicMock(return_value=None)
    mock_minion_error = MagicMock(side_effect=MinionError(err_msg))
    mock_parse = MagicMock(return_value=[{"firebox": "3.03"}, None])
    with patch.object(
            salt.utils.data, "is_true",
            MagicMock(return_value=True)), patch.object(
                win_pkg, "_get_package_info",
                MagicMock(return_value=ret__get_package_info)), patch.dict(
                    win_pkg.__salt__,
                    {"cp.cache_dir": mock_minion_error},
                ):
        ret = win_pkg.install(
            name="firebox",
            version="3.03",
        )
        expected = ("Failed to cache salt://software\n"
                    "Error: [Errno 1] failed reading salt://software")

        assert ret == expected