Beispiel #1
0
def main():
    arg_parser = argparse.ArgumentParser()
    arg_parser.add_argument(
        "path",
        help="Chemin du fichier de config à visualiser")
    arg_parser.add_argument(
        "module",
        help="Précise le module dans lequel se trouve le fichier de config")
    args = arg_parser.parse_args()

    parser = ExtendedConfigParser(
        config=environ.get("MFCONFIG", "GENERIC"),
        strict=False, inheritance='im')
    data = codecs.open(args.path, "r", "utf-8")
    module = args.module

    home_env = str(module) + "_HOME"
    home = environ.get(home_env)
    parser.read_file(data)
    res_dict = read_config_file(parser, parser.config_name, home)
    for s in res_dict:
        for o in res_dict[s]:
            print("export " + module.upper() + "_" + s.upper() + "_" +
                  o.upper() + "=\"" + str(res_dict[s][o]) + "\"")

    print("export %s_CONF_GENERATION_TIME=%i" % (module.upper(), time.time()))
Beispiel #2
0
 def init(self):
     self.in_dir = os.environ['MFDATA_DATA_IN_DIR']
     conf_file = os.path.join(os.environ['MODULE_RUNTIME_HOME'], "tmp",
                              "config_auto", "switch.ini")
     if not os.path.exists(conf_file):
         self.error_and_die("no switch configuration file")
     self.condition_tuples = []
     parser = ExtendedConfigParser(config=CONFIG,
                                   strict=False,
                                   inheritance='im',
                                   interpolation=None)
     parser.read(conf_file)
     sections = parser.sections()
     for section in sections:
         directory = parser.get(section, "directory").strip()
         plugin_name = parser.get(section, "plugin_name").strip()
         condition = parser.get(section, "condition").strip()
         magic_file = parser.get(section, "magic_file").strip()
         use_hardlink = parser.getboolean(section, "use_hardlink")
         if magic_file.lower() in ('null', 'none'):
             magic_file = None
         self.condition_tuples.append(
             (plugin_name, condition, directory, magic_file, use_hardlink))
     self.no_match_policy = self.args.no_match_policy
     if self.no_match_policy not in ('keep', 'delete', 'move'):
         self.error_and_die("unknown no-match policy: %s",
                            self.no_match_policy)
     if self.no_match_policy == "move":
         nmpmdd = self.args.no_match_policy_move_dest_dir
         if nmpmdd is None:
             self.error_and_die('you have to set a '
                                'no-match-policy-move-dest-dir'
                                ' in case of move no-match policy')
         mkdir_p_or_die(nmpmdd)
def main():
    arg_parser = argparse.ArgumentParser()
    arg_parser.add_argument("path",
                            help="Chemin du fichier de config à visualiser")
    arg_parser.add_argument(
        "module",
        help="Précise le module dans lequel se trouve le fichier de config")
    args = arg_parser.parse_args()

    parser = ExtendedConfigParser(config=environ.get("MFCONFIG", "GENERIC"),
                                  strict=False,
                                  inheritance='im')
    data = codecs.open(args.path, "r", "utf-8")
    module = args.module

    home_env = str(module) + "_HOME"
    home = environ.get(home_env)
    parser.read_file(data)
    res_dict = read_config_file(parser, parser.config_name, home)
    for s in res_dict:
        for o in res_dict[s]:
            print("export " + module.upper() + "_" + s.upper() + "_" +
                  o.upper() + "=\"" + str(res_dict[s][o]) + "\"")

    print("export %s_CONF_GENERATION_TIME=%i" % (module.upper(), time.time()))
Beispiel #4
0
def build_plugin(plugin_path, plugins_base_dir=None):
    plugin_path = os.path.abspath(plugin_path)
    plugins_base_dir = _get_plugins_base_dir(plugins_base_dir)
    base = os.path.join(plugins_base_dir, "base")
    pwd = os.getcwd()
    parser = ExtendedConfigParser(config=os.environ.get('MFCONFIG', 'GENERIC'),
                                  strict=False, inheritance="im")
    with open(os.path.join(plugin_path, "config.ini"), "r") as f:
        config_content = f.read()
    if six.PY2:
        parser.read_string(config_content.decode('utf-8'))
    else:
        parser.read_string(config_content)
    name = parser['general']['name']
    version = parser['general']['version']
    summary = parser['general']['summary']
    license = parser['general']['license']
    try:
        packager = parser['general']['packager']
    except Exception:
        packager = parser['general']['maintainer']
    vendor = parser['general']['vendor']
    url = parser['general']['url']
    tmpdir = os.path.join(RUNTIME_HOME, "tmp",
                          "plugin_%s" % get_unique_hexa_identifier())
    mkdir_p_or_die(os.path.join(tmpdir, "BUILD"))
    mkdir_p_or_die(os.path.join(tmpdir, "RPMS"))
    mkdir_p_or_die(os.path.join(tmpdir, "SRPMS"))
    _make_plugin_spec(os.path.join(tmpdir, "specfile.spec"), name, version,
                      summary, license, packager, vendor, url)
    cmd = "source %s/lib/bash_utils.sh ; " % MFEXT_HOME
    cmd = cmd + "layer_load rpm@mfext ; "
    cmd = cmd + 'rpmbuild --define "_topdir %s" --define "pwd %s" ' \
        '--define "prefix %s" --dbpath %s ' \
        '-bb %s/specfile.spec' % (tmpdir, plugin_path, tmpdir,
                                  base, tmpdir)
    x = BashWrapperOrRaise(cmd, MFUtilPluginCantBuild,
                           "can't build plugin %s" % plugin_path)
    tmp = glob.glob(os.path.join(tmpdir, "RPMS", "x86_64", "*.rpm"))
    if len(tmp) == 0:
        raise MFUtilPluginCantBuild("can't find generated plugin" %
                                    plugin_path, bash_wrapper=x)
    plugin_path = tmp[0]
    new_basename = \
        os.path.basename(plugin_path).replace("x86_64.rpm",
                                              "metwork.%s.plugin" %
                                              MODULE_LOWERCASE)
    new_plugin_path = os.path.join(pwd, new_basename)
    shutil.move(plugin_path, new_plugin_path)
    shutil.rmtree(tmpdir, True)
    os.chdir(pwd)
    return new_plugin_path
 def test_set_config_separator(self):
     self.x = ExtendedConfigParser(config='dev#dem#der',
                                   section_separator='%',
                                   list_separator='*')
     self.x.read('./test_cfg_kwargs.ini')
     self.x.set_config_separator('#')
     self.assertEqual(self.x.get('sect1', 'key1'), 'dev1')
 def test_set_section_separator_fail(self):
     self.x = ExtendedConfigParser(config='',
                                   config_separator='#',
                                   list_separator='*')
     self.x.read('./test_cfg_kwargs.ini')
     self.x.set_section_separator('%')
     self.assertEqual(self.x.get('sect1', 'key3'), 'val3')
 def test_set_list_separator_wrong(self):
     self.x = ExtendedConfigParser(config='dev',
                                   config_separator='#',
                                   section_separator='%')
     self.x.read('./test_cfg_kwargs.ini')
     self.x.set_list_separator('*')
     self.assertEqual(self.x.get('sect1', 'key_list'), 'damn;dang;nabbit')
 def test_set_list_separator(self):
     self.x = ExtendedConfigParser(config='dev',
                                   config_separator='#',
                                   section_separator='%')
     self.x.read('./test_cfg_kwargs.ini')
     self.x.set_list_separator('*')
     self.assertEqual(self.x.get('sect1', 'key2', isList=True),
                      ['dev2', '2ved', '2vedev2'])
