salt/tests/unit/modules/parted_test.py

# -*- coding: utf-8 -*-
'''
    :codeauthor: :email:`Dave Rawks (dave@pandora.com)`


    tests.unit.modules.parted_test
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'''

# Import Salt Testing libs
from salttesting import skipIf, TestCase
from salttesting.helpers import ensure_in_syspath
from salttesting.mock import NO_MOCK, NO_MOCK_REASON, MagicMock, patch
ensure_in_syspath('../../')

# Import salt libs
from salt.exceptions import CommandExecutionError
from salt.modules import parted


@skipIf(NO_MOCK, NO_MOCK_REASON)
class PartedTestCase(TestCase):

    # Setup for each test function.

    def setUp(self):
        parted.__salt__ = {
            'cmd.run': MagicMock(),
            'cmd.run_stdout': MagicMock(),
        }
        self.cmdrun = parted.__salt__['cmd.run']
        self.cmdrun_stdout = parted.__salt__['cmd.run_stdout']
        self.maxDiff = None

    # Test __virtual__ function for module registration

    @patch('salt.utils.is_windows', lambda: True)
    def test_virtual_bails_on_windows(self):
        '''If running windows, __virtual__ shouldn't register module'''
        ret = parted.__virtual__()
        self.assertFalse(ret)

    @patch('salt.utils.which', lambda exe: not exe == "parted")
    def test_virtual_bails_without_parted(self):
        '''If parted not in PATH, __virtual__ shouldn't register module'''
        ret = parted.__virtual__()
        self.assertFalse(ret)

    @patch('salt.utils.which', lambda exe: not exe == "lsblk")
    def test_virtual_bails_without_lsblk(self):
        '''If lsblk not in PATH, __virtual__ shouldn't register module'''
        ret = parted.__virtual__()
        self.assertFalse(ret)

    @patch('salt.utils.which', lambda exe: not exe == "partprobe")
    def test_virtual_bails_without_partprobe(self):
        '''If partprobe not in PATH, __virtual__ shouldn't register module'''
        ret = parted.__virtual__()
        self.assertFalse(ret)

    @patch('salt.utils.is_windows', lambda: False)
    @patch('salt.utils.which',
           lambda exe: (
               exe == "parted"
               or
               exe == "lsblk"
               or
               exe == "partprobe"))
    def test_virtual(self):
        '''On expected platform with correct utils in PATH, register
        "partition" module'''
        ret = parted.__virtual__()
        expect = 'partition'
        self.assertEqual(ret, expect)

    # Test probe function

    def test_probe_wo_args(self):
        parted.probe()
        self.cmdrun.assert_called_once_with('partprobe -- ')

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_probe_w_single_arg(self):
        parted.probe("/dev/sda")
        self.cmdrun.assert_called_once_with('partprobe -- /dev/sda')

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_probe_w_multiple_args(self):
        parted.probe('/dev/sda', '/dev/sdb')
        self.cmdrun.assert_called_once_with('partprobe -- /dev/sda /dev/sdb')

    @staticmethod
    def check_kwargs_warn_until_devices(device_kwargs):
        def check_args(kwargs, version):
            assert kwargs == device_kwargs
            assert version == 'Beryllium'
        parted.salt.utils.kwargs_warn_until.side_effect = check_args

    @patch('salt.utils.kwargs_warn_until')
    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_probe_w_device_kwarg(self, *args, **kwargs):
        device_kwargs = {'device': '/dev/sda'}
        parted.probe(**device_kwargs)
        self.check_kwargs_warn_until_devices(device_kwargs)
        self.cmdrun.assert_called_once_with('partprobe -- /dev/sda')

    @patch('salt.utils.kwargs_warn_until')
    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_probe_w_device_kwarg_and_arg(self, *args, **kwargs):
        '''device arg is concatenated with positional args'''
        device_kwargs = {'device': '/dev/sda'}
        parted.probe("/dev/sdb", **device_kwargs)
        self.check_kwargs_warn_until_devices(device_kwargs)
        self.cmdrun.assert_called_once_with('partprobe -- /dev/sda /dev/sdb')

    @patch('salt.utils.kwargs_warn_until')
    def test_probe_w_extra_kwarg(self, *args, **kwargs):
        device_kwargs = {'foo': 'bar'}
        self.assertRaises(TypeError, parted.probe, **device_kwargs)
        self.check_kwargs_warn_until_devices(device_kwargs)
        self.assertFalse(self.cmdrun.called)

    # Test part_list function

    @patch('salt.modules.parted.list_')
    @patch('salt.utils.warn_until')
    def test_part_list(self, *args, **kwargs):
        '''Function should call new function and raise deprecation warning'''
        parted.part_list("foo", "bar")
        parted.list_.assert_called_once_with("foo", "bar")
        parted.salt.utils.warn_until.assert_called_once_with(
            'Beryllium',
            '''The \'part_list\' function has been deprecated in favor of
        \'list_\'. Please update your code and configs to reflect this.''')

    # Test _list function

    @staticmethod
    def parted_print_output(k):
        output = {
            "valid": (
                '''BYT;\n'''
                '''/dev/sda:4000GB:scsi:512:512:gpt:AMCC 9650SE-24M DISK:;\n'''
                '''1:17.4kB:150MB:150MB:ext3::boot;\n'''
                '''2:3921GB:4000GB:79.3GB:linux-swap(v1)::;\n'''
            ),
            "valid_legacy": (
                '''BYT;\n'''
                '''/dev/sda:4000GB:scsi:512:512:gpt:AMCC 9650SE-24M DISK;\n'''
                '''1:17.4kB:150MB:150MB:ext3::boot;\n'''
                '''2:3921GB:4000GB:79.3GB:linux-swap(v1)::;\n'''
            ),
            "empty": '',
            "bad_label_info": (
                '''BYT;\n'''
                '''badbadbadbad\n'''
                '''1:17.4kB:150MB:150MB:ext3::boot;\n'''
                '''2:3921GB:4000GB:79.3GB:linux-swap(v1)::;\n'''
            ),
            "bad_header": (
                '''badbadbadbad\n'''
                '''/dev/sda:4000GB:scsi:512:512:gpt:AMCC 9650SE-24M DISK:;\n'''
                '''1:17.4kB:150MB:150MB:ext3::boot;\n'''
                '''2:3921GB:4000GB:79.3GB:linux-swap(v1)::;\n'''
            ),
            "bad_partition": (
                '''BYT;\n'''
                '''/dev/sda:4000GB:scsi:512:512:gpt:AMCC 9650SE-24M DISK:;\n'''
                '''badbadbadbad\n'''
                '''2:3921GB:4000GB:79.3GB:linux-swap(v1)::;\n'''
            ),
        }
        return output[k]

    def test_list__without_device(self):
        self.assertRaises(TypeError, parted.list_)

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__empty_cmd_output(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('empty')
        output = parted.list_('/dev/sda')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda print')
        expected = {'info': {}, 'partitions': {}}
        self.assertEqual(output, expected)

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__valid_unit_empty_cmd_output(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('empty')
        output = parted.list_('/dev/sda', unit='s')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda unit s print')
        expected = {'info': {}, 'partitions': {}}
        self.assertEqual(output, expected)

    def test_list__invalid_unit(self):
        self.assertRaises(CommandExecutionError, parted.list_, '/dev/sda',
                          unit='badbadbad')
        self.assertFalse(self.cmdrun.called)

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__bad_header(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('bad_header')
        self.assertRaises(CommandExecutionError, parted.list_, '/dev/sda')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda print')

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__bad_label_info(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('bad_label_info')
        self.assertRaises(CommandExecutionError, parted.list_, '/dev/sda')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda print')

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__bad_partition(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('bad_partition')
        self.assertRaises(CommandExecutionError, parted.list_, '/dev/sda')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda print')

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__valid_cmd_output(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('valid')
        output = parted.list_('/dev/sda')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda print')
        expected = {
            'info': {
                'logical sector': '512',
                'physical sector': '512',
                'interface': 'scsi',
                'model': 'AMCC 9650SE-24M DISK',
                'disk': '/dev/sda',
                'disk flags': '',
                'partition table': 'gpt',
                'size': '4000GB'
            },
            'partitions': {
                '1': {
                    'end': '150MB',
                    'number': '1',
                    'start': '17.4kB',
                    'file system': '',
                    'flags': 'boot',
                    'type': 'ext3',
                    'size': '150MB'},
                '2': {
                    'end': '4000GB',
                    'number': '2',
                    'start': '3921GB',
                    'file system': '',
                    'flags': '',
                    'type': 'linux-swap(v1)',
                    'size': '79.3GB'
                }
            }
        }
        self.assertEqual(output, expected)

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__valid_unit_valid_cmd_output(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('valid')
        output = parted.list_('/dev/sda', unit='s')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda unit s print')
        expected = {
            'info': {
                'logical sector': '512',
                'physical sector': '512',
                'interface': 'scsi',
                'model': 'AMCC 9650SE-24M DISK',
                'disk': '/dev/sda',
                'disk flags': '',
                'partition table': 'gpt',
                'size': '4000GB'
            },
            'partitions': {
                '1': {
                    'end': '150MB',
                    'number': '1',
                    'start': '17.4kB',
                    'file system': '',
                    'flags': 'boot',
                    'type': 'ext3',
                    'size': '150MB'},
                '2': {
                    'end': '4000GB',
                    'number': '2',
                    'start': '3921GB',
                    'file system': '',
                    'flags': '',
                    'type': 'linux-swap(v1)',
                    'size': '79.3GB'
                }
            }
        }
        self.assertEqual(output, expected)

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__valid_legacy_cmd_output(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('valid_legacy')
        output = parted.list_('/dev/sda')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda print')
        expected = {
            'info': {
                'logical sector': '512',
                'physical sector': '512',
                'interface': 'scsi',
                'model': 'AMCC 9650SE-24M DISK',
                'disk': '/dev/sda',
                'partition table': 'gpt',
                'size': '4000GB'
            },
            'partitions': {
                '1': {
                    'end': '150MB',
                    'number': '1',
                    'start': '17.4kB',
                    'file system': '',
                    'flags': 'boot',
                    'type': 'ext3',
                    'size': '150MB'},
                '2': {
                    'end': '4000GB',
                    'number': '2',
                    'start': '3921GB',
                    'file system': '',
                    'flags': '',
                    'type': 'linux-swap(v1)',
                    'size': '79.3GB'
                }
            }
        }
        self.assertEqual(output, expected)

    @patch('salt.modules.parted._validate_device', MagicMock())
    def test_list__valid_unit_valid_legacy_cmd_output(self):
        self.cmdrun_stdout.return_value = self.parted_print_output('valid_legacy')
        output = parted.list_('/dev/sda', unit='s')
        self.cmdrun_stdout.assert_called_once_with('parted -m -s /dev/sda unit s print')
        expected = {
            'info': {
                'logical sector': '512',
                'physical sector': '512',
                'interface': 'scsi',
                'model': 'AMCC 9650SE-24M DISK',
                'disk': '/dev/sda',
                'partition table': 'gpt',
                'size': '4000GB'
            },
            'partitions': {
                '1': {
                    'end': '150MB',
                    'number': '1',
                    'start': '17.4kB',
                    'file system': '',
                    'flags': 'boot',
                    'type': 'ext3',
                    'size': '150MB'},
                '2': {
                    'end': '4000GB',
                    'number': '2',
                    'start': '3921GB',
                    'file system': '',
                    'flags': '',
                    'type': 'linux-swap(v1)',
                    'size': '79.3GB'
                }
            }
        }
        self.assertEqual(output, expected)


if __name__ == '__main__':
    from integration import run_tests
    run_tests(PartedTestCase, needs_daemon=False)