Add deprecated_group Opt kwarg2013.1b5

We often wish to take existing configuration options and move them
from the DEFAULT group to a more specialized group, while still
supporting existing configurations.

We can support this by adding a new deprecated_group kwarg which
allows an option to be aliased to a name in another group e.g.

  CONF.register_opt(cfg.StrOpt('foo',
                               deprecated_name='bar',
                               deprecated_group='DEFAULT'),
                    group='blaa')

or where the option was simply moved between groups:

  CONF.register_opt(cfg.StrOpt('foo',
                               deprecated_group='DEFAULT'),
                    group='blaa')

Implements blueprint cfg-move-opts-between-groups

Change-Id: I4d974c71fab3e3c5c7a3e6514bdd9cb20e7200ff

2 files changed, 403 insertions, 65 deletions

diff --git a/oslo/config/cfg.py b/oslo/config/cfg.py
index ab4bc62..f391604 100644
--- a/oslo/config/cfg.py
+++ b/oslo/config/cfg.py
@@ -515,7 +515,8 @@ class Opt(object):
 
     def __init__(self, name, dest=None, short=None, default=None,
                  positional=False, metavar=None, help=None,
-                 secret=False, required=False, deprecated_name=None):
+                 secret=False, required=False,
+                 deprecated_name=None, deprecated_group=None):
         """Construct an Opt object.
 
         The only required parameter is the option's name. However, it is
@@ -531,6 +532,7 @@ class Opt(object):
         :param secret: true iff the value should be obfuscated in log output
         :param required: true iff a value must be supplied for this option
         :param deprecated_name: deprecated name option.  Acts like an alias
+        :param deprecated_group: the group containing a deprecated alias
         """
         self.name = name
         if dest is None:
@@ -548,6 +550,7 @@ class Opt(object):
             self.deprecated_name = deprecated_name.replace('-', '_')
         else:
             self.deprecated_name = None
+        self.deprecated_group = deprecated_group
 
     def __ne__(self, another):
         return vars(self) != vars(another)
@@ -567,8 +570,12 @@ class Opt(object):
     def _cparser_get_with_deprecated(self, cparser, section, multi=False):
         """If cannot find option as dest try deprecated_name alias."""
         names = [(section, self.dest)]
-        if self.deprecated_name is not None:
-            names.append((section, self.deprecated_name))
+
+        dname, dgroup = self.deprecated_name, self.deprecated_group
+        if dname or dgroup:
+            names.append((dgroup if dgroup else section,
+                          dname if dname else self.dest))
+
         return cparser.get(names, multi)
 
     def _add_to_cli(self, parser, group=None):
@@ -583,9 +590,11 @@ class Opt(object):
         """
         container = self._get_argparse_container(parser, group)
         kwargs = self._get_argparse_kwargs(group)
-        prefix = self._get_argparse_prefix('', group)
+        prefix = self._get_argparse_prefix('', group.name if group else None)
+        deprecated_name = self._get_deprecated_cli_name(self.deprecated_name,
+                                                        self.deprecated_group)
         self._add_to_argparse(container, self.name, self.short, kwargs, prefix,
-                              self.positional, self.deprecated_name)
+                              self.positional, deprecated_name)
 
     def _add_to_argparse(self, container, name, short, kwargs, prefix='',
                          positional=False, deprecated_name=None):
@@ -606,7 +615,7 @@ class Opt(object):
         if short:
             args.append(hyphen('-') + short)
         if deprecated_name:
-            args.append(hyphen('--') + prefix + deprecated_name)
+            args.append(hyphen('--') + deprecated_name)
 
         try:
             container.add_argument(*args, **kwargs)
@@ -647,7 +656,7 @@ class Opt(object):
                        'help': self.help, })
         return kwargs
 
-    def _get_argparse_prefix(self, prefix, group):
+    def _get_argparse_prefix(self, prefix, group_name):
         """Build a prefix for the CLI option name, if required.
 
         CLI options in a group are prefixed with the group's name in order
@@ -655,14 +664,41 @@ class Opt(object):
         groups.
 
         :param prefix: an existing prefix to append to (e.g. 'no' or '')
