mirror of
https://github.com/valitydev/salt.git
synced 2024-11-07 08:58:59 +00:00
409 lines
13 KiB
Python
409 lines
13 KiB
Python
# -*- 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()}
|
|
self.cmdrun = parted.__salt__['cmd.run']
|
|
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.called_once_with(
|
|
['partprobe'], python_shell=False)
|
|
|
|
def test_probe_w_single_arg(self):
|
|
parted.probe("/dev/sda")
|
|
self.cmdrun.called_once_with(
|
|
['partprobe', '/dev/sda'], python_shell=False)
|
|
|
|
def test_probe_w_multiple_args(self):
|
|
parted.probe('/dev/sda', '/dev/sdb')
|
|
self.cmdrun.called_once_with(
|
|
['partprobe', '/dev/sda', '/dev/sdb'], python_shell=False)
|
|
|
|
@patch('salt.utils.kwargs_warn_until')
|
|
def test_probe_w_device_kwarg(self, *args, **kwargs):
|
|
parted.probe(device="/dev/sda")
|
|
parted.salt.utils.kwargs_warn_until.called_once_with({'device': '/dev/sda'})
|
|
self.cmdrun.called_once_with(['partprobe', '/dev/sda'], python_shell=False)
|
|
|
|
@patch('salt.utils.kwargs_warn_until')
|
|
def test_probe_w_device_kwarg_and_arg(self, *args, **kwargs):
|
|
'''device arg is concatanated with possitional args'''
|
|
parted.probe("/dev/sdb", device="/dev/sda")
|
|
parted.salt.utils.kwargs_warn_until.called_once_with({'device': '/dev/sda'})
|
|
self.cmdrun.called_once_with(
|
|
['partprobe', '/dev/sda', '/dev/sdb'], python_shell=False)
|
|
|
|
@patch('salt.utils.kwargs_warn_until')
|
|
def test_probe_w_extra_kwarg(self, *args, **kwargs):
|
|
self.assertRaises(TypeError, parted.probe, foo="bar")
|
|
parted.salt.utils.kwargs_warn_until.called_once_with({'device': '/dev/sda'})
|
|
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_.called_once_with("foo", "bar")
|
|
parted.salt.utils.warn_until.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_)
|
|
|
|
def test_list__empty_cmd_output(self):
|
|
self.cmdrun.return_value = self.parted_print_output('empty')
|
|
output = parted.list_('/dev/sda')
|
|
self.cmdrun.called_once_with(
|
|
['parted',
|
|
'-m',
|
|
'-s',
|
|
'/dev/sda'
|
|
'print']
|
|
)
|
|
expected = {'info': {}, 'partitions': {}}
|
|
self.assertEqual(output, expected)
|
|
|
|
def test_list__valid_unit_empty_cmd_output(self):
|
|
self.cmdrun.return_value = self.parted_print_output('empty')
|
|
output = parted.list_('/dev/sda', unit='s')
|
|
self.cmdrun.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)
|
|
|
|
def test_list__bad_header(self):
|
|
self.cmdrun.return_value = self.parted_print_output('bad_header')
|
|
self.assertRaises(CommandExecutionError, parted.list_, '/dev/sda')
|
|
self.cmdrun.called_once_with(
|
|
['parted',
|
|
'-m',
|
|
'-s',
|
|
'/dev/sda'
|
|
'print']
|
|
)
|
|
|
|
def test_list__bad_label_info(self):
|
|
self.cmdrun.return_value = self.parted_print_output('bad_label_info')
|
|
self.assertRaises(CommandExecutionError, parted.list_, '/dev/sda')
|
|
self.cmdrun.called_once_with(
|
|
['parted',
|
|
'-m',
|
|
'-s',
|
|
'/dev/sda'
|
|
'print']
|
|
)
|
|
|
|
def test_list__bad_partition(self):
|
|
self.cmdrun.return_value = self.parted_print_output('bad_partition')
|
|
self.assertRaises(CommandExecutionError, parted.list_, '/dev/sda')
|
|
self.cmdrun.called_once_with(
|
|
['parted',
|
|
'-m',
|
|
'-s',
|
|
'/dev/sda'
|
|
'print']
|
|
)
|
|
|
|
def test_list__valid_cmd_output(self):
|
|
self.cmdrun.return_value = self.parted_print_output('valid')
|
|
output = parted.list_('/dev/sda')
|
|
self.cmdrun.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)
|
|
|
|
def test_list__valid_unit_valid_cmd_output(self):
|
|
self.cmdrun.return_value = self.parted_print_output('valid')
|
|
output = parted.list_('/dev/sda', unit='s')
|
|
self.cmdrun.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)
|
|
|
|
def test_list__valid_legacy_cmd_output(self):
|
|
self.cmdrun.return_value = self.parted_print_output('valid_legacy')
|
|
output = parted.list_('/dev/sda')
|
|
self.cmdrun.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)
|
|
|
|
def test_list__valid_unit_valid_legacy_cmd_output(self):
|
|
self.cmdrun.return_value = self.parted_print_output('valid_legacy')
|
|
output = parted.list_('/dev/sda', unit='s')
|
|
self.cmdrun.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)
|