text: # -*- coding: utf-8 -*-
  """
  Unit tests for salt.config
  """
  
  # Import Python libs
  from __future__ import absolute_import, print_function, unicode_literals
  
  import logging
  import os
  import textwrap
  
  # Import Salt Testing libs
  from tests.support.helpers import with_tempdir, with_tempfile, patched_environ
  from tests.support.mixins import AdaptedConfigurationTestCaseMixin
  from tests.support.unit import skipIf, TestCase
  from tests.support.runtests import RUNTIME_VARS
  from tests.support.mock import (
      NO_MOCK,
      NO_MOCK_REASON,
      Mock,
      MagicMock,
      patch
  )
  
  # Import Salt libs
  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.ext import six
  from salt.syspaths import CONFIG_DIR
  from salt.exceptions import (
      CommandExecutionError,
      SaltCloudConfigError,
      SaltConfigurationError,
  )
  from salt.ext import six
  from salt.syspaths import CONFIG_DIR
  
  # Import Salt Testing libs
  from tests.support.helpers import patched_environ, 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
  
  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(object):
  
      @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)
              )
          #with patch('salt.sysRUNTIME_VARS.ROOT_DIR', RUNTIME_VARS.TMP):
          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)
  
      @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), set([
              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), set([
              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()
      @skipIf(True, "SLOWTEST skip")
      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), set([
              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), set([
              os.path.join(tempdir, 'a'),
              os.path.join(tempdir, 'b'),
              os.path.join(tempdir, 'c')
          ]))
  
      @with_tempdir()
      @skipIf(True, "SLOWTEST skip")
      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()
      @skipIf(True, "SLOWTEST skip")
      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()
      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()
      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()
      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()
      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'))
          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 six.iteritems(config):
                      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, six.string_types):
                      if isinstance(config, six.text_type):
                          tally["unicode"] = tally.get("unicode", 0) + 1
                      else:
                          # We will never reach this on PY3
                          tally.setdefault("non_unicode", []).append(config)
  
          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
          '''
          tally = self._get_tally(salt.config.master_config)  # pylint: disable=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
          '''
          tally = self._get_tally(salt.config.minion_config)  # pylint: disable=no-value-for-parameter
          non_unicode = tally.get('non_unicode', [])
          self.assertEqual(len(non_unicode), 0, non_unicode)
          self.assertTrue(tally["unicode"] > 0)
  
      # <---- 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')
  
      @skipIf(NO_MOCK, NO_MOCK_REASON)
      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')
  
      @skipIf(NO_MOCK, NO_MOCK_REASON)
      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 ``<path-to-salt-install>/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)
  
      @skipIf(NO_MOCK, NO_MOCK_REASON)
      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'
                            }],
                       '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'},
                      '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'
                            }],
                       'my-dev-envs':
                           [{'id': 'ABCDEFGHIJKLMNOP',
                             'user': 'user@mycorp.com',
                             'location': 'ap-southeast-1',
                             'key': 'supersecretkeysupersecretkey',
                             'driver': 'ec2'},
                            {'apikey': 'abcdefghijklmnopqrstuvwxyz',
                             'password': 'supersecret',
                             'driver': 'linode'}],
                       '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'}},
                 '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'}}}
          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'}],
                       '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'}],
                       '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'}],
                       '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
          '''
          log.warning('Clound config file path: %s', self.get_config_file_path('cloud'))
          config = salt.config.cloud_config(self.get_config_file_path('cloud'))
          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')
  
  
  @skipIf(NO_MOCK, NO_MOCK_REASON)
  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)
  