""" Unit tests for salt.config """ import logging import os import textwrap import salt.config import salt.minion import salt.syspaths import salt.utils.files import salt.utils.network import salt.utils.platform import salt.utils.yaml from salt.exceptions import ( CommandExecutionError, SaltCloudConfigError, SaltConfigurationError, ) from salt.ext import six from salt.syspaths import CONFIG_DIR from tests.support.helpers import patched_environ, slowTest, with_tempdir, with_tempfile from tests.support.mixins import AdaptedConfigurationTestCaseMixin from tests.support.mock import MagicMock, Mock, patch from tests.support.runtests import RUNTIME_VARS from tests.support.unit import TestCase, skipIf log = logging.getLogger(__name__) SAMPLE_CONF_DIR = os.path.join(RUNTIME_VARS.CODE_DIR, "conf") + os.sep # mock hostname should be more complex than the systems FQDN MOCK_HOSTNAME = "very.long.complex.fqdn.that.is.crazy.extra.long.example.com" MOCK_ETC_HOSTS = textwrap.dedent( """\ ## # Host Database # # localhost is used to configure the loopback interface # when the system is booting. Do not change this entry. ## The empty line below must remain, it factors into the tests. 127.0.0.1 localhost {hostname} 10.0.0.100 {hostname} 200.200.200.2 other.host.alias.com ::1 ip6-localhost ip6-loopback fe00::0 ip6-localnet ff00::0 ip6-mcastprefix """.format( hostname=MOCK_HOSTNAME ) ) MOCK_ETC_HOSTNAME = "{}\n".format(MOCK_HOSTNAME) PATH = "path/to/some/cloud/conf/file" DEFAULT = {"default_include": PATH} class DefaultConfigsBase: @classmethod def setUpClass(cls): cls.mock_master_default_opts = dict( root_dir=RUNTIME_VARS.TMP_ROOT_DIR, log_file=os.path.join( RUNTIME_VARS.TMP_ROOT_DIR, "var", "log", "salt", "master" ), pid_file=os.path.join( RUNTIME_VARS.TMP_ROOT_DIR, "var", "run", "salt-master.pid" ), ) class SampleConfTest(DefaultConfigsBase, TestCase): """ Validate files in the salt/conf directory. """ def test_conf_master_sample_is_commented(self): """ The sample config file located in salt/conf/master must be completely commented out. This test checks for any lines that are not commented or blank. """ master_config = SAMPLE_CONF_DIR + "master" ret = salt.config._read_conf_file(master_config) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format(master_config), ) def test_conf_minion_sample_is_commented(self): """ The sample config file located in salt/conf/minion must be completely commented out. This test checks for any lines that are not commented or blank. """ minion_config = SAMPLE_CONF_DIR + "minion" ret = salt.config._read_conf_file(minion_config) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format(minion_config), ) def test_conf_cloud_sample_is_commented(self): """ The sample config file located in salt/conf/cloud must be completely commented out. This test checks for any lines that are not commented or blank. """ cloud_config = SAMPLE_CONF_DIR + "cloud" ret = salt.config._read_conf_file(cloud_config) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format(cloud_config), ) def test_conf_cloud_profiles_sample_is_commented(self): """ The sample config file located in salt/conf/cloud.profiles must be completely commented out. This test checks for any lines that are not commented or blank. """ cloud_profiles_config = SAMPLE_CONF_DIR + "cloud.profiles" ret = salt.config._read_conf_file(cloud_profiles_config) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format( cloud_profiles_config ), ) def test_conf_cloud_providers_sample_is_commented(self): """ The sample config file located in salt/conf/cloud.providers must be completely commented out. This test checks for any lines that are not commented or blank. """ cloud_providers_config = SAMPLE_CONF_DIR + "cloud.providers" ret = salt.config._read_conf_file(cloud_providers_config) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format( cloud_providers_config ), ) def test_conf_proxy_sample_is_commented(self): """ The sample config file located in salt/conf/proxy must be completely commented out. This test checks for any lines that are not commented or blank. """ proxy_config = SAMPLE_CONF_DIR + "proxy" ret = salt.config._read_conf_file(proxy_config) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format(proxy_config), ) def test_conf_roster_sample_is_commented(self): """ The sample config file located in salt/conf/roster must be completely commented out. This test checks for any lines that are not commented or blank. """ roster_config = SAMPLE_CONF_DIR + "roster" ret = salt.config._read_conf_file(roster_config) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format(roster_config), ) def test_conf_cloud_profiles_d_files_are_commented(self): """ All cloud profile sample configs in salt/conf/cloud.profiles.d/* must be completely commented out. This test loops through all of the files in that directory to check for any lines that are not commented or blank. """ cloud_sample_dir = SAMPLE_CONF_DIR + "cloud.profiles.d/" if not os.path.exists(cloud_sample_dir): self.skipTest( "Sample config directory '{}' is missing.".format(cloud_sample_dir) ) cloud_sample_files = os.listdir(cloud_sample_dir) for conf_file in cloud_sample_files: profile_conf = cloud_sample_dir + conf_file ret = salt.config._read_conf_file(profile_conf) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format(conf_file), ) def test_conf_cloud_providers_d_files_are_commented(self): """ All cloud profile sample configs in salt/conf/cloud.providers.d/* must be completely commented out. This test loops through all of the files in that directory to check for any lines that are not commented or blank. """ cloud_sample_dir = SAMPLE_CONF_DIR + "cloud.providers.d/" if not os.path.exists(cloud_sample_dir): self.skipTest( "Sample config directory '{}' is missing.".format(cloud_sample_dir) ) cloud_sample_files = os.listdir(cloud_sample_dir) for conf_file in cloud_sample_files: provider_conf = cloud_sample_dir + conf_file ret = salt.config._read_conf_file(provider_conf) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format(conf_file), ) def test_conf_cloud_maps_d_files_are_commented(self): """ All cloud profile sample configs in salt/conf/cloud.maps.d/* must be completely commented out. This test loops through all of the files in that directory to check for any lines that are not commented or blank. """ cloud_sample_dir = SAMPLE_CONF_DIR + "cloud.maps.d/" if not os.path.exists(cloud_sample_dir): self.skipTest( "Sample config directory '{}' is missing.".format(cloud_sample_dir) ) cloud_sample_files = os.listdir(cloud_sample_dir) for conf_file in cloud_sample_files: map_conf = cloud_sample_dir + conf_file ret = salt.config._read_conf_file(map_conf) self.assertEqual( ret, {}, "Sample config file '{}' must be commented out.".format(conf_file), ) def _unhandled_mock_read(filename): """ Raise an error because we should not be calling salt.utils.files.fopen() """ raise CommandExecutionError("Unhandled mock read for {}".format(filename)) def _salt_configuration_error(filename): """ Raise an error to indicate error in the Salt configuration file """ raise SaltConfigurationError("Configuration error in {}".format(filename)) class ConfigTestCase(TestCase, AdaptedConfigurationTestCaseMixin): @with_tempfile() def test_sha256_is_default_for_master(self, fpath): with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write("root_dir: /\n" "key_logfile: key\n") config = salt.config.master_config(fpath) self.assertEqual(config["hash_type"], "sha256") @with_tempfile() def test_sha256_is_default_for_minion(self, fpath): with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write("root_dir: /\n" "key_logfile: key\n") config = salt.config.minion_config(fpath) self.assertEqual(config["hash_type"], "sha256") @with_tempfile() def test_proper_path_joining(self, fpath): temp_config = "root_dir: /\n" "key_logfile: key\n" if salt.utils.platform.is_windows(): temp_config = "root_dir: c:\\\n" "key_logfile: key\n" with salt.utils.files.fopen(fpath, "w") as fp_: fp_.write(temp_config) config = salt.config.master_config(fpath) expect_path_join = os.path.join("/", "key") expect_sep_join = "//key" if salt.utils.platform.is_windows(): expect_path_join = os.path.join("c:\\", "key") expect_sep_join = "c:\\\\key" # os.path.join behavior self.assertEqual(config["key_logfile"], expect_path_join) # os.sep.join behavior self.assertNotEqual(config["key_logfile"], expect_sep_join) @with_tempdir() def test_common_prefix_stripping(self, tempdir): root_dir = os.path.join(tempdir, "foo", "bar") os.makedirs(root_dir) fpath = os.path.join(root_dir, "config") with salt.utils.files.fopen(fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(root_dir, fpath)) config = salt.config.master_config(fpath) self.assertEqual(config["log_file"], fpath) @with_tempdir() def test_default_root_dir_included_in_config_root_dir(self, tempdir): root_dir = os.path.join(tempdir, "foo", "bar") os.makedirs(root_dir) fpath = os.path.join(root_dir, "config") with salt.utils.files.fopen(fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(root_dir, fpath)) config = salt.config.master_config(fpath) self.assertEqual(config["log_file"], fpath) @skipIf( salt.utils.platform.is_windows(), "You can't set an environment dynamically in Windows", ) @with_tempdir() def test_load_master_config_from_environ_var(self, tempdir): env_root_dir = os.path.join(tempdir, "foo", "env") os.makedirs(env_root_dir) env_fpath = os.path.join(env_root_dir, "config-env") with salt.utils.files.fopen(env_fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(env_root_dir, env_fpath)) with patched_environ(SALT_MASTER_CONFIG=env_fpath): # Should load from env variable, not the default configuration file. config = salt.config.master_config("{}/master".format(CONFIG_DIR)) self.assertEqual(config["log_file"], env_fpath) root_dir = os.path.join(tempdir, "foo", "bar") os.makedirs(root_dir) fpath = os.path.join(root_dir, "config") with salt.utils.files.fopen(fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(root_dir, fpath)) # Let's set the environment variable, yet, since the configuration # file path is not the default one, i.e., the user has passed an # alternative configuration file form the CLI parser, the # environment variable will be ignored. with patched_environ(SALT_MASTER_CONFIG=env_fpath): config = salt.config.master_config(fpath) self.assertEqual(config["log_file"], fpath) @skipIf( salt.utils.platform.is_windows(), "You can't set an environment dynamically in Windows", ) @with_tempdir() def test_load_minion_config_from_environ_var(self, tempdir): env_root_dir = os.path.join(tempdir, "foo", "env") os.makedirs(env_root_dir) env_fpath = os.path.join(env_root_dir, "config-env") with salt.utils.files.fopen(env_fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(env_root_dir, env_fpath)) with patched_environ(SALT_MINION_CONFIG=env_fpath): # Should load from env variable, not the default configuration file config = salt.config.minion_config("{}/minion".format(CONFIG_DIR)) self.assertEqual(config["log_file"], env_fpath) root_dir = os.path.join(tempdir, "foo", "bar") os.makedirs(root_dir) fpath = os.path.join(root_dir, "config") with salt.utils.files.fopen(fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(root_dir, fpath)) # Let's set the environment variable, yet, since the configuration # file path is not the default one, i.e., the user has passed an # alternative configuration file form the CLI parser, the # environment variable will be ignored. with patched_environ(SALT_MINION_CONFIG=env_fpath): config = salt.config.minion_config(fpath) self.assertEqual(config["log_file"], fpath) @skipIf( salt.utils.platform.is_windows(), "You can't set an environment dynamically in Windows", ) @with_tempdir() def test_load_client_config_from_environ_var(self, tempdir): env_root_dir = os.path.join(tempdir, "foo", "env") os.makedirs(env_root_dir) # Let's populate a master configuration file which should not get # picked up since the client configuration tries to load the master # configuration settings using the provided client configuration # file master_config = os.path.join(env_root_dir, "master") with salt.utils.files.fopen(master_config, "w") as fp_: fp_.write( "blah: true\n" "root_dir: {}\n" "log_file: {}\n".format(env_root_dir, master_config) ) # Now the client configuration file env_fpath = os.path.join(env_root_dir, "config-env") with salt.utils.files.fopen(env_fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(env_root_dir, env_fpath)) with patched_environ( SALT_MASTER_CONFIG=master_config, SALT_CLIENT_CONFIG=env_fpath ): # Should load from env variable, not the default configuration file config = salt.config.client_config(os.path.expanduser("~/.salt")) self.assertEqual(config["log_file"], env_fpath) self.assertTrue("blah" not in config) root_dir = os.path.join(tempdir, "foo", "bar") os.makedirs(root_dir) fpath = os.path.join(root_dir, "config") with salt.utils.files.fopen(fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(root_dir, fpath)) # Let's set the environment variable, yet, since the configuration # file path is not the default one, i.e., the user has passed an # alternative configuration file form the CLI parser, the # environment variable will be ignored. with patched_environ( SALT_MASTER_CONFIG=env_fpath, SALT_CLIENT_CONFIG=env_fpath ): config = salt.config.master_config(fpath) self.assertEqual(config["log_file"], fpath) @with_tempdir() def test_issue_5970_minion_confd_inclusion(self, tempdir): minion_config = os.path.join(tempdir, "minion") minion_confd = os.path.join(tempdir, "minion.d") os.makedirs(minion_confd) # Let's populate a minion configuration file with some basic # settings with salt.utils.files.fopen(minion_config, "w") as fp_: fp_.write( "blah: false\n" "root_dir: {}\n" "log_file: {}\n".format(tempdir, minion_config) ) # Now, let's populate an extra configuration file under minion.d # Notice that above we've set blah as False and below as True. # Since the minion.d files are loaded after the main configuration # file so overrides can happen, the final value of blah should be # True. extra_config = os.path.join(minion_confd, "extra.conf") with salt.utils.files.fopen(extra_config, "w") as fp_: fp_.write("blah: true\n") # Let's load the configuration config = salt.config.minion_config(minion_config) self.assertEqual(config["log_file"], minion_config) # As proven by the assertion below, blah is True self.assertTrue(config["blah"]) @with_tempdir() def test_master_confd_inclusion(self, tempdir): master_config = os.path.join(tempdir, "master") master_confd = os.path.join(tempdir, "master.d") os.makedirs(master_confd) # Let's populate a master configuration file with some basic # settings with salt.utils.files.fopen(master_config, "w") as fp_: fp_.write( "blah: false\n" "root_dir: {}\n" "log_file: {}\n".format(tempdir, master_config) ) # Now, let's populate an extra configuration file under master.d # Notice that above we've set blah as False and below as True. # Since the master.d files are loaded after the main configuration # file so overrides can happen, the final value of blah should be # True. extra_config = os.path.join(master_confd, "extra.conf") with salt.utils.files.fopen(extra_config, "w") as fp_: fp_.write("blah: true\n") # Let's load the configuration config = salt.config.master_config(master_config) self.assertEqual(config["log_file"], master_config) # As proven by the assertion below, blah is True self.assertTrue(config["blah"]) @with_tempfile() @with_tempdir() def test_master_file_roots_glob(self, tempdir, fpath): # Create some files for f in "abc": fpath = os.path.join(tempdir, f) with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write(f) with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write( "file_roots:\n" " base:\n" " - {}".format(os.path.join(tempdir, "*")) ) config = salt.config.master_config(fpath) base = config["file_roots"]["base"] self.assertEqual( set(base), { os.path.join(tempdir, "a"), os.path.join(tempdir, "b"), os.path.join(tempdir, "c"), }, ) def test_validate_bad_file_roots(self): expected = salt.config._expand_glob_path([salt.syspaths.BASE_FILE_ROOTS_DIR]) with patch("salt.config._normalize_roots") as mk: ret = salt.config._validate_file_roots(None) assert not mk.called assert ret == {"base": expected} @with_tempfile() @with_tempdir() def test_master_pillar_roots_glob(self, tempdir, fpath): # Create some files. for f in "abc": fpath = os.path.join(tempdir, f) with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write(f) with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write( "pillar_roots:\n" " base:\n" " - {}".format(os.path.join(tempdir, "*")) ) config = salt.config.master_config(fpath) base = config["pillar_roots"]["base"] self.assertEqual( set(base), { os.path.join(tempdir, "a"), os.path.join(tempdir, "b"), os.path.join(tempdir, "c"), }, ) def test_validate_bad_pillar_roots(self): expected = salt.config._expand_glob_path([salt.syspaths.BASE_PILLAR_ROOTS_DIR]) with patch("salt.config._normalize_roots") as mk: ret = salt.config._validate_pillar_roots(None) assert not mk.called assert ret == {"base": expected} @with_tempdir() @slowTest def test_master_id_function(self, tempdir): master_config = os.path.join(tempdir, "master") with salt.utils.files.fopen(master_config, "w") as fp_: fp_.write( "id_function:\n" " test.echo:\n" " text: hello_world\n" "root_dir: {}\n" "log_file: {}\n".format(tempdir, master_config) ) # Let's load the configuration config = salt.config.master_config(master_config) self.assertEqual(config["log_file"], master_config) # 'master_config' appends '_master' to the ID self.assertEqual(config["id"], "hello_world_master") @with_tempfile() @with_tempdir() def test_minion_file_roots_glob(self, tempdir, fpath): # Create some files. for f in "abc": fpath = os.path.join(tempdir, f) with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write(f) with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write( "file_roots:\n" " base:\n" " - {}".format(os.path.join(tempdir, "*")) ) config = salt.config.minion_config(fpath) base = config["file_roots"]["base"] self.assertEqual( set(base), { os.path.join(tempdir, "a"), os.path.join(tempdir, "b"), os.path.join(tempdir, "c"), }, ) @with_tempfile() @with_tempdir() def test_minion_pillar_roots_glob(self, tempdir, fpath): # Create some files. for f in "abc": fpath = os.path.join(tempdir, f) with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write(f) with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write( "pillar_roots:\n" " base:\n" " - {}".format(os.path.join(tempdir, "*")) ) config = salt.config.minion_config(fpath) base = config["pillar_roots"]["base"] self.assertEqual( set(base), { os.path.join(tempdir, "a"), os.path.join(tempdir, "b"), os.path.join(tempdir, "c"), }, ) @with_tempdir() @slowTest def test_minion_id_function(self, tempdir): minion_config = os.path.join(tempdir, "minion") with salt.utils.files.fopen(minion_config, "w") as fp_: fp_.write( "id_function:\n" " test.echo:\n" " text: hello_world\n" "root_dir: {}\n" "log_file: {}\n".format(tempdir, minion_config) ) # Let's load the configuration config = salt.config.minion_config(minion_config) self.assertEqual(config["log_file"], minion_config) self.assertEqual(config["id"], "hello_world") @with_tempdir() @slowTest def test_minion_id_lowercase(self, tempdir): """ This tests that setting `minion_id_lowercase: True` does lower case the minion id. Lowercase does not operate on a static `id: KING_BOB` setting, or a cached id. """ minion_config = os.path.join(tempdir, "minion") with salt.utils.files.fopen(minion_config, "w") as fp_: fp_.write( textwrap.dedent( """\ id_function: test.echo: text: KING_BOB minion_id_caching: False minion_id_lowercase: True """ ) ) config = salt.config.minion_config(minion_config) # Load the configuration self.assertEqual(config["minion_id_caching"], False) # Check the configuration self.assertEqual(config["minion_id_lowercase"], True) # Check the configuration self.assertEqual(config["id"], "king_bob") @with_tempdir() @slowTest def test_minion_id_remove_domain_string_positive(self, tempdir): """ This tests that the values of `minion_id_remove_domain` is suppressed from a generated minion id, effectivly generating a hostname minion_id. """ minion_config = os.path.join(tempdir, "minion") with salt.utils.files.fopen(minion_config, "w") as fp_: fp_.write( textwrap.dedent( """\ id_function: test.echo: text: king_bob.foo.org minion_id_remove_domain: foo.org minion_id_caching: False """ ) ) # Let's load the configuration config = salt.config.minion_config(minion_config) self.assertEqual(config["minion_id_remove_domain"], "foo.org") self.assertEqual(config["id"], "king_bob") @with_tempdir() @slowTest def test_minion_id_remove_domain_string_negative(self, tempdir): """ See above """ minion_config = os.path.join(tempdir, "minion") with salt.utils.files.fopen(minion_config, "w") as fp_: fp_.write( textwrap.dedent( """\ id_function: test.echo: text: king_bob.foo.org minion_id_remove_domain: bar.org minion_id_caching: False """ ) ) config = salt.config.minion_config(minion_config) self.assertEqual(config["id"], "king_bob.foo.org") @with_tempdir() @slowTest def test_minion_id_remove_domain_bool_true(self, tempdir): """ See above """ minion_config = os.path.join(tempdir, "minion") with salt.utils.files.fopen(minion_config, "w") as fp_: fp_.write( textwrap.dedent( """\ id_function: test.echo: text: king_bob.foo.org minion_id_remove_domain: True minion_id_caching: False """ ) ) config = salt.config.minion_config(minion_config) self.assertEqual(config["id"], "king_bob") @with_tempdir() @slowTest def test_minion_id_remove_domain_bool_false(self, tempdir): """ See above """ minion_config = os.path.join(tempdir, "minion") with salt.utils.files.fopen(minion_config, "w") as fp_: fp_.write( textwrap.dedent( """\ id_function: test.echo: text: king_bob.foo.org minion_id_remove_domain: False minion_id_caching: False """ ) ) config = salt.config.minion_config(minion_config) self.assertEqual(config["id"], "king_bob.foo.org") @with_tempdir() def test_backend_rename(self, tempdir): """ This tests that we successfully rename git, hg, svn, and minion to gitfs, hgfs, svnfs, and minionfs in the master and minion opts. """ fpath = salt.utils.files.mkstemp(dir=tempdir) with salt.utils.files.fopen(fpath, "w") as fp_: fp_.write( textwrap.dedent( """\ fileserver_backend: - roots - git - hg - svn - minion """ ) ) master_config = salt.config.master_config(fpath) minion_config = salt.config.minion_config(fpath) expected = ["roots", "gitfs", "hgfs", "svnfs", "minionfs"] self.assertEqual(master_config["fileserver_backend"], expected) self.assertEqual(minion_config["fileserver_backend"], expected) def test_syndic_config(self): minion_conf_path = self.get_config_file_path("syndic") master_conf_path = os.path.join(os.path.dirname(minion_conf_path), "master") syndic_opts = salt.config.syndic_config(master_conf_path, minion_conf_path) root_dir = syndic_opts["root_dir"] # id & pki dir are shared & so configured on the minion side self.assertEqual(syndic_opts["id"], "syndic") self.assertEqual(syndic_opts["pki_dir"], os.path.join(root_dir, "pki")) # the rest is configured master side if RUNTIME_VARS.PYTEST_SESSION is False: # Pytest assigns ports dynamically self.assertEqual(syndic_opts["master_port"], 54506) self.assertEqual(syndic_opts["master"], "localhost") self.assertEqual( syndic_opts["sock_dir"], os.path.join(root_dir, "syndic_sock") ) else: self.assertEqual(syndic_opts["master"], "127.0.0.1") self.assertEqual( syndic_opts["sock_dir"], os.path.join(root_dir, "run", "minion") ) self.assertEqual(syndic_opts["cachedir"], os.path.join(root_dir, "cache")) self.assertEqual( syndic_opts["log_file"], os.path.join(root_dir, "logs", "syndic.log") ) self.assertEqual( syndic_opts["pidfile"], os.path.join(root_dir, "run", "syndic.pid") ) # Show that the options of localclient that repub to local master # are not merged with syndic ones self.assertEqual(syndic_opts["_master_conf_file"], minion_conf_path) self.assertEqual(syndic_opts["_minion_conf_file"], master_conf_path) @with_tempfile() def _get_tally(self, fpath, conf_func): """ This ensures that any strings which are loaded are unicode strings """ tally = {} def _count_strings(config): if isinstance(config, dict): for key, val in config.items(): log.debug("counting strings in dict key: %s", key) log.debug("counting strings in dict val: %s", val) _count_strings(key) _count_strings(val) elif isinstance(config, list): log.debug("counting strings in list: %s", config) for item in config: _count_strings(item) else: if isinstance(config, str): tally["unicode"] = tally.get("unicode", 0) + 1 with salt.utils.files.fopen(fpath, "w") as wfh: wfh.write( textwrap.dedent( """ foo: bar mylist: - somestring - 9 - 123.456 - True - nested: - key: val - nestedlist: - foo - bar - baz mydict: - somestring: 9 - 123.456: 789 - True: False - nested: - key: val - nestedlist: - foo - bar - baz""" ) ) if conf_func is salt.config.master_config: wfh.write("\n\n") wfh.write( textwrap.dedent( """ rest_cherrypy: port: 8000 disable_ssl: True app_path: /beacon_demo app: /srv/web/html/index.html static: /srv/web/static""" ) ) config = conf_func(fpath) _count_strings(config) return tally def test_conf_file_strings_are_unicode_for_master(self): """ This ensures that any strings which are loaded are unicode strings """ # pylint: disable=no-value-for-parameter tally = self._get_tally(salt.config.master_config) # pylint: enable=no-value-for-parameter non_unicode = tally.get("non_unicode", []) self.assertEqual(len(non_unicode), 8 if six.PY2 else 0, non_unicode) self.assertTrue(tally["unicode"] > 0) def test_conf_file_strings_are_unicode_for_minion(self): """ This ensures that any strings which are loaded are unicode strings """ # pylint: disable=no-value-for-parameter tally = self._get_tally(salt.config.minion_config) # pylint: enable=no-value-for-parameter non_unicode = tally.get("non_unicode", []) self.assertEqual(len(non_unicode), 0, non_unicode) self.assertTrue(tally["unicode"] > 0) def test__read_conf_file_invalid_yaml__schedule_conf(self): """ If ``_schedule.conf`` is an invalid file a YAMLError will be thrown which should cause the invalid file to be replaced by ``_schedule.confYAMLError`` """ import salt.config as config yaml_error = MagicMock(side_effect=[salt.utils.yaml.YAMLError]) with patch("salt.utils.files.fopen", MagicMock()), patch( "salt.utils.yaml.safe_load", yaml_error ), patch("os.replace") as mock_os: path = os.sep + os.path.join("some", "path", "_schedule.conf") config._read_conf_file(path) mock_os.assert_called_once_with(path, path + "YAMLError") def test__read_conf_file_invalid_yaml(self): """ Any other file that throws a YAMLError should raise a SaltConfigurationError and should not trigger an os.replace """ import salt.config as config yaml_error = MagicMock(side_effect=[salt.utils.yaml.YAMLError]) with patch("salt.utils.files.fopen", MagicMock()), patch( "salt.utils.yaml.safe_load", yaml_error ), patch("os.replace") as mock_os: path = os.sep + os.path.join("etc", "salt", "minion") self.assertRaises(SaltConfigurationError, config._read_conf_file, path=path) mock_os.assert_not_called() def test__read_conf_file_empty_dict(self): """ A config file that is not rendered as a dictionary by the YAML loader should also raise a SaltConfigurationError and should not trigger an os.replace """ import salt.config as config mock_safe_load = MagicMock(return_value="some non dict data") with patch("salt.utils.files.fopen", MagicMock()), patch( "salt.utils.yaml.safe_load", mock_safe_load ), patch("os.replace") as mock_os: path = os.sep + os.path.join("etc", "salt", "minion") self.assertRaises(SaltConfigurationError, config._read_conf_file, path=path) mock_os.assert_not_called() def test__read_conf_file_integer_id(self): """ An integer id should be a string """ import salt.config as config mock_safe_load = MagicMock(return_value={"id": 1234}) with patch("salt.utils.files.fopen", MagicMock()), patch( "salt.utils.yaml.safe_load", mock_safe_load ), patch("os.replace") as mock_os: path = os.sep + os.path.join("etc", "salt", "minion") expected = {"id": "1234"} result = config._read_conf_file(path) mock_os.assert_not_called() self.assertEqual(expected, result) # <---- Salt Cloud Configuration Tests --------------------------------------------- # cloud_config tests def test_cloud_config_double_master_path(self): """ Tests passing in master_config_path and master_config kwargs. """ with patch("salt.config.load_config", MagicMock(return_value={})): self.assertRaises( SaltCloudConfigError, salt.config.cloud_config, PATH, master_config_path="foo", master_config="bar", ) def test_cloud_config_double_providers_path(self): """ Tests passing in providers_config_path and providers_config kwargs. """ with patch("salt.config.load_config", MagicMock(return_value={})): self.assertRaises( SaltCloudConfigError, salt.config.cloud_config, PATH, providers_config_path="foo", providers_config="bar", ) def test_cloud_config_double_profiles_path(self): """ Tests passing in profiles_config_path and profiles_config kwargs. """ with patch("salt.config.load_config", MagicMock(return_value={})): self.assertRaises( SaltCloudConfigError, salt.config.cloud_config, PATH, profiles_config_path="foo", profiles_config="bar", ) def test_cloud_config_providers_in_opts(self): """ Tests mixing old cloud providers with pre-configured providers configurations using the providers_config kwarg """ with patch("salt.config.load_config", MagicMock(return_value={})): with patch( "salt.config.apply_cloud_config", MagicMock(return_value={"providers": "foo"}), ): self.assertRaises( SaltCloudConfigError, salt.config.cloud_config, PATH, providers_config="bar", ) def test_cloud_config_providers_in_opts_path(self): """ Tests mixing old cloud providers with pre-configured providers configurations using the providers_config_path kwarg """ with patch("salt.config.load_config", MagicMock(return_value={})): with patch( "salt.config.apply_cloud_config", MagicMock(return_value={"providers": "foo"}), ): with patch("os.path.isfile", MagicMock(return_value=True)): self.assertRaises( SaltCloudConfigError, salt.config.cloud_config, PATH, providers_config_path="bar", ) def test_cloud_config_deploy_scripts_search_path(self): """ Tests the contents of the 'deploy_scripts_search_path' tuple to ensure that the correct deploy search paths are present. There should be two search paths reported in the tuple: ``/etc/salt/cloud.deploy.d`` and ``/salt/cloud/deploy``. The first element is usually ``/etc/salt/cloud.deploy.d``, but sometimes is can be something like ``/etc/local/salt/cloud.deploy.d``, so we'll only test against the last part of the path. """ with patch("os.path.isdir", MagicMock(return_value=True)): search_paths = salt.config.cloud_config("/etc/salt/cloud").get( "deploy_scripts_search_path" ) etc_deploy_path = "/salt/cloud.deploy.d" deploy_path = "/salt/cloud/deploy" if salt.utils.platform.is_windows(): etc_deploy_path = "/salt\\cloud.deploy.d" deploy_path = "\\salt\\cloud\\deploy" # Check cloud.deploy.d path is the first element in the search_paths tuple self.assertTrue(search_paths[0].endswith(etc_deploy_path)) # Check the second element in the search_paths tuple self.assertTrue(search_paths[1].endswith(deploy_path)) # apply_cloud_config tests def test_apply_cloud_config_no_provider_detail_list(self): """ Tests when the provider is not contained in a list of details """ overrides = {"providers": {"foo": [{"bar": "baz"}]}} self.assertRaises( SaltCloudConfigError, salt.config.apply_cloud_config, overrides, defaults=DEFAULT, ) def test_apply_cloud_config_no_provider_detail_dict(self): """ Tests when the provider is not contained in the details dictionary """ overrides = {"providers": {"foo": {"bar": "baz"}}} self.assertRaises( SaltCloudConfigError, salt.config.apply_cloud_config, overrides, defaults=DEFAULT, ) def test_apply_cloud_config_success_list(self): """ Tests success when valid data is passed into the function as a list """ with patch( "salt.config.old_to_new", MagicMock( return_value={ "default_include": "path/to/some/cloud/conf/file", "providers": {"foo": {"bar": {"driver": "foo:bar"}}}, } ), ): overrides = {"providers": {"foo": [{"driver": "bar"}]}} ret = { "default_include": "path/to/some/cloud/conf/file", "providers": {"foo": {"bar": {"driver": "foo:bar"}}}, } self.assertEqual( salt.config.apply_cloud_config(overrides, defaults=DEFAULT), ret ) def test_apply_cloud_config_success_dict(self): """ Tests success when valid data is passed into function as a dictionary """ with patch( "salt.config.old_to_new", MagicMock( return_value={ "default_include": "path/to/some/cloud/conf/file", "providers": {"foo": {"bar": {"driver": "foo:bar"}}}, } ), ): overrides = {"providers": {"foo": {"driver": "bar"}}} ret = { "default_include": "path/to/some/cloud/conf/file", "providers": {"foo": {"bar": {"driver": "foo:bar"}}}, } self.assertEqual( salt.config.apply_cloud_config(overrides, defaults=DEFAULT), ret ) # apply_vm_profiles_config tests def test_apply_vm_profiles_config_bad_profile_format(self): """ Tests passing in a bad profile format in overrides """ overrides = {"foo": "bar", "conf_file": PATH} self.assertRaises( SaltCloudConfigError, salt.config.apply_vm_profiles_config, PATH, overrides, defaults=DEFAULT, ) def test_apply_vm_profiles_config_success(self): """ Tests passing in valid provider and profile config files successfully """ providers = { "test-provider": { "digitalocean": {"driver": "digitalocean", "profiles": {}} } } overrides = { "test-profile": { "provider": "test-provider", "image": "Ubuntu 12.10 x64", "size": "512MB", }, "conf_file": PATH, } ret = { "test-profile": { "profile": "test-profile", "provider": "test-provider:digitalocean", "image": "Ubuntu 12.10 x64", "size": "512MB", } } self.assertEqual( salt.config.apply_vm_profiles_config( providers, overrides, defaults=DEFAULT ), ret, ) def test_apply_vm_profiles_config_extend_success(self): """ Tests profile extends functionality with valid provider and profile configs """ providers = {"test-config": {"ec2": {"profiles": {}, "driver": "ec2"}}} overrides = { "Amazon": {"image": "test-image-1", "extends": "dev-instances"}, "Fedora": {"image": "test-image-2", "extends": "dev-instances"}, "conf_file": PATH, "dev-instances": {"ssh_username": "test_user", "provider": "test-config"}, } ret = { "Amazon": { "profile": "Amazon", "ssh_username": "test_user", "image": "test-image-1", "provider": "test-config:ec2", }, "Fedora": { "profile": "Fedora", "ssh_username": "test_user", "image": "test-image-2", "provider": "test-config:ec2", }, "dev-instances": { "profile": "dev-instances", "ssh_username": "test_user", "provider": "test-config:ec2", }, } self.assertEqual( salt.config.apply_vm_profiles_config( providers, overrides, defaults=DEFAULT ), ret, ) def test_apply_vm_profiles_config_extend_override_success(self): """ Tests profile extends and recursively merges data elements """ self.maxDiff = None providers = {"test-config": {"ec2": {"profiles": {}, "driver": "ec2"}}} overrides = { "Fedora": { "image": "test-image-2", "extends": "dev-instances", "minion": {"grains": {"stage": "experimental"}}, }, "conf_file": PATH, "dev-instances": { "ssh_username": "test_user", "provider": "test-config", "minion": {"grains": {"role": "webserver"}}, }, } ret = { "Fedora": { "profile": "Fedora", "ssh_username": "test_user", "image": "test-image-2", "minion": {"grains": {"role": "webserver", "stage": "experimental"}}, "provider": "test-config:ec2", }, "dev-instances": { "profile": "dev-instances", "ssh_username": "test_user", "minion": {"grains": {"role": "webserver"}}, "provider": "test-config:ec2", }, } self.assertEqual( salt.config.apply_vm_profiles_config( providers, overrides, defaults=DEFAULT ), ret, ) # apply_cloud_providers_config tests def test_apply_cloud_providers_config_same_providers(self): """ Tests when two providers are given with the same provider name """ overrides = { "my-dev-envs": [ { "id": "ABCDEFGHIJKLMNOP", "key": "supersecretkeysupersecretkey", "driver": "ec2", }, { "apikey": "abcdefghijklmnopqrstuvwxyz", "password": "supersecret", "driver": "ec2", }, ], "conf_file": PATH, } self.assertRaises( SaltCloudConfigError, salt.config.apply_cloud_providers_config, overrides, DEFAULT, ) def test_apply_cloud_providers_config_extend(self): """ Tests the successful extension of a cloud provider """ overrides = { "my-production-envs": [ { "extends": "my-dev-envs:ec2", "location": "us-east-1", "user": "ec2-user@mycorp.com", } ], "my-dev-envs": [ { "id": "ABCDEFGHIJKLMNOP", "user": "user@mycorp.com", "location": "ap-southeast-1", "key": "supersecretkeysupersecretkey", "driver": "ec2", }, { "apikey": "abcdefghijklmnopqrstuvwxyz", "password": "supersecret", "driver": "linode", }, { "id": "a-tencentcloud-id", "key": "a-tencentcloud-key", "location": "ap-guangzhou", "driver": "tencentcloud", }, ], "conf_file": PATH, } ret = { "my-production-envs": { "ec2": { "profiles": {}, "location": "us-east-1", "key": "supersecretkeysupersecretkey", "driver": "ec2", "id": "ABCDEFGHIJKLMNOP", "user": "ec2-user@mycorp.com", } }, "my-dev-envs": { "linode": { "apikey": "abcdefghijklmnopqrstuvwxyz", "password": "supersecret", "profiles": {}, "driver": "linode", }, "tencentcloud": { "id": "a-tencentcloud-id", "key": "a-tencentcloud-key", "location": "ap-guangzhou", "profiles": {}, "driver": "tencentcloud", }, "ec2": { "profiles": {}, "location": "ap-southeast-1", "key": "supersecretkeysupersecretkey", "driver": "ec2", "id": "ABCDEFGHIJKLMNOP", "user": "user@mycorp.com", }, }, } self.assertEqual( ret, salt.config.apply_cloud_providers_config(overrides, defaults=DEFAULT) ) def test_apply_cloud_providers_config_extend_multiple(self): """ Tests the successful extension of two cloud providers """ overrides = { "my-production-envs": [ { "extends": "my-dev-envs:ec2", "location": "us-east-1", "user": "ec2-user@mycorp.com", }, { "password": "new-password", "extends": "my-dev-envs:linode", "location": "Salt Lake City", }, { "extends": "my-dev-envs:tencentcloud", "id": "new-id", "key": "new-key", "location": "ap-beijing", }, ], "my-dev-envs": [ { "id": "ABCDEFGHIJKLMNOP", "user": "user@mycorp.com", "location": "ap-southeast-1", "key": "supersecretkeysupersecretkey", "driver": "ec2", }, { "apikey": "abcdefghijklmnopqrstuvwxyz", "password": "supersecret", "driver": "linode", }, { "id": "the-tencentcloud-id", "location": "ap-beijing", "key": "the-tencentcloud-key", "driver": "tencentcloud", }, ], "conf_file": PATH, } ret = { "my-production-envs": { "linode": { "apikey": "abcdefghijklmnopqrstuvwxyz", "profiles": {}, "location": "Salt Lake City", "driver": "linode", "password": "new-password", }, "ec2": { "user": "ec2-user@mycorp.com", "key": "supersecretkeysupersecretkey", "driver": "ec2", "id": "ABCDEFGHIJKLMNOP", "profiles": {}, "location": "us-east-1", }, "tencentcloud": { "id": "new-id", "key": "new-key", "location": "ap-beijing", "profiles": {}, "driver": "tencentcloud", }, }, "my-dev-envs": { "linode": { "apikey": "abcdefghijklmnopqrstuvwxyz", "password": "supersecret", "profiles": {}, "driver": "linode", }, "ec2": { "profiles": {}, "user": "user@mycorp.com", "key": "supersecretkeysupersecretkey", "driver": "ec2", "id": "ABCDEFGHIJKLMNOP", "location": "ap-southeast-1", }, "tencentcloud": { "id": "the-tencentcloud-id", "key": "the-tencentcloud-key", "location": "ap-beijing", "profiles": {}, "driver": "tencentcloud", }, }, } self.assertEqual( ret, salt.config.apply_cloud_providers_config(overrides, defaults=DEFAULT) ) def test_apply_cloud_providers_config_extends_bad_alias(self): """ Tests when the extension contains an alias not found in providers list """ overrides = { "my-production-envs": [ { "extends": "test-alias:ec2", "location": "us-east-1", "user": "ec2-user@mycorp.com", } ], "my-dev-envs": [ { "id": "ABCDEFGHIJKLMNOP", "user": "user@mycorp.com", "location": "ap-southeast-1", "key": "supersecretkeysupersecretkey", "driver": "ec2", } ], "conf_file": PATH, } self.assertRaises( SaltCloudConfigError, salt.config.apply_cloud_providers_config, overrides, DEFAULT, ) def test_apply_cloud_providers_config_extends_bad_provider(self): """ Tests when the extension contains a provider not found in providers list """ overrides = { "my-production-envs": [ { "extends": "my-dev-envs:linode", "location": "us-east-1", "user": "ec2-user@mycorp.com", }, { "extends": "my-dev-envs:tencentcloud", "location": "ap-shanghai", "id": "the-tencentcloud-id", }, ], "my-dev-envs": [ { "id": "ABCDEFGHIJKLMNOP", "user": "user@mycorp.com", "location": "ap-southeast-1", "key": "supersecretkeysupersecretkey", "driver": "ec2", } ], "conf_file": PATH, } self.assertRaises( SaltCloudConfigError, salt.config.apply_cloud_providers_config, overrides, DEFAULT, ) def test_apply_cloud_providers_config_extends_no_provider(self): """ Tests when no provider is supplied in the extends statement """ overrides = { "my-production-envs": [ { "extends": "my-dev-envs", "location": "us-east-1", "user": "ec2-user@mycorp.com", }, { "extends": "my-dev-envs:tencentcloud", "location": "ap-shanghai", "id": "the-tencentcloud-id", }, ], "my-dev-envs": [ { "id": "ABCDEFGHIJKLMNOP", "user": "user@mycorp.com", "location": "ap-southeast-1", "key": "supersecretkeysupersecretkey", "driver": "linode", } ], "conf_file": PATH, } self.assertRaises( SaltCloudConfigError, salt.config.apply_cloud_providers_config, overrides, DEFAULT, ) def test_apply_cloud_providers_extends_not_in_providers(self): """ Tests when extends is not in the list of providers """ overrides = { "my-production-envs": [ { "extends": "my-dev-envs ec2", "location": "us-east-1", "user": "ec2-user@mycorp.com", } ], "my-dev-envs": [ { "id": "ABCDEFGHIJKLMNOP", "user": "user@mycorp.com", "location": "ap-southeast-1", "key": "supersecretkeysupersecretkey", "driver": "linode", }, { "id": "a-tencentcloud-id", "key": "a-tencentcloud-key", "location": "ap-guangzhou", "driver": "tencentcloud", }, ], "conf_file": PATH, } self.assertRaises( SaltCloudConfigError, salt.config.apply_cloud_providers_config, overrides, DEFAULT, ) # is_provider_configured tests def test_is_provider_configured_no_alias(self): """ Tests when provider alias is not in opts """ opts = {"providers": "test"} provider = "foo:bar" self.assertFalse(salt.config.is_provider_configured(opts, provider)) def test_is_provider_configured_no_driver(self): """ Tests when provider driver is not in opts """ opts = {"providers": {"foo": "baz"}} provider = "foo:bar" self.assertFalse(salt.config.is_provider_configured(opts, provider)) def test_is_provider_configured_key_is_none(self): """ Tests when a required configuration key is not set """ opts = {"providers": {"foo": {"bar": {"api_key": None}}}} provider = "foo:bar" self.assertFalse( salt.config.is_provider_configured( opts, provider, required_keys=("api_key",) ) ) def test_is_provider_configured_success(self): """ Tests successful cloud provider configuration """ opts = {"providers": {"foo": {"bar": {"api_key": "baz"}}}} provider = "foo:bar" ret = {"api_key": "baz"} self.assertEqual( salt.config.is_provider_configured( opts, provider, required_keys=("api_key",) ), ret, ) def test_is_provider_configured_multiple_driver_not_provider(self): """ Tests when the drive is not the same as the provider when searching through multiple providers """ opts = {"providers": {"foo": {"bar": {"api_key": "baz"}}}} provider = "foo" self.assertFalse(salt.config.is_provider_configured(opts, provider)) def test_is_provider_configured_multiple_key_is_none(self): """ Tests when a required configuration key is not set when searching through multiple providers """ opts = {"providers": {"foo": {"bar": {"api_key": None}}}} provider = "bar" self.assertFalse( salt.config.is_provider_configured( opts, provider, required_keys=("api_key",) ) ) def test_is_provider_configured_multiple_success(self): """ Tests successful cloud provider configuration when searching through multiple providers """ opts = {"providers": {"foo": {"bar": {"api_key": "baz"}}}} provider = "bar" ret = {"api_key": "baz"} self.assertEqual( salt.config.is_provider_configured( opts, provider, required_keys=("api_key",) ), ret, ) # other cloud configuration tests @skipIf( salt.utils.platform.is_windows(), "You can't set an environment dynamically in Windows", ) @with_tempdir() def test_load_cloud_config_from_environ_var(self, tempdir): env_root_dir = os.path.join(tempdir, "foo", "env") os.makedirs(env_root_dir) env_fpath = os.path.join(env_root_dir, "config-env") with salt.utils.files.fopen(env_fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(env_root_dir, env_fpath)) with patched_environ(SALT_CLOUD_CONFIG=env_fpath): # Should load from env variable, not the default configuration file config = salt.config.cloud_config("/etc/salt/cloud") self.assertEqual(config["log_file"], env_fpath) root_dir = os.path.join(tempdir, "foo", "bar") os.makedirs(root_dir) fpath = os.path.join(root_dir, "config") with salt.utils.files.fopen(fpath, "w") as fp_: fp_.write("root_dir: {}\n" "log_file: {}\n".format(root_dir, fpath)) # Let's set the environment variable, yet, since the configuration # file path is not the default one, i.e., the user has passed an # alternative configuration file form the CLI parser, the # environment variable will be ignored. with patched_environ(SALT_CLOUD_CONFIG=env_fpath): config = salt.config.cloud_config(fpath) self.assertEqual(config["log_file"], fpath) @with_tempdir() def test_deploy_search_path_as_string(self, temp_conf_dir): config_file_path = os.path.join(temp_conf_dir, "cloud") deploy_dir_path = os.path.join(temp_conf_dir, "test-deploy.d") for directory in (temp_conf_dir, deploy_dir_path): if not os.path.isdir(directory): os.makedirs(directory) default_config = salt.config.cloud_config(config_file_path) default_config["deploy_scripts_search_path"] = deploy_dir_path with salt.utils.files.fopen(config_file_path, "w") as cfd: salt.utils.yaml.safe_dump(default_config, cfd, default_flow_style=False) default_config = salt.config.cloud_config(config_file_path) # Our custom deploy scripts path was correctly added to the list self.assertIn(deploy_dir_path, default_config["deploy_scripts_search_path"]) # And it's even the first occurrence as it should self.assertEqual( deploy_dir_path, default_config["deploy_scripts_search_path"][0] ) def test_includes_load(self): """ Tests that cloud.{providers,profiles}.d directories are loaded, even if not directly passed in through path """ config_file = self.get_config_file_path("cloud") log.debug("Cloud config file path: %s", config_file) self.assertTrue( os.path.exists(config_file), "{} does not exist".format(config_file) ) config = salt.config.cloud_config(config_file) self.assertIn("providers", config) self.assertIn("ec2-config", config["providers"]) self.assertIn("ec2-test", config["profiles"]) # <---- Salt Cloud Configuration Tests --------------------------------------------- def test_include_config_without_errors(self): """ Tests that include_config function returns valid configuration """ include_file = "minion.d/my.conf" config_path = "/etc/salt/minion" config_opts = {"id": "myminion.example.com"} with patch("glob.glob", MagicMock(return_value=include_file)): with patch( "salt.config._read_conf_file", MagicMock(return_value=config_opts) ): configuration = salt.config.include_config( include_file, config_path, verbose=False ) self.assertEqual(config_opts, configuration) def test_include_config_with_errors(self): """ Tests that include_config function returns valid configuration even on errors """ include_file = "minion.d/my.conf" config_path = "/etc/salt/minion" config_opts = {} with patch("glob.glob", MagicMock(return_value=include_file)): with patch("salt.config._read_conf_file", _salt_configuration_error): configuration = salt.config.include_config( include_file, config_path, verbose=False ) self.assertEqual(config_opts, configuration) def test_include_config_with_errors_exit(self): """ Tests that include_config exits on errors """ include_file = "minion.d/my.conf" config_path = "/etc/salt/minion" with patch("glob.glob", MagicMock(return_value=include_file)): with patch("salt.config._read_conf_file", _salt_configuration_error): with self.assertRaises(SystemExit): salt.config.include_config( include_file, config_path, verbose=False, exit_on_config_errors=True, ) @staticmethod def _get_defaults(**kwargs): ret = { "saltenv": kwargs.pop("saltenv", None), "id": "test", "cachedir": "/A", "sock_dir": "/B", "root_dir": "/C", "fileserver_backend": "roots", "open_mode": False, "auto_accept": False, "file_roots": {}, "pillar_roots": {}, "file_ignore_glob": [], "file_ignore_regex": [], "worker_threads": 5, "hash_type": "sha256", "log_file": "foo.log", } ret.update(kwargs) return ret def test_apply_config(self): """ Ensure that the environment and saltenv options work properly """ with patch.object( salt.config, "_adjust_log_file_override", Mock() ), patch.object(salt.config, "_update_ssl_config", Mock()), patch.object( salt.config, "_update_discovery_config", Mock() ): # MASTER CONFIG # Ensure that environment overrides saltenv when saltenv not # explicitly passed. defaults = self._get_defaults(environment="foo") ret = salt.config.apply_master_config(defaults=defaults) self.assertEqual(ret["environment"], "foo") self.assertEqual(ret["saltenv"], "foo") # Ensure that environment overrides saltenv when saltenv not # explicitly passed. defaults = self._get_defaults(environment="foo", saltenv="bar") ret = salt.config.apply_master_config(defaults=defaults) self.assertEqual(ret["environment"], "bar") self.assertEqual(ret["saltenv"], "bar") # If environment was not explicitly set, it should not be in the # opts at all. defaults = self._get_defaults() ret = salt.config.apply_master_config(defaults=defaults) self.assertNotIn("environment", ret) self.assertEqual(ret["saltenv"], None) # Same test as above but with saltenv explicitly set defaults = self._get_defaults(saltenv="foo") ret = salt.config.apply_master_config(defaults=defaults) self.assertNotIn("environment", ret) self.assertEqual(ret["saltenv"], "foo") # MINION CONFIG # Ensure that environment overrides saltenv when saltenv not # explicitly passed. defaults = self._get_defaults(environment="foo") ret = salt.config.apply_minion_config(defaults=defaults) self.assertEqual(ret["environment"], "foo") self.assertEqual(ret["saltenv"], "foo") # Ensure that environment overrides saltenv when saltenv not # explicitly passed. defaults = self._get_defaults(environment="foo", saltenv="bar") ret = salt.config.apply_minion_config(defaults=defaults) self.assertEqual(ret["environment"], "bar") self.assertEqual(ret["saltenv"], "bar") # If environment was not explicitly set, it should not be in the # opts at all. defaults = self._get_defaults() ret = salt.config.apply_minion_config(defaults=defaults) self.assertNotIn("environment", ret) self.assertEqual(ret["saltenv"], None) # Same test as above but with saltenv explicitly set defaults = self._get_defaults(saltenv="foo") ret = salt.config.apply_minion_config(defaults=defaults) self.assertNotIn("environment", ret) self.assertEqual(ret["saltenv"], "foo") class APIConfigTestCase(DefaultConfigsBase, TestCase): """ TestCase for the api_config function in salt.config.__init__.py """ def setUp(self): # Copy DEFAULT_API_OPTS to restore after the test self.default_api_opts = salt.config.DEFAULT_API_OPTS.copy() def tearDown(self): # Reset DEFAULT_API_OPTS settings as to not interfere with other unit tests salt.config.DEFAULT_API_OPTS = self.default_api_opts def test_api_config_log_file_values(self): """ Tests the opts value of the 'log_file' after running through the various default dict updates. 'log_file' should be updated to match the DEFAULT_API_OPTS 'api_logfile' value. """ with patch( "salt.config.client_config", MagicMock(return_value=self.mock_master_default_opts), ): expected = "{}/var/log/salt/api".format( RUNTIME_VARS.TMP_ROOT_DIR if RUNTIME_VARS.TMP_ROOT_DIR != "/" else "" ) if salt.utils.platform.is_windows(): expected = "{}\\var\\log\\salt\\api".format(RUNTIME_VARS.TMP_ROOT_DIR) ret = salt.config.api_config("/some/fake/path") self.assertEqual(ret["log_file"], expected) def test_api_config_pidfile_values(self): """ Tests the opts value of the 'pidfile' after running through the various default dict updates. 'pidfile' should be updated to match the DEFAULT_API_OPTS 'api_pidfile' value. """ with patch( "salt.config.client_config", MagicMock(return_value=self.mock_master_default_opts), ): expected = "{}/var/run/salt-api.pid".format( RUNTIME_VARS.TMP_ROOT_DIR if RUNTIME_VARS.TMP_ROOT_DIR != "/" else "" ) if salt.utils.platform.is_windows(): expected = "{}\\var\\run\\salt-api.pid".format( RUNTIME_VARS.TMP_ROOT_DIR ) ret = salt.config.api_config("/some/fake/path") self.assertEqual(ret["pidfile"], expected) def test_master_config_file_overrides_defaults(self): """ Tests the opts value of the api config values after running through the various default dict updates that should be overridden by settings in the user's master config file. """ foo_dir = os.path.join(RUNTIME_VARS.TMP_ROOT_DIR, "foo/bar/baz") hello_dir = os.path.join(RUNTIME_VARS.TMP_ROOT_DIR, "hello/world") if salt.utils.platform.is_windows(): foo_dir = "c:\\{}".format(foo_dir.replace("/", "\\")) hello_dir = "c:\\{}".format(hello_dir.replace("/", "\\")) mock_master_config = { "api_pidfile": foo_dir, "api_logfile": hello_dir, "rest_timeout": 5, } mock_master_config.update(self.mock_master_default_opts.copy()) with patch( "salt.config.client_config", MagicMock(return_value=mock_master_config) ): ret = salt.config.api_config("/some/fake/path") self.assertEqual(ret["rest_timeout"], 5) self.assertEqual(ret["api_pidfile"], foo_dir) self.assertEqual(ret["pidfile"], foo_dir) self.assertEqual(ret["api_logfile"], hello_dir) self.assertEqual(ret["log_file"], hello_dir) def test_api_config_prepend_root_dirs_return(self): """ Tests the opts value of the api_logfile, log_file, api_pidfile, and pidfile when a custom root directory is used. This ensures that each of these values is present in the list of opts keys that should have the root_dir prepended when the api_config function returns the opts dictionary. """ mock_log = "/mock/root/var/log/salt/api" mock_pid = "/mock/root/var/run/salt-api.pid" mock_master_config = self.mock_master_default_opts.copy() mock_master_config["root_dir"] = "/mock/root/" if salt.utils.platform.is_windows(): mock_log = "c:\\mock\\root\\var\\log\\salt\\api" mock_pid = "c:\\mock\\root\\var\\run\\salt-api.pid" mock_master_config["root_dir"] = "c:\\mock\\root" with patch( "salt.config.client_config", MagicMock(return_value=mock_master_config) ): ret = salt.config.api_config("/some/fake/path") self.assertEqual(ret["api_logfile"], mock_log) self.assertEqual(ret["log_file"], mock_log) self.assertEqual(ret["api_pidfile"], mock_pid) self.assertEqual(ret["pidfile"], mock_pid)