-        :param group: an optional OptGroup object
+        :param group_name: an optional group name
         :returns: a CLI option prefix including the group name, if appropriate
         """
-        if group is not None:
-            return group.name + '-' + prefix
+        if group_name is not None:
+            return group_name + '-' + prefix
         else:
             return prefix
 
+    def _get_deprecated_cli_name(self, dname, dgroup, prefix=''):
+        """Build a CLi arg name for deprecated options.
+
+        Either a deprecated name or a deprecated group or both or
+        neither can be supplied:
+
+          dname, dgroup -> dgroup + '-' + dname
+          dname         -> dname
+          dgroup        -> dgroup + '-' + self.name
+          neither        -> None
+
+        :param dname: a deprecated name, which can be None
+        :param dgroup: a deprecated group, which can be None
+        :param prefix: an prefix to append to (e.g. 'no' or '')
+        :returns: a CLI argument name
+        """
+        if dgroup == 'DEFAULT':
+            dgroup = None
+
+        if dname is None and dgroup is None:
+            return None
+
+        if dname is None:
+            dname = self.name
+
+        return self._get_argparse_prefix(prefix, dgroup) + dname
+
 
 class StrOpt(Opt):
     """
@@ -711,10 +747,13 @@ class BoolOpt(Opt):
         """Add the --nooptname option to the option parser."""
         container = self._get_argparse_container(parser, group)
         kwargs = self._get_argparse_kwargs(group, action='store_false')
-        prefix = self._get_argparse_prefix('no', group)
+        prefix = self._get_argparse_prefix('no', group.name if group else None)
+        deprecated_name = self._get_deprecated_cli_name(self.deprecated_name,
+                                                        self.deprecated_group,
+                                                        prefix='no')
         kwargs["help"] = "The inverse of --" + self.name
         self._add_to_argparse(container, self.name, None, kwargs, prefix,
-                              self.positional, self.deprecated_name)
+                              self.positional, deprecated_name)
 
     def _get_argparse_kwargs(self, group, action='store_true', **kwargs):
         """Extends the base argparse keyword dict for boolean options."""
diff --git a/tests/test_cfg.py b/tests/test_cfg.py
index 255a5c5..e685052 100644
--- a/tests/test_cfg.py
+++ b/tests/test_cfg.py
@@ -152,9 +152,11 @@ class FindConfigFilesTestCase(BaseTestCase):
 
 class CliOptsTestCase(BaseTestCase):
 
-    def _do_cli_test(self, opt_class, default, cli_args, value):
+    def _do_cli_test(self, opt_class, default, cli_args, value,
+                     deps=(None, None)):
         self.conf.register_cli_opt(opt_class('foo', default=default,
-                                   deprecated_name='oldfoo'))
+                                             deprecated_name=deps[0],
+                                             deprecated_group=deps[1]))
 
         self.conf(cli_args)
 
@@ -167,8 +169,21 @@ class CliOptsTestCase(BaseTestCase):
     def test_str_arg(self):
         self._do_cli_test(StrOpt, None, ['--foo', 'bar'], 'bar')
 
-    def test_str_arg_deprecated(self):
-        self._do_cli_test(StrOpt, None, ['--oldfoo', 'bar'], 'bar')
+    def test_str_arg_deprecated_name(self):
+        self._do_cli_test(StrOpt, None, ['--oldfoo', 'bar'], 'bar',
+                          deps=('oldfoo', None))
+
+    def test_str_arg_deprecated_group(self):
+        self._do_cli_test(StrOpt, None, ['--old-foo', 'bar'], 'bar',
+                          deps=(None, 'old'))
+
+    def test_str_arg_deprecated_group_default(self):
+        self._do_cli_test(StrOpt, None, ['--foo', 'bar'], 'bar',
+                          deps=(None, 'DEFAULT'))
+
+    def test_str_arg_deprecated_group_and_name(self):
+        self._do_cli_test(StrOpt, None, ['--old-oof', 'bar'], 'bar',
+                          deps=('oof', 'old'))
 
     def test_bool_default(self):
         self._do_cli_test(BoolOpt, False, [], False)