Beispiel #9
0
def main():
    arg_parser = argparse.ArgumentParser(
        description="Lit le contenu d'un fichier .ini")
    arg_parser.add_argument(
        "path",
        help="Chemin du fichier de config a visualiser")
    arg_parser.add_argument(
        "section",
        help="Precise la section a afficher",
        nargs='?',
        default=None)
    arg_parser.add_argument(
        "option",
        help="Precise l'option a afficher",
        nargs='?',
        default=None)
    arg_parser.add_argument(
        "config",
        help="Precise la config a utiliser pour l'affichage",
        nargs='?',
        default=None)
    args = arg_parser.parse_args()

    if(args.config):
        parser = ExtendedConfigParser(config="NULL", strict=False,
                                      inheritance='im')
    else:
        parser = ExtendedConfigParser(
            config=environ.get("SYNCONFIG", "GENERIC"), strict=False,
            inheritance='im')
    data = codecs.open(str(args.path), "r", "utf-8")
    parser.read_file(data)

    if(args.section):
        # Affichage de la valeur d'une option
        if(args.option):
            print_option(parser, args.section, args.option)

        # Affichage du contenu d'une section
        else:
            print_section(parser, args.section)

    # Affichage de l'ensemble des sections du fichier
    else:
        print_file(parser)
Beispiel #10
0
def read_config_file(parser, config, home):
    res = OrderedDict()
    for s in parser._sections:
        # On inclut les sections des fichiers de config à inclure
        if (s.startswith("INCLUDE_")):
            parser_included = ExtendedConfigParser(config=config,
                                                   inheritance='im')
            included_file = s[8:]
            data = codecs.open(home + "/config/" + included_file, "r", "utf-8")
            parser_included.read_file(data)
            res.update(read_config_file(parser_included, config, home))
        # On ajoute la section si elle n'y est pas ou on la met à jour
        # si elle a été incluse auparavant
        else:
            try:
                res[s].update(read_section(parser, s, home))
            except KeyError:
                res[s] = read_section(parser, s, home)
    return res
Beispiel #11
0
def read_config_file(parser, config, home):
    res = OrderedDict()
    for s in parser._sections:
        # On inclut les sections des fichiers de config à inclure
        if(s.startswith("INCLUDE_")):
            parser_included = ExtendedConfigParser(config=config,
                                                   inheritance='im')
            included_file = s[8:]
            data = codecs.open(home + "/config/" + included_file, "r", "utf-8")
            parser_included.read_file(data)
            res.update(read_config_file(parser_included, config, home))
        # On ajoute la section si elle n'y est pas ou on la met à jour
        # si elle a été incluse auparavant
        else:
            try:
                res[s].update(read_section(parser, s, home))
            except KeyError:
                res[s] = read_section(parser, s, home)
    return res
class InheritanceTestCase(unittest.TestCase):

    def setUp(self):
        self.x = ExtendedConfigParser()
        self.x.read('./test_cfg.ini')

    def test_get_section_name(self):
        self.assertEqual(self.x.get_section_name('sect1'), 'sect1:sect2:sect3')

    def test_get_section_name_fail(self):
        self.assertRaises(NoSectionError, self.x.get_section_name, 'sect4')

    def test_get_basic2(self):
        self.assertEqual(self.x.get('sect1', 'key1'), 'val1')

    def test_get_basic_fail2(self):
        self.assertRaises(NoOptionError, self.x.get, 'sect1', 'key412')

    def test_get_sections(self):
        sections = ['sect1:sect2:sect3', 'sect2', 'sect3']
        self.assertEqual(self.x.get_corresponding_sections('sect1'), sections)

    def test_get_sections_fail(self):
        self.assertRaises(NoSectionError, lambda:
                          self.x.get_corresponding_sections('sect173'))

    def test_get_parent_key(self):
        self.assertEqual(self.x.get('sect1', 'key2'), 'val2')

    def test_get_grandparent_key(self):
        self.assertEqual(self.x.get('sect1', 'key3'), 'val3')

    def test_get_key_dict(self):
        self.assertEqual(self.x['sect1']['key1'], 'val1')

    def test_get_parent_key_dict(self):
        self.assertEqual(self.x['sect1']['key2'], 'val2')

    def test_get_grandparent_key_dict(self):
        self.assertEqual(self.x['sect1']['key3'], 'val3')

    def test_get_default_key_dict(self):
        self.assertEqual(self.x['sect1']['key049'], 'DEFAULT')

    def test_get_key_dict_fail(self):
        self.assertRaises(KeyError, lambda: self.x['sect2']['key4'])

    def test_get_sect_dict_fail(self):
        self.assertRaises(KeyError, lambda: self.x['sect42']['key1'])
 def test_get_kwargs(self):
     self.x = ExtendedConfigParser(config='dev',
                                   config_separator='#',
                                   section_separator='%',
                                   list_separator='*',
                                   delimiters=':',
                                   comment_prefixes=('#', ';'),
                                   inline_comment_prefixes=None,
                                   strict=True,
                                   empty_lines_in_values=True,
                                   default_section='THINGY',
                                   interpolation=None)
     self.x.read('./test_cfg_kwargs.ini')
     self.assertEqual(self.x.get('sect1', 'key2', isList=True),
                      ['dev2', '2ved', '2vedev2'])
