def validate(self): components = self.validate_specfile() # Grab minion opts opts = copy.deepcopy(config.DEFAULT_MINION_OPTS) # Put in our opts opts['cachedir'] = os.path.join(self.root_dir, '.cache', 'master') opts['file_client'] = 'local' opts['file_roots'] = { 'base': [self.root_dir] } opts['renderer'] = config.DEFAULT_MASTER_OPTS['renderer'] opts['state_top'] = config.DEFAULT_MASTER_OPTS['state_top'] opts['id'] = 'test-master' core.__opts__ = opts grains = core.os_data() grains.update(EXTRA_GRAINS) opts['grains'] = grains self.highstate = CustomHighState(opts, self.default_pillar) for component in components: self.validate_component(component) return not self.errors
def test_gnu_slash_linux_in_os_name(self): ''' Test to return a list of all enabled services ''' _path_exists_map = {'/proc/1/cmdline': False} _path_isfile_map = {} _cmd_run_map = { 'dpkg --print-architecture': 'amd64', } path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x]) path_isfile_mock = MagicMock( side_effect=lambda x: _path_isfile_map.get(x, False)) cmd_run_mock = MagicMock(side_effect=lambda x: _cmd_run_map[x]) empty_mock = MagicMock(return_value={}) orig_import = __import__ if six.PY2: built_in = '__builtin__' else: built_in = 'builtins' def _import_mock(name, *args): if name == 'lsb_release': raise ImportError('No module named lsb_release') return orig_import(name, *args) # - Skip the first if statement # - Skip the selinux/systemd stuff (not pertinent) # - Skip the init grain compilation (not pertinent) # - Ensure that lsb_release fails to import # - Skip all the /etc/*-release stuff (not pertinent) # - Mock linux_distribution to give us the OS name that we want # - Make a bunch of functions return empty dicts, we don't care about # these grains for the purposes of this test. # - Mock the osarch distro_mock = MagicMock(return_value=('Debian GNU/Linux', '8.3', '')) with patch.object(salt.utils.platform, 'is_proxy', MagicMock(return_value=False)), \ patch.object(core, '_linux_bin_exists', MagicMock(return_value=False)), \ patch.object(os.path, 'exists', path_exists_mock), \ patch('{0}.__import__'.format(built_in), side_effect=_import_mock), \ patch.object(os.path, 'isfile', path_isfile_mock), \ patch.object(core, '_parse_lsb_release', empty_mock), \ patch.object(core, '_parse_os_release', empty_mock), \ patch.object(core, '_parse_lsb_release', empty_mock), \ patch.object(core, 'linux_distribution', distro_mock), \ patch.object(core, '_linux_cpudata', empty_mock), \ patch.object(core, '_linux_gpu_data', empty_mock), \ patch.object(core, '_memdata', empty_mock), \ patch.object(core, '_hw_data', empty_mock), \ patch.object(core, '_virtual', empty_mock), \ patch.object(core, '_ps', empty_mock), \ patch.dict(core.__salt__, {'cmd.run': cmd_run_mock}): os_grains = core.os_data() self.assertEqual(os_grains.get('os_family'), 'Debian')
def test_linux_memdata(self): ''' Test memdata on Linux systems ''' _path_exists_map = {'/proc/1/cmdline': False, '/proc/meminfo': True} _path_isfile_map = {'/proc/meminfo': True} _cmd_run_map = { 'dpkg --print-architecture': 'amd64', 'rpm --eval %{_host_cpu}': 'x86_64' } path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x]) path_isfile_mock = MagicMock( side_effect=lambda x: _path_isfile_map.get(x, False)) cmd_run_mock = MagicMock(side_effect=lambda x: _cmd_run_map[x]) empty_mock = MagicMock(return_value={}) _proc_meminfo = textwrap.dedent('''\ MemTotal: 16277028 kB SwapTotal: 4789244 kB''') orig_import = __import__ if six.PY2: built_in = '__builtin__' else: built_in = 'builtins' def _import_mock(name, *args): if name == 'lsb_release': raise ImportError('No module named lsb_release') return orig_import(name, *args) # Mock a bunch of stuff so we can isolate the mem stuff: # - Skip the first if statement # - Skip the init grain compilation (not pertinent) # - Ensure that lsb_release fails to import # - Skip all the /etc/*-release stuff (not pertinent) # - Make a bunch of functions return empty dicts, we don't care # about these grains for the purposes of this test. # - Mock the osarch # - And most importantly, mock the contents of /proc/meminfo with patch.object(salt.utils.platform, 'is_proxy', MagicMock(return_value=False)), \ patch.object(core, '_linux_bin_exists', MagicMock(return_value=False)), \ patch.object(os.path, 'exists', path_exists_mock), \ patch('{0}.__import__'.format(built_in), side_effect=_import_mock), \ patch.object(os.path, 'isfile', path_isfile_mock), \ patch.object(core, '_linux_cpudata', empty_mock), \ patch.object(core, '_linux_gpu_data', empty_mock), \ patch.object(core, '_hw_data', empty_mock), \ patch.object(core, '_virtual', empty_mock), \ patch.object(core, '_ps', empty_mock), \ patch.dict(core.__salt__, {'cmd.run': cmd_run_mock}), \ patch('salt.utils.files.fopen', mock_open(read_data=_proc_meminfo)): os_grains = core.os_data() self.assertEqual(os_grains.get('mem_total'), 15895) self.assertEqual(os_grains.get('swap_total'), 4676)
def _run_os_grains_tests(self, os_release_filename, os_release_map, expectation): path_isfile_mock = MagicMock(side_effect=lambda x: x in os_release_map.get('files', [])) empty_mock = MagicMock(return_value={}) osarch_mock = MagicMock(return_value="amd64") if os_release_filename: os_release_data = core._parse_os_release( os.path.join(OS_RELEASE_DIR, os_release_filename) ) else: os_release_data = os_release_map.get('os_release_file', {}) os_release_mock = MagicMock(return_value=os_release_data) orig_import = __import__ if six.PY2: built_in = '__builtin__' else: built_in = 'builtins' def _import_mock(name, *args): if name == 'lsb_release': raise ImportError('No module named lsb_release') return orig_import(name, *args) suse_release_file = os_release_map.get('suse_release_file') file_contents = {'/proc/1/cmdline': ''} if suse_release_file: file_contents['/etc/SuSE-release'] = suse_release_file # - Skip the first if statement # - Skip the selinux/systemd stuff (not pertinent) # - Skip the init grain compilation (not pertinent) # - Ensure that lsb_release fails to import # - Skip all the /etc/*-release stuff (not pertinent) # - Mock linux_distribution to give us the OS name that we want # - Mock the osarch distro_mock = MagicMock(return_value=os_release_map['linux_distribution']) with patch.object(salt.utils.platform, 'is_proxy', MagicMock(return_value=False)), \ patch.object(core, '_linux_bin_exists', MagicMock(return_value=False)), \ patch.object(os.path, 'exists', path_isfile_mock), \ patch('{0}.__import__'.format(built_in), side_effect=_import_mock), \ patch.object(os.path, 'isfile', path_isfile_mock), \ patch.object(core, '_parse_os_release', os_release_mock), \ patch.object(core, '_parse_lsb_release', empty_mock), \ patch('salt.utils.files.fopen', mock_open(read_data=file_contents)), \ patch.object(core, 'linux_distribution', distro_mock), \ patch.object(core, '_linux_gpu_data', empty_mock), \ patch.object(core, '_linux_cpudata', empty_mock), \ patch.object(core, '_virtual', empty_mock), \ patch.dict(core.__salt__, {'cmd.run': osarch_mock}): os_grains = core.os_data() grains = {k: v for k, v in os_grains.items() if k in set(["os", "os_family", "osfullname", "oscodename", "osfinger", "osrelease", "osrelease_info", "osmajorrelease"])} self.assertEqual(grains, expectation)
def test_bsd_memdata(self): ''' Test to memdata on *BSD systems ''' _path_exists_map = {} _path_isfile_map = {} _cmd_run_map = { 'freebsd-version -u': '10.3-RELEASE', '/sbin/sysctl -n hw.physmem': '2121781248', '/sbin/sysctl -n vm.swap_total': '419430400' } path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x]) path_isfile_mock = MagicMock( side_effect=lambda x: _path_isfile_map.get(x, False)) cmd_run_mock = MagicMock(side_effect=lambda x: _cmd_run_map[x]) empty_mock = MagicMock(return_value={}) mock_freebsd_uname = ( 'FreeBSD', 'freebsd10.3-hostname-8148', '10.3-RELEASE', 'FreeBSD 10.3-RELEASE #0 r297264: Fri Mar 25 02:10:02 UTC 2016 [email protected]:/usr/obj/usr/src/sys/GENERIC', 'amd64', 'amd64') with patch('platform.uname', MagicMock(return_value=mock_freebsd_uname)): with patch.object(salt.utils.platform, 'is_linux', MagicMock(return_value=False)): with patch.object(salt.utils.platform, 'is_freebsd', MagicMock(return_value=True)): # Skip the first if statement with patch.object(salt.utils.platform, 'is_proxy', MagicMock(return_value=False)): # Skip the init grain compilation (not pertinent) with patch.object(os.path, 'exists', path_exists_mock): with patch('salt.utils.path.which') as mock: mock.return_value = '/sbin/sysctl' # Make a bunch of functions return empty dicts, # we don't care about these grains for the # purposes of this test. with patch.object(core, '_bsd_cpudata', empty_mock): with patch.object(core, '_hw_data', empty_mock): with patch.object( core, '_virtual', empty_mock): with patch.object( core, '_ps', empty_mock): # Mock the osarch with patch.dict( core.__salt__, {'cmd.run': cmd_run_mock}): os_grains = core.os_data() self.assertEqual(os_grains.get('mem_total'), 2023) self.assertEqual(os_grains.get('swap_total'), 400)
def _run_suse_os_grains_tests(self, os_release_map): path_isfile_mock = MagicMock(side_effect=lambda x: x in os_release_map['files']) empty_mock = MagicMock(return_value={}) osarch_mock = MagicMock(return_value="amd64") os_release_mock = MagicMock(return_value=os_release_map.get('os_release_file')) orig_import = __import__ if six.PY2: built_in = '__builtin__' else: built_in = 'builtins' def _import_mock(name, *args): if name == 'lsb_release': raise ImportError('No module named lsb_release') return orig_import(name, *args) # Skip the first if statement with patch.object(salt.utils, 'is_proxy', MagicMock(return_value=False)): # Skip the selinux/systemd stuff (not pertinent) with patch.object(core, '_linux_bin_exists', MagicMock(return_value=False)): # Skip the init grain compilation (not pertinent) with patch.object(os.path, 'exists', path_isfile_mock): # Ensure that lsb_release fails to import with patch('{0}.__import__'.format(built_in), side_effect=_import_mock): # Skip all the /etc/*-release stuff (not pertinent) with patch.object(os.path, 'isfile', path_isfile_mock): with patch.object(core, '_parse_os_release', os_release_mock): # Mock platform.linux_distribution to give us the # OS name that we want. distro_mock = MagicMock( return_value=('SUSE test', 'version', 'arch') ) with patch("salt.utils.fopen", mock_open()) as suse_release_file: suse_release_file.return_value.__iter__.return_value = os_release_map.get('suse_release_file', '').splitlines() with patch.object(platform, 'linux_distribution', distro_mock): with patch.object(core, '_linux_gpu_data', empty_mock): with patch.object(core, '_linux_cpudata', empty_mock): with patch.object(core, '_virtual', empty_mock): # Mock the osarch with patch.dict(core.__salt__, {'cmd.run': osarch_mock}): os_grains = core.os_data() self.assertEqual(os_grains.get('os'), 'SUSE') self.assertEqual(os_grains.get('os_family'), 'Suse') self.assertEqual(os_grains.get('osfullname'), os_release_map['osfullname']) self.assertEqual(os_grains.get('oscodename'), os_release_map['oscodename']) self.assertEqual(os_grains.get('osrelease'), os_release_map['osrelease']) self.assertListEqual(list(os_grains.get('osrelease_info')), os_release_map['osrelease_info']) self.assertEqual(os_grains.get('osmajorrelease'), os_release_map['osmajorrelease'])
def _check_solaris_sparc_productname_grains(self, prtdata, expectation): ''' verify product grains on solaris sparc ''' import platform path_isfile_mock = MagicMock( side_effect=lambda x: x in ['/etc/release']) with salt.utils.files.fopen( os.path.join(OS_RELEASE_DIR, "solaris-11.3")) as os_release_file: os_release_content = os_release_file.readlines() uname_mock = MagicMock(return_value=('SunOS', 'testsystem', '5.11', '11.3', 'sunv4', 'sparc')) with patch.object(platform, 'uname', uname_mock), \ patch.object(salt.utils.platform, 'is_proxy', MagicMock(return_value=False)), \ patch.object(salt.utils.platform, 'is_linux', MagicMock(return_value=False)), \ patch.object(salt.utils.platform, 'is_windows', MagicMock(return_value=False)), \ patch.object(salt.utils.platform, 'is_smartos', MagicMock(return_value=False)), \ patch.object(salt.utils.path, 'which_bin', MagicMock(return_value=None)), \ patch.object(os.path, 'isfile', path_isfile_mock), \ patch('salt.utils.files.fopen', mock_open(read_data=os_release_content)) as os_release_file, \ patch.object(core, '_sunos_cpudata', MagicMock(return_value={ 'cpuarch': 'sparcv9', 'num_cpus': '1', 'cpu_model': 'MOCK_CPU_MODEL', 'cpu_flags': []})), \ patch.object(core, '_memdata', MagicMock(return_value={'mem_total': 16384})), \ patch.object(core, '_virtual', MagicMock(return_value={})), \ patch.object(core, '_ps', MagicMock(return_value={})), \ patch.object(salt.utils.path, 'which', MagicMock(return_value=True)), \ patch.dict(core.__salt__, {'cmd.run': MagicMock(return_value=prtdata)}): os_grains = core.os_data() grains = { k: v for k, v in os_grains.items() if k in set(['product', 'productname']) } self.assertEqual(grains, expectation)
def test_suse_os_from_cpe_data(self): ''' Test if 'os' grain is parsed from CPE_NAME of /etc/os-release ''' _path_exists_map = {'/proc/1/cmdline': False} _path_isfile_map = { '/etc/os-release': True, } _os_release_map = { 'NAME': 'SLES', 'VERSION': '12-SP1', 'VERSION_ID': '12.1', 'PRETTY_NAME': 'SUSE Linux Enterprise Server 12 SP1', 'ID': 'sles', 'ANSI_COLOR': '0;32', 'CPE_NAME': 'cpe:/o:suse:sles:12:sp1' } path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x]) path_isfile_mock = MagicMock( side_effect=lambda x: _path_isfile_map.get(x, False)) empty_mock = MagicMock(return_value={}) osarch_mock = MagicMock(return_value="amd64") os_release_mock = MagicMock(return_value=_os_release_map) orig_import = __import__ if six.PY2: built_in = '__builtin__' else: built_in = 'builtins' def _import_mock(name, *args): if name == 'lsb_release': raise ImportError('No module named lsb_release') return orig_import(name, *args) # Skip the first if statement with patch.object(salt.utils, 'is_proxy', MagicMock(return_value=False)): # Skip the selinux/systemd stuff (not pertinent) with patch.object(core, '_linux_bin_exists', MagicMock(return_value=False)): # Skip the init grain compilation (not pertinent) with patch.object(os.path, 'exists', path_exists_mock): # Ensure that lsb_release fails to import with patch('{0}.__import__'.format(built_in), side_effect=_import_mock): # Skip all the /etc/*-release stuff (not pertinent) with patch.object(os.path, 'isfile', path_isfile_mock): with patch.object(core, '_parse_os_release', os_release_mock): # Mock platform.linux_distribution to give us the # OS name that we want. distro_mock = MagicMock(return_value=( 'SUSE Linux Enterprise Server ', '12', 'x86_64')) with patch.object(platform, 'linux_distribution', distro_mock): with patch.object(core, '_linux_gpu_data', empty_mock): with patch.object( core, '_linux_cpudata', empty_mock): with patch.object( core, '_virtual', empty_mock): # Mock the osarch with patch.dict( core.__salt__, {'cmd.run': osarch_mock}): os_grains = core.os_data() self.assertEqual(os_grains.get('os_family'), 'Suse') self.assertEqual(os_grains.get('os'), 'SUSE')
def test_linux_memdata(self): ''' Test memdata on Linux systems ''' _path_exists_map = {'/proc/1/cmdline': False, '/proc/meminfo': True} _path_isfile_map = {'/proc/meminfo': True} _cmd_run_map = {'dpkg --print-architecture': 'amd64'} path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x]) path_isfile_mock = MagicMock( side_effect=lambda x: _path_isfile_map.get(x, False)) cmd_run_mock = MagicMock(side_effect=lambda x: _cmd_run_map[x]) empty_mock = MagicMock(return_value={}) _proc_meminfo_file = '''MemTotal: 16277028 kB SwapTotal: 4789244 kB''' orig_import = __import__ if six.PY2: built_in = '__builtin__' else: built_in = 'builtins' def _import_mock(name, *args): if name == 'lsb_release': raise ImportError('No module named lsb_release') return orig_import(name, *args) # Skip the first if statement with patch.object(salt.utils.platform, 'is_proxy', MagicMock(return_value=False)): # Skip the selinux/systemd stuff (not pertinent) with patch.object(core, '_linux_bin_exists', MagicMock(return_value=False)): # Skip the init grain compilation (not pertinent) with patch.object(os.path, 'exists', path_exists_mock): # Ensure that lsb_release fails to import with patch('{0}.__import__'.format(built_in), side_effect=_import_mock): # Skip all the /etc/*-release stuff (not pertinent) with patch.object(os.path, 'isfile', path_isfile_mock): # Make a bunch of functions return empty dicts, # we don't care about these grains for the # purposes of this test. with patch.object(core, '_linux_cpudata', empty_mock): with patch.object(core, '_linux_gpu_data', empty_mock): with patch('salt.utils.files.fopen', mock_open()) as _proc_meminfo: _proc_meminfo.return_value.__iter__.return_value = _proc_meminfo_file.splitlines( ) with patch.object( core, '_hw_data', empty_mock): with patch.object( core, '_virtual', empty_mock): with patch.object( core, '_ps', empty_mock): # Mock the osarch with patch.dict( core.__salt__, { 'cmd.run': cmd_run_mock }): os_grains = core.os_data( ) self.assertEqual(os_grains.get('mem_total'), 15895) self.assertEqual(os_grains.get('swap_total'), 4676)
def test_gnu_slash_linux_in_os_name(self): ''' Test to return a list of all enabled services ''' _path_exists_map = { '/proc/1/cmdline': False } _path_isfile_map = {} _cmd_run_map = { 'dpkg --print-architecture': 'amd64' } path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x]) path_isfile_mock = MagicMock( side_effect=lambda x: _path_isfile_map.get(x, False) ) cmd_run_mock = MagicMock( side_effect=lambda x: _cmd_run_map[x] ) empty_mock = MagicMock(return_value={}) orig_import = __import__ if six.PY2: built_in = '__builtin__' else: built_in = 'builtins' def _import_mock(name, *args): if name == 'lsb_release': raise ImportError('No module named lsb_release') return orig_import(name, *args) # Skip the first if statement with patch.object(salt.utils, 'is_proxy', MagicMock(return_value=False)): # Skip the selinux/systemd stuff (not pertinent) with patch.object(core, '_linux_bin_exists', MagicMock(return_value=False)): # Skip the init grain compilation (not pertinent) with patch.object(os.path, 'exists', path_exists_mock): # Ensure that lsb_release fails to import with patch('{0}.__import__'.format(built_in), side_effect=_import_mock): # Skip all the /etc/*-release stuff (not pertinent) with patch.object(os.path, 'isfile', path_isfile_mock): # Mock platform.linux_distribution to give us the # OS name that we want. distro_mock = MagicMock( return_value=('Debian GNU/Linux', '8.3', '') ) with patch.object( platform, 'linux_distribution', distro_mock): # Make a bunch of functions return empty dicts, # we don't care about these grains for the # purposes of this test. with patch.object( core, '_linux_cpudata', empty_mock): with patch.object( core, '_linux_gpu_data', empty_mock): with patch.object( core, '_memdata', empty_mock): with patch.object( core, '_hw_data', empty_mock): with patch.object( core, '_virtual', empty_mock): with patch.object( core, '_ps', empty_mock): # Mock the osarch with patch.dict( core.__salt__, {'cmd.run': cmd_run_mock}): os_grains = core.os_data() self.assertEqual(os_grains.get('os_family'), 'Debian')
def test_suse_os_from_cpe_data(self): ''' Test if 'os' grain is parsed from CPE_NAME of /etc/os-release ''' _path_exists_map = { '/proc/1/cmdline': False } _path_isfile_map = { '/etc/os-release': True, } _os_release_map = { 'NAME': 'SLES', 'VERSION': '12-SP1', 'VERSION_ID': '12.1', 'PRETTY_NAME': 'SUSE Linux Enterprise Server 12 SP1', 'ID': 'sles', 'ANSI_COLOR': '0;32', 'CPE_NAME': 'cpe:/o:suse:sles:12:sp1' } path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x]) path_isfile_mock = MagicMock( side_effect=lambda x: _path_isfile_map.get(x, False) ) empty_mock = MagicMock(return_value={}) osarch_mock = MagicMock(return_value="amd64") os_release_mock = MagicMock(return_value=_os_release_map) orig_import = __import__ if six.PY2: built_in = '__builtin__' else: built_in = 'builtins' def _import_mock(name, *args): if name == 'lsb_release': raise ImportError('No module named lsb_release') return orig_import(name, *args) # Skip the first if statement with patch.object(salt.utils, 'is_proxy', MagicMock(return_value=False)): # Skip the selinux/systemd stuff (not pertinent) with patch.object(core, '_linux_bin_exists', MagicMock(return_value=False)): # Skip the init grain compilation (not pertinent) with patch.object(os.path, 'exists', path_exists_mock): # Ensure that lsb_release fails to import with patch('{0}.__import__'.format(built_in), side_effect=_import_mock): # Skip all the /etc/*-release stuff (not pertinent) with patch.object(os.path, 'isfile', path_isfile_mock): with patch.object(core, '_parse_os_release', os_release_mock): # Mock platform.linux_distribution to give us the # OS name that we want. distro_mock = MagicMock( return_value=('SUSE Linux Enterprise Server ', '12', 'x86_64') ) with patch.object(platform, 'linux_distribution', distro_mock): with patch.object(core, '_linux_gpu_data', empty_mock): with patch.object(core, '_linux_cpudata', empty_mock): with patch.object(core, '_virtual', empty_mock): # Mock the osarch with patch.dict(core.__salt__, {'cmd.run': osarch_mock}): os_grains = core.os_data() self.assertEqual(os_grains.get('os_family'), 'Suse') self.assertEqual(os_grains.get('os'), 'SUSE')