@@ -176,14 +191,40 @@ class CliOptsTestCase(BaseTestCase):
     def test_bool_arg(self):
         self._do_cli_test(BoolOpt, None, ['--foo'], True)
 
-    def test_bool_arg_deprecated(self):
-        self._do_cli_test(BoolOpt, None, ['--oldfoo'], True)
+    def test_bool_arg_deprecated_name(self):
+        self._do_cli_test(BoolOpt, None, ['--oldfoo'], True,
+                          deps=('oldfoo', None))
+
+    def test_bool_arg_deprecated_group(self):
+        self._do_cli_test(BoolOpt, None, ['--old-foo'], True,
+                          deps=(None, 'old'))
+
+    def test_bool_arg_deprecated_group_default(self):
+        self._do_cli_test(BoolOpt, None, ['--foo'], True,
+                          deps=(None, 'DEFAULT'))
+
+    def test_bool_arg_deprecated_group_and_name(self):
+        self._do_cli_test(BoolOpt, None, ['--old-oof'], True,
+                          deps=('oof', 'old'))
 
     def test_bool_arg_inverse(self):
         self._do_cli_test(BoolOpt, None, ['--foo', '--nofoo'], False)
 
-    def test_bool_arg_inverse_deprecated(self):
-        self._do_cli_test(BoolOpt, None, ['--oldfoo', '--nooldfoo'], False)
+    def test_bool_arg_inverse_deprecated_name(self):
+        self._do_cli_test(BoolOpt, None, ['--oldfoo', '--nooldfoo'], False,
+                          deps=('oldfoo', None))
+
+    def test_bool_arg_inverse_deprecated_group(self):
+        self._do_cli_test(BoolOpt, None, ['--old-foo', '--old-nofoo'], False,
+                          deps=(None, 'old'))
+
+    def test_bool_arg_inverse_deprecated_group_default(self):
+        self._do_cli_test(BoolOpt, None, ['--foo', '--nofoo'], False,
+                          deps=(None, 'DEFAULT'))
+
+    def test_bool_arg_inverse_deprecated_group_and_name(self):
+        self._do_cli_test(BoolOpt, None, ['--old-oof', '--old-nooof'], False,
+                          deps=('oof', 'old'))
 
     def test_int_default(self):
         self._do_cli_test(IntOpt, 10, [], 10)
@@ -191,8 +232,21 @@ class CliOptsTestCase(BaseTestCase):
     def test_int_arg(self):
         self._do_cli_test(IntOpt, None, ['--foo=20'], 20)
 
-    def test_int_arg_deprecated(self):
-        self._do_cli_test(IntOpt, None, ['--oldfoo=20'], 20)
+    def test_int_arg_deprecated_name(self):
+        self._do_cli_test(IntOpt, None, ['--oldfoo=20'], 20,
+                          deps=('oldfoo', None))
+
+    def test_int_arg_deprecated_group(self):
+        self._do_cli_test(IntOpt, None, ['--old-foo=20'], 20,
+                          deps=(None, 'old'))
+
+    def test_int_arg_deprecated_group_default(self):
+        self._do_cli_test(IntOpt, None, ['--foo=20'], 20,
+                          deps=(None, 'DEFAULT'))
+
+    def test_int_arg_deprecated_group_and_name(self):
+        self._do_cli_test(IntOpt, None, ['--old-oof=20'], 20,
+                          deps=('oof', 'old'))
 
     def test_float_default(self):
         self._do_cli_test(FloatOpt, 1.0, [], 1.0)
@@ -200,8 +254,21 @@ class CliOptsTestCase(BaseTestCase):
     def test_float_arg(self):
         self._do_cli_test(FloatOpt, None, ['--foo', '2.0'], 2.0)
 