Beispiel #14
0
def build_plugin(plugin_path, plugins_base_dir=None):
    plugin_path = os.path.abspath(plugin_path)
    plugins_base_dir = _get_plugins_base_dir(plugins_base_dir)
    base = os.path.join(plugins_base_dir, "base")
    pwd = os.getcwd()
    parser = ExtendedConfigParser(config=os.environ.get('MFCONFIG', 'GENERIC'),
                                  strict=False,
                                  inheritance="im")
    with open(os.path.join(plugin_path, "config.ini"), "r") as f:
        config_content = f.read()
    if six.PY2:
        parser.read_string(config_content.decode('utf-8'))
    else:
        parser.read_string(config_content)
    name = parser['general']['name']
    version = parser['general']['version']
    summary = parser['general']['summary']
    license = parser['general']['license']
    try:
        packager = parser['general']['packager']
    except Exception:
        packager = parser['general']['maintainer']
    vendor = parser['general']['vendor']
    url = parser['general']['url']
    tmpdir = os.path.join(RUNTIME_HOME, "tmp",
                          "plugin_%s" % get_unique_hexa_identifier())
    mkdir_p_or_die(os.path.join(tmpdir, "BUILD"))
    mkdir_p_or_die(os.path.join(tmpdir, "RPMS"))
    mkdir_p_or_die(os.path.join(tmpdir, "SRPMS"))
    _make_plugin_spec(os.path.join(tmpdir, "specfile.spec"), name, version,
                      summary, license, packager, vendor, url)
    cmd = "source %s/lib/bash_utils.sh ; " % MFEXT_HOME
    cmd = cmd + "layer_load rpm@mfext ; "
    cmd = cmd + 'rpmbuild --define "_topdir %s" --define "pwd %s" ' \
        '--define "prefix %s" --dbpath %s ' \
        '-bb %s/specfile.spec' % (tmpdir, plugin_path, tmpdir,
                                  base, tmpdir)
    x = BashWrapperOrRaise(cmd, MFUtilPluginCantBuild,
                           "can't build plugin %s" % plugin_path)
    tmp = glob.glob(os.path.join(tmpdir, "RPMS", "x86_64", "*.rpm"))
    if len(tmp) == 0:
        raise MFUtilPluginCantBuild("can't find generated plugin" %
                                    plugin_path,
                                    bash_wrapper=x)
    plugin_path = tmp[0]
    new_basename = \
        os.path.basename(plugin_path).replace("x86_64.rpm",
                                              "metwork.%s.plugin" %
                                              MODULE_LOWERCASE)
    new_plugin_path = os.path.join(pwd, new_basename)
    shutil.move(plugin_path, new_plugin_path)
    shutil.rmtree(tmpdir, True)
    os.chdir(pwd)
    return new_plugin_path
    def parse(self, stream):
        """Parses the keys and values from a config file.

        NOTE: For keys that were specified to configargparse as
        action="store_true" or "store_false", the config file value must be
        one of: "yes", "no", "true", "false".
        Otherwise an error will be raised.

        Args:
            stream: A config file input stream (such as an open file object).

        Returns:
            OrderedDict of items where the keys have type string and the
            values have type either string or list (eg. to support config file
            formats like YAML which allow lists).
        """
        f = self.custom_environment_callable
        f(self.plugin_name, self.step_name)
        config = os.environ.get('MFCONFIG', 'GENERIC')
        config_parser = ExtendedConfigParser(config=config,
                                             inheritance='im',
                                             interpolation=None)
        content = stream.read()
        if (sys.version_info < (3, 0)):
            content = content.decode("utf-8")
        config_parser.read_string(content)
        section = "step_%s" % self.step_name
        result = collections.OrderedDict()
        for key in config_parser.options(section):
            if not key.startswith('arg_'):
                continue
            if (sys.version_info < (3, 0)):
                result[key.replace('arg_', '', 1)] = envtpl.render_string(
                    config_parser.get(section, key),
                    keep_multi_blank_lines=False).encode('utf-8')
            else:
                result[key.replace('arg_', '', 1)] = envtpl.render_string(
                    config_parser.get(section, key),
                    keep_multi_blank_lines=False)
        return result
Beispiel #16
0
def main():
    arg_parser = argparse.ArgumentParser(
        description="Lit le contenu d'un fichier .ini")
    arg_parser.add_argument("path",
                            help="Chemin du fichier de config a visualiser")
    arg_parser.add_argument("section",
                            help="Precise la section a afficher",
                            nargs='?',
                            default=None)
    arg_parser.add_argument("option",
                            help="Precise l'option a afficher",
                            nargs='?',
                            default=None)
    arg_parser.add_argument(
        "config",
        help="Precise la config a utiliser pour l'affichage",
        nargs='?',
        default=None)
    args = arg_parser.parse_args()

    if (args.config):
        parser = ExtendedConfigParser(config="NULL",
                                      strict=False,
                                      inheritance='im')
    else:
        parser = ExtendedConfigParser(config=environ.get(
            "SYNCONFIG", "GENERIC"),
                                      strict=False,
                                      inheritance='im')
    data = codecs.open(str(args.path), "r", "utf-8")
    parser.read_file(data)

    if (args.section):
        # Affichage de la valeur d'une option
        if (args.option):
            print_option(parser, args.section, args.option)

        # Affichage du contenu d'une section
        else:
            print_section(parser, args.section)

    # Affichage de l'ensemble des sections du fichier
    else:
        print_file(parser)
 def test_read_file(self):
     self.x = ExtendedConfigParser()
     data = open('./test_cfg.ini', 'r')
     self.x.read_file(data)
     self.assertEqual(self.x.get('sect2', 'key2'), 'val2')
