« back to all changes in this revision
Viewing changes to bzrlib/tests/test_config.py
- browse files at revision 6609
- compare with another revision
- download diff
- download tarball
- view history from revision 6609
- Committer: Patch Queue Manager
- Date: 2016-01-15 09:21:49 UTC
- mfrom: (6606.2.1 autodoc-unicode)
- Revision ID: pqm@pqm.ubuntu.com-20160115092149-z5f4sfq3jvaz0enb
(vila) Fix autodoc runner when LANG=C. (Jelmer Vernooij)
- files removed:
- doc/en/release-notes/bzr-2.8.txt
- files modified:
- Makefile
added
removed
bzrlib/tests/test_config.py
448
448
output = outfile.getvalue()
449
449
# now we're trying to read it back
450
450
co2 = config.ConfigObj(StringIO(output))
451
self.assertEqual(triple_quotes_value, co2['test'])
451
self.assertEquals(triple_quotes_value, co2['test'])
452
452
453
453
454
454
erroneous_config = """[section] # line 1
649
649
self.path = self.uid = self.gid = None
650
650
conf = config.IniBasedConfig(file_name='./foo.conf')
651
651
conf._write_config_file()
652
self.assertEqual(self.path, './foo.conf')
652
self.assertEquals(self.path, './foo.conf')
653
653
self.assertTrue(isinstance(self.uid, int))
654
654
self.assertTrue(isinstance(self.gid, int))
655
655
699
699
return c
700
700
701
701
def assertExpansion(self, expected, conf, string, env=None):
702
self.assertEqual(expected, conf.expand_options(string, env))
702
self.assertEquals(expected, conf.expand_options(string, env))
703
703
704
704
def test_no_expansion(self):
705
705
c = self.get_config('')
747
747
baz={foo}''')
748
748
e = self.assertRaises(errors.OptionExpansionLoop,
749
749
c.expand_options, '{foo}')
750
self.assertEqual('foo->bar->baz', e.refs)
751
self.assertEqual('{foo}', e.string)
750
self.assertEquals('foo->bar->baz', e.refs)
751
self.assertEquals('{foo}', e.string)
752
752
753
753
def test_list(self):
754
754
conf = self.get_config('''
757
757
baz=end
758
758
list={foo},{bar},{baz}
759
759
''')
760
self.assertEqual(['start', 'middle', 'end'],
760
self.assertEquals(['start', 'middle', 'end'],
761
761
conf.get_user_option('list', expand=True))
762
762
763
763
def test_cascading_list(self):
767
767
baz=end
768
768
list={foo}
769
769
''')
770
self.assertEqual(['start', 'middle', 'end'],
770
self.assertEquals(['start', 'middle', 'end'],
771
771
conf.get_user_option('list', expand=True))
772
772
773
773
def test_pathological_hidden_list(self):
781
781
''')
782
782
# Nope, it's either a string or a list, and the list wins as soon as a
783
783
# ',' appears, so the string concatenation never occur.
784
self.assertEqual(['{foo', '}', '{', 'bar}'],
784
self.assertEquals(['{foo', '}', '{', 'bar}'],
785
785
conf.get_user_option('hidden', expand=True))
786
786
787
787
815
815
[/project/branch/path]
816
816
bar = {foo}ux
817
817
''')
818
self.assertEqual('quux', c.get_user_option('bar', expand=True))
818
self.assertEquals('quux', c.get_user_option('bar', expand=True))
819
819
820
820
821
821
class TestIniBaseConfigOnDisk(tests.TestCaseInTempDir):
861
861
return c
862
862
863
863
def test_simple_read_access(self):
864
self.assertEqual('1', self.config.get_user_option('one'))
864
self.assertEquals('1', self.config.get_user_option('one'))
865
865
866
866
def test_simple_write_access(self):
867
867
self.config.set_user_option('one', 'one')
868
self.assertEqual('one', self.config.get_user_option('one'))
868
self.assertEquals('one', self.config.get_user_option('one'))
869
869
870
870
def test_listen_to_the_last_speaker(self):
871
871
c1 = self.config
872
872
c2 = self.get_existing_config()
873
873
c1.set_user_option('one', 'ONE')
874
874
c2.set_user_option('two', 'TWO')
875
self.assertEqual('ONE', c1.get_user_option('one'))
876
self.assertEqual('TWO', c2.get_user_option('two'))
875
self.assertEquals('ONE', c1.get_user_option('one'))
876
self.assertEquals('TWO', c2.get_user_option('two'))
877
877
# The second update respect the first one
878
self.assertEqual('ONE', c2.get_user_option('one'))
878
self.assertEquals('ONE', c2.get_user_option('one'))
879
879
880
880
def test_last_speaker_wins(self):
881
881
# If the same config is not shared, the same variable modified twice
884
884
c2 = self.get_existing_config()
885
885
c1.set_user_option('one', 'c1')
886
886
c2.set_user_option('one', 'c2')
887
self.assertEqual('c2', c2._get_user_option('one'))
887
self.assertEquals('c2', c2._get_user_option('one'))
888
888
# The first modification is still available until another refresh
889
889
# occur
890
self.assertEqual('c1', c1._get_user_option('one'))
890
self.assertEquals('c1', c1._get_user_option('one'))
891
891
c1.set_user_option('two', 'done')
892
self.assertEqual('c2', c1._get_user_option('one'))
892
self.assertEquals('c2', c1._get_user_option('one'))
893
893
894
894
def test_writes_are_serialized(self):
895
895
c1 = self.config
920
920
self.assertTrue(c1._lock.is_held)
921
921
self.assertRaises(errors.LockContention,
922
922
c2.set_user_option, 'one', 'c2')
923
self.assertEqual('c1', c1.get_user_option('one'))
923
self.assertEquals('c1', c1.get_user_option('one'))
924
924
# Let the lock be released
925
925
after_writing.set()
926
926
writing_done.wait()
927
927
c2.set_user_option('one', 'c2')
928
self.assertEqual('c2', c2.get_user_option('one'))
928
self.assertEquals('c2', c2.get_user_option('one'))
929
929
930
930
def test_read_while_writing(self):
931
931
c1 = self.config
953
953
# Ensure the thread is ready to write
954
954
ready_to_write.wait()
955
955
self.assertTrue(c1._lock.is_held)
956
self.assertEqual('c1', c1.get_user_option('one'))
956
self.assertEquals('c1', c1.get_user_option('one'))
957
957
# If we read during the write, we get the old value
958
958
c2 = self.get_existing_config()
959
self.assertEqual('1', c2.get_user_option('one'))
959
self.assertEquals('1', c2.get_user_option('one'))
960
960
# Let the writing occur and ensure it occurred
961
961
do_writing.set()
962
962
writing_done.wait()
963
963
# Now we get the updated value
964
964
c3 = self.get_existing_config()
965
self.assertEqual('c1', c3.get_user_option('one'))
965
self.assertEquals('c1', c3.get_user_option('one'))
966
966
967
967
968
968
class TestGetUserOptionAs(TestIniConfig):
983
983
self.overrideAttr(trace, 'warning', warning)
984
984
msg = 'Value "%s" is not a boolean for "%s"'
985
985
self.assertIs(None, get_bool('an_invalid_bool'))
986
self.assertEqual(msg % ('maybe', 'an_invalid_bool'), warnings[0])
986
self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
987
987
warnings = []
988
988
self.assertIs(None, get_bool('not_defined_in_this_config'))
989
self.assertEqual([], warnings)
989
self.assertEquals([], warnings)
990
990
991
991
def test_get_user_option_as_list(self):
992
992
conf, parser = self.make_config_parser("""
1340
1340
def test_find_merge_tool_known(self):
1341
1341
conf = self._get_empty_config()
1342
1342
cmdline = conf.find_merge_tool('kdiff3')
1343
self.assertEqual('kdiff3 {base} {this} {other} -o {result}', cmdline)
1343
self.assertEquals('kdiff3 {base} {this} {other} -o {result}', cmdline)
1344
1344
1345
1345
def test_find_merge_tool_override_known(self):
1346
1346
conf = self._get_empty_config()
1906
1906
# Store the raw content in the config file
1907
1907
t.put_bytes('foo.conf', utf8_content)
1908
1908
conf = config.TransportConfig(t, 'foo.conf')
1909
self.assertEqual(unicode_user, conf.get_option('user'))
1909
self.assertEquals(unicode_user, conf.get_option('user'))
1910
1910
1911
1911
def test_load_non_ascii(self):
1912
1912
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
1940
1940
cfg = config.TransportConfig(
1941
1941
DenyingTransport("nonexisting://"), 'control.conf')
1942
1942
self.assertIs(None, cfg.get_option('non-existant', 'SECTION'))
1943
self.assertEqual(
1943
self.assertEquals(
1944
1944
warnings,
1945
1945
[u'Permission denied while trying to open configuration file '
1946
1946
u'nonexisting:///control.conf.'])
1998
1998
config.OldConfigHooks.uninstall_named_hook, 'get', None)
1999
1999
self.assertLength(0, calls)
2000
2000
actual_value = conf.get_user_option(name)
2001
self.assertEqual(value, actual_value)
2001
self.assertEquals(value, actual_value)
2002
2002
self.assertLength(1, calls)
2003
self.assertEqual((conf, name, value), calls[0])
2003
self.assertEquals((conf, name, value), calls[0])
2004
2004
2005
2005
def test_get_hook_bazaar(self):
2006
2006
self.assertGetHook(self.bazaar_config, 'file', 'bazaar')
2026
2026
# We can't assert the conf object below as different configs use
2027
2027
# different means to implement set_user_option and we care only about
2028
2028
# coverage here.
2029
self.assertEqual((name, value), calls[0][1:])
2029
self.assertEquals((name, value), calls[0][1:])
2030
2030
2031
2031
def test_set_hook_bazaar(self):
2032
2032
self.assertSetHook(self.bazaar_config, 'foo', 'bazaar')
2050
2050
# We can't assert the conf object below as different configs use
2051
2051
# different means to implement remove_user_option and we care only about
2052
2052
# coverage here.
2053
self.assertEqual((name,), calls[0][1:])
2053
self.assertEquals((name,), calls[0][1:])
2054
2054
2055
2055
def test_remove_hook_bazaar(self):
2056
2056
self.assertRemoveHook(self.bazaar_config, 'file')
2129
2129
config.OldConfigHooks.uninstall_named_hook, 'get', None)
2130
2130
self.assertLength(0, calls)
2131
2131
actual_value = conf.get_option(name)
2132
self.assertEqual(value, actual_value)
2132
self.assertEquals(value, actual_value)
2133
2133
self.assertLength(1, calls)
2134
self.assertEqual((conf, name, value), calls[0])
2134
self.assertEquals((conf, name, value), calls[0])
2135
2135
2136
2136
def test_get_hook_remote_branch(self):
2137
2137
remote_branch = branch.Branch.open(self.get_url('tree'))
2156
2156
# We can't assert the conf object below as different configs use
2157
2157
# different means to implement set_user_option and we care only about
2158
2158
# coverage here.
2159
self.assertEqual((name, value), calls[0][1:])
2159
self.assertEquals((name, value), calls[0][1:])
2160
2160
2161
2161
def test_set_hook_remote_branch(self):
2162
2162
remote_branch = branch.Branch.open(self.get_url('tree'))
2237
2237
self.assertTrue(self.is_valid('__bar__'))
2238
2238
self.assertTrue(self.is_valid('a_'))
2239
2239
self.assertTrue(self.is_valid('a1'))
2240
# Don't break bzr-svn for no good reason
2241
self.assertTrue(self.is_valid('guessed-layout'))
2242
2240
2243
2241
def test_invalid_names(self):
2244
2242
self.assertFalse(self.is_valid(' foo'))
2252
2250
self.assertFalse(self.is_valid('{}'))
2253
2251
self.assertFalse(self.is_valid('{a}'))
2254
2252
self.assertFalse(self.is_valid('a\n'))
2255
self.assertFalse(self.is_valid('-'))
2256
self.assertFalse(self.is_valid('-a'))
2257
self.assertFalse(self.is_valid('a-'))
2258
self.assertFalse(self.is_valid('a--a'))
2259
2253
2260
2254
def assertSingleGroup(self, reference):
2261
2255
# the regexp is used with split and as such should match the reference
2272
2266
2273
2267
def test_default_value(self):
2274
2268
opt = config.Option('foo', default='bar')
2275
self.assertEqual('bar', opt.get_default())
2269
self.assertEquals('bar', opt.get_default())
2276
2270
2277
2271
def test_callable_default_value(self):
2278
2272
def bar_as_unicode():
2279
2273
return u'bar'
2280
2274
opt = config.Option('foo', default=bar_as_unicode)
2281
self.assertEqual('bar', opt.get_default())
2275
self.assertEquals('bar', opt.get_default())
2282
2276
2283
2277
def test_default_value_from_env(self):
2284
2278
opt = config.Option('foo', default='bar', default_from_env=['FOO'])
2285
2279
self.overrideEnv('FOO', 'quux')
2286
2280
# Env variable provides a default taking over the option one
2287
self.assertEqual('quux', opt.get_default())
2281
self.assertEquals('quux', opt.get_default())
2288
2282
2289
2283
def test_first_default_value_from_env_wins(self):
2290
2284
opt = config.Option('foo', default='bar',
2292
2286
self.overrideEnv('FOO', 'foo')
2293
2287
self.overrideEnv('BAZ', 'baz')
2294
2288
# The first env var set wins
2295
self.assertEqual('foo', opt.get_default())
2289
self.assertEquals('foo', opt.get_default())
2296
2290
2297
2291
def test_not_supported_list_default_value(self):
2298
2292
self.assertRaises(AssertionError, config.Option, 'foo', default=[1])
2309
2303
2310
2304
def test_get_help_topic(self):
2311
2305
opt = config.Option('foo')
2312
self.assertEqual('foo', opt.get_help_topic())
2306
self.assertEquals('foo', opt.get_help_topic())
2313
2307
2314
2308
2315
2309
class TestOptionConverter(tests.TestCase):
2316
2310
2317
2311
def assertConverted(self, expected, opt, value):
2318
self.assertEqual(expected, opt.convert_from_unicode(None, value))
2312
self.assertEquals(expected, opt.convert_from_unicode(None, value))
2319
2313
2320
2314
def assertCallsWarning(self, opt, value):
2321
2315
warnings = []
2323
2317
def warning(*args):
2324
2318
warnings.append(args[0] % args[1:])
2325
2319
self.overrideAttr(trace, 'warning', warning)
2326
self.assertEqual(None, opt.convert_from_unicode(None, value))
2320
self.assertEquals(None, opt.convert_from_unicode(None, value))
2327
2321
self.assertLength(1, warnings)
2328
self.assertEqual(
2322
self.assertEquals(
2329
2323
'Value "%s" is not valid for "%s"' % (value, opt.name),
2330
2324
warnings[0])
2331
2325
2335
2329
2336
2330
def assertConvertInvalid(self, opt, invalid_value):
2337
2331
opt.invalid = None
2338
self.assertEqual(None, opt.convert_from_unicode(None, invalid_value))
2332
self.assertEquals(None, opt.convert_from_unicode(None, invalid_value))
2339
2333
opt.invalid = 'warning'
2340
2334
self.assertCallsWarning(opt, invalid_value)
2341
2335
opt.invalid = 'error'
2456
2450
registry.register("someval", 1234, help="some option")
2457
2451
registry.register("dunno", 1234, help="some other option")
2458
2452
opt = self.get_option(registry)
2459
self.assertEqual(
2453
self.assertEquals(
2460
2454
'A registry option.\n'
2461
2455
'\n'
2462
2456
'The following values are supported:\n'
2469
2463
registry.register("someval", 1234, help="some option")
2470
2464
registry.register("dunno", 1234, help="some other option")
2471
2465
opt = self.get_option(registry)
2472
self.assertEqual(
2466
self.assertEquals(
2473
2467
'A registry option.\n'
2474
2468
'\n'
2475
2469
'The following values are supported:\n'
2494
2488
def test_registered_help(self):
2495
2489
opt = config.Option('foo', help='A simple option')
2496
2490
self.registry.register(opt)
2497
self.assertEqual('A simple option', self.registry.get_help('foo'))
2491
self.assertEquals('A simple option', self.registry.get_help('foo'))
2498
2492
2499
2493
def test_dont_register_illegal_name(self):
2500
2494
self.assertRaises(errors.IllegalOptionName,
2512
2506
def test_registered_lazy_help(self):
2513
2507
self.registry.register_lazy('lazy_foo', self.__module__,
2514
2508
'TestOptionRegistry.lazy_option')
2515
self.assertEqual('Lazy help', self.registry.get_help('lazy_foo'))
2509
self.assertEquals('Lazy help', self.registry.get_help('lazy_foo'))
2516
2510
2517
2511
def test_dont_lazy_register_illegal_name(self):
2518
2512
# This is where the root cause of http://pad.lv/1235099 is better
2541
2535
def test_proper_name(self):
2542
2536
# An option should be registered under its own name, this can't be
2543
2537
# checked at registration time for the lazy ones.
2544
self.assertEqual(self.option_name, self.option.name)
2538
self.assertEquals(self.option_name, self.option.name)
2545
2539
2546
2540
def test_help_is_set(self):
2547
2541
option_help = self.registry.get_help(self.option_name)
2548
2542
# Come on, think about the user, he really wants to know what the
2549
2543
# option is about
2550
2544
self.assertIsNot(None, option_help)
2551
self.assertNotEqual('', option_help)
2545
self.assertNotEquals('', option_help)
2552
2546
2553
2547
2554
2548
class TestSection(tests.TestCase):
2559
2553
def test_get_a_value(self):
2560
2554
a_dict = dict(foo='bar')
2561
2555
section = config.Section('myID', a_dict)
2562
self.assertEqual('bar', section.get('foo'))
2556
self.assertEquals('bar', section.get('foo'))
2563
2557
2564
2558
def test_get_unknown_option(self):
2565
2559
a_dict = dict()
2566
2560
section = config.Section(None, a_dict)
2567
self.assertEqual('out of thin air',
2561
self.assertEquals('out of thin air',
2568
2562
section.get('foo', 'out of thin air'))
2569
2563
2570
2564
def test_options_is_shared(self):
2584
2578
a_dict = dict(foo='bar')
2585
2579
section = self.get_section(a_dict)
2586
2580
section.set('foo', 'new_value')
2587
self.assertEqual('new_value', section.get('foo'))
2581
self.assertEquals('new_value', section.get('foo'))
2588
2582
# The change appears in the shared section
2589
self.assertEqual('new_value', a_dict.get('foo'))
2583
self.assertEquals('new_value', a_dict.get('foo'))
2590
2584
# We keep track of the change
2591
2585
self.assertTrue('foo' in section.orig)
2592
self.assertEqual('bar', section.orig.get('foo'))
2586
self.assertEquals('bar', section.orig.get('foo'))
2593
2587
2594
2588
def test_set_preserve_original_once(self):
2595
2589
a_dict = dict(foo='bar')
2598
2592
section.set('foo', 'second_value')
2599
2593
# We keep track of the original value
2600
2594
self.assertTrue('foo' in section.orig)
2601
self.assertEqual('bar', section.orig.get('foo'))
2595
self.assertEquals('bar', section.orig.get('foo'))
2602
2596
2603
2597
def test_remove(self):
2604
2598
a_dict = dict(foo='bar')
2605
2599
section = self.get_section(a_dict)
2606
2600
section.remove('foo')
2607
2601
# We get None for unknown options via the default value
2608
self.assertEqual(None, section.get('foo'))
2602
self.assertEquals(None, section.get('foo'))
2609
2603
# Or we just get the default value
2610
self.assertEqual('unknown', section.get('foo', 'unknown'))
2604
self.assertEquals('unknown', section.get('foo', 'unknown'))
2611
2605
self.assertFalse('foo' in section.options)
2612
2606
# We keep track of the deletion
2613
2607
self.assertTrue('foo' in section.orig)
2614
self.assertEqual('bar', section.orig.get('foo'))
2608
self.assertEquals('bar', section.orig.get('foo'))
2615
2609
2616
2610
def test_remove_new_option(self):
2617
2611
a_dict = dict()
2622
2616
# The option didn't exist initially so it we need to keep track of it
2623
2617
# with a special value
2624
2618
self.assertTrue('foo' in section.orig)
2625
self.assertEqual(config._NewlyCreatedOption, section.orig['foo'])
2619
self.assertEquals(config._NewlyCreatedOption, section.orig['foo'])
2626
2620
2627
2621
2628
2622
class TestCommandLineStore(tests.TestCase):
2637
2631
sections = list(self.store.get_sections())
2638
2632
self.assertLength(1, sections)
2639
2633
store, section = sections[0]
2640
self.assertEqual(self.store, store)
2634
self.assertEquals(self.store, store)
2641
2635
return section
2642
2636
2643
2637
def test_no_override(self):
2664
2658
def test_multiple_overrides(self):
2665
2659
self.store._from_cmdline(['a=b', 'x=y'])
2666
2660
section = self.get_section()
2667
self.assertEqual('b', section.get('a'))
2668
self.assertEqual('y', section.get('x'))
2661
self.assertEquals('b', section.get('a'))
2662
self.assertEquals('y', section.get('x'))
2669
2663
2670
2664
def test_wrong_syntax(self):
2671
2665
self.assertRaises(errors.BzrCommandError,
2691
2685
def assertSectionContent(self, expected, (store, section)):
2692
2686
"""Assert that some options have the proper values in a section."""
2693
2687
expected_name, expected_options = expected
2694
self.assertEqual(expected_name, section.id)
2695
self.assertEqual(
2688
self.assertEquals(expected_name, section.id)
2689
self.assertEquals(
2696
2690
expected_options,
2697
2691
dict([(k, section.get(k)) for k in expected_options.keys()]))
2698
2692
2704
2698
2705
2699
def test_building_delays_load(self):
2706
2700
store = self.get_store(self)
2707
self.assertEqual(False, store.is_loaded())
2701
self.assertEquals(False, store.is_loaded())
2708
2702
store._load_from_string('')
2709
self.assertEqual(True, store.is_loaded())
2703
self.assertEquals(True, store.is_loaded())
2710
2704
2711
2705
def test_get_no_sections_for_empty(self):
2712
2706
store = self.get_store(self)
2713
2707
store._load_from_string('')
2714
self.assertEqual([], list(store.get_sections()))
2708
self.assertEquals([], list(store.get_sections()))
2715
2709
2716
2710
def test_get_default_section(self):
2717
2711
store = self.get_store(self)
2752
2746
2753
2747
:param s: A string, quoted if required.
2754
2748
"""
2755
self.assertEqual(s, self.store.quote(self.store.unquote(s)))
2756
self.assertEqual(s, self.store.unquote(self.store.quote(s)))
2749
self.assertEquals(s, self.store.quote(self.store.unquote(s)))
2750
self.assertEquals(s, self.store.unquote(self.store.quote(s)))
2757
2751
2758
2752
def test_empty_string(self):
2759
2753
if isinstance(self.store, config.IniFileStore):
2797
2791
value = conf.get('a_section')
2798
2792
# Urgh, despite 'conf' asking for the no-name section, we get the
2799
2793
# content of another section as a dict o_O
2800
self.assertEqual({'a': '1'}, value)
2794
self.assertEquals({'a': '1'}, value)
2801
2795
unquoted = conf.store.unquote(value)
2802
2796
# Which cannot be unquoted but shouldn't crash either (the use cases
2803
2797
# are getting the value or displaying it. In the later case, '%s' will
2804
2798
# do).
2805
self.assertEqual({'a': '1'}, unquoted)
2806
self.assertEqual("{u'a': u'1'}", '%s' % (unquoted,))
2799
self.assertEquals({'a': '1'}, unquoted)
2800
self.assertEquals("{u'a': u'1'}", '%s' % (unquoted,))
2807
2801
2808
2802
2809
2803
class TestIniFileStoreContent(tests.TestCaseWithTransport):
2829
2823
store = config.TransportIniFileStore(t, 'foo.conf')
2830
2824
store.load()
2831
2825
stack = config.Stack([store.get_sections], store)
2832
self.assertEqual(unicode_user, stack.get('user'))
2826
self.assertEquals(unicode_user, stack.get('user'))
2833
2827
2834
2828
def test_load_non_ascii(self):
2835
2829
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
2859
2853
t.get_bytes = get_bytes
2860
2854
store = config.TransportIniFileStore(t, 'foo.conf')
2861
2855
self.assertRaises(errors.PermissionDenied, store.load)
2862
self.assertEqual(
2856
self.assertEquals(
2863
2857
warnings,
2864
2858
[u'Permission denied while trying to load configuration store %s.'
2865
2859
% store.external_url()])
2886
2880
with open('foo.conf', 'wb') as f:
2887
2881
f.write(utf8_content)
2888
2882
conf = config.IniBasedConfig(file_name='foo.conf')
2889
self.assertEqual(unicode_user, conf.get_user_option('user'))
2883
self.assertEquals(unicode_user, conf.get_user_option('user'))
2890
2884
2891
2885
def test_load_badly_encoded_content(self):
2892
2886
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
2925
2919
'branch.conf is *always* created when a branch is initialized')
2926
2920
store = self.get_store(self)
2927
2921
store.save()
2928
self.assertEqual(False, self.has_store(store))
2922
self.assertEquals(False, self.has_store(store))
2929
2923
2930
2924
def test_mutable_section_shared(self):
2931
2925
store = self.get_store(self)
2952
2946
section = store.get_mutable_section(None)
2953
2947
section.remove('foo')
2954
2948
store.save()
2955
self.assertEqual(True, self.has_store(store))
2949
self.assertEquals(True, self.has_store(store))
2956
2950
modified_store = self.get_store(self)
2957
2951
sections = list(modified_store.get_sections())
2958
2952
self.assertLength(0, sections)
2965
2959
'branch.conf is *always* created when a branch is initialized')
2966
2960
store = self.get_store(self)
2967
2961
store._load_from_string('foo=bar\n')
2968
self.assertEqual(False, self.has_store(store))
2962
self.assertEquals(False, self.has_store(store))
2969
2963
store.save()
2970
self.assertEqual(True, self.has_store(store))
2964
self.assertEquals(True, self.has_store(store))
2971
2965
modified_store = self.get_store(self)
2972
2966
sections = list(modified_store.get_sections())
2973
2967
self.assertLength(1, sections)
3040
3034
self.assertLength(0, calls)
3041
3035
store.load()
3042
3036
self.assertLength(1, calls)
3043
self.assertEqual((store,), calls[0])
3037
self.assertEquals((store,), calls[0])
3044
3038
3045
3039
def test_save_hook(self):
3046
3040
calls = []
3058
3052
section.set('foo', 'bar')
3059
3053
store.save()
3060
3054
self.assertLength(1, calls)
3061
self.assertEqual((store,), calls[0])
3055
self.assertEquals((store,), calls[0])
3062
3056
3063
3057
def test_set_mark_dirty(self):
3064
3058
stack = config.MemoryStack('')
3103
3097
def test_no_changes_no_save(self):
3104
3098
s = self.get_stack(self.st1)
3105
3099
s.store.save_changes()
3106
self.assertEqual(False, self.has_store(self.st1))
3100
self.assertEquals(False, self.has_store(self.st1))
3107
3101
3108
3102
def test_unrelated_concurrent_update(self):
3109
3103
s1 = self.get_stack(self.st1)
3112
3106
s2.set('baz', 'quux')
3113
3107
s1.store.save()
3114
3108
# Changes don't propagate magically
3115
self.assertEqual(None, s1.get('baz'))
3109
self.assertEquals(None, s1.get('baz'))
3116
3110
s2.store.save_changes()
3117
self.assertEqual('quux', s2.get('baz'))
3111
self.assertEquals('quux', s2.get('baz'))
3118
3112
# Changes are acquired when saving
3119
self.assertEqual('bar', s2.get('foo'))
3113
self.assertEquals('bar', s2.get('foo'))
3120
3114
# Since there is no overlap, no warnings are emitted
3121
3115
self.assertLength(0, self.warnings)
3122
3116
3128
3122
s1.store.save()
3129
3123
# Last speaker wins
3130
3124
s2.store.save_changes()
3131
self.assertEqual('baz', s2.get('foo'))
3125
self.assertEquals('baz', s2.get('foo'))
3132
3126
# But the user get a warning
3133
3127
self.assertLength(1, self.warnings)
3134
3128
warning = self.warnings[0]
3164
3158
store = self.get_store()
3165
3159
store._load_from_string('foo= " abc "')
3166
3160
stack = config.Stack([store.get_sections])
3167
self.assertEqual(' abc ', stack.get('foo'))
3161
self.assertEquals(' abc ', stack.get('foo'))
3168
3162
3169
3163
def test_set_quoted_string(self):
3170
3164
store = self.get_store()
3183
3177
3184
3178
def test_invalid_content(self):
3185
3179
store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3186
self.assertEqual(False, store.is_loaded())
3180
self.assertEquals(False, store.is_loaded())
3187
3181
exc = self.assertRaises(
3188
3182
errors.ParseConfigError, store._load_from_string,
3189
3183
'this is invalid !')
3190
3184
self.assertEndsWith(exc.filename, 'foo.conf')
3191
3185
# And the load failed
3192
self.assertEqual(False, store.is_loaded())
3186
self.assertEquals(False, store.is_loaded())
3193
3187
3194
3188
def test_get_embedded_sections(self):
3195
3189
# A more complicated example (which also shows that section names and
3262
3256
self.stack.store.save()
3263
3257
3264
3258
def test_simple_read_access(self):
3265
self.assertEqual('1', self.stack.get('one'))
3259
self.assertEquals('1', self.stack.get('one'))
3266
3260
3267
3261
def test_simple_write_access(self):
3268
3262
self.stack.set('one', 'one')
3269
self.assertEqual('one', self.stack.get('one'))
3263
self.assertEquals('one', self.stack.get('one'))
3270
3264
3271
3265
def test_listen_to_the_last_speaker(self):
3272
3266
c1 = self.stack
3273
3267
c2 = self.get_stack(self)
3274
3268
c1.set('one', 'ONE')
3275
3269
c2.set('two', 'TWO')
3276
self.assertEqual('ONE', c1.get('one'))
3277
self.assertEqual('TWO', c2.get('two'))
3270
self.assertEquals('ONE', c1.get('one'))
3271
self.assertEquals('TWO', c2.get('two'))
3278
3272
# The second update respect the first one
3279
self.assertEqual('ONE', c2.get('one'))
3273
self.assertEquals('ONE', c2.get('one'))
3280
3274
3281
3275
def test_last_speaker_wins(self):
3282
3276
# If the same config is not shared, the same variable modified twice
3285
3279
c2 = self.get_stack(self)
3286
3280
c1.set('one', 'c1')
3287
3281
c2.set('one', 'c2')
3288
self.assertEqual('c2', c2.get('one'))
3282
self.assertEquals('c2', c2.get('one'))
3289
3283
# The first modification is still available until another refresh
3290
3284
# occur
3291
self.assertEqual('c1', c1.get('one'))
3285
self.assertEquals('c1', c1.get('one'))
3292
3286
c1.set('two', 'done')
3293
self.assertEqual('c2', c1.get('one'))
3287
self.assertEquals('c2', c1.get('one'))
3294
3288
3295
3289
def test_writes_are_serialized(self):
3296
3290
c1 = self.stack
3320
3314
before_writing.wait()
3321
3315
self.assertRaises(errors.LockContention,
3322
3316
c2.set, 'one', 'c2')
3323
self.assertEqual('c1', c1.get('one'))
3317
self.assertEquals('c1', c1.get('one'))
3324
3318
# Let the lock be released
3325
3319
after_writing.set()
3326
3320
writing_done.wait()
3327
3321
c2.set('one', 'c2')
3328
self.assertEqual('c2', c2.get('one'))
3322
self.assertEquals('c2', c2.get('one'))
3329
3323
3330
3324
def test_read_while_writing(self):
3331
3325
c1 = self.stack
3353
3347
t1.start()
3354
3348
# Ensure the thread is ready to write
3355
3349
ready_to_write.wait()
3356
self.assertEqual('c1', c1.get('one'))
3350
self.assertEquals('c1', c1.get('one'))
3357
3351
# If we read during the write, we get the old value
3358
3352
c2 = self.get_stack(self)
3359
self.assertEqual('1', c2.get('one'))
3353
self.assertEquals('1', c2.get('one'))
3360
3354
# Let the writing occur and ensure it occurred
3361
3355
do_writing.set()
3362
3356
writing_done.wait()
3363
3357
# Now we get the updated value
3364
3358
c3 = self.get_stack(self)
3365
self.assertEqual('c1', c3.get('one'))
3359
self.assertEquals('c1', c3.get('one'))
3366
3360
3367
3361
# FIXME: It may be worth looking into removing the lock dir when it's not
3368
3362
# needed anymore and look at possible fallouts for concurrent lockers. This
3384
3378
store = self.get_store(self)
3385
3379
store._load_from_string('')
3386
3380
matcher = self.matcher(store, '/bar')
3387
self.assertEqual([], list(matcher.get_sections()))
3381
self.assertEquals([], list(matcher.get_sections()))
3388
3382
3389
3383
def test_build_doesnt_load_store(self):
3390
3384
store = self.get_store(self)
3400
3394
3401
3395
def test_simple_option(self):
3402
3396
section = self.get_section({'foo': 'bar'}, '')
3403
self.assertEqual('bar', section.get('foo'))
3397
self.assertEquals('bar', section.get('foo'))
3404
3398
3405
3399
def test_option_with_extra_path(self):
3406
3400
section = self.get_section({'foo': 'bar', 'foo:policy': 'appendpath'},
3407
3401
'baz')
3408
self.assertEqual('bar/baz', section.get('foo'))
3402
self.assertEquals('bar/baz', section.get('foo'))
3409
3403
3410
3404
def test_invalid_policy(self):
3411
3405
section = self.get_section({'foo': 'bar', 'foo:policy': 'die'},
3412
3406
'baz')
3413
3407
# invalid policies are ignored
3414
self.assertEqual('bar', section.get('foo'))
3408
self.assertEquals('bar', section.get('foo'))
3415
3409
3416
3410
3417
3411
class TestLocationMatcher(TestStore):
3435
3429
[/quux/quux]
3436
3430
section=/quux/quux
3437
3431
''')
3438
self.assertEqual(['/foo', '/foo/baz', '/foo/bar', '/foo/bar/baz',
3432
self.assertEquals(['/foo', '/foo/baz', '/foo/bar', '/foo/bar/baz',
3439
3433
'/quux/quux'],
3440
3434
[section.id for _, section in store.get_sections()])
3441
3435
matcher = config.LocationMatcher(store, '/foo/bar/quux')
3442
3436
sections = [section for _, section in matcher.get_sections()]
3443
self.assertEqual(['/foo/bar', '/foo'],
3437
self.assertEquals(['/foo/bar', '/foo'],
3444
3438
[section.id for section in sections])
3445
self.assertEqual(['quux', 'bar/quux'],
3439
self.assertEquals(['quux', 'bar/quux'],
3446
3440
[section.extra_path for section in sections])
3447
3441
3448
3442
def test_more_specific_sections_first(self):
3453
3447
[/foo/bar]
3454
3448
section=/foo/bar
3455
3449
''')
3456
self.assertEqual(['/foo', '/foo/bar'],
3450
self.assertEquals(['/foo', '/foo/bar'],
3457
3451
[section.id for _, section in store.get_sections()])
3458
3452
matcher = config.LocationMatcher(store, '/foo/bar/baz')
3459
3453
sections = [section for _, section in matcher.get_sections()]
3460
self.assertEqual(['/foo/bar', '/foo'],
3454
self.assertEquals(['/foo/bar', '/foo'],
3461
3455
[section.id for section in sections])
3462
self.assertEqual(['baz', 'bar/baz'],
3456
self.assertEquals(['baz', 'bar/baz'],
3463
3457
[section.extra_path for section in sections])
3464
3458
3465
3459
def test_appendpath_in_no_name_section(self):
3473
3467
matcher = config.LocationMatcher(store, 'dir/subdir')
3474
3468
sections = list(matcher.get_sections())
3475
3469
self.assertLength(1, sections)
3476
self.assertEqual('bar/dir/subdir', sections[0][1].get('foo'))
3470
self.assertEquals('bar/dir/subdir', sections[0][1].get('foo'))
3477
3471
3478
3472
def test_file_urls_are_normalized(self):
3479
3473
store = self.get_store(self)
3484
3478
expected_url = 'file:///dir/subdir'
3485
3479
expected_location = '/dir/subdir'
3486
3480
matcher = config.LocationMatcher(store, expected_url)
3487
self.assertEqual(expected_location, matcher.location)
3481
self.assertEquals(expected_location, matcher.location)
3488
3482
3489
3483
def test_branch_name_colo(self):
3490
3484
store = self.get_store(self)
3553
3547
[/foo]
3554
3548
[/foo/bar]
3555
3549
''')
3556
self.assertEqual(['baz', 'bar/baz', '/foo/bar/baz'],
3550
self.assertEquals(['baz', 'bar/baz', '/foo/bar/baz'],
3557
3551
[s.locals['relpath'] for _, s in sections])
3558
3552
3559
3553
def test_order_reversed(self):
3580
3574
# Note that 'baz' as a relpath for /foo/b* is not fully correct, but
3581
3575
# nothing really is... as far using {relpath} to append it to something
3582
3576
# else, this seems good enough though.
3583
self.assertEqual(['', 'baz', 'bar/baz'],
3577
self.assertEquals(['', 'baz', 'bar/baz'],
3584
3578
[s.locals['relpath'] for _, s in sections])
3585
3579
3586
3580
def test_respect_order(self):
3636
3630
store2 = config.IniFileStore()
3637
3631
store2._load_from_string('foo=baz')
3638
3632
conf = config.Stack([store1.get_sections, store2.get_sections])
3639
self.assertEqual('bar', conf.get('foo'))
3633
self.assertEquals('bar', conf.get('foo'))
3640
3634
3641
3635
def test_get_with_registered_default_value(self):
3642
3636
config.option_registry.register(config.Option('foo', default='bar'))
3643
3637
conf_stack = config.Stack([])
3644
self.assertEqual('bar', conf_stack.get('foo'))
3638
self.assertEquals('bar', conf_stack.get('foo'))
3645
3639
3646
3640
def test_get_without_registered_default_value(self):
3647
3641
config.option_registry.register(config.Option('foo'))
3648
3642
conf_stack = config.Stack([])
3649
self.assertEqual(None, conf_stack.get('foo'))
3643
self.assertEquals(None, conf_stack.get('foo'))
3650
3644
3651
3645
def test_get_without_default_value_for_not_registered(self):
3652
3646
conf_stack = config.Stack([])
3653
self.assertEqual(None, conf_stack.get('foo'))
3647
self.assertEquals(None, conf_stack.get('foo'))
3654
3648
3655
3649
def test_get_for_empty_section_callable(self):
3656
3650
conf_stack = config.Stack([lambda : []])
3657
self.assertEqual(None, conf_stack.get('foo'))
3651
self.assertEquals(None, conf_stack.get('foo'))
3658
3652
3659
3653
def test_get_for_broken_callable(self):
3660
3654
# Trying to use and invalid callable raises an exception on first use
3679
3673
self.overrideEnv('FOO', 'quux')
3680
3674
# Env variable provides a default taking over the option one
3681
3675
conf = self.get_conf('foo=store')
3682
self.assertEqual('quux', conf.get('foo'))
3676
self.assertEquals('quux', conf.get('foo'))
3683
3677
3684
3678
def test_first_override_value_from_env_wins(self):
3685
3679
self.overrideEnv('NO_VALUE', None)
3692
3686
self.overrideEnv('BAZ', 'baz')
3693
3687
# The first env var set wins
3694
3688
conf = self.get_conf('foo=store')
3695
self.assertEqual('foo', conf.get('foo'))
3689
self.assertEquals('foo', conf.get('foo'))
3696
3690
3697
3691
3698
3692
class TestMemoryStack(tests.TestCase):
3699
3693
3700
3694
def test_get(self):
3701
3695
conf = config.MemoryStack('foo=bar')
3702
self.assertEqual('bar', conf.get('foo'))
3696
self.assertEquals('bar', conf.get('foo'))
3703
3697
3704
3698
def test_set(self):
3705
3699
conf = config.MemoryStack('foo=bar')
3706
3700
conf.set('foo', 'baz')
3707
self.assertEqual('baz', conf.get('foo'))
3701
self.assertEquals('baz', conf.get('foo'))
3708
3702
3709
3703
def test_no_content(self):
3710
3704
conf = config.MemoryStack()
3713
3707
self.assertRaises(NotImplementedError, conf.get, 'foo')
3714
3708
# But a content can still be provided
3715
3709
conf.store._load_from_string('foo=bar')
3716
self.assertEqual('bar', conf.get('foo'))
3710
self.assertEquals('bar', conf.get('foo'))
3717
3711
3718
3712
3719
3713
class TestStackIterSections(tests.TestCase):
3771
3765
self.conf = self.get_stack(self)
3772
3766
3773
3767
def test_get_for_empty_stack(self):
3774
self.assertEqual(None, self.conf.get('foo'))
3768
self.assertEquals(None, self.conf.get('foo'))
3775
3769
3776
3770
def test_get_hook(self):
3777
3771
self.conf.set('foo', 'bar')
3781
3775
config.ConfigHooks.install_named_hook('get', hook, None)
3782
3776
self.assertLength(0, calls)
3783
3777
value = self.conf.get('foo')
3784
self.assertEqual('bar', value)
3778
self.assertEquals('bar', value)
3785
3779
self.assertLength(1, calls)
3786
self.assertEqual((self.conf, 'foo', 'bar'), calls[0])
3780
self.assertEquals((self.conf, 'foo', 'bar'), calls[0])
3787
3781
3788
3782
3789
3783
class TestStackGetWithConverter(tests.TestCase):
3805
3799
def test_get_default_bool_None(self):
3806
3800
self.register_bool_option('foo')
3807
3801
conf = self.get_conf('')
3808
self.assertEqual(None, conf.get('foo'))
3802
self.assertEquals(None, conf.get('foo'))
3809
3803
3810
3804
def test_get_default_bool_True(self):
3811
3805
self.register_bool_option('foo', u'True')
3812
3806
conf = self.get_conf('')
3813
self.assertEqual(True, conf.get('foo'))
3807
self.assertEquals(True, conf.get('foo'))
3814
3808
3815
3809
def test_get_default_bool_False(self):
3816
3810
self.register_bool_option('foo', False)
3817
3811
conf = self.get_conf('')
3818
self.assertEqual(False, conf.get('foo'))
3812
self.assertEquals(False, conf.get('foo'))
3819
3813
3820
3814
def test_get_default_bool_False_as_string(self):
3821
3815
self.register_bool_option('foo', u'False')
3822
3816
conf = self.get_conf('')
3823
self.assertEqual(False, conf.get('foo'))
3817
self.assertEquals(False, conf.get('foo'))
3824
3818
3825
3819
def test_get_default_bool_from_env_converted(self):
3826
3820
self.register_bool_option('foo', u'True', default_from_env=['FOO'])
3827
3821
self.overrideEnv('FOO', 'False')
3828
3822
conf = self.get_conf('')
3829
self.assertEqual(False, conf.get('foo'))
3823
self.assertEquals(False, conf.get('foo'))
3830
3824
3831
3825
def test_get_default_bool_when_conversion_fails(self):
3832
3826
self.register_bool_option('foo', default='True')
3833
3827
conf = self.get_conf('foo=invalid boolean')
3834
self.assertEqual(True, conf.get('foo'))
3828
self.assertEquals(True, conf.get('foo'))
3835
3829
3836
3830
def register_integer_option(self, name,
3837
3831
default=None, default_from_env=None):
3843
3837
def test_get_default_integer_None(self):
3844
3838
self.register_integer_option('foo')
3845
3839
conf = self.get_conf('')
3846
self.assertEqual(None, conf.get('foo'))
3840
self.assertEquals(None, conf.get('foo'))
3847
3841
3848
3842
def test_get_default_integer(self):
3849
3843
self.register_integer_option('foo', 42)
3850
3844
conf = self.get_conf('')
3851
self.assertEqual(42, conf.get('foo'))
3845
self.assertEquals(42, conf.get('foo'))
3852
3846
3853
3847
def test_get_default_integer_as_string(self):
3854
3848
self.register_integer_option('foo', u'42')
3855
3849
conf = self.get_conf('')
3856
self.assertEqual(42, conf.get('foo'))
3850
self.assertEquals(42, conf.get('foo'))
3857
3851
3858
3852
def test_get_default_integer_from_env(self):
3859
3853
self.register_integer_option('foo', default_from_env=['FOO'])
3860
3854
self.overrideEnv('FOO', '18')
3861
3855
conf = self.get_conf('')
3862
self.assertEqual(18, conf.get('foo'))
3856
self.assertEquals(18, conf.get('foo'))
3863
3857
3864
3858
def test_get_default_integer_when_conversion_fails(self):
3865
3859
self.register_integer_option('foo', default='12')
3866
3860
conf = self.get_conf('foo=invalid integer')
3867
self.assertEqual(12, conf.get('foo'))
3861
self.assertEquals(12, conf.get('foo'))
3868
3862
3869
3863
def register_list_option(self, name, default=None, default_from_env=None):
3870
3864
l = config.ListOption(name, help='A list.', default=default,
3874
3868
def test_get_default_list_None(self):
3875
3869
self.register_list_option('foo')
3876
3870
conf = self.get_conf('')
3877
self.assertEqual(None, conf.get('foo'))
3871
self.assertEquals(None, conf.get('foo'))
3878
3872
3879
3873
def test_get_default_list_empty(self):
3880
3874
self.register_list_option('foo', '')
3881
3875
conf = self.get_conf('')
3882
self.assertEqual([], conf.get('foo'))
3876
self.assertEquals([], conf.get('foo'))
3883
3877
3884
3878
def test_get_default_list_from_env(self):
3885
3879
self.register_list_option('foo', default_from_env=['FOO'])
3886
3880
self.overrideEnv('FOO', '')
3887
3881
conf = self.get_conf('')
3888
self.assertEqual([], conf.get('foo'))
3882
self.assertEquals([], conf.get('foo'))
3889
3883
3890
3884
def test_get_with_list_converter_no_item(self):
3891
3885
self.register_list_option('foo', None)
3892
3886
conf = self.get_conf('foo=,')
3893
self.assertEqual([], conf.get('foo'))
3887
self.assertEquals([], conf.get('foo'))
3894
3888
3895
3889
def test_get_with_list_converter_many_items(self):
3896
3890
self.register_list_option('foo', None)
3897
3891
conf = self.get_conf('foo=m,o,r,e')
3898
self.assertEqual(['m', 'o', 'r', 'e'], conf.get('foo'))
3892
self.assertEquals(['m', 'o', 'r', 'e'], conf.get('foo'))
3899
3893
3900
3894
def test_get_with_list_converter_embedded_spaces_many_items(self):
3901
3895
self.register_list_option('foo', None)
3902
3896
conf = self.get_conf('foo=" bar", "baz "')
3903
self.assertEqual([' bar', 'baz '], conf.get('foo'))
3897
self.assertEquals([' bar', 'baz '], conf.get('foo'))
3904
3898
3905
3899
def test_get_with_list_converter_stripped_spaces_many_items(self):
3906
3900
self.register_list_option('foo', None)
3907
3901
conf = self.get_conf('foo= bar , baz ')
3908
self.assertEqual(['bar', 'baz'], conf.get('foo'))
3902
self.assertEquals(['bar', 'baz'], conf.get('foo'))
3909
3903
3910
3904
3911
3905
class TestIterOptionRefs(tests.TestCase):
3912
3906
"""iter_option_refs is a bit unusual, document some cases."""
3913
3907
3914
3908
def assertRefs(self, expected, string):
3915
self.assertEqual(expected, list(config.iter_option_refs(string)))
3909
self.assertEquals(expected, list(config.iter_option_refs(string)))
3916
3910
3917
3911
def test_empty(self):
3918
3912
self.assertRefs([(False, '')], '')
3950
3944
self.conf = config.Stack([store.get_sections], store)
3951
3945
3952
3946
def assertExpansion(self, expected, string, env=None):
3953
self.assertEqual(expected, self.conf.expand_options(string, env))
3947
self.assertEquals(expected, self.conf.expand_options(string, env))
3954
3948
3955
3949
def test_no_expansion(self):
3956
3950
self.assertExpansion('foo', 'foo')
3958
3952
def test_expand_default_value(self):
3959
3953
self.conf.store._load_from_string('bar=baz')
3960
3954
self.registry.register(config.Option('foo', default=u'{bar}'))
3961
self.assertEqual('baz', self.conf.get('foo', expand=True))
3955
self.assertEquals('baz', self.conf.get('foo', expand=True))
3962
3956
3963
3957
def test_expand_default_from_env(self):
3964
3958
self.conf.store._load_from_string('bar=baz')
3965
3959
self.registry.register(config.Option('foo', default_from_env=['FOO']))
3966
3960
self.overrideEnv('FOO', '{bar}')
3967
self.assertEqual('baz', self.conf.get('foo', expand=True))
3961
self.assertEquals('baz', self.conf.get('foo', expand=True))
3968
3962
3969
3963
def test_expand_default_on_failed_conversion(self):
3970
3964
self.conf.store._load_from_string('baz=bogus\nbar=42\nfoo={baz}')
3971
3965
self.registry.register(
3972
3966
config.Option('foo', default=u'{bar}',
3973
3967
from_unicode=config.int_from_store))
3974
self.assertEqual(42, self.conf.get('foo', expand=True))
3968
self.assertEquals(42, self.conf.get('foo', expand=True))
3975
3969
3976
3970
def test_env_adding_options(self):
3977
3971
self.assertExpansion('bar', '{foo}', {'foo': 'bar'})
4019
4013
baz={foo}''')
4020
4014
e = self.assertRaises(errors.OptionExpansionLoop,
4021
4015
self.conf.expand_options, '{foo}')
4022
self.assertEqual('foo->bar->baz', e.refs)
4023
self.assertEqual('{foo}', e.string)
4016
self.assertEquals('foo->bar->baz', e.refs)
4017
self.assertEquals('{foo}', e.string)
4024
4018
4025
4019
def test_list(self):
4026
4020
self.conf.store._load_from_string('''
4031
4025
''')
4032
4026
self.registry.register(
4033
4027
config.ListOption('list'))
4034
self.assertEqual(['start', 'middle', 'end'],
4028
self.assertEquals(['start', 'middle', 'end'],
4035
4029
self.conf.get('list', expand=True))
4036
4030
4037
4031
def test_cascading_list(self):
4046
4040
# happen while expanding. Conversion should only occur for the original
4047
4041
# option ('list' here).
4048
4042
self.registry.register(config.ListOption('baz'))
4049
self.assertEqual(['start', 'middle', 'end'],
4043
self.assertEquals(['start', 'middle', 'end'],
4050
4044
self.conf.get('list', expand=True))
4051
4045
4052
4046
def test_pathologically_hidden_list(self):
4061
4055
# What matters is what the registration says, the conversion happens
4062
4056
# only after all expansions have been performed
4063
4057
self.registry.register(config.ListOption('hidden'))
4064
self.assertEqual(['bin', 'go'],
4058
self.assertEquals(['bin', 'go'],
4065
4059
self.conf.get('hidden', expand=True))
4066
4060
4067
4061
4099
4093
[/project/branch/path]
4100
4094
bar = {foo}ux
4101
4095
''')
4102
self.assertEqual('quux', c.get('bar', expand=True))
4096
self.assertEquals('quux', c.get('bar', expand=True))
4103
4097
4104
4098
4105
4099
class TestStackCrossStoresExpand(tests.TestCaseWithTransport):
4120
4114
''')
4121
4115
g_store.save()
4122
4116
stack = config.LocationStack('/branch')
4123
self.assertEqual('glob-bar', stack.get('lbar', expand=True))
4124
self.assertEqual('loc-foo', stack.get('gfoo', expand=True))
4117
self.assertEquals('glob-bar', stack.get('lbar', expand=True))
4118
self.assertEquals('loc-foo', stack.get('gfoo', expand=True))
4125
4119
4126
4120
4127
4121
class TestStackExpandSectionLocals(tests.TestCaseWithTransport):
4135
4129
''')
4136
4130
l_store.save()
4137
4131
stack = config.LocationStack('/home/user/project/')
4138
self.assertEqual('', stack.get('base', expand=True))
4139
self.assertEqual('', stack.get('rel', expand=True))
4132
self.assertEquals('', stack.get('base', expand=True))
4133
self.assertEquals('', stack.get('rel', expand=True))
4140
4134
4141
4135
def test_expand_basename_locally(self):
4142
4136
l_store = config.LocationStore()
4146
4140
''')
4147
4141
l_store.save()
4148
4142
stack = config.LocationStack('/home/user/project/branch')
4149
self.assertEqual('branch', stack.get('bfoo', expand=True))
4143
self.assertEquals('branch', stack.get('bfoo', expand=True))
4150
4144
4151
4145
def test_expand_basename_locally_longer_path(self):
4152
4146
l_store = config.LocationStore()
4156
4150
''')
4157
4151
l_store.save()
4158
4152
stack = config.LocationStack('/home/user/project/dir/branch')
4159
self.assertEqual('branch', stack.get('bfoo', expand=True))
4153
self.assertEquals('branch', stack.get('bfoo', expand=True))
4160
4154
4161
4155
def test_expand_relpath_locally(self):
4162
4156
l_store = config.LocationStore()
4166
4160
''')
4167
4161
l_store.save()
4168
4162
stack = config.LocationStack('/home/user/project/branch')
4169
self.assertEqual('loc-foo/branch', stack.get('lfoo', expand=True))
4163
self.assertEquals('loc-foo/branch', stack.get('lfoo', expand=True))
4170
4164
4171
4165
def test_expand_relpath_unknonw_in_global(self):
4172
4166
g_store = config.GlobalStore()
4195
4189
''')
4196
4190
g_store.save()
4197
4191
stack = config.LocationStack('/home/user/project/branch')
4198
self.assertEqual('glob-bar', stack.get('lbar', expand=True))
4199
self.assertEqual('loc-foo/branch', stack.get('gfoo', expand=True))
4192
self.assertEquals('glob-bar', stack.get('lbar', expand=True))
4193
self.assertEquals('loc-foo/branch', stack.get('gfoo', expand=True))
4200
4194
4201
4195
def test_locals_dont_leak(self):
4202
4196
"""Make sure we chose the right local in presence of several sections.
4210
4204
''')
4211
4205
l_store.save()
4212
4206
stack = config.LocationStack('/home/user/project/branch')
4213
self.assertEqual('loc-foo/branch', stack.get('lfoo', expand=True))
4207
self.assertEquals('loc-foo/branch', stack.get('lfoo', expand=True))
4214
4208
stack = config.LocationStack('/home/user/bar/baz')
4215
self.assertEqual('loc-foo/bar/baz', stack.get('lfoo', expand=True))
4209
self.assertEquals('loc-foo/bar/baz', stack.get('lfoo', expand=True))
4216
4210
4217
4211
4218
4212
4220
4214
4221
4215
def test_simple_set(self):
4222
4216
conf = self.get_stack(self)
4223
self.assertEqual(None, conf.get('foo'))
4217
self.assertEquals(None, conf.get('foo'))
4224
4218
conf.set('foo', 'baz')
4225
4219
# Did we get it back ?
4226
self.assertEqual('baz', conf.get('foo'))
4220
self.assertEquals('baz', conf.get('foo'))
4227
4221
4228
4222
def test_set_creates_a_new_section(self):
4229
4223
conf = self.get_stack(self)
4230
4224
conf.set('foo', 'baz')
4231
self.assertEqual, 'baz', conf.get('foo')
4225
self.assertEquals, 'baz', conf.get('foo')
4232
4226
4233
4227
def test_set_hook(self):
4234
4228
calls = []
4239
4233
conf = self.get_stack(self)
4240
4234
conf.set('foo', 'bar')
4241
4235
self.assertLength(1, calls)
4242
self.assertEqual((conf, 'foo', 'bar'), calls[0])
4236
self.assertEquals((conf, 'foo', 'bar'), calls[0])
4243
4237
4244
4238
4245
4239
class TestStackRemove(TestStackWithTransport):
4247
4241
def test_remove_existing(self):
4248
4242
conf = self.get_stack(self)
4249
4243
conf.set('foo', 'bar')
4250
self.assertEqual('bar', conf.get('foo'))
4244
self.assertEquals('bar', conf.get('foo'))
4251
4245
conf.remove('foo')
4252
4246
# Did we get it back ?
4253
self.assertEqual(None, conf.get('foo'))
4247
self.assertEquals(None, conf.get('foo'))
4254
4248
4255
4249
def test_remove_unknown(self):
4256
4250
conf = self.get_stack(self)
4266
4260
conf.set('foo', 'bar')
4267
4261
conf.remove('foo')
4268
4262
self.assertLength(1, calls)
4269
self.assertEqual((conf, 'foo'), calls[0])
4263
self.assertEquals((conf, 'foo'), calls[0])
4270
4264
4271
4265
4272
4266
class TestConfigGetOptions(tests.TestCaseWithTransport, TestOptionsMixin):
4441
4435
else:
4442
4436
user = credentials['user']
4443
4437
password = credentials['password']
4444
self.assertEqual(expected_user, user)
4445
self.assertEqual(expected_password, password)
4438
self.assertEquals(expected_user, user)
4439
self.assertEquals(expected_password, password)
4446
4440
4447
4441
def test_empty_config(self):
4448
4442
conf = config.AuthenticationConfig(_file=StringIO())
4449
self.assertEqual({}, conf._get_config())
4443
self.assertEquals({}, conf._get_config())
4450
4444
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
4451
4445
4452
4446
def test_non_utf8_config(self):
4634
4628
password=bendover
4635
4629
"""))
4636
4630
credentials = conf.get_credentials('https', 'bar.org')
4637
self.assertEqual(False, credentials.get('verify_certificates'))
4631
self.assertEquals(False, credentials.get('verify_certificates'))
4638
4632
credentials = conf.get_credentials('https', 'foo.net')
4639
self.assertEqual(True, credentials.get('verify_certificates'))
4633
self.assertEquals(True, credentials.get('verify_certificates'))
4640
4634
4641
4635
4642
4636
class TestAuthenticationStorage(tests.TestCaseInTempDir):
4689
4683
stdout=stdout, stderr=stderr)
4690
4684
# We use an empty conf so that the user is always prompted
4691
4685
conf = config.AuthenticationConfig()
4692
self.assertEqual(password,
4686
self.assertEquals(password,
4693
4687
conf.get_password(scheme, host, user, port=port,
4694
4688
realm=realm, path=path))
4695
self.assertEqual(expected_prompt, stderr.getvalue())
4696
self.assertEqual('', stdout.getvalue())
4689
self.assertEquals(expected_prompt, stderr.getvalue())
4690
self.assertEquals('', stdout.getvalue())
4697
4691
4698
4692
def _check_default_username_prompt(self, expected_prompt_format, scheme,
4699
4693
host=None, port=None, realm=None,
4710
4704
stdout=stdout, stderr=stderr)
4711
4705
# We use an empty conf so that the user is always prompted
4712
4706
conf = config.AuthenticationConfig()
4713
self.assertEqual(username, conf.get_user(scheme, host, port=port,
4707
self.assertEquals(username, conf.get_user(scheme, host, port=port,
4714
4708
realm=realm, path=path, ask=True))
4715
self.assertEqual(expected_prompt, stderr.getvalue())
4716
self.assertEqual('', stdout.getvalue())
4709
self.assertEquals(expected_prompt, stderr.getvalue())
4710
self.assertEquals('', stdout.getvalue())
4717
4711
4718
4712
def test_username_defaults_prompts(self):
4719
4713
# HTTP prompts can't be tested here, see test_http.py
4725
4719
4726
4720
def test_username_default_no_prompt(self):
4727
4721
conf = config.AuthenticationConfig()
4728
self.assertEqual(None,
4722
self.assertEquals(None,
4729
4723
conf.get_user('ftp', 'example.com'))
4730
self.assertEqual("explicitdefault",
4724
self.assertEquals("explicitdefault",
4731
4725
conf.get_user('ftp', 'example.com', default="explicitdefault"))
4732
4726
4733
4727
def test_password_default_prompts(self):
4766
4760
4767
4761
# Since the password defined in the authentication config is ignored,
4768
4762
# the user is prompted
4769
self.assertEqual(entered_password,
4763
self.assertEquals(entered_password,
4770
4764
conf.get_password('ssh', 'bar.org', user='jim'))
4771
4765
self.assertContainsRe(
4772
4766
self.get_log(),
4789
4783
4790
4784
# Since the password defined in the authentication config is ignored,
4791
4785
# the user is prompted
4792
self.assertEqual(entered_password,
4786
self.assertEquals(entered_password,
4793
4787
conf.get_password('ssh', 'bar.org', user='jim'))
4794
4788
# No warning shoud be emitted since there is no password. We are only
4795
4789
# providing "user".
4805
4799
config.credential_store_registry.register("stub", store, fallback=True)
4806
4800
conf = config.AuthenticationConfig(_file=StringIO())
4807
4801
creds = conf.get_credentials("http", "example.com")
4808
self.assertEqual("joe", creds["user"])
4809
self.assertEqual("secret", creds["password"])
4802
self.assertEquals("joe", creds["user"])
4803
self.assertEquals("secret", creds["password"])
4810
4804
4811
4805
4812
4806
class StubCredentialStore(config.CredentialStore):
4857
4851
4858
4852
def test_fallback_none_registered(self):
4859
4853
r = config.CredentialStoreRegistry()
4860
self.assertEqual(None,
4854
self.assertEquals(None,
4861
4855
r.get_fallback_credentials("http", "example.com"))
4862
4856
4863
4857
def test_register(self):
4864
4858
r = config.CredentialStoreRegistry()
4865
4859
r.register("stub", StubCredentialStore(), fallback=False)
4866
4860
r.register("another", StubCredentialStore(), fallback=True)
4867
self.assertEqual(["another", "stub"], r.keys())
4861
self.assertEquals(["another", "stub"], r.keys())
4868
4862
4869
4863
def test_register_lazy(self):
4870
4864
r = config.CredentialStoreRegistry()
4871
4865
r.register_lazy("stub", "bzrlib.tests.test_config",
4872
4866
"StubCredentialStore", fallback=False)
4873
self.assertEqual(["stub"], r.keys())
4867
self.assertEquals(["stub"], r.keys())
4874
4868
self.assertIsInstance(r.get_credential_store("stub"),
4875
4869
StubCredentialStore)
4876
4870
4878
4872
r = config.CredentialStoreRegistry()
4879
4873
r.register("stub1", None, fallback=False)
4880
4874
r.register("stub2", None, fallback=True)
4881
self.assertEqual(False, r.is_fallback("stub1"))
4882
self.assertEqual(True, r.is_fallback("stub2"))
4875
self.assertEquals(False, r.is_fallback("stub1"))
4876
self.assertEquals(True, r.is_fallback("stub2"))
4883
4877
4884
4878
def test_no_fallback(self):
4885
4879
r = config.CredentialStoreRegistry()
4886
4880
store = CountingCredentialStore()
4887
4881
r.register("count", store, fallback=False)
4888
self.assertEqual(None,
4882
self.assertEquals(None,
4889
4883
r.get_fallback_credentials("http", "example.com"))
4890
self.assertEqual(0, store._calls)
4884
self.assertEquals(0, store._calls)
4891
4885
4892
4886
def test_fallback_credentials(self):
4893
4887
r = config.CredentialStoreRegistry()
4896
4890
"somebody", "geheim")
4897
4891
r.register("stub", store, fallback=True)
4898
4892
creds = r.get_fallback_credentials("http", "example.com")
4899
self.assertEqual("somebody", creds["user"])
4900
self.assertEqual("geheim", creds["password"])
4893
self.assertEquals("somebody", creds["user"])
4894
self.assertEquals("geheim", creds["password"])
4901
4895
4902
4896
def test_fallback_first_wins(self):
4903
4897
r = config.CredentialStoreRegistry()
4910
4904
"somebody", "stub2")
4911
4905
r.register("stub2", stub1, fallback=True)
4912
4906
creds = r.get_fallback_credentials("http", "example.com")
4913
self.assertEqual("somebody", creds["user"])
4914
self.assertEqual("stub1", creds["password"])
4907
self.assertEquals("somebody", creds["user"])
4908
self.assertEquals("stub1", creds["password"])
4915
4909
4916
4910
4917
4911
class TestPlainTextCredentialStore(tests.TestCase):
4920
4914
r = config.credential_store_registry
4921
4915
plain_text = r.get_credential_store()
4922
4916
decoded = plain_text.decode_password(dict(password='secret'))
4923
self.assertEqual('secret', decoded)
4917
self.assertEquals('secret', decoded)
4924
4918
4925
4919
4926
4920
class TestBase64CredentialStore(tests.TestCase):
4929
4923
r = config.credential_store_registry
4930
4924
plain_text = r.get_credential_store('base64')
4931
4925
decoded = plain_text.decode_password(dict(password='c2VjcmV0'))
4932
self.assertEqual('secret', decoded)
4926
self.assertEquals('secret', decoded)
4933
4927
4934
4928
4935
4929
# FIXME: Once we have a way to declare authentication to all test servers, we
4963
4957
self.assertIsNot(None, realname)
4964
4958
self.assertIsNot(None, address)
4965
4959
else:
4966
self.assertEqual((None, None), (realname, address))
4960
self.assertEquals((None, None), (realname, address))
4967
4961
4968
4962
4969
4963
class TestDefaultMailDomain(tests.TestCaseInTempDir):
4976
4970
finally:
4977
4971
f.close()
4978
4972
r = config._get_default_mail_domain('simple')
4979
self.assertEqual('domainname.com', r)
4973
self.assertEquals('domainname.com', r)
4980
4974
4981
4975
def test_default_mail_domain_no_eol(self):
4982
4976
f = file('no_eol', 'w')
4985
4979
finally:
4986
4980
f.close()
4987
4981
r = config._get_default_mail_domain('no_eol')
4988
self.assertEqual('domainname.com', r)
4982
self.assertEquals('domainname.com', r)
4989
4983
4990
4984
def test_default_mail_domain_multiple_lines(self):
4991
4985
f = file('multiple_lines', 'w')
4994
4988
finally:
4995
4989
f.close()
4996
4990
r = config._get_default_mail_domain('multiple_lines')
4997
self.assertEqual('domainname.com', r)
4991
self.assertEquals('domainname.com', r)
4998
4992
4999
4993
5000
4994
class EmailOptionTests(tests.TestCase):
5004
4998
# BZR_EMAIL takes precedence over EMAIL
5005
4999
self.overrideEnv('BZR_EMAIL', 'jelmer@samba.org')
5006
5000
self.overrideEnv('EMAIL', 'jelmer@apache.org')
5007
self.assertEqual('jelmer@samba.org', conf.get('email'))
5001
self.assertEquals('jelmer@samba.org', conf.get('email'))
5008
5002
5009
5003
def test_default_email_uses_EMAIL(self):
5010
5004
conf = config.MemoryStack('')
5011
5005
self.overrideEnv('BZR_EMAIL', None)
5012
5006
self.overrideEnv('EMAIL', 'jelmer@apache.org')
5013
self.assertEqual('jelmer@apache.org', conf.get('email'))
5007
self.assertEquals('jelmer@apache.org', conf.get('email'))
5014
5008
5015
5009
def test_BZR_EMAIL_overrides(self):
5016
5010
conf = config.MemoryStack('email=jelmer@debian.org')
5017
5011
self.overrideEnv('BZR_EMAIL', 'jelmer@apache.org')
5018
self.assertEqual('jelmer@apache.org', conf.get('email'))
5012
self.assertEquals('jelmer@apache.org', conf.get('email'))
5019
5013
self.overrideEnv('BZR_EMAIL', None)
5020
5014
self.overrideEnv('EMAIL', 'jelmer@samba.org')
5021
self.assertEqual('jelmer@debian.org', conf.get('email'))
5015
self.assertEquals('jelmer@debian.org', conf.get('email'))
5022
5016
5023
5017
5024
5018
class MailClientOptionTests(tests.TestCase):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1