-    def test_float_arg_deprecated(self):
-        self._do_cli_test(FloatOpt, None, ['--oldfoo', '2.0'], 2.0)
+    def test_float_arg_deprecated_name(self):
+        self._do_cli_test(FloatOpt, None, ['--oldfoo', '2.0'], 2.0,
+                          deps=('oldfoo', None))
+
+    def test_float_arg_deprecated_group(self):
+        self._do_cli_test(FloatOpt, None, ['--old-foo', '2.0'], 2.0,
+                          deps=(None, 'old'))
+
+    def test_float_arg_deprecated_group_default(self):
+        self._do_cli_test(FloatOpt, None, ['--foo', '2.0'], 2.0,
+                          deps=(None, 'DEFAULT'))
+
+    def test_float_arg_deprecated_group_and_name(self):
+        self._do_cli_test(FloatOpt, None, ['--old-oof', '2.0'], 2.0,
+                          deps=('oof', 'old'))
 
     def test_list_default(self):
         self._do_cli_test(ListOpt, ['bar'], [], ['bar'])
@@ -214,9 +281,25 @@ class CliOptsTestCase(BaseTestCase):
         self._do_cli_test(ListOpt, None,
                           ['--foo', 'blaa ,bar'], ['blaa', 'bar'])
 
-    def test_list_arg_deprecated(self):
+    def test_list_arg_deprecated_name(self):
+        self._do_cli_test(ListOpt, None,
+                          ['--oldfoo', 'blaa,bar'], ['blaa', 'bar'],
+                          deps=('oldfoo', None))
+
+    def test_list_arg_deprecated_group(self):
+        self._do_cli_test(ListOpt, None,
+                          ['--old-foo', 'blaa,bar'], ['blaa', 'bar'],
+                          deps=(None, 'old'))
+
+    def test_list_arg_deprecated_group_default(self):
+        self._do_cli_test(ListOpt, None,
+                          ['--foo', 'blaa,bar'], ['blaa', 'bar'],
+                          deps=(None, 'DEFAULT'))
+
+    def test_list_arg_deprecated_group_and_name(self):
         self._do_cli_test(ListOpt, None,
-                          ['--oldfoo', 'blaa,bar'], ['blaa', 'bar'])
+                          ['--old-oof', 'blaa,bar'], ['blaa', 'bar'],
+                          deps=('oof', 'old'))
 
     def test_multistr_default(self):
         self._do_cli_test(MultiStrOpt, ['bar'], [], ['bar'])
@@ -225,10 +308,29 @@ class CliOptsTestCase(BaseTestCase):
         self._do_cli_test(MultiStrOpt, None,
                           ['--foo', 'blaa', '--foo', 'bar'], ['blaa', 'bar'])
 
-    def test_multistr_arg_deprecated(self):
+    def test_multistr_arg_deprecated_name(self):
         self._do_cli_test(MultiStrOpt, None,
                           ['--oldfoo', 'blaa', '--oldfoo', 'bar'],
-                          ['blaa', 'bar'])
+                          ['blaa', 'bar'],
+                          deps=('oldfoo', None))
+
+    def test_multistr_arg_deprecated_group(self):
+        self._do_cli_test(MultiStrOpt, None,
+                          ['--old-foo', 'blaa', '--old-foo', 'bar'],
+                          ['blaa', 'bar'],
+                          deps=(None, 'old'))
+
+    def test_multistr_arg_deprecated_group_default(self):
+        self._do_cli_test(MultiStrOpt, None,
+                          ['--foo', 'blaa', '--foo', 'bar'],
+                          ['blaa', 'bar'],
+                          deps=(None, 'DEFAULT'))
+
+    def test_multistr_arg_deprecated_group_and_name(self):
+        self._do_cli_test(MultiStrOpt, None,
+                          ['--old-oof', 'blaa', '--old-oof', 'bar'],
+                          ['blaa', 'bar'],
+                          deps=('oof', 'old'))
 
     def test_help(self):
         self.stubs.Set(sys, 'stdout', StringIO.StringIO())
@@ -318,27 +420,48 @@ class PositionalTestCase(BaseTestCase):
 
 class ConfigFileOptsTestCase(BaseTestCase):
 