class AdvancedTestCase(unittest.TestCase):

    def setUp(self):
        self.x = ExtendedConfigParser()
        self.x.read('./test_cfg.ini')

    def test_get_not_list(self):
        res = 'damn;dang;nabbit'
        self.assertEqual(self.x.get('sect1', 'key_list'), res)

    def test_get_list(self):
        res = ['damn', 'dang', 'nabbit']
        self.assertEqual(self.x.get('sect1', 'key_list', isList=True), res)

    def test_get_list_int(self):
        res = [1, 7, 3]
        self.assertEqual(self.x.getintlist('sect1', 'key_list_int'), res)

    def test_get_list_bool(self):
        res = [True, False, True]
        self.assertEqual(self.x.getbooleanlist('sect1', 'key_list_bool'), res)

    def test_get_list_float(self):
        res = [0.96, 1.73, 6.82]
        self.assertEqual(self.x.getfloatlist('sect1', 'key_list_float'), res)

    def test_get_fallback_list(self):
        # If not found in the section or parents (tests list for defaults,
        # fallback, father,...)
        self.assertEqual(self.x.get('sect1', 'key173', fallback='deez',
                                    isList=True), ['deez'])

    def test_get_father(self):
        self.x = ExtendedConfigParser(defaults={'key4': 'father'})
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect1', 'key4'), 'father')

    def test_get_default_over_father(self):
        self.x = ExtendedConfigParser(defaults={'key049': 'father'})
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect1', 'key049'), 'DEFAULT')

    def test_get_config_plus(self):
        self.x = ExtendedConfigParser(config='mem_plop_toto')
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect3', 'key3', cfg_plus=True), 'toto3')

    def test_get_config_section_loop_basic(self):
        self.x = ExtendedConfigParser(config='dev_plop_toto')
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect1', 'key1', sect_first=False),
                         'dev_plop_toto1_sect3')

    def test_get_config_section_loop_default(self):
        self.x = ExtendedConfigParser(config='dev_plop_toto_stuff')
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect1', 'key1', sect_first=False),
                         'dev_plop_toto1_default')

    def test_get_config_section_loop_father(self):
        self.x = ExtendedConfigParser(config='dev_plop_toto_stuff',
                                      defaults={'key049[dev_plop]': 'father'})
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect1', 'key049', sect_first=False),
                         'father')

    def test_get_config_section_loop_vars_specified(self):
        self.x = ExtendedConfigParser(config='dev_plop_toto_stuff')
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect1', 'key1', sect_first=False,
                                    vars={'key1[dev_plop_toto_stuff]':
                                          'vars'}), 'vars')

    def test_get_config_section_loop_vars(self):
        self.x = ExtendedConfigParser(config='mem_plop_toto_stuff')
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect2', 'key1', sect_first=False,
                                    vars={'key1': 'vars'}), 'vars')

    def test_get_config_section_loop_vars_unspecified(self):
        self.x = ExtendedConfigParser()
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect2', 'key1', sect_first=False,
                                    vars={'key1': 'vars'}), 'vars')

    def test_get_config_section_loop_sect_unspecified(self):
        self.x = ExtendedConfigParser(config='dev_plop')
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect2', 'key1', sect_first=False),
                         'val1_sect2')

    def test_get_config_section_loop_default_unspecified(self):
        self.x = ExtendedConfigParser(config='mem_plop')
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect2', 'key049', sect_first=False),
                         'DEFAULT')

    def test_get_config_section_loop_father_unspecified(self):
        self.x = ExtendedConfigParser(config='mem_plop', defaults={'key096':
                                                                   'father'})
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect2', 'key096', sect_first=False),
                         'father')

    def test_get_config_section_loop_fallback(self):
        self.assertEqual(self.x.get('sect2', 'key173', sect_first=False,
                                    fallback='SCP-173'), 'SCP-173')

    def test_get_config_section_loop_fail(self):
        self.assertRaises(NoOptionError, self.x.get, 'sect1', 'key682',
                          sect_first=False)

    def test_get_config_section_loop_config_plus(self):
        self.x = ExtendedConfigParser(config='mem_plop_toto')
        self.x.read('./test_cfg.ini')
        self.assertEqual(self.x.get('sect3', 'key3', sect_first=False,
                         cfg_plus=True), 'toto3')

    def test_get_config_section_loop_list(self):
        self.assertEqual(self.x.get('sect2', 'key173', sect_first=False,
                                    fallback='SCP-173', isList=True),
                         ['SCP-173'])

    def test_get_kwargs(self):
        self.x = ExtendedConfigParser(config='dev',
                                      config_separator='#',
                                      section_separator='%',
                                      list_separator='*',
                                      delimiters=':',
                                      comment_prefixes=('#', ';'),
                                      inline_comment_prefixes=None,
                                      strict=True,
                                      empty_lines_in_values=True,
                                      default_section='THINGY',
                                      interpolation=None)
        self.x.read('./test_cfg_kwargs.ini')
        self.assertEqual(self.x.get('sect1', 'key2', isList=True),
                         ['dev2', '2ved', '2vedev2'])

    def test_set_config_separator(self):
        self.x = ExtendedConfigParser(config='dev#dem#der',
                                      section_separator='%',
                                      list_separator='*')
        self.x.read('./test_cfg_kwargs.ini')
        self.x.set_config_separator('#')
        self.assertEqual(self.x.get('sect1', 'key1'), 'dev1')

    def test_set_config_separator_wrong(self):
        self.x = ExtendedConfigParser(config='dev_dem_der',
                                      section_separator='%',
                                      list_separator='*')
        self.x.read('./test_cfg_kwargs.ini')
        self.x.set_config_separator('#')
        self.x.set_config_name('dev_dem_der')
        self.assertEqual(self.x.get('sect1', 'key1'), 'val1')

    def test_set_section_separator(self):
        self.x = ExtendedConfigParser(config='',
                                      config_separator='#',
                                      list_separator='*')
        self.x.read('./test_cfg_kwargs.ini')
        self.x.set_section_separator('%')
        self.assertEqual(self.x.get('sect1', 'key3'), 'val3')

    def test_set_section_separator_fail(self):
        self.x = ExtendedConfigParser(config='',
                                      config_separator='#',
                                      list_separator='*')
        self.x.read('./test_cfg_kwargs.ini')
        self.x.set_section_separator('%')
        self.assertEqual(self.x.get('sect1', 'key3'), 'val3')

    def test_set_list_separator(self):
        self.x = ExtendedConfigParser(config='dev',
                                      config_separator='#',
                                      section_separator='%')
        self.x.read('./test_cfg_kwargs.ini')
        self.x.set_list_separator('*')
        self.assertEqual(self.x.get('sect1', 'key2', isList=True),
                         ['dev2', '2ved', '2vedev2'])

    def test_set_list_separator_wrong(self):
        self.x = ExtendedConfigParser(config='dev',
                                      config_separator='#',
                                      section_separator='%')
        self.x.read('./test_cfg_kwargs.ini')
        self.x.set_list_separator('*')
        self.assertEqual(self.x.get('sect1', 'key_list'), 'damn;dang;nabbit')

    def test_get_section_name_compact_basic(self):
        self.assertEqual(self.x.get_section_name_compact('sect2'), 'sect2')

    def test_get_section_name_compact_parents(self):
        self.assertEqual(self.x.get_section_name_compact('sect1:sect2:sect3'),
                         'sect1')

    def test_get_first_section(self):
        self.assertEqual(self.x.get_first_section(), 'sect1')
 def setUp(self):
     self.x = ExtendedConfigParser(config='dev')
     self.x.read('./test_cfg.ini')
