# Globals defaults.__grains__ = {} defaults.__salt__ = {} defaults.__opts__ = {} @skipIf(NO_MOCK, NO_MOCK_REASON) class DefaultsTestCase(TestCase): ''' Test cases for salt.modules.defaults ''' @patch('salt.modules.defaults.get', MagicMock(return_value={'users': { 'root': [0] }})) def test_get_mock(self): ''' Test if it execute a defaults client run and return a dict ''' with patch.object(inspect, 'stack', MagicMock(return_value=[])): self.assertEqual(defaults.get('core:users:root'), {'users': { 'root': [0] }}) if __name__ == '__main__': from integration import run_tests run_tests(DefaultsTestCase, needs_daemon=False)
raise AssertionError( 'No exception should have been raised: {0}'.format(err) ) # Remove the testing handler log.removeHandler(handler) # Test for a format which does not include digits in name formatting. log_format = '[%(name)s] %(message)s' handler = TestsLoggingHandler(format=log_format) log.addHandler(handler) # Trigger TestsLoggingHandler.__enter__ with handler: # Let's create another log instance to trigger salt's logging class # calculations. try: saltlog.SaltLoggingClass('{0}.without_digits'.format(__name__)) except Exception as err: raise AssertionError( 'No exception should have been raised: {0}'.format(err) ) # Remove the testing handler log.removeHandler(handler) if __name__ == '__main__': from integration import run_tests run_tests(TestLog, needs_daemon=False)
fd.write("foo") fd.close() finder = salt.utils.find.Finder({'name': 'test_name'}) self.assertEqual(list(finder.find('')), []) finder = salt.utils.find.Finder({'name': 'hello.txt'}) self.assertEqual(list(finder.find(self.tmpdir)), [hello_file]) finder = salt.utils.find.Finder({'type': 'f', 'print': 'path'}) self.assertEqual(list(finder.find(self.tmpdir)), [os.path.join(self.tmpdir, 'hello.txt')]) finder = salt.utils.find.Finder({'size': '+1G', 'print': 'path'}) self.assertEqual(list(finder.find(self.tmpdir)), []) finder = salt.utils.find.Finder( {'name': 'hello.txt', 'print': 'path name'} ) self.assertEqual( list(finder.find(self.tmpdir)), [[hello_file, 'hello.txt']] ) if __name__ == '__main__': from integration import run_tests run_tests( [TestFind, TestGrepOption, TestPrintOption, TestFinder], needs_daemon=False )
self.proc = self.result[pid] def test_cmd_is_empty_string(self): self.assertEqual(self.proc['cmd'], '') #class TestProcsComInitialization(TestProcsBase): # def setUp(self): # call_count = 5 # for _ in range(call_count): # self.call_procs() # self.expected_calls = [call()] * call_count # # def test_initialize_and_uninitialize_called(self): # pythoncom.CoInitialize.assert_has_calls(self.expected_calls) # pythoncom.CoUninitialize.assert_has_calls(self.expected_calls) if __name__ == '__main__': from integration import run_tests run_tests( [ TestProcsCount, TestProcsAttributes, TestProcsUnicodeAttributes, TestProcsWMIGetOwnerErrorsAreLogged, TestProcsWMIGetOwnerAccessDeniedWorkaround, ], needs_daemon=False )
mock = MagicMock(side_effect=[['rahulha@salt'], [''], ['']]) with patch.dict(rabbitmq_cluster.__salt__, {"rabbitmq.cluster_status": mock}): ret.update({'comment': 'Already in cluster'}) self.assertDictEqual(rabbitmq_cluster.joined('salt', 'salt', 'rahulha'), ret) with patch.dict(rabbitmq_cluster.__opts__, {"test": True}): ret.update({'result': None, 'comment': 'Node is set to join ' 'cluster rahulha@salt'}) self.assertDictEqual(rabbitmq_cluster.joined('salt', 'salt', 'rahulha'), ret) with patch.dict(rabbitmq_cluster.__opts__, {"test": False}): mock = MagicMock(return_value={'Error': 'ERR'}) with patch.dict(rabbitmq_cluster.__salt__, {"rabbitmq.join_cluster": mock}): ret.update({'result': False, 'comment': 'ERR'}) self.assertDictEqual(rabbitmq_cluster.joined('salt', 'salt', 'rahulha'), ret) if __name__ == '__main__': from integration import run_tests run_tests(RabbitmqClusterTestCase, needs_daemon=False)
with patch.dict(__opts__, {'ipv6': False, 'master': float('127.0'), 'master_port': '4555', 'retry_dns': False}): self.assertRaises(SaltSystemExit, minion.resolve_dns, __opts__) @skipIf(os.geteuid() != 0, 'You must be logged in as root to run this test') def test_sock_path_len(self): ''' This tests whether or not a larger hash causes the sock path to exceed the system's max sock path length. See the below link for more information. https://github.com/saltstack/salt/issues/12172#issuecomment-43903643 ''' opts = { 'id': 'salt-testing', 'hash_type': 'sha512', 'sock_dir': os.path.join(salt.syspaths.SOCK_DIR, 'minion') } with patch.dict(__opts__, opts): testminion = minion.MinionBase(__opts__) try: testminion._prepare_minion_event_system() result = True except SaltSystemExit: result = False self.assertTrue(result) if __name__ == '__main__': from integration import run_tests run_tests(MinionTestCase, needs_daemon=False)
signer = RSAX931Signer('bogus key data') with self.assertRaises(ValueError): signer = RSAX931Signer(RSAX931Test.pubkey_data) signer = RSAX931Signer(RSAX931Test.privkey_data) with self.assertRaises(ValueError): signer.sign('x'*255) # message too long sig = signer.sign(RSAX931Test.hello_world) self.assertEqual(RSAX931Test.hello_world_sig, sig) def test_verifier(self): with self.assertRaises(ValueError): verifier = RSAX931Verifier('bogus key data') with self.assertRaises(ValueError): verifier = RSAX931Verifier(RSAX931Test.privkey_data) verifier = RSAX931Verifier(RSAX931Test.pubkey_data) with self.assertRaises(ValueError): verifier.verify('') with self.assertRaises(ValueError): verifier.verify(RSAX931Test.hello_world_sig + b'junk') msg = verifier.verify(RSAX931Test.hello_world_sig) self.assertEqual(RSAX931Test.hello_world, msg) if __name__ == '__main__': from integration import run_tests run_tests(RSAX931Test, needs_daemon=False)
with salt.utils.fopen(conf_file, 'r') as f_in: for line in f_in: if to_find in line: return True return False @destructiveTest @skipIf(os.geteuid() != 0, 'You must be logged in as root to run this test') @requires_system_grains def tearDown(self, grains=None): ''' Clean up after tests ''' ret = self.run_function('sysctl.get', [ASSIGN_CMD]) if ret != self.val: self.run_function('sysctl.assign', [ASSIGN_CMD, self.val]) if self.has_conf is True: # restore original sysctl file self.__restore_sysctl() if self.has_conf is False and os.path.isfile(CONFIG): # remove sysctl.conf created by tests os.remove(CONFIG) if __name__ == '__main__': from integration import run_tests run_tests(DarwinSysctlModuleTest)
method='POST', body=urlencode(self.auth_creds), headers={'Content-Type': self.content_type_map['form']}) token = json.loads(response.body)['return'][0]['token'] url = 'ws://127.0.0.1:{0}/hook/{1}'.format(self.get_http_port(), token) # Example.com should works request = HTTPRequest(url, headers={ 'Origin': 'http://example.com', 'Host': 'example.com' }) ws = yield websocket_connect(request) ws.write_message('websocket client ready') ws.close() # Foo.bar too request = HTTPRequest(url, headers={ 'Origin': 'http://foo.bar', 'Host': 'example.com' }) ws = yield websocket_connect(request) ws.write_message('websocket client ready') ws.close() if __name__ == '__main__': from integration import run_tests # pylint: disable=import-error run_tests(TestBaseSaltAPIHandler, TestSaltAuthHandler, needs_daemon=False)
'retcode': 0, 'stdout': 'stdout' }) }): with patch.object(rbenv, 'rehash', return_value=None): self.assertEqual(rbenv.do(), 'stdout') with patch.dict( rbenv.__salt__, { 'cmd.run_all': MagicMock(return_value={ 'retcode': 1, 'stdout': 'stdout' }) }): with patch.object(rbenv, 'rehash', return_value=None): self.assertFalse(rbenv.do(), 'stdout') def test_do_with_ruby(self): ''' Test for execute a ruby command with rbenv's shims using a specific ruby version. ''' with patch.object(rbenv, 'do', return_value='A'): self.assertEqual(rbenv.do_with_ruby('ruby', 'cmdline'), 'A') if __name__ == '__main__': from integration import run_tests run_tests(RbenvTestCase, needs_daemon=False)
self.assertIn('Gromit', data) self.assertNotIn('Comte', data) finally: os.unlink(tgt) def test_get_file_from_env_in_url(self): tgt = os.path.join(integration.TMP, 'cheese') try: self.run_function('cp.get_file', ['salt://cheese?env=prod', tgt]) with salt.utils.fopen(tgt, 'r') as cheese: data = cheese.read() self.assertIn('Gromit', data) self.assertIn('Comte', data) finally: os.unlink(tgt) try: self.run_function('cp.get_file', ['salt://cheese?saltenv=prod', tgt]) with salt.utils.fopen(tgt, 'r') as cheese: data = cheese.read() self.assertIn('Gromit', data) self.assertIn('Comte', data) finally: os.unlink(tgt) if __name__ == '__main__': from integration import run_tests run_tests(CPModuleTest)
''' sys.list_moduels ''' mods = self.run_function('sys.list_modules') self.assertTrue('hosts' in mods) self.assertTrue('pkg' in mods) def test_valid_docs(self): ''' Make sure no functions are exposed that don't have valid docstrings ''' docs = self.run_function('sys.doc') bad = set() for fun in docs: if fun.startswith('runtests_helpers'): continue if not isinstance(docs[fun], basestring): bad.add(fun) elif not 'Example::' in docs[fun]: if not 'Examples::' in docs[fun]: bad.add(fun) if bad: import pprint pprint.pprint(sorted(bad)) self.assertFalse(bool(bad)) if __name__ == '__main__': from integration import run_tests run_tests(SysModuleTest)
Test get_slave_status in the mysql execution module ''' self._test_call(mysql.get_slave_status, 'SHOW SLAVE STATUS') @skipIf(True, 'MySQL module claims this function is not ready for production') def test_free_slave(self): pass def test_query(self): self._test_call(mysql.query, 'SELECT * FROM testdb', 'testdb', 'SELECT * FROM testdb') def _test_call(self, function, expected_sql, *args, **kwargs): connect_mock = MagicMock() mysql._connect = connect_mock with patch.dict(mysql.__salt__, {'config.option': MagicMock()}): function(*args, **kwargs) if isinstance(expected_sql, dict): calls = call().cursor().execute( '{0}'.format(expected_sql['sql']), expected_sql['sql_args']) else: calls = call().cursor().execute('{0}'.format(expected_sql)) connect_mock.assert_has_calls((calls, ), True) if __name__ == '__main__': from integration import run_tests run_tests(MySQLTestCase, needs_daemon=False)
# Only run the state once and keep the return data state_run = self.run_function('state.sls', mods='requisites.listen_simple') # Both listeners are expected to trigger listener_state = 'cmd_|-listener_test_listening_resolution_one_|-echo "Successful listen resolution"_|-mod_watch' self.assertIn(listener_state, state_run) listener_state = 'cmd_|-listener_test_listening_resolution_two_|-echo "Successful listen resolution"_|-mod_watch' self.assertIn(listener_state, state_run) def test_issue_30820_requisite_in_match_by_name(self): ''' This tests the case where a requisite_in matches by name instead of ID See https://github.com/saltstack/salt/issues/30820 for more info ''' state_run = self.run_function( 'state.sls', mods='requisites.requisite_in_match_by_name' ) bar_state = 'cmd_|-bar state_|-echo bar_|-wait' self.assertIn(bar_state, state_run) self.assertEqual(state_run[bar_state]['comment'], 'Command "echo bar" run') if __name__ == '__main__': from integration import run_tests run_tests(StateModuleTest)
def test_ssh_custom_module(self): ''' Test custom module work using SSHCase environment ''' expected = 'hello'[::-1] cmd = self.run_function('test.recho', arg=['hello']) self.assertEqual(expected, cmd) def test_ssh_sls_with_custom_module(self): ''' Test sls with custom module work using SSHCase environment ''' expected = { "module_|-regular-module_|-test.echo_|-run": 'hello', "module_|-custom-module_|-test.recho_|-run": 'olleh'} cmd = self.run_function('state.sls', arg=['custom_module']) for key in cmd: if not isinstance(cmd, dict) or not isinstance(cmd[key], dict): raise AssertionError('{0} is not a proper state return' .format(cmd)) elif not cmd[key]['result']: raise AssertionError(cmd[key]['comment']) cmd_ret = cmd[key]['changes'].get('ret', None) self.assertEqual(cmd_ret, expected[key]) if __name__ == '__main__': from integration import run_tests run_tests(SSHCustomModuleTest)
@skipIf(NO_MOCK, NO_MOCK_REASON) class KeyTestCase(TestCase): ''' Test cases for salt.modules.key ''' def test_finger(self): ''' Test for finger ''' with patch.object(os.path, 'join', return_value='A'): with patch.object(salt.utils, 'pem_finger', return_value='A'): with patch.dict(key.__opts__, {'pki_dir': MagicMock(return_value='A')}): self.assertEqual(key.finger(), 'A') def test_finger_master(self): ''' Test for finger ''' with patch.object(os.path, 'join', return_value='A'): with patch.object(salt.utils, 'pem_finger', return_value='A'): with patch.dict(key.__opts__, {'pki_dir': 'A'}): self.assertEqual(key.finger_master(), 'A') if __name__ == '__main__': from integration import run_tests run_tests(KeyTestCase, needs_daemon=False)
def test_build_network_settings(self): ''' Test to build the global network script. ''' with patch.object(rh_ip, '_parse_rh_config', MagicMock()): with patch.object(rh_ip, '_parse_network_settings', MagicMock()): mock = jinja2.exceptions.TemplateNotFound('foo') with patch.object(jinja2.Environment, 'get_template', MagicMock(side_effect=mock)): self.assertEqual(rh_ip.build_network_settings(), '') with patch.object(jinja2.Environment, 'get_template', MagicMock()): with patch.object(rh_ip, '_read_temp', return_value='A'): self.assertEqual(rh_ip.build_network_settings (test='t'), 'A') with patch.object(rh_ip, '_write_file_network', return_value=None): with patch.object(rh_ip, '_read_file', return_value='A'): self.assertEqual(rh_ip.build_network_settings (test=None), 'A') if __name__ == '__main__': from integration import run_tests run_tests(RhipTestCase, needs_daemon=False)
ret = self.run_call('test.ping --out=yaml') self.assertEqual(ret, expected) def test_output_unicodebad(self): ''' Tests outputter reliability with utf8 ''' opts = copy.deepcopy(self.minion_opts) opts['output_file'] = os.path.join(self.minion_opts['root_dir'], 'outputtest') data = { 'foo': { 'result': False, 'aaa': 'azerzaeréééé', 'comment': u'ééééàààà' } } try: # this should not raises UnicodeEncodeError display_output(data, opts=self.minion_opts) self.assertTrue(True) except Exception: # display trace in error message for debugging on jenkins trace = traceback.format_exc() self.assertEqual(trace, '') if __name__ == '__main__': from integration import run_tests run_tests(OutputReturnTest)
# Import Salt libs from salt import template class TemplateTestCase(TestCase): render_dict = {'jinja': 'fake_jinja_func', 'json': 'fake_json_func', 'mako': 'fake_make_func'} def test_compile_template_bad_type(self): ''' Test to ensure that unsupported types cannot be passed to the template compiler ''' ret = template.compile_template(['1', '2', '3'], None, None) self.assertDictEqual(ret, {}) def test_check_render_pipe_str(self): ''' Check that all renderers specified in the pipe string are available. ''' ret = template.check_render_pipe_str('jinja|json', self.render_dict) self.assertIn(('fake_jinja_func', ''), ret) self.assertIn(('fake_json_func', ''), ret) self.assertNotIn(('OBVIOUSLY_NOT_HERE', ''), ret) if __name__ == '__main__': from integration import run_tests run_tests(TemplateTestCase, needs_daemon=False)
@requires_network() @destructiveTest def test_refresh_db(self): ''' test refreshing the package database ''' func = 'pkg.refresh_db' os_family = self.run_function('grains.item', ['os_family'])['os_family'] if os_family == 'RedHat': ret = self.run_function(func) self.assertIn(ret, (True, None)) elif os_family == 'Debian': ret = self.run_function(func) self.assertNotEqual(ret, {}) if not isinstance(ret, dict): self.skipTest( 'Upstream repo did not return coherent results. Skipping test.' ) for source, state in ret.items(): self.assertIn(state, (True, False, None)) else: os_grain = self.run_function('grains.item', ['os'])['os'] self.skipTest('{0} is unavailable on {1}'.format(func, os_grain)) if __name__ == '__main__': from integration import run_tests run_tests(PkgModuleTest)
else: os_grain = self.run_function('grains.item', ['os'])['os'] self.skipTest('{0} is unavailable on {1}'.format('pkg.hold', os_grain)) @requires_network() @destructiveTest def test_refresh_db(self): ''' test refreshing the package database ''' func = 'pkg.refresh_db' os_family = self.run_function('grains.item', ['os_family'])['os_family'] if os_family == 'RedHat': ret = self.run_function(func) self.assertIn(ret, (True, None)) elif os_family == 'Debian': ret = self.run_function(func) self.assertNotEqual(ret, {}) for source, state in ret.items(): self.assertIn(state, (True, False, None)) else: os_grain = self.run_function('grains.item', ['os'])['os'] self.skipTest('{0} is unavailable on {1}'.format(func, os_grain)) if __name__ == '__main__': from integration import run_tests run_tests(PkgModuleTest)
''' supervisord.dead When service needs to be added. ''' self.start_supervisord(autostart=False) self.run_function( 'supervisord.remove', ['sleep_service', None, self.supervisor_conf, self.venv_dir]) ret = self.run_state('supervisord.dead', name='sleep_service', bin_env=self.venv_dir, conf_file=self.supervisor_conf) self.assertSaltTrueReturn(ret) def test_dead_notexists(self): ''' supervisord.dead When service does not exist. ''' self.start_supervisord(autostart=True) ret = self.run_state('supervisord.dead', name='does_not_exist', bin_env=self.venv_dir, conf_file=self.supervisor_conf) self.assertSaltTrueReturn(ret) if __name__ == '__main__': from integration import run_tests run_tests(SupervisordTest)
hostname_cmd = salt.utils.which('hostnamectl') if hostname_cmd: desc = self.run_function('cmd.run', ["hostnamectl status --pretty"]) self.assertEqual(res, desc) else: if not os.path.isfile('/etc/machine-info'): self.assertFalse(res) else: with salt.utils.fopen('/etc/machine-info', 'r') as mach_info: data = mach_info.read() self.assertIn(res, data.decode('string_escape')) @destructiveTest @skipIf(os.geteuid() != 0, 'you must be root to run this test') def test_set_computer_desc(self): ''' Test setting the system hostname ''' self._save_machine_info() desc = "test" ret = self.run_function('system.set_computer_desc', [desc]) computer_desc = self.run_function('system.get_computer_desc') self.assertTrue(ret) self.assertIn(desc, computer_desc) if __name__ == '__main__': from integration import run_tests run_tests(SystemModuleTest)
'stderr': '' } run_all_mock = MagicMock(return_value=cmd_out) patches = { 'cmd.run_all': run_all_mock, 'pkg_resource.parse_targets': MagicMock(return_value=parsed_targets), 'pkg_resource.stringify': MagicMock(), 'pkg_resource.sort_pkglist': MagicMock(), } with patch.dict(openbsdpkg.__salt__, patches): with patch('salt.modules.openbsdpkg.list_pkgs', ListPackages()): added = openbsdpkg.install() expected = { 'png': {'new': '1.6.23', 'old': ''}, 'ruby': {'new': '2.3.1p1', 'old': ''} } self.assertDictEqual(added, expected) expected_calls = [ call('pkg_add -x -I png--%', output_loglevel='trace', python_shell=False), call('pkg_add -x -I ruby--%2.3', output_loglevel='trace', python_shell=False), call('pkg_add -x -I vim--gtk2%', output_loglevel='trace', python_shell=False), ] run_all_mock.assert_has_calls(expected_calls, any_order=True) self.assertEqual(run_all_mock.call_count, 3) if __name__ == '__main__': from integration import run_tests run_tests(OpenbsdpkgTestCase, needs_daemon=False)
''' # check if instance with salt installed returned try: self.assertIn( INSTANCE_NAME, [i.strip() for i in self.run_cloud('-p digitalocean-test {0}'.format(INSTANCE_NAME))] ) except AssertionError: self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME)) raise # delete the instance try: self.assertIn( 'True', [i.strip() for i in self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME))] ) except AssertionError: raise # Final clean-up of created instance, in case something went wrong. # This was originally in a tearDown function, but that didn't make sense # To run this for each test when not all tests create instances. if INSTANCE_NAME in [i.strip() for i in self.run_cloud('--query')]: self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME)) if __name__ == '__main__': from integration import run_tests run_tests(DigitalOceanTest)
def test_handle_decoded_payload_jid_queue_reduced_minion_jid_queue_hwm( self): ''' Tests that the _handle_decoded_payload function removes a jid from the minion's jid_queue when the minion's jid_queue high water mark (minion_jid_queue_hwm) is hit. ''' mock_opts = { 'cachedir': '', 'extension_modules': '', 'minion_jid_queue_hwm': 2 } mock_data = {'fun': 'foo.bar', 'jid': 789} mock_jid_queue = [123, 456] minion = salt.minion.Minion(mock_opts, jid_queue=copy.copy(mock_jid_queue)) # Assert that the minion's jid_queue attribute matches the mock_jid_queue as a baseline # This can help debug any test failures if the _handle_decoded_payload call fails. self.assertEqual(minion.jid_queue, mock_jid_queue) # Call the _handle_decoded_payload function and check that the queue is smaller by one item # and contains the new jid minion._handle_decoded_payload(mock_data) self.assertEqual(len(minion.jid_queue), 2) self.assertEqual(minion.jid_queue, [456, 789]) if __name__ == '__main__': from integration import run_tests run_tests(MinionTestCase, needs_daemon=False)
# returns X, the second Y, the third Z, etc... osaccess.side_effect = [ # The first os.access should return False(the abspath one) False, # The second, iterating through $PATH, should also return False, # still checking for Linux False, # We will now also return False 3 times so we get a .CMD back from # the function, see PATHEXT below. # Lastly return True, this is the windows check. False, False, False, True ] # Let's patch os.environ to provide a custom PATH variable with patch.dict(os.environ, {'PATH': '/bin', 'PATHEXT': '.COM;.EXE;.BAT;.CMD;.VBS;' '.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PY'}): # Let's also patch is_windows to return True with patch('salt.utils.is_windows', lambda: True): with patch('os.path.isfile', lambda x: True): self.assertEqual( salt.utils.which('this-binary-exists-under-windows'), # The returned path should return the .exe suffix '/bin/this-binary-exists-under-windows.CMD' ) if __name__ == '__main__': from integration import run_tests run_tests(TestWhich, needs_daemon=False)
_HASHES = dict( md5=dict(pw_salt='TgIp9OTu', pw_hash='$1$TgIp9OTu$.d0FFP6jVi5ANoQmk6GpM1'), sha256=dict( pw_salt='3vINbSrC', pw_hash='$5$3vINbSrC$hH8A04jAY3bG123yU4FQ0wvP678QDTvWBhHHFbz6j0D'), sha512=dict( pw_salt='PiGA3V2o', pw_hash= '$6$PiGA3V2o$/PrntRYufz49bRV/V5Eb1V6DdHaS65LB0fu73Tp/xxmDFr6HWJKptY2TvHRDViXZugWpnAcOnrbORpOgZUGTn.' ), ) @skipIf(not is_linux(), 'minion is not Linux') class LinuxShadowTest(TestCase): def test_gen_password(self): ''' Test shadow.gen_password ''' self.assertTrue(HAS_SHADOW) for algorithm, hash_info in _HASHES.iteritems(): self.assertEqual( shadow.gen_password(_PASSWORD, crypt_salt=hash_info['pw_salt'], algorithm=algorithm), hash_info['pw_hash']) if __name__ == '__main__': from integration import run_tests run_tests(LinuxShadowTest, needs_daemon=False)
if not os.path.isfile(KNOWN_HOSTS): self.skipTest( 'Unable to copy {0} to {1}'.format( known_hosts, KNOWN_HOSTS ) ) kwargs = {'name': 'github.com', 'user': '******', 'config': KNOWN_HOSTS} # test first ret = self.run_state('ssh_known_hosts.absent', test=True, **kwargs) self.assertSaltNoneReturn(ret) # remove once, the key is gone ret = self.run_state('ssh_known_hosts.absent', **kwargs) self.assertSaltStateChangesEqual( ret, GITHUB_FINGERPRINT, keys=('old', 'fingerprint') ) # remove twice, nothing has changed ret = self.run_state('ssh_known_hosts.absent', **kwargs) self.assertSaltStateChangesEqual(ret, {}) # test again ret = self.run_state('ssh_known_hosts.absent', test=True, **kwargs) self.assertSaltNoneReturn(ret) if __name__ == '__main__': from integration import run_tests run_tests(SSHKnownHostsStateTest)
state_filename = state_name + '.sls' state_file = os.path.join(STATE_DIR, state_filename) # the result of running self.cmd not in a shell disabled_ret = ( 'first second third | wc -l ; export SALTY_VARIABLE=saltines ' '&& echo $SALTY_VARIABLE ; echo duh &> /dev/null') ret_key = 'test_|-shell_enabled_|-{0}_|-configurable_test_state'.format( disabled_ret) try: with salt.utils.fopen(state_file, 'w') as fp_: fp_.write( textwrap.dedent('''\ {{% set shell_disabled = salt['cmd.run']("{0}") %}} shell_enabled: test.configurable_test_state: - name: '{{{{ shell_disabled }}}}' '''.format(self.cmd))) ret = self.run_function('state.sls', [state_name]) self.assertEqual(ret[ret_key]['name'], disabled_ret) finally: os.remove(state_file) if __name__ == '__main__': from integration import run_tests run_tests(EnabledTest)
# set user password set_pw_cmd = "shadow.set_password {0} '{1}'".format( self.userB, password if salt.utils.is_darwin() else hashed_pwd ) self.run_call(set_pw_cmd) # test group auth against pam: saltadm is not configured in # external_auth, but saltops is and saldadm is a member of saltops cmd = ('-a pam "*" test.ping ' '--username {0} --password {1}'.format(self.userB, password)) resp = self.run_salt(cmd) self.assertTrue( 'minion:' in resp ) @destructiveTest @skipIf(is_not_root, 'You must be logged in as root to run this test') def test_zzzz_tearDown(self): for user in (self.userA, self.userB): if pwd.getpwnam(user): self.run_call('user.delete {0}'.format(user)) if grp.getgrnam(self.group): self.run_call('group.delete {0}'.format(self.group)) if __name__ == '__main__': from integration import run_tests run_tests(AuthTest)
shutil.rmtree(dir) def test_archive_extracted_skip_verify(self): ''' test archive.extracted with skip_verify ''' ret = self.run_state('archive.extracted', name=ARCHIVE_DIR, source=ARCHIVE_TAR_SOURCE, archive_format='tar', skip_verify=True) self.assertSaltTrueReturn(ret) self._check_ext_remove(ARCHIVE_DIR, UNTAR_FILE) def test_archive_extracted_with_source_hash(self): ''' test archive.extracted without skip_verify only external resources work to check to ensure source_hash is verified correctly ''' ret = self.run_state('archive.extracted', name=ARCHIVE_DIR, source=ARCHIVE_TAR_SOURCE, archive_format='tar', source_hash=ARCHIVE_TAR_HASH) self.assertSaltTrueReturn(ret) self._check_ext_remove(ARCHIVE_DIR, UNTAR_FILE) if __name__ == '__main__': from integration import run_tests run_tests(ArchiveTest)
gateway = '10.225.108.1' ret = {'name': ip_, 'result': None, 'comment': '', 'changes': {}} net_info = {'IPv4 settings': {'IP Address': ip_, 'Subnet Mask': netmask, 'Gateway': gateway}} mock_info = MagicMock(return_value=net_info) mock_bool = MagicMock(side_effect=[True, False]) with patch.dict(drac.__salt__, {'drac.network_info': mock_info, 'drac.set_network': mock_bool}): with patch.dict(drac.__opts__, {'test': True}): self.assertDictEqual(drac.network(ip_, netmask, gateway), ret) with patch.dict(drac.__opts__, {'test': False}): comt = ('Network is in the desired state') ret.update({'comment': comt, 'result': True}) self.assertDictEqual(drac.network(ip_, netmask, gateway), ret) comt = ('unable to configure network') ret.update({'comment': comt, 'result': False}) self.assertDictEqual(drac.network(ip_, netmask, gateway), ret) if __name__ == '__main__': from integration import run_tests run_tests(DracTestCase, needs_daemon=False)
'fun': 'key.list_keys', } low.update(self.eauth_creds) self.wheel.cmd_async(low) def test_cmd_sync_w_arg(self): low = { 'fun': 'key.finger', 'match': '*', } low.update(self.eauth_creds) ret = self.wheel.cmd_sync(low) self.assertIn('return', ret.get('data', {})) def test_wildcard_auth(self): low = { 'username': '******', 'password': '******', 'eauth': 'auto', 'fun': 'key.list_all', } self.wheel.cmd_sync(low) if __name__ == '__main__': from integration import run_tests run_tests(WheelModuleTest, needs_daemon=True)
class PillarModuleTest(integration.ModuleCase): ''' Validate the pillar module ''' def test_data(self): ''' pillar.data ''' grains = self.run_function('grains.items') pillar = self.run_function('pillar.data') self.assertEqual(pillar['os'], grains['os']) self.assertEqual(pillar['monty'], 'python') if grains['os'] == 'Fedora': self.assertEqual(pillar['class'], 'redhat') else: self.assertEqual(pillar['class'], 'other') def test_ext_cmd_yaml(self): ''' pillar.data for ext_pillar cmd.yaml ''' self.assertEqual( self.run_function('pillar.data')['ext_spam'], 'eggs' ) if __name__ == '__main__': from integration import run_tests run_tests(PillarModuleTest)
@skipIf(NO_MOCK, NO_MOCK_REASON) class ChefTestCase(TestCase): ''' Test cases for salt.modules.chef ''' # 'client' function tests: 1 @patch('salt.modules.chef._exec_cmd', MagicMock(return_value={})) @patch('salt.utils.which', MagicMock(return_value=True)) def test_client(self): ''' Test if it execute a chef client run and return a dict ''' self.assertDictEqual(chef.client(), {}) # 'solo' function tests: 1 @patch('salt.modules.chef._exec_cmd', MagicMock(return_value={})) @patch('salt.utils.which', MagicMock(return_value=True)) def test_solo(self): ''' Test if it execute a chef solo run and return a dict ''' self.assertDictEqual(chef.solo('/dev/sda1'), {}) if __name__ == '__main__': from integration import run_tests run_tests(ChefTestCase, needs_daemon=False)
uinfo = self.run_function('user.info', [uname]) self.assertIn(uname, uinfo['groups']) # This uid is available, store it uid = uinfo['uid'] self.run_function('user.delete', [uname, True, True]) # Now, a weird group id gname = self.__random_string() if self.run_function('group.add', [gname]) is not True: self.skipTest('Failed to create group') ginfo = self.run_function('group.info', [gname]) # And create the user with that gid if self.run_function('user.add', [uname, uid, ginfo['gid']]) is False: # Skip because creating is not what we're testing here self.skipTest('Failed to create user') uinfo = self.run_function('user.info', [uname]) self.assertIn(gname, uinfo['groups']) self.run_function('user.delete', [uname, True, True]) if __name__ == '__main__': from integration import run_tests run_tests(UseraddModuleTest)
Test that serializers have: [] ''' self._verify_globals(salt.loader.serializers(self.master_opts)) def test_states(self): ''' Test that states: - __pillar__ - __salt__ - __opts__ - __grains__ - __context__ ''' self._verify_globals(salt.loader.states(self.master_opts, {}, {}, {})) def test_renderers(self): ''' Test that renderers have: - __salt__ # Execution functions (i.e. __salt__['test.echo']('foo')) - __grains__ # Grains (i.e. __grains__['os']) - __pillar__ # Pillar data (i.e. __pillar__['foo']) - __opts__ # Minion configuration options - __context__ # Context dict shared amongst all modules of the same type ''' self._verify_globals(salt.loader.render(self.master_opts, {})) if __name__ == '__main__': from integration import run_tests run_tests(LoaderGlobalsTest, needs_daemon=False)
rendered = env.from_string('{{ data }}').render(data=data) self.assertEqual(rendered, u"{'foo': {'bar': 'baz', 'qux': 42}}") rendered = env.from_string('{{ data }}').render(data=[ OrderedDict( foo='bar', ), OrderedDict( baz=42, ) ]) self.assertEqual(rendered, u"[{'foo': 'bar'}, {'baz': 42}]") # def test_print(self): # env = Environment(extensions=[SerializerExtension]) # source = '{% import_yaml "toto.foo" as docu %}' # name, filename = None, '<filename>' # parsed = env._parse(source, name, filename) # print parsed # print # compiled = env._generate(parsed, name, filename) # print compiled # return if __name__ == '__main__': from integration import run_tests run_tests(TestSaltCacheLoader, TestGetTemplate, TestCustomExtensions, needs_daemon=False)
self.assertDictEqual( { 'hash_type': 'blob_sha1', 'hsum': '0d234303e6451128d756c5c259175de37d767742' }, ret) def test_serve_file(self): with patch.dict( gitfs.__opts__, { 'cachedir': self.master_opts['cachedir'], 'gitfs_remotes': ['file://' + self.tmp_repo_git], 'sock_dir': self.master_opts['sock_dir'], 'file_buffer_size': 262144 }): fnd = {'rel': 'testfile', 'path': 'testfile'} tmp_load = load tmp_load['loc'] = 0 ret = gitfs.serve_file(load, fnd) self.assertDictEqual( { 'data': 'Scene 24\n\n \n OLD MAN: Ah, hee he he ha!\n ARTHUR: And this enchanter of whom you speak, he has seen the grail?\n OLD MAN: Ha ha he he he he!\n ARTHUR: Where does he live? Old man, where does he live?\n OLD MAN: He knows of a cave, a cave which no man has entered.\n ARTHUR: And the Grail... The Grail is there?\n OLD MAN: Very much danger, for beyond the cave lies the Gorge\n of Eternal Peril, which no man has ever crossed.\n ARTHUR: But the Grail! Where is the Grail!?\n OLD MAN: Seek you the Bridge of Death.\n ARTHUR: The Bridge of Death, which leads to the Grail?\n OLD MAN: Hee hee ha ha!\n\n', 'dest': 'testfile' }, ret) if __name__ == '__main__': integration.run_tests(GitFSTest)
self.assertEqual( sconfig.get_id(cache=False), ('foo.bar.org', False) ) @patch('salt.utils.network.get_fqhostname', MagicMock(return_value='localhost')) def test_get_id_etc_hostname(self): ''' Test calling salt.config.get_id() and falling back to looking at /etc/hostname. ''' with patch('salt.utils.fopen', _fopen_side_effect_etc_hostname): self.assertEqual( sconfig.get_id(cache=False), ('foo.bar.com', False) ) @patch('salt.utils.network.get_fqhostname', MagicMock(return_value='localhost')) def test_get_id_etc_hosts(self): ''' Test calling salt.config.get_id() and falling back all the way to looking up data from /etc/hosts. ''' with patch('salt.utils.fopen', _fopen_side_effect_etc_hosts): self.assertEqual( sconfig.get_id(cache=False), ('foo.bar.net', False) ) if __name__ == '__main__': from integration import run_tests run_tests(ConfigTestCase, needs_daemon=False)
name='Setup Keys', source='salt://{0}?saltenv=prod'.format(key_fname), enc='ssh-rsa', user=username, comment=username) self.assertSaltTrueReturn(ret) with salt.utils.fopen(authorized_keys_file, 'r') as fhr: self.assertEqual( fhr.read(), 'ssh-rsa AAAAB3NzaC1kcQ9J5bYTEyZ== {0}\n'.format(username)) os.unlink(authorized_keys_file) ret = self.run_state('ssh_auth.present', name='Setup Keys', source='salt://{0}'.format(key_fname), enc='ssh-rsa', user=username, comment=username, saltenv='prod') self.assertSaltTrueReturn(ret) with salt.utils.fopen(authorized_keys_file, 'r') as fhr: self.assertEqual( fhr.read(), 'ssh-rsa AAAAB3NzaC1kcQ9J5bYTEyZ== {0}\n'.format(username)) if __name__ == '__main__': from integration import run_tests run_tests([SSHKnownHostsStateTest, SSHAuthStateTests])
events.put_nowait( me.get_event(wait=10, tag='salttest', full=False) ) threading.Thread(target=get_event, args=(events,)).start() time.sleep(1) # Allow multiprocessing.Process to start ret = self.run_function( 'event.fire', ['event.fire: just test it!!!!', 'salttest'], minion_tgt='sub_minion' ) self.assertTrue(ret) eventfired = events.get(block=True, timeout=10) self.assertIsNotNone(eventfired) self.assertIn('event.fire: just test it!!!!', eventfired) ret = self.run_function( 'event.fire', ['event.fire: just test it!!!!', 'salttest-miss'], minion_tgt='sub_minion' ) self.assertTrue(ret) with self.assertRaises(Empty): eventfired = events.get(block=True, timeout=10) if __name__ == '__main__': from integration import run_tests run_tests(EventModuleTest)
''' ret = self.run_state('npm.installed', name='git://github.com/request/request') self.assertSaltTrueReturn(ret) ret = self.run_state('npm.removed', name='git://github.com/request/request') self.assertSaltTrueReturn(ret) @requires_network() @destructiveTest def test_npm_installed_pkgs(self): ''' Basic test to determine if NPM module successfully installs multiple packages. ''' ret = self.run_state('npm.installed', name=None, pkgs=['pm2', 'grunt']) self.assertSaltTrueReturn(ret) @destructiveTest def test_npm_cache_clean(self): ''' Basic test to determine if NPM successfully cleans its cached packages. ''' ret = self.run_state('npm.cache_cleaned', name=None) self.assertSaltTrueReturn(ret) if __name__ == '__main__': from integration import run_tests run_tests(NpmStateTest)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}): self.assertEqual(zfs.set('myzpool/mydataset', compression='lz4'), res) @patch('salt.modules.zfs._check_zfs', MagicMock(return_value='/sbin/zfs')) def test_set_failure(self): ''' Tests zfs set failure ''' res = {'myzpool/mydataset': {'canmount': "'canmount' must be one of 'on | off | noauto'"}} ret = {'pid': 79887, 'retcode': 1, 'stderr': "cannot set property for 'myzpool/mydataset': 'canmount' must be one of 'on | off | noauto'", 'stdout': ''} mock_cmd = MagicMock(return_value=ret) with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}): self.assertEqual(zfs.set('myzpool/mydataset', canmount='lz4'), res) @patch('salt.modules.zfs._check_zfs', MagicMock(return_value='/sbin/zfs')) def test_get_success(self): ''' Tests zfs get success ''' res = OrderedDict([('myzpool', {'compression': {'value': 'off'}})]) ret = {'pid': 562, 'retcode': 0, 'stderr': '', 'stdout': 'myzpool\tcompression\toff'} mock_cmd = MagicMock(return_value=ret) with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}): self.assertEqual(zfs.get('myzpool', properties='compression', fields='value'), res) if __name__ == '__main__': from integration import run_tests run_tests(ZfsTestCase, needs_daemon=False) # vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
# check if instance installed salt and returned correctly try: self.assertIn(ret_str, instance) except AssertionError: self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME)) raise # delete the instance delete = self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME)) not_deleted = 'No machines were found to be destroyed' try: self.assertNotEqual(not_deleted, delete) except AssertionError: raise def tearDown(self): ''' Clean up after tests ''' query = self.run_cloud('--query') ret_str = ' {0}:'.format(INSTANCE_NAME) # if test instance is still present, delete it if ret_str in query: self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME)) if __name__ == '__main__': from integration import run_tests # pylint: disable=import-error run_tests(AzureTest)
@patch('salt.modules.snapper._get_num_interval', MagicMock(return_value=(55, 0))) @patch('salt.modules.snapper.snapper.MountSnapshot', MagicMock( side_effect=["/.snapshots/55/snapshot", "", "/.snapshots/55/snapshot", ""])) @patch('salt.modules.snapper.snapper.UmountSnapshot', MagicMock(return_value="")) @patch('salt.modules.snapper.changed_files', MagicMock(return_value=["/tmp/foo3"])) @patch('salt.modules.snapper._is_text_file', MagicMock(return_value=False)) @patch('os.path.isfile', MagicMock(side_effect=[True, True])) @patch('os.path.isdir', MagicMock(return_value=False)) @patch.dict(snapper.__salt__, { 'hashutil.sha256_digest': MagicMock(side_effect=[ "e61f8b762d83f3b4aeb3689564b0ffbe54fa731a69a1e208dc9440ce0f69d19b", "f18f971f1517449208a66589085ddd3723f7f6cefb56c141e3d97ae49e1d87fa", ]) }) def test_diff_binary_files(self): fopen_effect = [ mock_open(read_data="dummy binary").return_value, mock_open(read_data="dummy binary").return_value, ] with patch('salt.utils.fopen') as fopen_mock: fopen_mock.side_effect = fopen_effect module_ret = { "/tmp/foo3": MODULE_RET['DIFF']["/tmp/foo3"], } self.assertEqual(snapper.diff(), module_ret) if __name__ == '__main__': from integration import run_tests run_tests(SnapperTestCase, needs_daemon=False)
comt = ('Boolean is in the correct state') ret.update({'comment': comt, 'result': True}) self.assertDictEqual(selinux.boolean(name, value), ret) mock_bools = MagicMock(return_value={name: {'State': 'off', 'Default': 'on'}}) mock = MagicMock(side_effect=[True, False]) with patch.dict(selinux.__salt__, {'selinux.list_sebool': mock_bools, 'selinux.setsebool': mock}): with patch.dict(selinux.__opts__, {'test': True}): comt = ('Boolean samba_create_home_dirs' ' is set to be changed to on') ret.update({'comment': comt, 'result': None}) self.assertDictEqual(selinux.boolean(name, value), ret) with patch.dict(selinux.__opts__, {'test': False}): comt = ('Boolean samba_create_home_dirs has been set to on') ret.update({'comment': comt, 'result': True}) self.assertDictEqual(selinux.boolean(name, value), ret) comt = ('Failed to set the boolean ' 'samba_create_home_dirs to on') ret.update({'comment': comt, 'result': True}) self.assertDictEqual(selinux.boolean(name, value), ret) if __name__ == '__main__': from integration import run_tests run_tests(SelinuxTestCase, needs_daemon=False)
class TestAsyncEventPublisher(AsyncTestCase): def get_new_ioloop(self): return zmq.eventloop.ioloop.ZMQIOLoop() def setUp(self): super(TestAsyncEventPublisher, self).setUp() self.publisher = event.AsyncEventPublisher( {'sock_dir': SOCK_DIR}, self._handle_publish, self.io_loop, ) def _handle_publish(self, raw): self.tag, self.data = event.SaltEvent.unpack(raw) self.stop() def test_event_subscription(self): '''Test a single event is received''' me = event.MinionEvent({'sock_dir': SOCK_DIR}, listen=True) me.fire_event({'data': 'foo1'}, 'evt1') self.wait() evt1 = me.get_event(tag='evt1') self.assertEqual(self.tag, 'evt1') self.data.pop('_stamp') # drop the stamp self.assertEqual(self.data, {'data': 'foo1'}) if __name__ == '__main__': from integration import run_tests run_tests(TestSaltEvent, needs_daemon=False)
''' tmpl_str = '''Hello, {{ salt['mocktest.ping']() }}.''' ret = self.render(tmpl_str) self.assertEqual(ret, 'Hello, True.') def test_dotlookup(self): ''' Check calling a stub function using awesome dot-notation ''' tmpl_str = '''Hello, {{ salt.mocktest.ping() }}.''' ret = self.render(tmpl_str) self.assertEqual(ret, 'Hello, True.') def test_shadowed_dict_method(self): ''' Check calling a stub function with a name that shadows a ``dict`` method name ''' tmpl_str = '''Hello, {{ salt.mockgrains.get('id') }}.''' ret = self.render(tmpl_str) self.assertEqual(ret, 'Hello, jerry.') if __name__ == '__main__': from integration import run_tests run_tests(TestSaltCacheLoader, TestGetTemplate, TestCustomExtensions, TestDotNotationLookup, needs_daemon=False)
'job': 101, 'queue': 'A', 'tag': '', 'time': '19:48:47', 'user': '******'}]}) with patch.dict(at.__grains__, {'os_family': ''}): mock = MagicMock(return_value=None) with patch.dict(at.__salt__, {'cmd.run': mock}): self.assertEqual(at.at('12:05am', '/sbin/reboot', tag='reboot'), "'at.at' is not available.") def test_atc(self): """ Tests for atc """ with patch.object(at, '_cmd', return_value=None): self.assertEqual(at.atc(101), '\'at.atc\' is not available.') with patch.object(at, '_cmd', return_value=''): self.assertDictEqual(at.atc(101), {'error': 'invalid job id 101'}) with patch.object(at, '_cmd', return_value='101\tThu Dec 11 19:48:47 2014 A B'): self.assertEqual(at.atc(101), '101\tThu Dec 11 19:48:47 2014 A B') if __name__ == '__main__': from integration import run_tests run_tests(AtTestCase, needs_daemon=False)
if version is None: version = strip_initial_non_numbers_regex.search(vs).group('vs') self.assertEqual(saltstack_version.string, version) def test_version_comparison(self): examples = ( ('debian/0.11.1+ds-1-3-ga0afcbd', '0.11.1+ds-2'), ('v0.12.0-85-g2880105', 'v0.12.0-19-g767d4f9'), ('v0.17.0rc1-1-g52ebdfd', '0.17.0rc1'), ('v0.17.0', 'v0.17.0rc1'), ('Hydrogen', '0.17.0'), ('Helium', 'Hydrogen'), ('v2014.1.4.1-n/a-abcdefgh', 'v2014.1.4.1rc3-n/a-abcdefgh'), ('v2014.1.4.1-1-abcdefgh', 'v2014.1.4.1-n/a-abcdefgh') ) for higher_version, lower_version in examples: self.assertTrue(SaltStackVersion.parse(higher_version) > lower_version) self.assertTrue(SaltStackVersion.parse(lower_version) < higher_version) def test_unparsable_version(self): with self.assertRaises(ValueError): SaltStackVersion.from_name('Drunk') with self.assertRaises(ValueError): SaltStackVersion.parse('Drunk') if __name__ == '__main__': from integration import run_tests run_tests(VersionTestCase, needs_daemon=False)
def test_omits(self): with patch.dict(config.DEFAULTS, DEFAULTS): with patch.dict(config.__pillar__, __pillar__): with patch.dict(config.__opts__, __opts__): opt_name = 'test.option.all' opt = config.option(opt_name, omit_opts=False, omit_master=True, omit_pillar=True) self.assertEqual(opt, config.__opts__[opt_name]) opt = config.option(opt_name, omit_opts=True, omit_master=True, omit_pillar=False) self.assertEqual(opt, config.__pillar__[opt_name]) opt = config.option(opt_name, omit_opts=True, omit_master=False, omit_pillar=True) self.assertEqual( opt, config.__pillar__['master'][opt_name]) if __name__ == '__main__': from integration import run_tests run_tests(TestModulesConfig, needs_daemon=False)
self.setGrains({'a': 'aval'}) ret = grains.list_absent(name='foo:list', value='baz') self.assertEqual(ret['result'], True) self.assertEqual(ret['comment'], 'Grain foo:list does not exist') self.assertEqual(ret['changes'], {}) self.assertEqual(grains.__grains__, {'a': 'aval'}) self.assertGrainFileContent("a: aval\n") def test_list_absent_not_a_list(self): self.setGrains({'a': 'aval', 'foo': 'bar'}) ret = grains.list_absent(name='foo', value='bar') self.assertEqual(ret['result'], False) self.assertEqual(ret['comment'], 'Grain foo is not a valid list') self.assertEqual(ret['changes'], {}) self.assertEqual(grains.__grains__, {'a': 'aval', 'foo': 'bar'}) self.assertGrainFileContent("a: aval\n" + "foo: bar\n") def test_list_absent_already(self): self.setGrains({'a': 'aval', 'foo': ['bar']}) ret = grains.list_absent(name='foo', value='baz') self.assertEqual(ret['result'], True) self.assertEqual(ret['comment'], 'Value baz is absent from grain foo') self.assertEqual(ret['changes'], {}) self.assertEqual(grains.__grains__, {'a': 'aval', 'foo': ['bar']}) self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- bar\n") if __name__ == '__main__': from integration import run_tests run_tests(GrainsTestCase, needs_daemon=False)
name=name, bare=True ) self.assertSaltFalseReturn(ret) self.assertFalse(os.path.isfile(os.path.join(name, 'HEAD'))) finally: shutil.rmtree(name, ignore_errors=True) def test_present_empty_dir(self): ''' git.present ''' name = os.path.join(integration.TMP, 'salt_repo') if not os.path.isdir(name): os.mkdir(name) try: ret = self.run_state( 'git.present', name=name, bare=True ) self.assertSaltTrueReturn(ret) self.assertTrue(os.path.isfile(os.path.join(name, 'HEAD'))) finally: shutil.rmtree(name, ignore_errors=True) if __name__ == '__main__': from integration import run_tests run_tests(GitTest)
mock_l = MagicMock(return_value=[{'key': 'salt'}]) with patch.dict(powerpath.__salt__, {'powerpath.has_powerpath': mock, 'powerpath.list_licenses': mock_l, 'powerpath.remove_license': mock_t}): comt = ('PowerPath is not installed.') ret.update({'comment': comt, 'result': False}) self.assertDictEqual(powerpath.license_absent(name), ret) comt = ('License key {0} not present'.format(name)) ret.update({'comment': comt, 'result': True}) self.assertDictEqual(powerpath.license_absent(name), ret) with patch.dict(powerpath.__opts__, {'test': True}): comt = ('License key salt is set to be removed') ret.update({'comment': comt, 'result': None, 'name': 'salt'}) self.assertDictEqual(powerpath.license_absent('salt'), ret) with patch.dict(powerpath.__opts__, {'test': False}): ret.update({'comment': name, 'result': True, 'changes': {'salt': 'removed'}}) self.assertDictEqual(powerpath.license_absent('salt'), ret) ret.update({'result': False, 'changes': {}}) self.assertDictEqual(powerpath.license_absent('salt'), ret) if __name__ == '__main__': from integration import run_tests run_tests(PowerpathTestCase, needs_daemon=False)
contain a schedule key and neither does self.schedule.opts ''' saved = {'foo': 'bar'} ret = {'schedule': {'foo': 'bar'}} Schedule.reload(self.schedule, saved) self.assertEqual(self.schedule.opts, ret) def test_reload_schedule_in_saved_but_not_opts(self): ''' Tests reloading the schedule from saved schedule that contains a schedule key, but self.schedule.opts does not ''' saved = {'schedule': {'foo': 'bar'}} ret = {'schedule': {'schedule': {'foo': 'bar'}}} Schedule.reload(self.schedule, saved) self.assertEqual(self.schedule.opts, ret) # eval tests def test_eval_schedule_is_not_dict(self): ''' Tests if the schedule is a dictionary ''' self.schedule.opts = {'schedule': ''} self.assertRaises(ValueError, Schedule.eval, self.schedule) if __name__ == '__main__': from integration import run_tests run_tests(ScheduleTestCase, needs_daemon=False)
self.start_supervisord(autostart=False) ret = self.run_function( 'supervisord.stop', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir) self.assertEqual(ret, 'sleep_service: ERROR (not running)') def test_status_all(self): ''' Status for all services ''' self.start_supervisord(autostart=True) ret = self.run_function( 'supervisord.status', [], conf_file=self.supervisor_conf, bin_env=self.venv_dir) self.assertEqual(ret.keys(), ['sleep_service', 'sleep_service2']) def test_status_one(self): ''' Status for a specific service. ''' self.start_supervisord(autostart=True) ret = self.run_function( 'supervisord.status', ['sleep_service'], conf_file=self.supervisor_conf, bin_env=self.venv_dir) self.assertTrue(ret) if __name__ == '__main__': from integration import run_tests run_tests(SupervisordModuleTest)
{'iptables.flush': mock}): ret.update({'changes': {'locale': 'salt'}, 'comment': 'Flush iptables rules in' ' table chain ipv4 family', 'result': True}) self.assertDictEqual(iptables.flush('salt', table='', chain=''), ret) ret.update({'changes': {}, 'comment': 'Failed to flush iptables rules', 'result': False}) self.assertDictEqual(iptables.flush('salt', table='', chain=''), ret) def test_mod_aggregate(self): ''' Test to mod_aggregate function ''' self.assertDictEqual(iptables.mod_aggregate({'fun': 'salt'}, [], []), {'fun': 'salt'}) self.assertDictEqual(iptables.mod_aggregate({'fun': 'append'}, [], []), {'fun': 'append'}) if __name__ == '__main__': from integration import run_tests run_tests(IptablesTestCase, needs_daemon=False)
with patch.dict(module.__salt__, {}): cmd = 'hello.world' ret = module.run(cmd) comment = 'Module function {0} is not available'.format(cmd) self.assertEqual(ret['comment'], comment) self.assertFalse(ret['result']) def test_module_run_test_true(self): ''' Tests the return of module.run state when test=True is passed in ''' with patch.dict(module.__opts__, {'test': True}): ret = module.run(CMD) comment = 'Module function {0} is set to execute'.format(CMD) self.assertEqual(ret['comment'], comment) @patch('salt.utils.args.get_function_argspec', MagicMock(return_value=aspec)) def test_module_run_missing_arg(self): ''' Tests the return of module.run state when arguments are missing ''' ret = module.run(CMD) comment = 'The following arguments are missing: world hello' self.assertEqual(ret['comment'], comment) if __name__ == '__main__': from integration import run_tests run_tests(ModuleStateTest, needs_daemon=False)