-    def _do_deprecated_test_use(self, opt_class, value, result):
-        self.conf.register_opt(opt_class('newfoo', deprecated_name='oldfoo'))
+    def _do_deprecated_test(self, opt_class, value, result, key,
+                            section='DEFAULT',
+                            dname=None, dgroup=None):
+        self.conf.register_opt(opt_class('newfoo',
+                                         deprecated_name=dname,
+                                         deprecated_group=dgroup))
 
         paths = self.create_tempfiles([('test',
-                                        '[DEFAULT]\n'
-                                        'oldfoo = %s\n' % value)])
+                                        '[' + section + ']\n' +
+                                        key + ' = ' + value + '\n')])
 
         self.conf(['--config-file', paths[0]])
         self.assertTrue(hasattr(self.conf, 'newfoo'))
         self.assertEquals(self.conf.newfoo, result)
 
-    def _do_deprecated_test_ignore(self, opt_class, value, result):
-        self.conf.register_opt(opt_class('newfoo', deprecated_name='oldfoo'))
+    def _do_dname_test_use(self, opt_class, value, result):
+        self._do_deprecated_test(opt_class, value, result, 'oldfoo',
+                                 dname='oldfoo')
 
-        paths2 = self.create_tempfiles([('test',
-                                         '[DEFAULT]\n'
-                                         'newfoo = %s\n' % value)])
+    def _do_dgroup_test_use(self, opt_class, value, result):
+        self._do_deprecated_test(opt_class, value, result, 'newfoo',
+                                 section='old', dgroup='old')
 
-        self.conf(['--config-file', paths2[0]])
-        self.assertTrue(hasattr(self.conf, 'newfoo'))
-        self.assertEquals(self.conf.newfoo, result)
+    def _do_default_dgroup_test_use(self, opt_class, value, result):
+        self._do_deprecated_test(opt_class, value, result, 'newfoo',
+                                 section='DEFAULT', dgroup='DEFAULT')
+
+    def _do_dgroup_and_dname_test_use(self, opt_class, value, result):
+        self._do_deprecated_test(opt_class, value, result, 'oof',
+                                 section='old', dgroup='old', dname='oof')
+
+    def _do_dname_test_ignore(self, opt_class, value, result):
+        self._do_deprecated_test(opt_class, value, result, 'newfoo',
+                                 dname='oldfoo')
+
+    def _do_dgroup_test_ignore(self, opt_class, value, result):
+        self._do_deprecated_test(opt_class, value, result, 'newfoo',
+                                 section='DEFAULT', dgroup='old')
+
+    def _do_dgroup_and_dname_test_ignore(self, opt_class, value, result):
+        self._do_deprecated_test(opt_class, value, result, 'oof',
+                                 section='old', dgroup='old', dname='oof')
 
     def test_conf_file_str_default(self):
         self.conf.register_opt(StrOpt('foo', default='bar'))
@@ -396,11 +519,26 @@ class ConfigFileOptsTestCase(BaseTestCase):
         self.assertFalse(hasattr(self.conf, 'oldfoo'))
         self.assertEquals(self.conf.newfoo, 'last')
 
-    def test_conf_file_str_use_deprecated(self):
-        self._do_deprecated_test_use(StrOpt, 'value1', 'value1')
+    def test_conf_file_str_use_dname(self):
+        self._do_dname_test_use(StrOpt, 'value1', 'value1')
+
+    def test_conf_file_str_use_dgroup(self):
+        self._do_dgroup_test_use(StrOpt, 'value1', 'value1')
+
+    def test_conf_file_str_use_default_dgroup(self):
+        self._do_default_dgroup_test_use(StrOpt, 'value1', 'value1')
+
+    def test_conf_file_str_use_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_use(StrOpt, 'value1', 'value1')
+
+    def test_conf_file_str_ignore_dname(self):
+        self._do_dname_test_ignore(StrOpt, 'value2', 'value2')
 
