# -*- coding: utf-8 -*-
'''
    :synopsis: Base class for kernelpkg modules
    :platform: Linux
    :maturity: develop
    versionadded:: 2018.3.0
'''
# pylint: disable=invalid-name,no-member

from __future__ import absolute_import, print_function, unicode_literals

# Salt testing libs
try:
    from tests.support.mock import MagicMock, patch
    from salt.exceptions import CommandExecutionError
except ImportError:
    pass


class KernelPkgTestCase(object):
    '''
    Test cases shared by all kernelpkg virtual modules
    '''

    def test_active(self):
        '''
        Test - Return return the active kernel version
        '''
        self.assertEqual(self._kernelpkg.active(), self.KERNEL_LIST[0])

    def test_latest_available_no_results(self):
        '''
        Test - Return the latest available kernel version
        '''
        mock = MagicMock(return_value='')
        with patch.dict(self._kernelpkg.__salt__, {'pkg.latest_version': mock}):
            with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[0]):
                self.assertEqual(self._kernelpkg.latest_available(), self.KERNEL_LIST[-1])

    def test_latest_available_at_latest(self):
        '''
        Test - Return the latest available kernel version
        '''
        mock = MagicMock(return_value=self.LATEST)
        with patch.dict(self._kernelpkg.__salt__, {'pkg.latest_version': mock}):
            with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[-1]):
                self.assertEqual(self._kernelpkg.latest_available(), self.KERNEL_LIST[-1])

    def test_latest_available_with_updates(self):
        '''
        Test - Return the latest available kernel version
        '''
        mock = MagicMock(return_value=self.LATEST)
        with patch.dict(self._kernelpkg.__salt__, {'pkg.latest_version': mock}):
            with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[0]):
                self.assertEqual(self._kernelpkg.latest_available(), self.KERNEL_LIST[-1])

    def test_latest_installed_with_updates(self):
        '''
        Test - Return the latest installed kernel version
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[0]):
            with patch.object(self._kernelpkg, 'list_installed', return_value=self.KERNEL_LIST):
                self.assertEqual(self._kernelpkg.latest_installed(), self.KERNEL_LIST[-1])

    def test_latest_installed_at_latest(self):
        '''
        Test - Return the latest installed kernel version
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[-1]):
            with patch.object(self._kernelpkg, 'list_installed', return_value=self.KERNEL_LIST):
                self.assertEqual(self._kernelpkg.latest_installed(), self.KERNEL_LIST[-1])

    def test_needs_reboot_with_update(self):
        '''
        Test - Return True if a new kernel is ready to be booted
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[0]):
            with patch.object(self._kernelpkg, 'latest_installed', return_value=self.KERNEL_LIST[1]):
                self.assertTrue(self._kernelpkg.needs_reboot())

    def test_needs_reboot_at_latest(self):
        '''
        Test - Return True if a new kernel is ready to be booted
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[1]):
            with patch.object(self._kernelpkg, 'latest_installed', return_value=self.KERNEL_LIST[1]):
                self.assertFalse(self._kernelpkg.needs_reboot())

    def test_needs_reboot_order_inverted(self):
        '''
        Test - Return True if a new kernel is ready to be booted
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[1]):
            with patch.object(self._kernelpkg, 'latest_installed', return_value=self.KERNEL_LIST[0]):
                self.assertFalse(self._kernelpkg.needs_reboot())

    def test_upgrade_not_needed_with_reboot(self):
        '''
        Test - Upgrade function when no upgrade is available and reboot has been requested
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[-1]):
            with patch.object(self._kernelpkg, 'list_installed', return_value=self.KERNEL_LIST):
                result = self._kernelpkg.upgrade(reboot=True)
                self.assertIn('upgrades', result)
                self.assertEqual(result['active'], self.KERNEL_LIST[-1])
                self.assertEqual(result['latest_installed'], self.KERNEL_LIST[-1])
                self.assertEqual(result['reboot_requested'], True)
                self.assertEqual(result['reboot_required'], False)
                self._kernelpkg.__salt__['system.reboot'].assert_not_called()

    def test_upgrade_not_needed_without_reboot(self):
        '''
        Test - Upgrade function when no upgrade is available and no reboot has been requested
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[-1]):
            with patch.object(self._kernelpkg, 'list_installed', return_value=self.KERNEL_LIST):
                result = self._kernelpkg.upgrade(reboot=False)
                self.assertIn('upgrades', result)
                self.assertEqual(result['active'], self.KERNEL_LIST[-1])
                self.assertEqual(result['latest_installed'], self.KERNEL_LIST[-1])
                self.assertEqual(result['reboot_requested'], False)
                self.assertEqual(result['reboot_required'], False)
                self._kernelpkg.__salt__['system.reboot'].assert_not_called()

    def test_upgrade_needed_with_reboot(self):
        '''
        Test - Upgrade function when an upgrade is available and reboot has been requested
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[0]):
            with patch.object(self._kernelpkg, 'list_installed', return_value=self.KERNEL_LIST):
                result = self._kernelpkg.upgrade(reboot=True)
                self.assertIn('upgrades', result)
                self.assertEqual(result['active'], self.KERNEL_LIST[0])
                self.assertEqual(result['latest_installed'], self.KERNEL_LIST[-1])
                self.assertEqual(result['reboot_requested'], True)
                self.assertEqual(result['reboot_required'], True)
                self.assert_called_once(self._kernelpkg.__salt__['system.reboot'])

    def test_upgrade_needed_without_reboot(self):
        '''
        Test - Upgrade function when an upgrade is available and no reboot has been requested
        '''
        with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[0]):
            with patch.object(self._kernelpkg, 'list_installed', return_value=self.KERNEL_LIST):
                result = self._kernelpkg.upgrade(reboot=False)
                self.assertIn('upgrades', result)
                self.assertEqual(result['active'], self.KERNEL_LIST[0])
                self.assertEqual(result['latest_installed'], self.KERNEL_LIST[-1])
                self.assertEqual(result['reboot_requested'], False)
                self.assertEqual(result['reboot_required'], True)
                self._kernelpkg.__salt__['system.reboot'].assert_not_called()

    def test_upgrade_available_true(self):
        '''
        Test - upgrade_available
        '''
        with patch.object(self._kernelpkg, 'latest_available', return_value=self.KERNEL_LIST[-1]):
            with patch.object(self._kernelpkg, 'latest_installed', return_value=self.KERNEL_LIST[0]):
                self.assertTrue(self._kernelpkg.upgrade_available())

    def test_upgrade_available_false(self):
        '''
        Test - upgrade_available
        '''
        with patch.object(self._kernelpkg, 'latest_available', return_value=self.KERNEL_LIST[-1]):
            with patch.object(self._kernelpkg, 'latest_installed', return_value=self.KERNEL_LIST[-1]):
                self.assertFalse(self._kernelpkg.upgrade_available())

    def test_upgrade_available_inverted(self):
        '''
        Test - upgrade_available
        '''
        with patch.object(self._kernelpkg, 'latest_available', return_value=self.KERNEL_LIST[0]):
            with patch.object(self._kernelpkg, 'latest_installed', return_value=self.KERNEL_LIST[-1]):
                self.assertFalse(self._kernelpkg.upgrade_available())

    def test_remove_active(self):
        '''
        Test - remove kernel package
        '''
        mock = MagicMock(return_value={'retcode': 0, 'stderr': []})
        with patch.dict(self._kernelpkg.__salt__, {'cmd.run_all': mock}):
            with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[-1]):
                with patch.object(self._kernelpkg, 'list_installed', return_value=self.KERNEL_LIST):
                    self.assertRaises(CommandExecutionError, self._kernelpkg.remove, release=self.KERNEL_LIST[-1])
                    self._kernelpkg.__salt__['cmd.run_all'].assert_not_called()

    def test_remove_invalid(self):
        '''
        Test - remove kernel package
        '''
        mock = MagicMock(return_value={'retcode': 0, 'stderr': []})
        with patch.dict(self._kernelpkg.__salt__, {'cmd.run_all': mock}):
            with patch.object(self._kernelpkg, 'active', return_value=self.KERNEL_LIST[-1]):
                with patch.object(self._kernelpkg, 'list_installed', return_value=self.KERNEL_LIST):
                    self.assertRaises(CommandExecutionError, self._kernelpkg.remove, release='invalid')
                    self._kernelpkg.__salt__['cmd.run_all'].assert_not_called()