class SpecificationTestCase(unittest.TestCase):

    def setUp(self):
        self.x = ExtendedConfigParser(config='dev')
        self.x.read('./test_cfg.ini')

    def test_get_config_name(self):
        self.assertEqual(self.x.get_config_name(), 'dev')

    def test_specification_basic_unspeced_key(self):
        self.assertEqual(self.x.get('sect2', 'key1'), 'val1_sect2')

    def test_specification_basic(self):
        self.assertEqual(self.x.get('sect1', 'key1'), 'dev1')

    def test_specification_goto_parent_config(self):
        self.x.set_config_name('dev_stuff')
        self.assertEqual(self.x.get('sect1', 'key1'), 'dev1')

    def test_specification_goto_grandparent(self):
        self.x.set_config_name('dev_dem_der')
        self.assertEqual(self.x.get('sect1', 'key1'), 'dev1')

    def test_get_configs(self):
        self.x.set_config_name('dev_plop_toto')
        res = ['dev_plop_toto', 'dev_plop', 'dev']
        self.assertEqual(self.x.get_configs(), res)

    def test_get_configs_param(self):
        res = ['dev_plop_toto', 'dev_plop', 'dev']
        self.assertEqual(self.x.get_configs('dev_plop_toto'), res)

    def test_get_configs_plus(self):
        self.x.set_config_name('dev_plop_toto')
        res = ['dev_plop_toto', 'plop_toto', 'toto', 'dev_plop', 'plop', 'dev']
        self.assertEqual(self.x.get_configs_plus(), res)

    def test_get_configs_plus_param(self):
        res = ['dev_plop_toto', 'plop_toto', 'toto', 'dev_plop', 'plop', 'dev']
        self.assertEqual(self.x.get_configs_plus('dev_plop_toto'), res)

    def test_specification_advanced(self):
        self.x.set_config_name('dev_plop_toto')
        self.assertEqual(self.x.get('sect3', 'key3'), 'dev_plop_toto3')

    def test_get_specified_defaults(self):
        self.assertEqual(self.x.get('sect3', 'key049'), 'DEFAULT_dev')

    def test_get_specified_vars(self):
        self.assertEqual(self.x.get('sect1', 'key1', vars={'key1[dev]': 'deez'}
                                    ), 'deez')
 def test_get_config_section_loop_default_unspecified(self):
     self.x = ExtendedConfigParser(config='mem_plop')
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect2', 'key049', sect_first=False),
                      'DEFAULT')