-    def test_conf_file_str_ignore_deprecated(self):
-        self._do_deprecated_test_ignore(StrOpt, 'value2', 'value2')
+    def test_conf_file_str_ignore_dgroup(self):
+        self._do_dgroup_test_ignore(StrOpt, 'value2', 'value2')
+
+    def test_conf_file_str_ignore_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_ignore(StrOpt, 'value2', 'value2')
 
     def test_conf_file_bool_default(self):
         self.conf.register_opt(BoolOpt('foo', default=False))
@@ -442,11 +580,26 @@ class ConfigFileOptsTestCase(BaseTestCase):
         self.assertTrue(hasattr(self.conf, 'foo'))
         self.assertEquals(self.conf.foo, True)
 
-    def test_conf_file_bool_use_deprecated(self):
-        self._do_deprecated_test_use(BoolOpt, 'yes', True)
+    def test_conf_file_bool_use_dname(self):
+        self._do_dname_test_use(BoolOpt, 'yes', True)
+
+    def test_conf_file_bool_use_dgroup(self):
+        self._do_dgroup_test_use(BoolOpt, 'yes', True)
+
+    def test_conf_file_bool_use_default_dgroup(self):
+        self._do_default_dgroup_test_use(BoolOpt, 'yes', True)
+
+    def test_conf_file_bool_use_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_use(BoolOpt, 'yes', True)
 
-    def test_conf_file_bool_ignore_deprecated(self):
-        self._do_deprecated_test_ignore(BoolOpt, 'no', False)
+    def test_conf_file_bool_ignore_dname(self):
+        self._do_dname_test_ignore(BoolOpt, 'no', False)
+
+    def test_conf_file_bool_ignore_dgroup(self):
+        self._do_dgroup_test_ignore(BoolOpt, 'no', False)
+
+    def test_conf_file_bool_ignore_group_and_dname(self):
+        self._do_dgroup_and_dname_test_ignore(BoolOpt, 'no', False)
 
     def test_conf_file_int_default(self):
         self.conf.register_opt(IntOpt('foo', default=666))
@@ -488,11 +641,26 @@ class ConfigFileOptsTestCase(BaseTestCase):
         self.assertTrue(hasattr(self.conf, 'foo'))
         self.assertEquals(self.conf.foo, 666)
 
-    def test_conf_file_int_use_deprecated(self):
-        self._do_deprecated_test_use(IntOpt, '66', 66)
+    def test_conf_file_int_use_dname(self):
+        self._do_dname_test_use(IntOpt, '66', 66)
+
+    def test_conf_file_int_use_dgroup(self):
+        self._do_dgroup_test_use(IntOpt, '66', 66)
+
+    def test_conf_file_int_use_default_dgroup(self):
+        self._do_default_dgroup_test_use(IntOpt, '66', 66)
 
-    def test_conf_file_int_ignore_deprecated(self):
-        self._do_deprecated_test_ignore(IntOpt, '64', 64)
+    def test_conf_file_int_use_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_use(IntOpt, '66', 66)
+
+    def test_conf_file_int_ignore_dname(self):
+        self._do_dname_test_ignore(IntOpt, '64', 64)
+
+    def test_conf_file_int_ignore_dgroup(self):
+        self._do_dgroup_test_ignore(IntOpt, '64', 64)
+
+    def test_conf_file_int_ignore_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_ignore(IntOpt, '64', 64)
 
     def test_conf_file_float_default(self):
         self.conf.register_opt(FloatOpt('foo', default=6.66))
@@ -534,11 +702,26 @@ class ConfigFileOptsTestCase(BaseTestCase):
         self.assertTrue(hasattr(self.conf, 'foo'))
         self.assertEquals(self.conf.foo, 6.66)
 
-    def test_conf_file_float_use_deprecated(self):
-        self._do_deprecated_test_use(FloatOpt, '66.54', 66.54)
+    def test_conf_file_float_use_dname(self):
+        self._do_dname_test_use(FloatOpt, '66.54', 66.54)
+
+    def test_conf_file_float_use_dgroup(self):
+        self._do_dgroup_test_use(FloatOpt, '66.54', 66.54)
 
