← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-15 13:49:38 UTC
  • mfrom: (6060.3.1 fix-last-revno-args)
  • Revision ID: pqm@pqm.ubuntu.com-20110815134938-4fuo63g4v2hj8jdt
(jelmer) Cope with the localhost having the name 'localhost' when running
 the test suite. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
160
160
editor=vim
161
161
change_editor=vimdiff -of @new_path @old_path
162
162
gpg_signing_command=gnome-gpg
 
163
gpg_signing_key=DD4D5088
163
164
log_format=short
164
165
validate_signatures_in_log=true
165
166
acceptable_keys=amy
214
215
[/a/]
215
216
check_signatures=check-available
216
217
gpg_signing_command=false
 
218
gpg_signing_key=default
217
219
user_local_option=local
218
220
# test trailing / matching
219
221
[/a/*]
1225
1227
        self.assertEqual("gnome-gpg", my_config.gpg_signing_command())
1226
1228
        self.assertEqual(False, my_config.signature_needed())
1227
1229
 
 
1230
    def test_gpg_signing_key(self):
 
1231
        my_config = self._get_sample_config()
 
1232
        self.assertEqual("DD4D5088", my_config.gpg_signing_key())
 
1233
 
1228
1234
    def _get_empty_config(self):
1229
1235
        my_config = config.GlobalConfig()
1230
1236
        return my_config
1520
1526
        self.get_branch_config('/a')
1521
1527
        self.assertEqual("false", self.my_config.gpg_signing_command())
1522
1528
 
 
1529
    def test_gpg_signing_key(self):
 
1530
        self.get_branch_config('/b')
 
1531
        self.assertEqual("DD4D5088", self.my_config.gpg_signing_key())
 
1532
 
 
1533
    def test_gpg_signing_key_default(self):
 
1534
        self.get_branch_config('/a')
 
1535
        self.assertEqual("erik@bagfors.nu", self.my_config.gpg_signing_key())
 
1536
 
1523
1537
    def test_get_user_option_global(self):
1524
1538
        self.get_branch_config('/a')
1525
1539
        self.assertEqual('something',
2205
2219
    def setUp(self):
2206
2220
        super(TestOptionRegistry, self).setUp()
2207
2221
        # Always start with an empty registry
2208
 
        self.overrideAttr(config, 'option_registry', registry.Registry())
 
2222
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
2209
2223
        self.registry = config.option_registry
2210
2224
 
2211
2225
    def test_register(self):
2212
2226
        opt = config.Option('foo')
2213
 
        self.registry.register('foo', opt)
 
2227
        self.registry.register(opt)
2214
2228
        self.assertIs(opt, self.registry.get('foo'))
2215
2229
 
2216
 
    lazy_option = config.Option('lazy_foo')
2217
 
 
2218
 
    def test_register_lazy(self):
2219
 
        self.registry.register_lazy('foo', self.__module__,
2220
 
                                    'TestOptionRegistry.lazy_option')
2221
 
        self.assertIs(self.lazy_option, self.registry.get('foo'))
2222
 
 
2223
2230
    def test_registered_help(self):
2224
 
        opt = config.Option('foo')
2225
 
        self.registry.register('foo', opt, help='A simple option')
 
2231
        opt = config.Option('foo', help='A simple option')
 
2232
        self.registry.register(opt)
2226
2233
        self.assertEquals('A simple option', self.registry.get_help('foo'))
2227
2234
 
 
2235
    lazy_option = config.Option('lazy_foo', help='Lazy help')
 
2236
 
 
2237
    def test_register_lazy(self):
 
2238
        self.registry.register_lazy('lazy_foo', self.__module__,
 
2239
                                    'TestOptionRegistry.lazy_option')
 
2240
        self.assertIs(self.lazy_option, self.registry.get('lazy_foo'))
 
2241
 
 
2242
    def test_registered_lazy_help(self):
 
2243
        self.registry.register_lazy('lazy_foo', self.__module__,
 
2244
                                    'TestOptionRegistry.lazy_option')
 
2245
        self.assertEquals('Lazy help', self.registry.get_help('lazy_foo'))
 
2246
 
2228
2247
 
2229
2248
class TestRegisteredOptions(tests.TestCase):
2230
2249
    """All registered options should verify some constraints."""
2244
2263
    def test_help_is_set(self):
2245
2264
        option_help = self.registry.get_help(self.option_name)
2246
2265
        self.assertNotEquals(None, option_help)
2247
 
        # Come on, think about the user, he really wants to know whst the
 
2266
        # Come on, think about the user, he really wants to know what the
2248
2267
        # option is about
 
2268
        self.assertIsNot(None, option_help)
2249
2269
        self.assertNotEquals('', option_help)
2250
2270
 
2251
2271
 
2852
2872
    # FIXME: This should be parametrized for all known Stack or dedicated
2853
2873
    # paramerized tests created to avoid bloating -- vila 2011-03-31
2854
2874
 
 
2875
    def overrideOptionRegistry(self):
 
2876
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
 
2877
 
2855
2878
    def test_single_config_get(self):
2856
2879
        conf = dict(foo='bar')
2857
2880
        conf_stack = config.Stack([conf])
2860
2883
    def test_get_with_registered_default_value(self):
2861
2884
        conf_stack = config.Stack([dict()])
2862
2885
        opt = config.Option('foo', default='bar')
2863
 
        self.overrideAttr(config, 'option_registry', registry.Registry())
 
2886
        self.overrideOptionRegistry()
2864
2887
        config.option_registry.register('foo', opt)
2865
2888
        self.assertEquals('bar', conf_stack.get('foo'))
2866
2889
 
2867
2890
    def test_get_without_registered_default_value(self):
2868
2891
        conf_stack = config.Stack([dict()])
2869
2892
        opt = config.Option('foo')
2870
 
        self.overrideAttr(config, 'option_registry', registry.Registry())
 
2893
        self.overrideOptionRegistry()
2871
2894
        config.option_registry.register('foo', opt)
2872
2895
        self.assertEquals(None, conf_stack.get('foo'))
2873
2896
 
2874
2897
    def test_get_without_default_value_for_not_registered(self):
2875
2898
        conf_stack = config.Stack([dict()])
2876
2899
        opt = config.Option('foo')
2877
 
        self.overrideAttr(config, 'option_registry', registry.Registry())
 
2900
        self.overrideOptionRegistry()
2878
2901
        self.assertEquals(None, conf_stack.get('foo'))
2879
2902
 
2880
2903
    def test_get_first_definition(self):
2914
2937
 
2915
2938
class TestStackGet(TestStackWithTransport):
2916
2939
 
 
2940
    def setUp(self):
 
2941
        super(TestStackGet, self).setUp()
 
2942
        self.conf = self.get_stack(self)
 
2943
 
2917
2944
    def test_get_for_empty_stack(self):
2918
 
        conf = self.get_stack(self)
2919
 
        self.assertEquals(None, conf.get('foo'))
 
2945
        self.assertEquals(None, self.conf.get('foo'))
2920
2946
 
2921
2947
    def test_get_hook(self):
2922
 
        conf = self.get_stack(self)
2923
 
        conf.store._load_from_string('foo=bar')
 
2948
        self.conf.store._load_from_string('foo=bar')
2924
2949
        calls = []
2925
2950
        def hook(*args):
2926
2951
            calls.append(args)
2927
2952
        config.ConfigHooks.install_named_hook('get', hook, None)
2928
2953
        self.assertLength(0, calls)
2929
 
        value = conf.get('foo')
 
2954
        value = self.conf.get('foo')
2930
2955
        self.assertEquals('bar', value)
2931
2956
        self.assertLength(1, calls)
2932
 
        self.assertEquals((conf, 'foo', 'bar'), calls[0])
 
2957
        self.assertEquals((self.conf, 'foo', 'bar'), calls[0])
 
2958
 
 
2959
 
 
2960
class TestStackGetWithConverter(TestStackGet):
 
2961
 
 
2962
    def setUp(self):
 
2963
        super(TestStackGetWithConverter, self).setUp()
 
2964
        self.overrideAttr(config, 'option_registry', config.OptionRegistry())
 
2965
        self.registry = config.option_registry
 
2966
 
 
2967
    def register_bool_option(self, name, default, invalid=None):
 
2968
        b = config.Option(name, default=default, help='A boolean.',
 
2969
                          from_unicode=config.bool_from_store,
 
2970
                          invalid=invalid)
 
2971
        self.registry.register(b)
 
2972
 
 
2973
    def test_get_with_bool_not_defined_default_true(self):
 
2974
        self.register_bool_option('foo', True)
 
2975
        self.assertEquals(True, self.conf.get('foo'))
 
2976
 
 
2977
    def test_get_with_bool_not_defined_default_false(self):
 
2978
        self.register_bool_option('foo', False)
 
2979
        self.assertEquals(False, self.conf.get('foo'))
 
2980
 
 
2981
    def test_get_with_bool_converter_not_default(self):
 
2982
        self.register_bool_option('foo', False)
 
2983
        self.conf.store._load_from_string('foo=yes')
 
2984
        self.assertEquals(True, self.conf.get('foo'))
 
2985
 
 
2986
    def test_get_with_bool_converter_invalid_string(self):
 
2987
        self.register_bool_option('foo', False)
 
2988
        self.conf.store._load_from_string('foo=not-a-boolean')
 
2989
        self.assertEquals(False, self.conf.get('foo'))
 
2990
 
 
2991
    def test_get_with_bool_converter_invalid_list(self):
 
2992
        self.register_bool_option('foo', False)
 
2993
        self.conf.store._load_from_string('foo=not,a,boolean')
 
2994
        self.assertEquals(False, self.conf.get('foo'))
 
2995
 
 
2996
    def test_get_invalid_warns(self):
 
2997
        self.register_bool_option('foo', False, invalid='warning')
 
2998
        self.conf.store._load_from_string('foo=not-a-boolean')
 
2999
        warnings = []
 
3000
        def warning(*args):
 
3001
            warnings.append(args[0] % args[1:])
 
3002
        self.overrideAttr(trace, 'warning', warning)
 
3003
        self.assertEquals(False, self.conf.get('foo'))
 
3004
        self.assertLength(1, warnings)
 
3005
        self.assertEquals('Value "not-a-boolean" is not valid for "foo"',
 
3006
                          warnings[0])
 
3007
 
 
3008
    def test_get_invalid_errors(self):
 
3009
        self.register_bool_option('foo', False, invalid='error')
 
3010
        self.conf.store._load_from_string('foo=not-a-boolean')
 
3011
        self.assertRaises(errors.ConfigOptionValueError, self.conf.get, 'foo')
 
3012
 
 
3013
    def register_integer_option(self, name, default):
 
3014
        i = config.Option(name, default=default, help='An integer.',
 
3015
                          from_unicode=config.int_from_store)
 
3016
        self.registry.register(i)
 
3017
 
 
3018
    def test_get_with_integer_not_defined_returns_default(self):
 
3019
        self.register_integer_option('foo', 42)
 
3020
        self.assertEquals(42, self.conf.get('foo'))
 
3021
 
 
3022
    def test_get_with_integer_converter_not_default(self):
 
3023
        self.register_integer_option('foo', 42)
 
3024
        self.conf.store._load_from_string('foo=16')
 
3025
        self.assertEquals(16, self.conf.get('foo'))
 
3026
 
 
3027
    def test_get_with_integer_converter_invalid_string(self):
 
3028
        # We don't set a default value
 
3029
        self.register_integer_option('foo', None)
 
3030
        self.conf.store._load_from_string('foo=forty-two')
 
3031
        # No default value, so we should get None
 
3032
        self.assertEquals(None, self.conf.get('foo'))
 
3033
 
 
3034
    def test_get_with_integer_converter_invalid_list(self):
 
3035
        # We don't set a default value
 
3036
        self.register_integer_option('foo', None)
 
3037
        self.conf.store._load_from_string('foo=a,list')
 
3038
        # No default value, so we should get None
 
3039
        self.assertEquals(None, self.conf.get('foo'))
 
3040
 
 
3041
    def register_list_option(self, name, default):
 
3042
        l = config.Option(name, default=default, help='A list.',
 
3043
                          from_unicode=config.list_from_store)
 
3044
        self.registry.register(l)
 
3045
 
 
3046
    def test_get_with_list_not_defined_returns_default(self):
 
3047
        self.register_list_option('foo', [])
 
3048
        self.assertEquals([], self.conf.get('foo'))
 
3049
 
 
3050
    def test_get_with_list_converter_nothing(self):
 
3051
        self.register_list_option('foo', [1])
 
3052
        self.conf.store._load_from_string('foo=')
 
3053
        self.assertEquals([], self.conf.get('foo'))
 
3054
 
 
3055
    def test_get_with_list_converter_no_item(self):
 
3056
        self.register_list_option('foo', [1])
 
3057
        self.conf.store._load_from_string('foo=,')
 
3058
        self.assertEquals([], self.conf.get('foo'))
 
3059
 
 
3060
    def test_get_with_list_converter_one_boolean(self):
 
3061
        self.register_list_option('foo', [1])
 
3062
        self.conf.store._load_from_string('foo=True')
 
3063
        # We get a list of one string
 
3064
        self.assertEquals(['True'], self.conf.get('foo'))
 
3065
 
 
3066
    def test_get_with_list_converter_one_integer(self):
 
3067
        self.register_list_option('foo', [1])
 
3068
        self.conf.store._load_from_string('foo=2')
 
3069
        # We get a list of one string
 
3070
        self.assertEquals(['2'], self.conf.get('foo'))
 
3071
 
 
3072
    def test_get_with_list_converter_one_string(self):
 
3073
        self.register_list_option('foo', ['foo'])
 
3074
        self.conf.store._load_from_string('foo=bar')
 
3075
        # We get a list of one string
 
3076
        self.assertEquals(['bar'], self.conf.get('foo'))
 
3077
 
 
3078
    def test_get_with_list_converter_many_items(self):
 
3079
        self.register_list_option('foo', [1])
 
3080
        self.conf.store._load_from_string('foo=m,o,r,e')
 
3081
        self.assertEquals(['m', 'o', 'r', 'e'], self.conf.get('foo'))
2933
3082
 
2934
3083
 
2935
3084
class TestStackSet(TestStackWithTransport):
3161
3310
        conf = config.AuthenticationConfig(_file=StringIO(
3162
3311
                'foo = bar\xff'))
3163
3312
        self.assertRaises(errors.ConfigContentError, conf._get_config)
3164
 
        
 
3313
 
3165
3314
    def test_missing_auth_section_header(self):
3166
3315
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
3167
3316
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')