コード例 #1
0
    def test_upgrade_CommandExecutionError_Exception2(self):

        """ UT: nxos_upgrade module:upgrade method - raise CommandExecutionError exception #2 """

        for platform in self.platform_list:
            if platform.invalid_command:
                with patch.dict(
                    nxos_upgrade.__salt__,
                    {
                        "nxos.sendline": MagicMock(
                            side_effect=[
                                platform.show_install_all_impact,
                                CommandExecutionError(
                                    {
                                        "rejected_input": "invalid CLI command",
                                        "message": "CLI excution error",
                                        "code": "400",
                                        "cli_error": platform.invalid_command,
                                    }
                                ),
                            ]
                        )
                    },
                ):
                    result = nxos_upgrade.upgrade(
                        platform.nimage, platform.nkimage, issu=False
                    )
                    if platform.upgrade_required:
                        self.assert_platform_upgrade(result["error_data"], platform)
                        self.assert_platform_upgrade(
                            result["invalid_command"], platform
                        )
                        self.assert_platform_upgrade(not result["succeeded"], platform)
                    else:
                        self.assert_platform_upgrade(result["succeeded"], platform)
コード例 #2
0
    def test_upgrade_NxosError_Exception2(self):

        """ UT: nxos_upgrade module:upgrade method - raise NxosError exception #2 """

        for platform in self.platform_list:
            if platform.internal_server_error_500:
                with patch.dict(
                    nxos_upgrade.__salt__,
                    {
                        "nxos.sendline": MagicMock(
                            side_effect=[
                                platform.show_install_all_impact,
                                NxosError(
                                    "{'Error Message': 'Not Found', 'Code': 404}"
                                ),
                            ]
                        )
                    },
                ):
                    result = nxos_upgrade.upgrade(
                        platform.nimage, platform.nkimage, issu=False
                    )
                    if platform.upgrade_required:
                        self.assert_platform_upgrade(
                            result["upgrade_in_progress"], platform
                        )
                        self.assert_platform_upgrade(not result["succeeded"], platform)
                    else:
                        self.assert_platform_upgrade(
                            not result["upgrade_in_progress"], platform
                        )
                        self.assert_platform_upgrade(result["succeeded"], platform)
コード例 #3
0
    def test_upgrade_NxosError_Exception(self):
        """ UT: nxos_upgrade module:upgrade method - raise NxosError exception """

        for platform in self.platform_list:
            if platform.internal_server_error_500:
                with patch.dict(
                        nxos_upgrade.__salt__, {
                            'nxos.sendline':
                            MagicMock(side_effect=[
                                platform.show_install_all_impact,
                                NxosError(platform.internal_server_error_500)
                            ])
                        }):
                    result = nxos_upgrade.upgrade(platform.nimage,
                                                  platform.nkimage,
                                                  issu=False)
                    if platform.upgrade_required:
                        self.assert_platform_upgrade(
                            result['upgrade_in_progress'], platform)
                        self.assert_platform_upgrade(not result['succeeded'],
                                                     platform)
                    else:
                        self.assert_platform_upgrade(
                            not result['upgrade_in_progress'], platform)
                        self.assert_platform_upgrade(result['succeeded'],
                                                     platform)
コード例 #4
0
    def test_upgrade_install_all_disruptive(self):

        """ UT: nxos_upgrade module:upgrade method - install all disruptive """

        for platform in self.platform_list:
            if platform.show_install_all_impact:
                with patch.dict(
                    nxos_upgrade.__salt__,
                    {
                        "nxos.sendline": MagicMock(
                            side_effect=[
                                platform.show_install_all_impact,
                                platform.install_all_disruptive_success,
                            ]
                        )
                    },
                ):
                    result = nxos_upgrade.upgrade(
                        platform.nimage, platform.nkimage, issu=False
                    )
                    self.assert_platform_upgrade(not result["error_data"], platform)
                    if platform.upgrade_required:
                        self.assert_platform_upgrade(
                            result["upgrade_in_progress"], platform
                        )
                    else:
                        self.assert_platform_upgrade(
                            not result["upgrade_in_progress"], platform
                        )
コード例 #5
0
    def test_upgrade_CommandExecutionError_Exception2(self):
        """ UT: nxos_upgrade module:upgrade method - raise CommandExecutionError exception #2 """

        for platform in self.platform_list:
            if platform.invalid_command:
                with patch.dict(
                        nxos_upgrade.__salt__,
                    {
                        'nxos.sendline':
                        MagicMock(side_effect=[
                            platform.show_install_all_impact,
                            CommandExecutionError(
                                {
                                    'rejected_input': 'invalid CLI command',
                                    'message': 'CLI excution error',
                                    'code': '400',
                                    'cli_error': platform.invalid_command
                                })
                        ])
                    }):
                    result = nxos_upgrade.upgrade(platform.nimage,
                                                  platform.nkimage,
                                                  issu=False)
                    if platform.upgrade_required:
                        self.assert_platform_upgrade(result['error_data'],
                                                     platform)
                        self.assert_platform_upgrade(result['invalid_command'],
                                                     platform)
                        self.assert_platform_upgrade(not result['succeeded'],
                                                     platform)
                    else:
                        self.assert_platform_upgrade(result['succeeded'],
                                                     platform)