-    def test_conf_file_float_ignore_deprecated(self):
-        self._do_deprecated_test_ignore(FloatOpt, '64.54', 64.54)
+    def test_conf_file_float_use_default_dgroup(self):
+        self._do_default_dgroup_test_use(FloatOpt, '66.54', 66.54)
+
+    def test_conf_file_float_use_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_use(FloatOpt, '66.54', 66.54)
+
+    def test_conf_file_float_ignore_dname(self):
+        self._do_dname_test_ignore(FloatOpt, '64.54', 64.54)
+
+    def test_conf_file_float_ignore_dgroup(self):
+        self._do_dgroup_test_ignore(FloatOpt, '64.54', 64.54)
+
+    def test_conf_file_float_ignore_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_ignore(FloatOpt, '64.54', 64.54)
 
     def test_conf_file_list_default(self):
         self.conf.register_opt(ListOpt('foo', default=['bar']))
@@ -580,17 +763,49 @@ class ConfigFileOptsTestCase(BaseTestCase):
         self.assertTrue(hasattr(self.conf, 'foo'))
         self.assertEquals(self.conf.foo, ['b', 'a', 'r'])
 
-    def test_conf_file_list_use_deprecated(self):
-        self._do_deprecated_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
+    def test_conf_file_list_use_dname(self):
+        self._do_dname_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
+
+    def test_conf_file_list_use_dgroup(self):
+        self._do_dgroup_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
+
+    def test_conf_file_list_use_default_dgroup(self):
+        self._do_default_dgroup_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
+
+    def test_conf_file_list_use_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_use(ListOpt, 'a,b,c', ['a', 'b', 'c'])
+
+    def test_conf_file_list_ignore_dname(self):
+        self._do_dname_test_ignore(ListOpt, 'd,e,f', ['d', 'e', 'f'])
 
-    def test_conf_file_list_ignore_deprecated(self):
-        self._do_deprecated_test_ignore(ListOpt, 'd,e,f', ['d', 'e', 'f'])
+    def test_conf_file_list_ignore_dgroup(self):
+        self._do_dgroup_test_ignore(ListOpt, 'd,e,f', ['d', 'e', 'f'])
 
-    def test_conf_file_list_spaces_use_deprecated(self):
-        self._do_deprecated_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
+    def test_conf_file_list_ignore_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_ignore(ListOpt, 'd,e,f',
+                                              ['d', 'e', 'f'])
 
-    def test_conf_file_list_spaces_ignore_deprecated(self):
-        self._do_deprecated_test_ignore(ListOpt, 'd, e, f', ['d', 'e', 'f'])
+    def test_conf_file_list_spaces_use_dname(self):
+        self._do_dname_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
+
+    def test_conf_file_list_spaces_use_dgroup(self):
+        self._do_dgroup_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
+
+    def test_conf_file_list_spaces_use_default_dgroup(self):
+        self._do_default_dgroup_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
+
+    def test_conf_file_list_spaces_use_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_use(ListOpt, 'a, b, c', ['a', 'b', 'c'])
+
+    def test_conf_file_list_spaces_ignore_dname(self):
+        self._do_dname_test_ignore(ListOpt, 'd, e, f', ['d', 'e', 'f'])
+
+    def test_conf_file_list_spaces_ignore_dgroup(self):
+        self._do_dgroup_test_ignore(ListOpt, 'd, e, f', ['d', 'e', 'f'])
+
+    def test_conf_file_list_spaces_ignore_dgroup_and_dname(self):
+        self._do_dgroup_and_dname_test_ignore(ListOpt, 'd, e, f',
+                                              ['d', 'e', 'f'])
 
     def test_conf_file_multistr_default(self):
         self.conf.register_opt(MultiStrOpt('foo', default=['bar']))
@@ -762,7 +977,7 @@ class OptGroupsTestCase(BaseTestCase):
         self.assertTrue(hasattr(self.conf.blaa, 'foo'))
         self.assertEquals(self.conf.blaa.foo, 'bar')
 
-    def test_arg_group_in_config_file_with_deprecated(self):
+    def test_arg_group_in_config_file_with_deprecated_name(self):
         self.conf.register_group(OptGroup('blaa'))
         self.conf.register_opt(StrOpt('foo', deprecated_name='oldfoo'),
                                group='blaa')