Beispiel #22
0
def init():
    global monitors, inactivityTimeout, logger

    if monitors:
        # Init already performed
        return True

    arg_parser = ArgumentParser()
    arg_parser.add_argument('-c',
                            '--config',
                            help='Configuration filename '
                            '( absolute or relative path to a directory under '
                            'module home directory )')
    args = arg_parser.parse_args()
    homedir = None
    try:
        if args.config is None:
            logger.critical("you must provide a configuration file")
            sys.exit(1)
        if args.config.startswith('~'):
            args.config = os.path.abspath(args.config)

        if args.config.startswith('/'):
            ficconfig = args.config
            if not os.path.exists(ficconfig):
                logger.critical("File %s does not exist or is not accessible" %
                                ficconfig)
                ficconfig = None
        else:
            ficconfig = None
            homedir = os.environ[os.environ['MFMODULE'] + '_HOME']
            for directory in DEFAULT_HOME_CONFIG_DIRS:
                ficconfig = os.path.abspath(homedir)
                ficconfig = os.path.join(ficconfig, directory)
                ficconfig = os.path.join(ficconfig, args.config)
                if os.path.exists(ficconfig):
                    break
                ficconfig = None
            if not ficconfig:
                logger.info("File %s not found under standard configuration"
                            " directories")
                pass
    except KeyError:
        logger.critical("Can't obtain Module home directory")
        ficconfig = None

    if ficconfig and os.path.isdir(ficconfig):
        logger.critical("%s is a directory !" % ficconfig)
        ficconfig = None

    if not ficconfig:
        return False

    parser = ExtendedConfigParser(config=environ.get("MFCONFIG", "GENERIC"),
                                  strict=False,
                                  inheritance='im')
    data = codecs.open(ficconfig, "r", "utf-8")
    try:
        parser.read_file(data)
    except Exception:
        logger.critical('Error Loading config: %s' % ficconfig)
        return False

    Monitor.server = None
    Monitor.port = None
    Monitor.redis = None
    Monitor.unix_socket = None
    Monitor.wm = None

    monitor_inactivitytimeout = None

    monitors = []

    for s in parser._sections:
        mon = Monitor()
        active = False
        key = 'active'
        if parser.has_option(s, key):
            active = parser.getboolean(s, key)
        if not active:
            continue

        key = 'redis_server'
        if not parser.has_option(s, key):
            continue
        server = parser[s][key]
        if Monitor.server is None:
            Monitor.server = server
        elif Monitor.server != server:
            logger.critical('Only 1 redis server Please')
            return False

        key = 'redis_unix_socket'
        if not parser.has_option(s, key):
            continue

        unix_socket = parser[s][key]
        if len(unix_socket) == 0 or unix_socket == "null":
            unix_socket = None
        Monitor.unix_socket = unix_socket

        key = 'redis_port'
        if not parser.has_option(s, key):
            continue

        port = parser.getint(s, key)
        if Monitor.port is None:
            Monitor.port = port
        elif Monitor.port != port:
            logger.critical('Only 1 redis port Please')
            return False

        key = 'monitor_inactivitytimeout'
        if parser.has_option(s, key):
            timeout = parser.getint(s, key)
            if timeout <= 0:  # Standardization
                timeout = -1
            if monitor_inactivitytimeout is None:
                monitor_inactivitytimeout = timeout
                inactivityTimeout = timeout
            elif monitor_inactivitytimeout != timeout:
                logger.critical('Only 1 monitor_inactivitytimeout Please')
                return False

        key = 'directory'
        if not parser.has_option(s, key):
            continue

        mon.dir = parser[s][key]

        key = 'queue'
        if not parser.has_option(s, key):
            continue
        mon.redisqueue = parser[s][key]
        if not mon.redisqueue:
            logger.critical('Invalid redis queue name')
            continue

        q = mon.redisqueue.replace('queue:', '').replace('out_', 'out.')
        q = re.sub(r'stage(\d+)_', r'stage\1.', q)

        key = 'timeout'
        if parser.has_option(s, key):
            mon.redistimeout = parser.getint(s, key)

        key = 'forced_poll'
        if parser.has_option(s, key):
            mon.tpolling = parser.getint(s, key)

        key = 'poll_queue_limit'
        if parser.has_option(s, key):
            mon.pollinglimit = parser.getint(s, key)

        key = 'only'
        if parser.has_option(s, key):
            mon.only = getMask(parser[s][key])

        key = 'ignore'
        cnfgignorestr = None
        if parser.has_option(s, key):
            cnfgignorestr = parser[s][key]
        mon.ignore = getMask(cnfgignorestr, (r'^.*\.working$', ))

        monitors.append(mon)

    if not monitors or len(monitors) < 1:
        logger.critical('No directory to scan')
        return False

    return True
 def test_get_config_section_loop_default(self):
     self.x = ExtendedConfigParser(config='dev_plop_toto_stuff')
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect1', 'key1', sect_first=False),
                      'dev_plop_toto1_default')
 def test_get_config_section_loop_father(self):
     self.x = ExtendedConfigParser(config='dev_plop_toto_stuff',
                                   defaults={'key049[dev_plop]': 'father'})
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect1', 'key049', sect_first=False),
                      'father')
 def test_get_config_section_loop_vars(self):
     self.x = ExtendedConfigParser(config='mem_plop_toto_stuff')
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect2', 'key1', sect_first=False,
                                 vars={'key1': 'vars'}), 'vars')
 def test_get_config_section_loop_vars_unspecified(self):
     self.x = ExtendedConfigParser()
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect2', 'key1', sect_first=False,
                                 vars={'key1': 'vars'}), 'vars')
 def test_get_config_section_loop_config_plus(self):
     self.x = ExtendedConfigParser(config='mem_plop_toto')
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect3', 'key3', sect_first=False,
                      cfg_plus=True), 'toto3')
 def test_defaults(self):
     self.x = ExtendedConfigParser(defaults={'william': 'Overbeck'})
     self.x.read('./test_cfg.ini')
     res = OrderedDict([('william', 'Overbeck')])
     self.assertEquals(self.x.defaults(), res)
 def test_get_default_over_father(self):
     self.x = ExtendedConfigParser(defaults={'key049': 'father'})
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect1', 'key049'), 'DEFAULT')
class BasicTestCase(unittest.TestCase):

    def setUp(self):
        self.x = ExtendedConfigParser()
        self.x.read('./test_cfg.ini')

    def test_basic(self):
        self.assertTrue(self.x is not None)

    def test_get_basic(self):
        self.assertEqual(self.x.get('sect2', 'key2'), 'val2')

    def test_get_basic_fail(self):
        self.assertRaises(NoOptionError, self.x.get, 'sect2', 'key4')

    def test_get_basic_fail2(self):
        self.assertRaises(NoSectionError, self.x.get, 'sect4', 'key3')

    def test_get_int(self):
        self.assertEqual(self.x.getint('sect1', 'key_int'), 1)

    def test_get_float(self):
        self.assertEqual(self.x.getfloat('sect1', 'key_float'), 1.24)

    def test_get_boolean_true(self):
        self.assertTrue(self.x.getboolean('sect1', 'key_bool1'))

    def test_get_boolean_on(self):
        self.assertTrue(self.x.getboolean('sect1', 'key_bool2'))

    def test_get_boolean_1(self):
        self.assertTrue(self.x.getboolean('sect1', 'key_bool3'))

    def test_get_boolean_yes(self):
        self.assertTrue(self.x.getboolean('sect1', 'key_bool4'))

    def test_get_boolean_false(self):
        self.assertFalse(self.x.getboolean('sect1', 'key_bool5'))

    def test_get_boolean_random(self):
        self.assertRaises(ValueError, self.x.getboolean, 'sect1', 'key_bool6')

    def test_default(self):
        self.assertEqual(self.x.get('sect3', 'key2'), 'default2')

    def test_default_section(self):
        default = OrderedDict([('key1[dev_plop_toto_stuff]',
                                'dev_plop_toto1_default'),
                              ('key2', 'default2'), ('key3', 'default3'),
                              ('key049', 'DEFAULT'),
                              ('key049[dev]', 'DEFAULT_dev')])
        self.assertEqual(self.x.default_section, default)

    def test_get_vars(self):
        self.assertEqual(self.x.get('sect1', 'key1', vars={'key1': 'deez'}),
                         'deez')

    def test_get_fallback(self):
        self.assertEqual(self.x.get('sect1', 'key173', fallback='deez'),
                         'deez')

    def test_has_section(self):
        self.assertTrue(self.x.has_section('sect2'))

    def test_has_section_advanced(self):
        self.assertTrue(self.x.has_section('sect1'))

    def test_has_section_fail(self):
        self.assertFalse(self.x.has_section('sect42'))

    def test_has_option(self):
        self.assertTrue(self.x.has_option('sect3', 'key3'))

    def test_has_option_config(self):
        self.assertTrue(self.x.has_option('sect3', 'key2', 'dev'))

    def test_has_option_config_fail(self):
        self.assertFalse(self.x.has_option('sect3', 'key2', 'scp'))

    def test_has_option_inheritance(self):
        self.assertTrue(self.x.has_option('sect1', 'key3'))

    def test_has_option_specificaction_fail(self):
        # Because config dependant
        self.assertFalse(self.x.has_option('sect3', 'key2'))

    def test_has_option_fail(self):
        self.assertFalse(self.x.has_option('sect3', 'key4'))

    def test_has_option_strict(self):
        self.assertTrue(self.x.has_option('sect3', 'key3', strict=True))

    def test_has_option_strict_config(self):
        self.assertTrue(self.x.has_option('sect3', 'key2', 'dev', strict=True))

    def test_has_option_strict_config_fail(self):
        self.assertFalse(self.x.has_option('sect3', 'key2', 'scp',
                                           strict=True))

    def test_has_option_strict_inheritance(self):
        # Because strict
        self.assertFalse(self.x.has_option('sect1', 'key3', strict=True))

    def test_has_option_strict_specificaction_fail(self):
        # Because config dependant
        self.assertFalse(self.x.has_option('sect3', 'key2', strict=True))

    def test_has_option_strict_fail(self):
        self.assertFalse(self.x.has_option('sect3', 'key4', strict=True))

    def test_has_option_config_ind(self):
        self.assertTrue(self.x.has_option('sect3', 'key3', cfg_ind=True))

    def test_has_option_config_ind_inheritance(self):
        self.assertTrue(self.x.has_option('sect1', 'key3', cfg_ind=True))

    def test_has_option_config_ind_specificaction(self):
        self.assertTrue(self.x.has_option('sect3', 'key2', cfg_ind=True))

    def test_has_option_config_ind_fail(self):
        self.assertFalse(self.x.has_option('sect3', 'key4', cfg_ind=True))

    def test_has_option_strict_config_ind(self):
        self.assertTrue(self.x.has_option('sect3', 'key3', cfg_ind=True,
                                          strict=True))

    def test_has_option_strict_config_ind_inheritance(self):
        self.assertFalse(self.x.has_option('sect1', 'key3', cfg_ind=True,
                                           strict=True))

    def test_has_option_strict_config_ind_specificaction(self):
        self.assertTrue(self.x.has_option('sect3', 'key2', cfg_ind=True,
                                          strict=True))

    def test_has_option_strict_config_ind_fail(self):
        self.assertFalse(self.x.has_option('sect3', 'key4', cfg_ind=True,
                                           strict=True))

    def test_options_basic(self):
        res = ['key1', 'key2', 'key2[dev]', 'key2[dev_plop]',
               'key1[dev_plop_toto_stuff]', 'key2', 'key3', 'key049',
               'key049[dev]']
        self.assertEquals(self.x.options('sect2'), res)

    def test_options_inheritance(self):
        res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3',
               'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list',
               'key_list_int', 'key_list_bool', 'key_list_float', 'key1[dev]',
               'key1', 'key2', 'key2[dev]', 'key2[dev_plop]',
               'key1[dev_plop_toto]', 'key2[dev]', 'key3', 'key3[dev]',
               'key3[toto]', 'key3[dev_plop]', 'key3[dev_plop_toto]',
               'key1[dev_plop_toto_stuff]', 'key2', 'key3', 'key049',
               'key049[dev]']
        self.assertEquals(self.x.options('sect1'), res)

    def test_options_strict(self):
        res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3',
               'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list',
               'key_list_int', 'key_list_bool', 'key_list_float', 'key1[dev]']
        self.assertEquals(self.x.options('sect1', strict=True), res)

    def test_options_strict_defaults(self):
        res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3',
               'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list',
               'key_list_int', 'key_list_bool', 'key_list_float', 'key1[dev]',
               'key1[dev_plop_toto_stuff]', 'key2', 'key3', 'key049',
               'key049[dev]']
        self.assertEquals(self.x.options('sect1', strict=True, defaults=True),
                          res)

    def test_options_strict_config_ind(self):
        res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3',
               'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list',
               'key_list_int', 'key_list_bool', 'key_list_float']
        self.assertEquals(self.x.options('sect1', strict=True, cfg_ind=True),
                          res)

    def test_options_strict_config_ind_defaults(self):
        res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3',
               'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list',
               'key_list_int', 'key_list_bool', 'key_list_float', 'key2',
               'key3', 'key049']
        self.assertEquals(self.x.options('sect1', strict=True, defaults=True,
                          cfg_ind=True), res)

    def test_options_config_ind(self):
        res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3',
               'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list',
               'key_list_int', 'key_list_bool', 'key_list_float',
               'key2', 'key3', 'key049']
        self.assertEquals(self.x.options('sect1', cfg_ind=True).sort(),
                          res.sort())

    def test_items_basic(self):
        res = [('key1', 'val1_sect2'),
               ('key2', 'val2'),
               ('key2[dev]', 'dev2'),
               ('key2[dev_plop]', 'dev_plop2'),
               ('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'),
               ('key2', 'default2'),
               ('key3', 'default3'),
               ('key049', 'DEFAULT'),
               ('key049[dev]', 'DEFAULT_dev')]
        res.sort()
        test = self.x.items('sect2')
        test.sort()
        self.assertEquals(test, res)

    def test_items_inheritance(self):
        res = [('key1', 'val1'),
               ('key_int', '1'),
               ('key_bool1', 'true'),
               ('key_bool2', 'on'),
               ('key_bool3', '1'),
               ('key_bool4', 'yes'),
               ('key_bool5', 'false'),
               ('key_bool6', 'random'),
               ('key_float', '1.24'),
               ('key_list', 'damn;dang;nabbit'),
               ('key_list_int', '1;7;3'),
               ('key_list_bool', 'true;false;true'),
               ('key_list_float', '0.96;1.73;6.82'),
               ('key1[dev]', 'dev1'),
               ('key1', 'val1_sect2'),
               ('key2', 'val2'),
               ('key2[dev]', 'dev2'),
               ('key2[dev_plop]', 'dev_plop2'),
               ('key1[dev_plop_toto]', 'dev_plop_toto1_sect3'),
               ('key2[dev]', 'dev2_sect3'),
               ('key3', 'val3'),
               ('key3[dev]', 'dev3'),
               ('key3[toto]', 'toto3'),
               ('key3[dev_plop]', 'dev_plop3'),
               ('key3[dev_plop_toto]', 'dev_plop_toto3'),
               ('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'),
               ('key2', 'default2'),
               ('key3', 'default3'),
               ('key049', 'DEFAULT'),
               ('key049[dev]', 'DEFAULT_dev')]
        res.sort()
        test = self.x.items('sect1')
        test.sort()
        self.assertEquals(test, res)

    def test_items_strict_basic(self):
        res = [('key1', 'val1'),
               ('key_int', '1'),
               ('key_bool1', 'true'),
               ('key_bool2', 'on'),
               ('key_bool3', '1'),
               ('key_bool4', 'yes'),
               ('key_bool5', 'false'),
               ('key_bool6', 'random'),
               ('key_float', '1.24'),
               ('key_list', 'damn;dang;nabbit'),
               ('key_list_int', '1;7;3'),
               ('key_list_bool', 'true;false;true'),
               ('key_list_float', '0.96;1.73;6.82'),
               ('key1[dev]', 'dev1')]
        res.sort()
        test = self.x.items('sect1', strict=True)
        test.sort()
        self.assertEquals(test, res)

    def test_items_strict_defaults(self):
        res = [('key1', 'val1'),
               ('key_int', '1'),
               ('key_bool1', 'true'),
               ('key_bool2', 'on'),
               ('key_bool3', '1'),
               ('key_bool4', 'yes'),
               ('key_bool5', 'false'),
               ('key_bool6', 'random'),
               ('key_float', '1.24'),
               ('key_list', 'damn;dang;nabbit'),
               ('key_list_int', '1;7;3'),
               ('key_list_bool', 'true;false;true'),
               ('key_list_float', '0.96;1.73;6.82'),
               ('key1[dev]', 'dev1'),
               ('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'),
               ('key2', 'default2'),
               ('key3', 'default3'),
               ('key049', 'DEFAULT'),
               ('key049[dev]', 'DEFAULT_dev')]
        res.sort()
        test = self.x.items('sect1', defaults=True, strict=True)
        test.sort()
        self.assertEquals(test, res)

    def test_items_all(self):
        res = []
        for key in self.x._sections:
            res.append((key, SectionProxyExtended(self.x, key)))
        res.sort()
        test = self.x.items()
        test.sort()
        self.assertEquals(test, res)

    def test_items_strict_all(self):
        res = []
        for key in self.x._sections:
            res.append((key, SectionProxyExtended(self.x, key)))
        res.sort()
        test = self.x.items(strict=True)
        test.sort()
        self.assertEquals(test, res)

    def test_items_vars(self):
        res = [('william', 'Overbeck'),
               ('key1', 'val1_sect2'),
               ('key2', 'val2'),
               ('key2[dev]', 'dev2'),
               ('key2[dev_plop]', 'dev_plop2'),
               ('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'),
               ('key2', 'default2'),
               ('key3', 'default3'),
               ('key049', 'DEFAULT'),
               ('key049[dev]', 'DEFAULT_dev')]
        res.sort()
        test = self.x.items('sect2', vars={'William': 'Overbeck'})
        test.sort()
        self.assertEquals(test, res)

    def test_items_vars_strict(self):
        res = [('william', 'Overbeck'),
               ('key1', 'val1_sect2'),
               ('key2', 'val2'),
               ('key2[dev]', 'dev2'),
               ('key2[dev_plop]', 'dev_plop2')]
        res.sort()
        test = self.x.items('sect2', vars={'William': 'Overbeck'}, strict=True)
        test.sort()
        self.assertEquals(test, res)

    def test_get_key_dict(self):
        self.assertEqual(self.x['sect2']['key2'], 'val2')

    def test_get_sect_dict_fail(self):
        self.assertRaises(KeyError, lambda: self.x['sect4'])

    def test_get_key_dict_fail(self):
        self.assertRaises(KeyError, lambda: self.x['sect2']['key42'])

    def test_has_section_strict(self):
        self.assertTrue(self.x.has_section('sect2', strict=True))

    def test_has_section_strict_fail(self):
        self.assertFalse(self.x.has_section('sect1', strict=True))

    def test_defaults(self):
        self.x = ExtendedConfigParser(defaults={'william': 'Overbeck'})
        self.x.read('./test_cfg.ini')
        res = OrderedDict([('william', 'Overbeck')])
        self.assertEquals(self.x.defaults(), res)

    def test_add_section(self):
        self.x.add_section('Jim Hoxworth')
        self.assertTrue(self.x.has_section('Jim Hoxworth'))
        self.assertEqual(self.x.get('Jim Hoxworth', 'key2'), 'default2')
        self.assertEqual(self.x['Jim Hoxworth']['key2'], 'default2')

    def test_read_file(self):
        self.x = ExtendedConfigParser()
        data = open('./test_cfg.ini', 'r')
        self.x.read_file(data)
        self.assertEqual(self.x.get('sect2', 'key2'), 'val2')
 def test_get_father(self):
     self.x = ExtendedConfigParser(defaults={'key4': 'father'})
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect1', 'key4'), 'father')
 def test_get_config_section_loop_father_unspecified(self):
     self.x = ExtendedConfigParser(config='mem_plop', defaults={'key096':
                                                                'father'})
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect2', 'key096', sect_first=False),
                      'father')
 def test_get_config_section_loop_sect_unspecified(self):
     self.x = ExtendedConfigParser(config='dev_plop')
     self.x.read('./test_cfg.ini')
     self.assertEqual(self.x.get('sect2', 'key1', sect_first=False),
                      'val1_sect2')