コード例 #6
0
    def test_upgrade_invalid_command(self):

        """ UT: nxos_upgrade module:upgrade method - invalid command """

        for platform in self.platform_list:
            if platform.invalid_command:
                with patch.dict(
                    nxos_upgrade.__salt__,
                    {"nxos.sendline": MagicMock(return_value=platform.invalid_command)},
                ):
                    result = nxos_upgrade.upgrade(platform.nimage, platform.nkimage)
                    self.assert_platform_upgrade(result["error_data"], platform)
                    self.assert_platform_upgrade(not result["succeeded"], platform)
コード例 #7
0
    def test_upgrade_install_in_progress_sans_terminal_dont_ask(self):

        """ UT: nxos_upgrade module:upgrade method - in-progress (sans terminal don't-ask) """

        for platform in self.platform_list:
            if platform.invalid_command:
                with patch.dict(
                    nxos_upgrade.__salt__,
                    {
                        "nxos.sendline": MagicMock(
                            return_value=[platform.show_install_all_impact_in_progress]
                        )
                    },
                ):
                    result = nxos_upgrade.upgrade(platform.nimage, platform.nkimage)
                    self.assert_platform_upgrade(result["error_data"], platform)
                    self.assert_platform_upgrade(not result["succeeded"], platform)
コード例 #8
0
    def test_upgrade_install_in_progress(self):

        """ UT: nxos_upgrade module:upgrade method - in-progress """

        for platform in self.platform_list:
            if platform.show_install_all_impact_in_progress:
                with patch.dict(
                    nxos_upgrade.__salt__,
                    {
                        "nxos.sendline": MagicMock(
                            return_value=platform.show_install_all_impact_in_progress
                        )
                    },
                ):
                    result = nxos_upgrade.upgrade(platform.nimage, platform.nkimage)
                    self.assert_platform_upgrade(result["error_data"], platform)
                    self.assert_platform_upgrade(not result["succeeded"], platform)
コード例 #9
0
    def test_upgrade_show_install_all_impact_no_module_data(self):
        """ UT: nxos_upgrade module: upgrade method - no module data """

        for platform in self.platform_list:
            if platform.show_install_all_impact_no_module_data:
                with patch.dict(
                        nxos_upgrade.__salt__, {
                            'nxos.sendline':
                            MagicMock(return_value=platform.
                                      show_install_all_impact_no_module_data)
                        }):
                    result = nxos_upgrade.upgrade(platform.nimage, issu=False)
                    self.assert_platform_upgrade(not result['succeeded'],
                                                 platform)
                    self.assert_platform_upgrade(
                        result['error_data'] == result['upgrade_data'],
                        platform)
コード例 #10
0
    def test_upgrade_internal_server_error_500(self):
        """ UT: nxos_upgrade module:upgrade method - internal server error 500 """

        for platform in self.platform_list:
            if platform.backend_processing_error_500:
                with patch.dict(
                        nxos_upgrade.__salt__,
                    {
                        'nxos.sendline':
                        MagicMock(
                            return_value=platform.internal_server_error_500)
                    }):
                    result = nxos_upgrade.upgrade(platform.nimage)
                    self.assert_platform_upgrade(result['error_data'],
                                                 platform)
                    self.assert_platform_upgrade(
                        result['backend_processing_error'], platform)
                    self.assert_platform_upgrade(not result['succeeded'],
                                                 platform)
コード例 #11
0
    def test_upgrade_install_all_non_disruptive(self):
        """ UT: nxos_upgrade module:upgrade method - install all non-disruptive """

        for platform in self.platform_list:
            if platform.show_install_all_impact_non_disruptive:
                with patch.dict(
                        nxos_upgrade.__salt__,
                    {
                        'nxos.sendline':
                        MagicMock(side_effect=[
                            platform.show_install_all_impact_non_disruptive,
                            platform.install_all_non_disruptive_success
                        ])
                    }):
                    result = nxos_upgrade.upgrade(platform.nimage,
                                                  platform.nkimage,
                                                  issu=True)
                    self.assert_platform_upgrade(not result['error_data'],
                                                 platform)
                    self.assert_platform_upgrade(result['succeeded'], platform)
コード例 #12
0
    def test_upgrade_input_validation():

        """ UT: nxos_upgrade module:upgrade method - input validation """

        result = nxos_upgrade.upgrade("dummy-platform-image.bin", issu=1)
        assert "Input Error" in result