@@ -777,6 +992,90 @@ class OptGroupsTestCase(BaseTestCase):
         self.assertTrue(hasattr(self.conf.blaa, 'foo'))
         self.assertEquals(self.conf.blaa.foo, 'bar')
 
+    def test_arg_group_in_config_file_with_deprecated_group(self):
+        self.conf.register_group(OptGroup('blaa'))
+        self.conf.register_opt(StrOpt('foo', deprecated_group='DEFAULT'),
+                               group='blaa')
+
+        paths = self.create_tempfiles([('test',
+                                        '[DEFAULT]\n'
+                                        'foo = bar\n')])
+
+        self.conf(['--config-file', paths[0]])
+
+        self.assertTrue(hasattr(self.conf, 'blaa'))
+        self.assertTrue(hasattr(self.conf.blaa, 'foo'))
+        self.assertEquals(self.conf.blaa.foo, 'bar')
+
+    def test_arg_group_in_config_file_with_deprecated_group_and_name(self):
+        self.conf.register_group(OptGroup('blaa'))
+        self.conf.register_opt(StrOpt('foo',
+                                      deprecated_group='DEFAULT',
+                                      deprecated_name='oldfoo'),
+                               group='blaa')
+
+        paths = self.create_tempfiles([('test',
+                                        '[DEFAULT]\n'
+                                        'oldfoo = bar\n')])
+
+        self.conf(['--config-file', paths[0]])
+
+        self.assertTrue(hasattr(self.conf, 'blaa'))
+        self.assertTrue(hasattr(self.conf.blaa, 'foo'))
+        self.assertEquals(self.conf.blaa.foo, 'bar')
+
+    def test_arg_group_in_config_file_override_deprecated_name(self):
+        self.conf.register_group(OptGroup('blaa'))
+        self.conf.register_opt(StrOpt('foo', deprecated_name='oldfoo'),
+                               group='blaa')
+
+        paths = self.create_tempfiles([('test',
+                                        '[blaa]\n'
+                                        'foo = bar\n'
+                                        'oldfoo = blabla\n')])
+
+        self.conf(['--config-file', paths[0]])
+
+        self.assertTrue(hasattr(self.conf, 'blaa'))
+        self.assertTrue(hasattr(self.conf.blaa, 'foo'))
+        self.assertEquals(self.conf.blaa.foo, 'bar')
+
+    def test_arg_group_in_config_file_override_deprecated_group(self):
+        self.conf.register_group(OptGroup('blaa'))
+        self.conf.register_opt(StrOpt('foo', deprecated_group='DEFAULT'),
+                               group='blaa')
+
+        paths = self.create_tempfiles([('test',
+                                        '[DEFAULT]\n'
+                                        'foo = blabla\n'
+                                        '[blaa]\n'
+                                        'foo = bar\n')])
+
+        self.conf(['--config-file', paths[0]])
+
+        self.assertTrue(hasattr(self.conf, 'blaa'))
+        self.assertTrue(hasattr(self.conf.blaa, 'foo'))
+        self.assertEquals(self.conf.blaa.foo, 'bar')
+
+    def test_arg_group_in_config_file_override_deprecated_group_and_name(self):
+        self.conf.register_group(OptGroup('blaa'))
+        self.conf.register_opt(StrOpt('foo',
+                                      deprecated_group='DEFAULT',
+                                      deprecated_name='oldfoo'),
+                               group='blaa')
+
+        paths = self.create_tempfiles([('test',
+                                        '[DEFAULT]\n'
+                                        'oldfoo = blabla\n'
+                                        '[blaa]\n'
+                                        'foo = bar\n')])
+
+        self.conf(['--config-file', paths[0]])
+
+        self.assertTrue(hasattr(self.conf, 'blaa'))
+        self.assertTrue(hasattr(self.conf.blaa, 'foo'))
+        self.assertEquals(self.conf.blaa.foo, 'bar')
+
 
 class MappingInterfaceTestCase(BaseTestCase):