13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
18
"""Tests for finding and reading the bzr config file[s]."""
18
19
# import system imports here
20
from ConfigParser import ConfigParser
19
21
from cStringIO import StringIO
23
25
#import bzrlib specific imports here
38
from bzrlib.util.configobj import configobj
41
sample_long_alias="log -r-15..-1 --line"
42
sample_config_text = u"""
44
email=Erik B\u00e5gfors <erik@bagfors.nu>
46
change_editor=vimdiff -of @new_path @old_path
47
gpg_signing_command=gnome-gpg
49
user_global_option=something
52
ll=""" + sample_long_alias + "\n"
55
sample_always_signatures = """
57
check_signatures=ignore
58
create_signatures=always
61
sample_ignore_signatures = """
63
check_signatures=require
64
create_signatures=never
67
sample_maybe_signatures = """
69
check_signatures=ignore
70
create_signatures=when-required
73
sample_branches_text = """
74
[http://www.example.com]
76
email=Robert Collins <robertc@example.org>
77
normal_option = normal
78
appendpath_option = append
79
appendpath_option:policy = appendpath
80
norecurse_option = norecurse
81
norecurse_option:policy = norecurse
82
[http://www.example.com/ignoreparent]
83
# different project: ignore parent dir config
85
[http://www.example.com/norecurse]
86
# configuration items that only apply to this dir
88
normal_option = norecurse
89
[http://www.example.com/dir]
90
appendpath_option = normal
92
check_signatures=require
93
# test trailing / matching with no children
95
check_signatures=check-available
96
gpg_signing_command=false
97
user_local_option=local
98
# test trailing / matching
100
#subdirs will match but not the parent
102
check_signatures=ignore
103
post_commit=bzrlib.tests.test_config.post_commit
104
#testing explicit beats globs
108
class InstrumentedConfigObj(object):
109
"""A config obj look-enough-alike to record calls made to it."""
111
def __contains__(self, thing):
112
self._calls.append(('__contains__', thing))
115
def __getitem__(self, key):
116
self._calls.append(('__getitem__', key))
119
def __init__(self, input, encoding=None):
120
self._calls = [('__init__', input, encoding)]
122
def __setitem__(self, key, value):
123
self._calls.append(('__setitem__', key, value))
125
def __delitem__(self, key):
126
self._calls.append(('__delitem__', key))
129
self._calls.append(('keys',))
132
def write(self, arg):
133
self._calls.append(('write',))
135
def as_bool(self, value):
136
self._calls.append(('as_bool', value))
139
def get_value(self, section, name):
140
self._calls.append(('get_value', section, name))
144
class FakeBranch(object):
146
def __init__(self, base=None, user_id=None):
148
self.base = "http://example.com/branches/demo"
151
self._transport = self.control_files = \
152
FakeControlFilesAndTransport(user_id=user_id)
154
def _get_config(self):
155
return config.TransportConfig(self._transport, 'branch.conf')
157
def lock_write(self):
164
class FakeControlFilesAndTransport(object):
166
def __init__(self, user_id=None):
169
self.files['email'] = user_id
170
self._transport = self
172
def get_utf8(self, filename):
174
raise AssertionError("get_utf8 should no longer be used")
176
def get(self, filename):
179
return StringIO(self.files[filename])
181
raise errors.NoSuchFile(filename)
183
def get_bytes(self, filename):
186
return self.files[filename]
188
raise errors.NoSuchFile(filename)
190
def put(self, filename, fileobj):
191
self.files[filename] = fileobj.read()
193
def put_file(self, filename, fileobj):
194
return self.put(filename, fileobj)
197
class InstrumentedConfig(config.Config):
198
"""An instrumented config that supplies stubs for template methods."""
26
import bzrlib.config as config
27
from bzrlib.selftest import TestCase, TestCaseInTempDir
30
sample_config_text = ("[DEFAULT]\n"
31
"email=Robert Collins <robertc@example.com>\n"
33
"gpg_signing_command=gnome-gpg\n")
35
class InstrumentedConfigParser(object):
36
"""A config parser look-enough-alike to record calls made to it."""
200
38
def __init__(self):
201
super(InstrumentedConfig, self).__init__()
203
self._signatures = config.CHECK_NEVER
205
def _get_user_id(self):
206
self._calls.append('_get_user_id')
207
return "Robert Collins <robert.collins@example.org>"
209
def _get_signature_checking(self):
210
self._calls.append('_get_signature_checking')
211
return self._signatures
213
def _get_change_editor(self):
214
self._calls.append('_get_change_editor')
215
return 'vimdiff -fo @new_path @old_path'
218
bool_config = """[DEFAULT]
227
class TestConfigObj(tests.TestCase):
229
def test_get_bool(self):
230
co = config.ConfigObj(StringIO(bool_config))
231
self.assertIs(co.get_bool('DEFAULT', 'active'), True)
232
self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
233
self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
234
self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
236
def test_hash_sign_in_value(self):
238
Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
239
treated as comments when read in again. (#86838)
241
co = config.ConfigObj()
242
co['test'] = 'foo#bar'
244
self.assertEqual(lines, ['test = "foo#bar"'])
245
co2 = config.ConfigObj(lines)
246
self.assertEqual(co2['test'], 'foo#bar')
249
erroneous_config = """[section] # line 1
252
whocares=notme # line 4
256
class TestConfigObjErrors(tests.TestCase):
258
def test_duplicate_section_name_error_line(self):
260
co = configobj.ConfigObj(StringIO(erroneous_config),
262
except config.configobj.DuplicateError, e:
263
self.assertEqual(3, e.line_number)
265
self.fail('Error in config file not detected')
268
class TestConfig(tests.TestCase):
270
def test_constructs(self):
273
def test_no_default_editor(self):
274
self.assertRaises(NotImplementedError, config.Config().get_editor)
276
def test_user_email(self):
277
my_config = InstrumentedConfig()
278
self.assertEqual('robert.collins@example.org', my_config.user_email())
279
self.assertEqual(['_get_user_id'], my_config._calls)
281
def test_username(self):
282
my_config = InstrumentedConfig()
283
self.assertEqual('Robert Collins <robert.collins@example.org>',
284
my_config.username())
285
self.assertEqual(['_get_user_id'], my_config._calls)
287
def test_signatures_default(self):
288
my_config = config.Config()
289
self.assertFalse(my_config.signature_needed())
290
self.assertEqual(config.CHECK_IF_POSSIBLE,
291
my_config.signature_checking())
292
self.assertEqual(config.SIGN_WHEN_REQUIRED,
293
my_config.signing_policy())
295
def test_signatures_template_method(self):
296
my_config = InstrumentedConfig()
297
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
298
self.assertEqual(['_get_signature_checking'], my_config._calls)
300
def test_signatures_template_method_none(self):
301
my_config = InstrumentedConfig()
302
my_config._signatures = None
303
self.assertEqual(config.CHECK_IF_POSSIBLE,
304
my_config.signature_checking())
305
self.assertEqual(['_get_signature_checking'], my_config._calls)
307
def test_gpg_signing_command_default(self):
308
my_config = config.Config()
309
self.assertEqual('gpg', my_config.gpg_signing_command())
311
def test_get_user_option_default(self):
312
my_config = config.Config()
313
self.assertEqual(None, my_config.get_user_option('no_option'))
315
def test_post_commit_default(self):
316
my_config = config.Config()
317
self.assertEqual(None, my_config.post_commit())
319
def test_log_format_default(self):
320
my_config = config.Config()
321
self.assertEqual('long', my_config.log_format())
323
def test_get_change_editor(self):
324
my_config = InstrumentedConfig()
325
change_editor = my_config.get_change_editor('old_tree', 'new_tree')
326
self.assertEqual(['_get_change_editor'], my_config._calls)
327
self.assertIs(diff.DiffFromTool, change_editor.__class__)
328
self.assertEqual(['vimdiff', '-fo', '@new_path', '@old_path'],
329
change_editor.command_template)
332
class TestConfigPath(tests.TestCase):
41
def read(self, filenames):
42
self._calls.append(('read', filenames))
45
class TestConfigPath(TestCase):
335
48
super(TestConfigPath, self).setUp()
49
self.oldenv = os.environ.get('HOME', None)
336
50
os.environ['HOME'] = '/home/bogus'
337
os.environ['XDG_CACHE_DIR'] = ''
338
if sys.platform == 'win32':
339
os.environ['BZR_HOME'] = \
340
r'C:\Documents and Settings\bogus\Application Data'
342
'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
344
self.bzr_home = '/home/bogus/.bazaar'
53
os.environ['HOME'] = self.oldenv
346
55
def test_config_dir(self):
347
self.assertEqual(config.config_dir(), self.bzr_home)
56
self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
349
58
def test_config_filename(self):
350
59
self.assertEqual(config.config_filename(),
351
self.bzr_home + '/bazaar.conf')
353
def test_branches_config_filename(self):
354
self.assertEqual(config.branches_config_filename(),
355
self.bzr_home + '/branches.conf')
357
def test_locations_config_filename(self):
358
self.assertEqual(config.locations_config_filename(),
359
self.bzr_home + '/locations.conf')
361
def test_authentication_config_filename(self):
362
self.assertEqual(config.authentication_config_filename(),
363
self.bzr_home + '/authentication.conf')
365
def test_xdg_cache_dir(self):
366
self.assertEqual(config.xdg_cache_dir(),
367
'/home/bogus/.cache')
370
class TestIniConfig(tests.TestCase):
372
def make_config_parser(self, s):
373
conf = config.IniBasedConfig(None)
374
parser = conf._get_parser(file=StringIO(s.encode('utf-8')))
378
class TestIniConfigBuilding(TestIniConfig):
380
def test_contructs(self):
381
my_config = config.IniBasedConfig("nothing")
60
'/home/bogus/.bazaar/bazaar.conf')
63
class TestGetConfig(TestCase):
383
65
def test_from_fp(self):
384
config_file = StringIO(sample_config_text.encode('utf-8'))
385
my_config = config.IniBasedConfig(None)
387
isinstance(my_config._get_parser(file=config_file),
388
configobj.ConfigObj))
390
def test_cached(self):
391
config_file = StringIO(sample_config_text.encode('utf-8'))
392
my_config = config.IniBasedConfig(None)
393
parser = my_config._get_parser(file=config_file)
394
self.failUnless(my_config._get_parser() is parser)
397
class TestGetUserOptionAs(TestIniConfig):
399
def test_get_user_option_as_bool(self):
400
conf, parser = self.make_config_parser("""
403
an_invalid_bool = maybe
404
a_list = hmm, who knows ? # This is interpreted as a list !
406
get_bool = conf.get_user_option_as_bool
407
self.assertEqual(True, get_bool('a_true_bool'))
408
self.assertEqual(False, get_bool('a_false_bool'))
409
self.assertIs(None, get_bool('an_invalid_bool'))
410
self.assertIs(None, get_bool('not_defined_in_this_config'))
413
def test_get_user_option_as_list(self):
414
conf, parser = self.make_config_parser("""
419
get_list = conf.get_user_option_as_list
420
self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
421
self.assertEqual(['1'], get_list('length_1'))
422
self.assertEqual('x', conf.get_user_option('one_item'))
423
# automatically cast to list
424
self.assertEqual(['x'], get_list('one_item'))
427
class TestSupressWarning(TestIniConfig):
429
def make_warnings_config(self, s):
430
conf, parser = self.make_config_parser(s)
431
return conf.suppress_warning
433
def test_suppress_warning_unknown(self):
434
suppress_warning = self.make_warnings_config('')
435
self.assertEqual(False, suppress_warning('unknown_warning'))
437
def test_suppress_warning_known(self):
438
suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
439
self.assertEqual(False, suppress_warning('c'))
440
self.assertEqual(True, suppress_warning('a'))
441
self.assertEqual(True, suppress_warning('b'))
444
class TestGetConfig(tests.TestCase):
446
def test_constructs(self):
447
my_config = config.GlobalConfig()
66
config_file = StringIO(sample_config_text)
67
self.failUnless(isinstance(config._get_config_parser(file=config_file),
449
70
def test_calls_read_filenames(self):
450
# replace the class that is constructed, to check its parameters
451
oldparserclass = config.ConfigObj
452
config.ConfigObj = InstrumentedConfigObj
453
my_config = config.GlobalConfig()
455
parser = my_config._get_parser()
457
config.ConfigObj = oldparserclass
458
self.failUnless(isinstance(parser, InstrumentedConfigObj))
459
self.assertEqual(parser._calls, [('__init__', config.config_filename(),
463
class TestBranchConfig(tests.TestCaseWithTransport):
465
def test_constructs(self):
466
branch = FakeBranch()
467
my_config = config.BranchConfig(branch)
468
self.assertRaises(TypeError, config.BranchConfig)
470
def test_get_location_config(self):
471
branch = FakeBranch()
472
my_config = config.BranchConfig(branch)
473
location_config = my_config._get_location_config()
474
self.assertEqual(branch.base, location_config.location)
475
self.failUnless(location_config is my_config._get_location_config())
477
def test_get_config(self):
478
"""The Branch.get_config method works properly"""
479
b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
480
my_config = b.get_config()
481
self.assertIs(my_config.get_user_option('wacky'), None)
482
my_config.set_user_option('wacky', 'unlikely')
483
self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
485
# Ensure we get the same thing if we start again
486
b2 = branch.Branch.open('.')
487
my_config2 = b2.get_config()
488
self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
490
def test_has_explicit_nickname(self):
491
b = self.make_branch('.')
492
self.assertFalse(b.get_config().has_explicit_nickname())
494
self.assertTrue(b.get_config().has_explicit_nickname())
496
def test_config_url(self):
497
"""The Branch.get_config will use section that uses a local url"""
498
branch = self.make_branch('branch')
499
self.assertEqual('branch', branch.nick)
501
locations = config.locations_config_filename()
502
config.ensure_config_dir_exists()
503
local_url = urlutils.local_path_to_url('branch')
504
open(locations, 'wb').write('[%s]\nnickname = foobar'
506
self.assertEqual('foobar', branch.nick)
508
def test_config_local_path(self):
509
"""The Branch.get_config will use a local system path"""
510
branch = self.make_branch('branch')
511
self.assertEqual('branch', branch.nick)
513
locations = config.locations_config_filename()
514
config.ensure_config_dir_exists()
515
open(locations, 'wb').write('[%s/branch]\nnickname = barry'
516
% (osutils.getcwd().encode('utf8'),))
517
self.assertEqual('barry', branch.nick)
519
def test_config_creates_local(self):
520
"""Creating a new entry in config uses a local path."""
521
branch = self.make_branch('branch', format='knit')
522
branch.set_push_location('http://foobar')
523
locations = config.locations_config_filename()
524
local_path = osutils.getcwd().encode('utf8')
525
# Surprisingly ConfigObj doesn't create a trailing newline
526
self.check_file_contents(locations,
528
'push_location = http://foobar\n'
529
'push_location:policy = norecurse\n'
532
def test_autonick_urlencoded(self):
533
b = self.make_branch('!repo')
534
self.assertEqual('!repo', b.get_config().get_nickname())
536
def test_warn_if_masked(self):
537
_warning = trace.warning
540
warnings.append(args[0] % args[1:])
542
def set_option(store, warn_masked=True):
544
conf.set_user_option('example_option', repr(store), store=store,
545
warn_masked=warn_masked)
546
def assertWarning(warning):
548
self.assertEqual(0, len(warnings))
550
self.assertEqual(1, len(warnings))
551
self.assertEqual(warning, warnings[0])
552
trace.warning = warning
554
branch = self.make_branch('.')
555
conf = branch.get_config()
556
set_option(config.STORE_GLOBAL)
558
set_option(config.STORE_BRANCH)
560
set_option(config.STORE_GLOBAL)
561
assertWarning('Value "4" is masked by "3" from branch.conf')
562
set_option(config.STORE_GLOBAL, warn_masked=False)
564
set_option(config.STORE_LOCATION)
566
set_option(config.STORE_BRANCH)
567
assertWarning('Value "3" is masked by "0" from locations.conf')
568
set_option(config.STORE_BRANCH, warn_masked=False)
571
trace.warning = _warning
574
class TestGlobalConfigItems(tests.TestCase):
71
# note the monkey patching. if config access was via a class instance,
72
# we would not have to - if this changes in future, be sure to stop
73
# monkey patching RBC 20051011
74
oldparserclass = config.ConfigParser
75
config.ConfigParser = InstrumentedConfigParser
77
parser = config._get_config_parser()
79
config.ConfigParser = oldparserclass
80
self.failUnless(isinstance(parser, InstrumentedConfigParser))
81
self.assertEqual(parser._calls, [('read', [config.config_filename()])])
84
class TestConfigItems(TestCase):
87
super(TestConfigItems, self).setUp()
88
self.bzr_email = os.environ.get('BZREMAIL')
89
if self.bzr_email is not None:
90
del os.environ['BZREMAIL']
91
self.email = os.environ.get('EMAIL')
92
if self.email is not None:
93
del os.environ['EMAIL']
94
self.oldenv = os.environ.get('HOME', None)
95
os.environ['HOME'] = os.getcwd()
98
os.environ['HOME'] = self.oldenv
99
if self.bzr_email is not None:
100
os.environ['BZREMAIL'] = bzr_email
101
if self.email is not None:
102
os.environ['EMAIL'] = email
103
super(TestConfigItems, self).tearDown()
576
105
def test_user_id(self):
577
config_file = StringIO(sample_config_text.encode('utf-8'))
578
my_config = config.GlobalConfig()
579
my_config._parser = my_config._get_parser(file=config_file)
580
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
581
my_config._get_user_id())
106
config_file = StringIO(sample_config_text)
107
parser = config._get_config_parser(file=config_file)
108
self.assertEqual("Robert Collins <robertc@example.com>",
109
config._get_user_id(parser = parser))
583
111
def test_absent_user_id(self):
584
112
config_file = StringIO("")
585
my_config = config.GlobalConfig()
586
my_config._parser = my_config._get_parser(file=config_file)
587
self.assertEqual(None, my_config._get_user_id())
589
def test_configured_editor(self):
590
config_file = StringIO(sample_config_text.encode('utf-8'))
591
my_config = config.GlobalConfig()
592
my_config._parser = my_config._get_parser(file=config_file)
593
self.assertEqual("vim", my_config.get_editor())
595
def test_signatures_always(self):
596
config_file = StringIO(sample_always_signatures)
597
my_config = config.GlobalConfig()
598
my_config._parser = my_config._get_parser(file=config_file)
599
self.assertEqual(config.CHECK_NEVER,
600
my_config.signature_checking())
601
self.assertEqual(config.SIGN_ALWAYS,
602
my_config.signing_policy())
603
self.assertEqual(True, my_config.signature_needed())
605
def test_signatures_if_possible(self):
606
config_file = StringIO(sample_maybe_signatures)
607
my_config = config.GlobalConfig()
608
my_config._parser = my_config._get_parser(file=config_file)
609
self.assertEqual(config.CHECK_NEVER,
610
my_config.signature_checking())
611
self.assertEqual(config.SIGN_WHEN_REQUIRED,
612
my_config.signing_policy())
613
self.assertEqual(False, my_config.signature_needed())
615
def test_signatures_ignore(self):
616
config_file = StringIO(sample_ignore_signatures)
617
my_config = config.GlobalConfig()
618
my_config._parser = my_config._get_parser(file=config_file)
619
self.assertEqual(config.CHECK_ALWAYS,
620
my_config.signature_checking())
621
self.assertEqual(config.SIGN_NEVER,
622
my_config.signing_policy())
623
self.assertEqual(False, my_config.signature_needed())
625
def _get_sample_config(self):
626
config_file = StringIO(sample_config_text.encode('utf-8'))
627
my_config = config.GlobalConfig()
628
my_config._parser = my_config._get_parser(file=config_file)
631
def test_gpg_signing_command(self):
632
my_config = self._get_sample_config()
633
self.assertEqual("gnome-gpg", my_config.gpg_signing_command())
634
self.assertEqual(False, my_config.signature_needed())
636
def _get_empty_config(self):
637
config_file = StringIO("")
638
my_config = config.GlobalConfig()
639
my_config._parser = my_config._get_parser(file=config_file)
642
def test_gpg_signing_command_unset(self):
643
my_config = self._get_empty_config()
644
self.assertEqual("gpg", my_config.gpg_signing_command())
646
def test_get_user_option_default(self):
647
my_config = self._get_empty_config()
648
self.assertEqual(None, my_config.get_user_option('no_option'))
650
def test_get_user_option_global(self):
651
my_config = self._get_sample_config()
652
self.assertEqual("something",
653
my_config.get_user_option('user_global_option'))
655
def test_post_commit_default(self):
656
my_config = self._get_sample_config()
657
self.assertEqual(None, my_config.post_commit())
659
def test_configured_logformat(self):
660
my_config = self._get_sample_config()
661
self.assertEqual("short", my_config.log_format())
663
def test_get_alias(self):
664
my_config = self._get_sample_config()
665
self.assertEqual('help', my_config.get_alias('h'))
667
def test_get_aliases(self):
668
my_config = self._get_sample_config()
669
aliases = my_config.get_aliases()
670
self.assertEqual(2, len(aliases))
671
sorted_keys = sorted(aliases)
672
self.assertEqual('help', aliases[sorted_keys[0]])
673
self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
675
def test_get_no_alias(self):
676
my_config = self._get_sample_config()
677
self.assertEqual(None, my_config.get_alias('foo'))
679
def test_get_long_alias(self):
680
my_config = self._get_sample_config()
681
self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
683
def test_get_change_editor(self):
684
my_config = self._get_sample_config()
685
change_editor = my_config.get_change_editor('old', 'new')
686
self.assertIs(diff.DiffFromTool, change_editor.__class__)
687
self.assertEqual('vimdiff -of @new_path @old_path',
688
' '.join(change_editor.command_template))
690
def test_get_no_change_editor(self):
691
my_config = self._get_empty_config()
692
change_editor = my_config.get_change_editor('old', 'new')
693
self.assertIs(None, change_editor)
696
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
698
def test_empty(self):
699
my_config = config.GlobalConfig()
700
self.assertEqual(0, len(my_config.get_aliases()))
702
def test_set_alias(self):
703
my_config = config.GlobalConfig()
704
alias_value = 'commit --strict'
705
my_config.set_alias('commit', alias_value)
706
new_config = config.GlobalConfig()
707
self.assertEqual(alias_value, new_config.get_alias('commit'))
709
def test_remove_alias(self):
710
my_config = config.GlobalConfig()
711
my_config.set_alias('commit', 'commit --strict')
712
# Now remove the alias again.
713
my_config.unset_alias('commit')
714
new_config = config.GlobalConfig()
715
self.assertIs(None, new_config.get_alias('commit'))
718
class TestLocationConfig(tests.TestCaseInTempDir):
720
def test_constructs(self):
721
my_config = config.LocationConfig('http://example.com')
722
self.assertRaises(TypeError, config.LocationConfig)
724
def test_branch_calls_read_filenames(self):
725
# This is testing the correct file names are provided.
726
# TODO: consolidate with the test for GlobalConfigs filename checks.
728
# replace the class that is constructed, to check its parameters
729
oldparserclass = config.ConfigObj
730
config.ConfigObj = InstrumentedConfigObj
732
my_config = config.LocationConfig('http://www.example.com')
733
parser = my_config._get_parser()
735
config.ConfigObj = oldparserclass
736
self.failUnless(isinstance(parser, InstrumentedConfigObj))
737
self.assertEqual(parser._calls,
738
[('__init__', config.locations_config_filename(),
740
config.ensure_config_dir_exists()
741
#os.mkdir(config.config_dir())
742
f = file(config.branches_config_filename(), 'wb')
745
oldparserclass = config.ConfigObj
746
config.ConfigObj = InstrumentedConfigObj
748
my_config = config.LocationConfig('http://www.example.com')
749
parser = my_config._get_parser()
751
config.ConfigObj = oldparserclass
753
def test_get_global_config(self):
754
my_config = config.BranchConfig(FakeBranch('http://example.com'))
755
global_config = my_config._get_global_config()
756
self.failUnless(isinstance(global_config, config.GlobalConfig))
757
self.failUnless(global_config is my_config._get_global_config())
759
def test__get_matching_sections_no_match(self):
760
self.get_branch_config('/')
761
self.assertEqual([], self.my_location_config._get_matching_sections())
763
def test__get_matching_sections_exact(self):
764
self.get_branch_config('http://www.example.com')
765
self.assertEqual([('http://www.example.com', '')],
766
self.my_location_config._get_matching_sections())
768
def test__get_matching_sections_suffix_does_not(self):
769
self.get_branch_config('http://www.example.com-com')
770
self.assertEqual([], self.my_location_config._get_matching_sections())
772
def test__get_matching_sections_subdir_recursive(self):
773
self.get_branch_config('http://www.example.com/com')
774
self.assertEqual([('http://www.example.com', 'com')],
775
self.my_location_config._get_matching_sections())
777
def test__get_matching_sections_ignoreparent(self):
778
self.get_branch_config('http://www.example.com/ignoreparent')
779
self.assertEqual([('http://www.example.com/ignoreparent', '')],
780
self.my_location_config._get_matching_sections())
782
def test__get_matching_sections_ignoreparent_subdir(self):
783
self.get_branch_config(
784
'http://www.example.com/ignoreparent/childbranch')
785
self.assertEqual([('http://www.example.com/ignoreparent',
787
self.my_location_config._get_matching_sections())
789
def test__get_matching_sections_subdir_trailing_slash(self):
790
self.get_branch_config('/b')
791
self.assertEqual([('/b/', '')],
792
self.my_location_config._get_matching_sections())
794
def test__get_matching_sections_subdir_child(self):
795
self.get_branch_config('/a/foo')
796
self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
797
self.my_location_config._get_matching_sections())
799
def test__get_matching_sections_subdir_child_child(self):
800
self.get_branch_config('/a/foo/bar')
801
self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
802
self.my_location_config._get_matching_sections())
804
def test__get_matching_sections_trailing_slash_with_children(self):
805
self.get_branch_config('/a/')
806
self.assertEqual([('/a/', '')],
807
self.my_location_config._get_matching_sections())
809
def test__get_matching_sections_explicit_over_glob(self):
810
# XXX: 2006-09-08 jamesh
811
# This test only passes because ord('c') > ord('*'). If there
812
# was a config section for '/a/?', it would get precedence
814
self.get_branch_config('/a/c')
815
self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
816
self.my_location_config._get_matching_sections())
818
def test__get_option_policy_normal(self):
819
self.get_branch_config('http://www.example.com')
821
self.my_location_config._get_config_policy(
822
'http://www.example.com', 'normal_option'),
825
def test__get_option_policy_norecurse(self):
826
self.get_branch_config('http://www.example.com')
828
self.my_location_config._get_option_policy(
829
'http://www.example.com', 'norecurse_option'),
830
config.POLICY_NORECURSE)
831
# Test old recurse=False setting:
833
self.my_location_config._get_option_policy(
834
'http://www.example.com/norecurse', 'normal_option'),
835
config.POLICY_NORECURSE)
837
def test__get_option_policy_normal(self):
838
self.get_branch_config('http://www.example.com')
840
self.my_location_config._get_option_policy(
841
'http://www.example.com', 'appendpath_option'),
842
config.POLICY_APPENDPATH)
844
def test_location_without_username(self):
845
self.get_branch_config('http://www.example.com/ignoreparent')
846
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
847
self.my_config.username())
849
def test_location_not_listed(self):
850
"""Test that the global username is used when no location matches"""
851
self.get_branch_config('/home/robertc/sources')
852
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
853
self.my_config.username())
855
def test_overriding_location(self):
856
self.get_branch_config('http://www.example.com/foo')
857
self.assertEqual('Robert Collins <robertc@example.org>',
858
self.my_config.username())
860
def test_signatures_not_set(self):
861
self.get_branch_config('http://www.example.com',
862
global_config=sample_ignore_signatures)
863
self.assertEqual(config.CHECK_ALWAYS,
864
self.my_config.signature_checking())
865
self.assertEqual(config.SIGN_NEVER,
866
self.my_config.signing_policy())
868
def test_signatures_never(self):
869
self.get_branch_config('/a/c')
870
self.assertEqual(config.CHECK_NEVER,
871
self.my_config.signature_checking())
873
def test_signatures_when_available(self):
874
self.get_branch_config('/a/', global_config=sample_ignore_signatures)
875
self.assertEqual(config.CHECK_IF_POSSIBLE,
876
self.my_config.signature_checking())
878
def test_signatures_always(self):
879
self.get_branch_config('/b')
880
self.assertEqual(config.CHECK_ALWAYS,
881
self.my_config.signature_checking())
883
def test_gpg_signing_command(self):
884
self.get_branch_config('/b')
885
self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
887
def test_gpg_signing_command_missing(self):
888
self.get_branch_config('/a')
889
self.assertEqual("false", self.my_config.gpg_signing_command())
891
def test_get_user_option_global(self):
892
self.get_branch_config('/a')
893
self.assertEqual('something',
894
self.my_config.get_user_option('user_global_option'))
896
def test_get_user_option_local(self):
897
self.get_branch_config('/a')
898
self.assertEqual('local',
899
self.my_config.get_user_option('user_local_option'))
901
def test_get_user_option_appendpath(self):
902
# returned as is for the base path:
903
self.get_branch_config('http://www.example.com')
904
self.assertEqual('append',
905
self.my_config.get_user_option('appendpath_option'))
906
# Extra path components get appended:
907
self.get_branch_config('http://www.example.com/a/b/c')
908
self.assertEqual('append/a/b/c',
909
self.my_config.get_user_option('appendpath_option'))
910
# Overriden for http://www.example.com/dir, where it is a
912
self.get_branch_config('http://www.example.com/dir/a/b/c')
913
self.assertEqual('normal',
914
self.my_config.get_user_option('appendpath_option'))
916
def test_get_user_option_norecurse(self):
917
self.get_branch_config('http://www.example.com')
918
self.assertEqual('norecurse',
919
self.my_config.get_user_option('norecurse_option'))
920
self.get_branch_config('http://www.example.com/dir')
113
parser = config._get_config_parser(file=config_file)
921
114
self.assertEqual(None,
922
self.my_config.get_user_option('norecurse_option'))
923
# http://www.example.com/norecurse is a recurse=False section
924
# that redefines normal_option. Subdirectories do not pick up
926
self.get_branch_config('http://www.example.com/norecurse')
927
self.assertEqual('norecurse',
928
self.my_config.get_user_option('normal_option'))
929
self.get_branch_config('http://www.example.com/norecurse/subdir')
930
self.assertEqual('normal',
931
self.my_config.get_user_option('normal_option'))
933
def test_set_user_option_norecurse(self):
934
self.get_branch_config('http://www.example.com')
935
self.my_config.set_user_option('foo', 'bar',
936
store=config.STORE_LOCATION_NORECURSE)
938
self.my_location_config._get_option_policy(
939
'http://www.example.com', 'foo'),
940
config.POLICY_NORECURSE)
942
def test_set_user_option_appendpath(self):
943
self.get_branch_config('http://www.example.com')
944
self.my_config.set_user_option('foo', 'bar',
945
store=config.STORE_LOCATION_APPENDPATH)
947
self.my_location_config._get_option_policy(
948
'http://www.example.com', 'foo'),
949
config.POLICY_APPENDPATH)
951
def test_set_user_option_change_policy(self):
952
self.get_branch_config('http://www.example.com')
953
self.my_config.set_user_option('norecurse_option', 'normal',
954
store=config.STORE_LOCATION)
956
self.my_location_config._get_option_policy(
957
'http://www.example.com', 'norecurse_option'),
960
def test_set_user_option_recurse_false_section(self):
961
# The following section has recurse=False set. The test is to
962
# make sure that a normal option can be added to the section,
963
# converting recurse=False to the norecurse policy.
964
self.get_branch_config('http://www.example.com/norecurse')
965
self.callDeprecated(['The recurse option is deprecated as of 0.14. '
966
'The section "http://www.example.com/norecurse" '
967
'has been converted to use policies.'],
968
self.my_config.set_user_option,
969
'foo', 'bar', store=config.STORE_LOCATION)
971
self.my_location_config._get_option_policy(
972
'http://www.example.com/norecurse', 'foo'),
974
# The previously existing option is still norecurse:
976
self.my_location_config._get_option_policy(
977
'http://www.example.com/norecurse', 'normal_option'),
978
config.POLICY_NORECURSE)
980
def test_post_commit_default(self):
981
self.get_branch_config('/a/c')
982
self.assertEqual('bzrlib.tests.test_config.post_commit',
983
self.my_config.post_commit())
985
def get_branch_config(self, location, global_config=None):
986
if global_config is None:
987
global_file = StringIO(sample_config_text.encode('utf-8'))
989
global_file = StringIO(global_config.encode('utf-8'))
990
branches_file = StringIO(sample_branches_text.encode('utf-8'))
991
self.my_config = config.BranchConfig(FakeBranch(location))
992
# Force location config to use specified file
993
self.my_location_config = self.my_config._get_location_config()
994
self.my_location_config._get_parser(branches_file)
995
# Force global config to use specified file
996
self.my_config._get_global_config()._get_parser(global_file)
998
def test_set_user_setting_sets_and_saves(self):
999
self.get_branch_config('/a/c')
1000
record = InstrumentedConfigObj("foo")
1001
self.my_location_config._parser = record
1003
real_mkdir = os.mkdir
1004
self.created = False
1005
def checked_mkdir(path, mode=0777):
1006
self.log('making directory: %s', path)
1007
real_mkdir(path, mode)
1010
os.mkdir = checked_mkdir
1012
self.callDeprecated(['The recurse option is deprecated as of '
1013
'0.14. The section "/a/c" has been '
1014
'converted to use policies.'],
1015
self.my_config.set_user_option,
1016
'foo', 'bar', store=config.STORE_LOCATION)
1018
os.mkdir = real_mkdir
1020
self.failUnless(self.created, 'Failed to create ~/.bazaar')
1021
self.assertEqual([('__contains__', '/a/c'),
1022
('__contains__', '/a/c/'),
1023
('__setitem__', '/a/c', {}),
1024
('__getitem__', '/a/c'),
1025
('__setitem__', 'foo', 'bar'),
1026
('__getitem__', '/a/c'),
1027
('as_bool', 'recurse'),
1028
('__getitem__', '/a/c'),
1029
('__delitem__', 'recurse'),
1030
('__getitem__', '/a/c'),
1032
('__getitem__', '/a/c'),
1033
('__contains__', 'foo:policy'),
1037
def test_set_user_setting_sets_and_saves2(self):
1038
self.get_branch_config('/a/c')
1039
self.assertIs(self.my_config.get_user_option('foo'), None)
1040
self.my_config.set_user_option('foo', 'bar')
1042
self.my_config.branch.control_files.files['branch.conf'].strip(),
1044
self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1045
self.my_config.set_user_option('foo', 'baz',
1046
store=config.STORE_LOCATION)
1047
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1048
self.my_config.set_user_option('foo', 'qux')
1049
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1051
def test_get_bzr_remote_path(self):
1052
my_config = config.LocationConfig('/a/c')
1053
self.assertEqual('bzr', my_config.get_bzr_remote_path())
1054
my_config.set_user_option('bzr_remote_path', '/path-bzr')
1055
self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
1056
os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
1057
self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
1060
precedence_global = 'option = global'
1061
precedence_branch = 'option = branch'
1062
precedence_location = """
1066
[http://example.com/specific]
1071
class TestBranchConfigItems(tests.TestCaseInTempDir):
1073
def get_branch_config(self, global_config=None, location=None,
1074
location_config=None, branch_data_config=None):
1075
my_config = config.BranchConfig(FakeBranch(location))
1076
if global_config is not None:
1077
global_file = StringIO(global_config.encode('utf-8'))
1078
my_config._get_global_config()._get_parser(global_file)
1079
self.my_location_config = my_config._get_location_config()
1080
if location_config is not None:
1081
location_file = StringIO(location_config.encode('utf-8'))
1082
self.my_location_config._get_parser(location_file)
1083
if branch_data_config is not None:
1084
my_config.branch.control_files.files['branch.conf'] = \
1088
def test_user_id(self):
1089
branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
1090
my_config = config.BranchConfig(branch)
1091
self.assertEqual("Robert Collins <robertc@example.net>",
1092
my_config.username())
1093
my_config.branch.control_files.files['email'] = "John"
1094
my_config.set_user_option('email',
1095
"Robert Collins <robertc@example.org>")
1096
self.assertEqual("John", my_config.username())
1097
del my_config.branch.control_files.files['email']
1098
self.assertEqual("Robert Collins <robertc@example.org>",
1099
my_config.username())
1101
def test_not_set_in_branch(self):
1102
my_config = self.get_branch_config(sample_config_text)
1103
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1104
my_config._get_user_id())
1105
my_config.branch.control_files.files['email'] = "John"
1106
self.assertEqual("John", my_config._get_user_id())
1108
def test_BZR_EMAIL_OVERRIDES(self):
1109
os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
1110
branch = FakeBranch()
1111
my_config = config.BranchConfig(branch)
1112
self.assertEqual("Robert Collins <robertc@example.org>",
1113
my_config.username())
1115
def test_signatures_forced(self):
1116
my_config = self.get_branch_config(
1117
global_config=sample_always_signatures)
1118
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1119
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1120
self.assertTrue(my_config.signature_needed())
1122
def test_signatures_forced_branch(self):
1123
my_config = self.get_branch_config(
1124
global_config=sample_ignore_signatures,
1125
branch_data_config=sample_always_signatures)
1126
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1127
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1128
self.assertTrue(my_config.signature_needed())
1130
def test_gpg_signing_command(self):
1131
my_config = self.get_branch_config(
1132
# branch data cannot set gpg_signing_command
1133
branch_data_config="gpg_signing_command=pgp")
1134
config_file = StringIO(sample_config_text.encode('utf-8'))
1135
my_config._get_global_config()._get_parser(config_file)
1136
self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1138
def test_get_user_option_global(self):
1139
branch = FakeBranch()
1140
my_config = config.BranchConfig(branch)
1141
config_file = StringIO(sample_config_text.encode('utf-8'))
1142
(my_config._get_global_config()._get_parser(config_file))
1143
self.assertEqual('something',
1144
my_config.get_user_option('user_global_option'))
1146
def test_post_commit_default(self):
1147
branch = FakeBranch()
1148
my_config = self.get_branch_config(sample_config_text, '/a/c',
1149
sample_branches_text)
1150
self.assertEqual(my_config.branch.base, '/a/c')
1151
self.assertEqual('bzrlib.tests.test_config.post_commit',
1152
my_config.post_commit())
1153
my_config.set_user_option('post_commit', 'rmtree_root')
1154
# post-commit is ignored when bresent in branch data
1155
self.assertEqual('bzrlib.tests.test_config.post_commit',
1156
my_config.post_commit())
1157
my_config.set_user_option('post_commit', 'rmtree_root',
1158
store=config.STORE_LOCATION)
1159
self.assertEqual('rmtree_root', my_config.post_commit())
1161
def test_config_precedence(self):
1162
my_config = self.get_branch_config(global_config=precedence_global)
1163
self.assertEqual(my_config.get_user_option('option'), 'global')
1164
my_config = self.get_branch_config(global_config=precedence_global,
1165
branch_data_config=precedence_branch)
1166
self.assertEqual(my_config.get_user_option('option'), 'branch')
1167
my_config = self.get_branch_config(global_config=precedence_global,
1168
branch_data_config=precedence_branch,
1169
location_config=precedence_location)
1170
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1171
my_config = self.get_branch_config(global_config=precedence_global,
1172
branch_data_config=precedence_branch,
1173
location_config=precedence_location,
1174
location='http://example.com/specific')
1175
self.assertEqual(my_config.get_user_option('option'), 'exact')
1177
def test_get_mail_client(self):
1178
config = self.get_branch_config()
1179
client = config.get_mail_client()
1180
self.assertIsInstance(client, mail_client.DefaultMail)
1183
config.set_user_option('mail_client', 'evolution')
1184
client = config.get_mail_client()
1185
self.assertIsInstance(client, mail_client.Evolution)
1187
config.set_user_option('mail_client', 'kmail')
1188
client = config.get_mail_client()
1189
self.assertIsInstance(client, mail_client.KMail)
1191
config.set_user_option('mail_client', 'mutt')
1192
client = config.get_mail_client()
1193
self.assertIsInstance(client, mail_client.Mutt)
1195
config.set_user_option('mail_client', 'thunderbird')
1196
client = config.get_mail_client()
1197
self.assertIsInstance(client, mail_client.Thunderbird)
1200
config.set_user_option('mail_client', 'default')
1201
client = config.get_mail_client()
1202
self.assertIsInstance(client, mail_client.DefaultMail)
1204
config.set_user_option('mail_client', 'editor')
1205
client = config.get_mail_client()
1206
self.assertIsInstance(client, mail_client.Editor)
1208
config.set_user_option('mail_client', 'mapi')
1209
client = config.get_mail_client()
1210
self.assertIsInstance(client, mail_client.MAPIClient)
1212
config.set_user_option('mail_client', 'xdg-email')
1213
client = config.get_mail_client()
1214
self.assertIsInstance(client, mail_client.XDGEmail)
1216
config.set_user_option('mail_client', 'firebird')
1217
self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1220
class TestMailAddressExtraction(tests.TestCase):
1222
def test_extract_email_address(self):
1223
self.assertEqual('jane@test.com',
1224
config.extract_email_address('Jane <jane@test.com>'))
1225
self.assertRaises(errors.NoEmailInUsername,
1226
config.extract_email_address, 'Jane Tester')
1228
def test_parse_username(self):
1229
self.assertEqual(('', 'jdoe@example.com'),
1230
config.parse_username('jdoe@example.com'))
1231
self.assertEqual(('', 'jdoe@example.com'),
1232
config.parse_username('<jdoe@example.com>'))
1233
self.assertEqual(('John Doe', 'jdoe@example.com'),
1234
config.parse_username('John Doe <jdoe@example.com>'))
1235
self.assertEqual(('John Doe', ''),
1236
config.parse_username('John Doe'))
1237
self.assertEqual(('John Doe', 'jdoe@example.com'),
1238
config.parse_username('John Doe jdoe@example.com'))
1240
class TestTreeConfig(tests.TestCaseWithTransport):
1242
def test_get_value(self):
1243
"""Test that retreiving a value from a section is possible"""
1244
branch = self.make_branch('.')
1245
tree_config = config.TreeConfig(branch)
1246
tree_config.set_option('value', 'key', 'SECTION')
1247
tree_config.set_option('value2', 'key2')
1248
tree_config.set_option('value3-top', 'key3')
1249
tree_config.set_option('value3-section', 'key3', 'SECTION')
1250
value = tree_config.get_option('key', 'SECTION')
1251
self.assertEqual(value, 'value')
1252
value = tree_config.get_option('key2')
1253
self.assertEqual(value, 'value2')
1254
self.assertEqual(tree_config.get_option('non-existant'), None)
1255
value = tree_config.get_option('non-existant', 'SECTION')
1256
self.assertEqual(value, None)
1257
value = tree_config.get_option('non-existant', default='default')
1258
self.assertEqual(value, 'default')
1259
self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1260
value = tree_config.get_option('key2', 'NOSECTION', default='default')
1261
self.assertEqual(value, 'default')
1262
value = tree_config.get_option('key3')
1263
self.assertEqual(value, 'value3-top')
1264
value = tree_config.get_option('key3', 'SECTION')
1265
self.assertEqual(value, 'value3-section')
1268
class TestTransportConfig(tests.TestCaseWithTransport):
1270
def test_get_value(self):
1271
"""Test that retreiving a value from a section is possible"""
1272
bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1274
bzrdir_config.set_option('value', 'key', 'SECTION')
1275
bzrdir_config.set_option('value2', 'key2')
1276
bzrdir_config.set_option('value3-top', 'key3')
1277
bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1278
value = bzrdir_config.get_option('key', 'SECTION')
1279
self.assertEqual(value, 'value')
1280
value = bzrdir_config.get_option('key2')
1281
self.assertEqual(value, 'value2')
1282
self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1283
value = bzrdir_config.get_option('non-existant', 'SECTION')
1284
self.assertEqual(value, None)
1285
value = bzrdir_config.get_option('non-existant', default='default')
1286
self.assertEqual(value, 'default')
1287
self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1288
value = bzrdir_config.get_option('key2', 'NOSECTION',
1290
self.assertEqual(value, 'default')
1291
value = bzrdir_config.get_option('key3')
1292
self.assertEqual(value, 'value3-top')
1293
value = bzrdir_config.get_option('key3', 'SECTION')
1294
self.assertEqual(value, 'value3-section')
1296
def test_set_unset_default_stack_on(self):
1297
my_dir = self.make_bzrdir('.')
1298
bzrdir_config = config.BzrDirConfig(my_dir)
1299
self.assertIs(None, bzrdir_config.get_default_stack_on())
1300
bzrdir_config.set_default_stack_on('Foo')
1301
self.assertEqual('Foo', bzrdir_config._config.get_option(
1302
'default_stack_on'))
1303
self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1304
bzrdir_config.set_default_stack_on(None)
1305
self.assertIs(None, bzrdir_config.get_default_stack_on())
1308
class TestAuthenticationConfigFile(tests.TestCase):
1309
"""Test the authentication.conf file matching"""
1311
def _got_user_passwd(self, expected_user, expected_password,
1312
config, *args, **kwargs):
1313
credentials = config.get_credentials(*args, **kwargs)
1314
if credentials is None:
1318
user = credentials['user']
1319
password = credentials['password']
1320
self.assertEquals(expected_user, user)
1321
self.assertEquals(expected_password, password)
1323
def test_empty_config(self):
1324
conf = config.AuthenticationConfig(_file=StringIO())
1325
self.assertEquals({}, conf._get_config())
1326
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1328
def test_missing_auth_section_header(self):
1329
conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1330
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1332
def test_auth_section_header_not_closed(self):
1333
conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1334
self.assertRaises(errors.ParseConfigError, conf._get_config)
1336
def test_auth_value_not_boolean(self):
1337
conf = config.AuthenticationConfig(_file=StringIO(
1341
verify_certificates=askme # Error: Not a boolean
1343
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1345
def test_auth_value_not_int(self):
1346
conf = config.AuthenticationConfig(_file=StringIO(
1350
port=port # Error: Not an int
1352
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1354
def test_unknown_password_encoding(self):
1355
conf = config.AuthenticationConfig(_file=StringIO(
1359
password_encoding=unknown
1361
self.assertRaises(ValueError, conf.get_password,
1362
'ftp', 'foo.net', 'joe')
1364
def test_credentials_for_scheme_host(self):
1365
conf = config.AuthenticationConfig(_file=StringIO(
1366
"""# Identity on foo.net
1371
password=secret-pass
1374
self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1376
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1378
self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1380
def test_credentials_for_host_port(self):
1381
conf = config.AuthenticationConfig(_file=StringIO(
1382
"""# Identity on foo.net
1388
password=secret-pass
1391
self._got_user_passwd('joe', 'secret-pass',
1392
conf, 'ftp', 'foo.net', port=10021)
1394
self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1396
def test_for_matching_host(self):
1397
conf = config.AuthenticationConfig(_file=StringIO(
1398
"""# Identity on foo.net
1404
[sourceforge domain]
1411
self._got_user_passwd('georges', 'bendover',
1412
conf, 'bzr', 'foo.bzr.sf.net')
1414
self._got_user_passwd(None, None,
1415
conf, 'bzr', 'bbzr.sf.net')
1417
def test_for_matching_host_None(self):
1418
conf = config.AuthenticationConfig(_file=StringIO(
1419
"""# Identity on foo.net
1429
self._got_user_passwd('joe', 'joepass',
1430
conf, 'bzr', 'quux.net')
1431
# no host but different scheme
1432
self._got_user_passwd('georges', 'bendover',
1433
conf, 'ftp', 'quux.net')
1435
def test_credentials_for_path(self):
1436
conf = config.AuthenticationConfig(_file=StringIO(
1452
self._got_user_passwd(None, None,
1453
conf, 'http', host='bar.org', path='/dir3')
1455
self._got_user_passwd('georges', 'bendover',
1456
conf, 'http', host='bar.org', path='/dir2')
1458
self._got_user_passwd('jim', 'jimpass',
1459
conf, 'http', host='bar.org',path='/dir1/subdir')
1461
def test_credentials_for_user(self):
1462
conf = config.AuthenticationConfig(_file=StringIO(
1471
self._got_user_passwd('jim', 'jimpass',
1472
conf, 'http', 'bar.org')
1474
self._got_user_passwd('jim', 'jimpass',
1475
conf, 'http', 'bar.org', user='jim')
1476
# Don't get a different user if one is specified
1477
self._got_user_passwd(None, None,
1478
conf, 'http', 'bar.org', user='georges')
1480
def test_credentials_for_user_without_password(self):
1481
conf = config.AuthenticationConfig(_file=StringIO(
1488
# Get user but no password
1489
self._got_user_passwd('jim', None,
1490
conf, 'http', 'bar.org')
1492
def test_verify_certificates(self):
1493
conf = config.AuthenticationConfig(_file=StringIO(
1500
verify_certificates=False
1507
credentials = conf.get_credentials('https', 'bar.org')
1508
self.assertEquals(False, credentials.get('verify_certificates'))
1509
credentials = conf.get_credentials('https', 'foo.net')
1510
self.assertEquals(True, credentials.get('verify_certificates'))
1513
class TestAuthenticationStorage(tests.TestCaseInTempDir):
1515
def test_set_credentials(self):
1516
conf = config.AuthenticationConfig()
1517
conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
1518
99, path='/foo', verify_certificates=False, realm='realm')
1519
credentials = conf.get_credentials(host='host', scheme='scheme',
1520
port=99, path='/foo',
1522
CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1523
'verify_certificates': False, 'scheme': 'scheme',
1524
'host': 'host', 'port': 99, 'path': '/foo',
1526
self.assertEqual(CREDENTIALS, credentials)
1527
credentials_from_disk = config.AuthenticationConfig().get_credentials(
1528
host='host', scheme='scheme', port=99, path='/foo', realm='realm')
1529
self.assertEqual(CREDENTIALS, credentials_from_disk)
1531
def test_reset_credentials_different_name(self):
1532
conf = config.AuthenticationConfig()
1533
conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
1534
conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
1535
self.assertIs(None, conf._get_config().get('name'))
1536
credentials = conf.get_credentials(host='host', scheme='scheme')
1537
CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
1538
'password', 'verify_certificates': True,
1539
'scheme': 'scheme', 'host': 'host', 'port': None,
1540
'path': None, 'realm': None}
1541
self.assertEqual(CREDENTIALS, credentials)
1544
class TestAuthenticationConfig(tests.TestCase):
1545
"""Test AuthenticationConfig behaviour"""
1547
def _check_default_password_prompt(self, expected_prompt_format, scheme,
1548
host=None, port=None, realm=None,
1552
user, password = 'jim', 'precious'
1553
expected_prompt = expected_prompt_format % {
1554
'scheme': scheme, 'host': host, 'port': port,
1555
'user': user, 'realm': realm}
1557
stdout = tests.StringIOWrapper()
1558
stderr = tests.StringIOWrapper()
1559
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1560
stdout=stdout, stderr=stderr)
1561
# We use an empty conf so that the user is always prompted
1562
conf = config.AuthenticationConfig()
1563
self.assertEquals(password,
1564
conf.get_password(scheme, host, user, port=port,
1565
realm=realm, path=path))
1566
self.assertEquals(expected_prompt, stderr.getvalue())
1567
self.assertEquals('', stdout.getvalue())
1569
def _check_default_username_prompt(self, expected_prompt_format, scheme,
1570
host=None, port=None, realm=None,
1575
expected_prompt = expected_prompt_format % {
1576
'scheme': scheme, 'host': host, 'port': port,
1578
stdout = tests.StringIOWrapper()
1579
stderr = tests.StringIOWrapper()
1580
ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
1581
stdout=stdout, stderr=stderr)
1582
# We use an empty conf so that the user is always prompted
1583
conf = config.AuthenticationConfig()
1584
self.assertEquals(username, conf.get_user(scheme, host, port=port,
1585
realm=realm, path=path, ask=True))
1586
self.assertEquals(expected_prompt, stderr.getvalue())
1587
self.assertEquals('', stdout.getvalue())
1589
def test_username_defaults_prompts(self):
1590
# HTTP prompts can't be tested here, see test_http.py
1591
self._check_default_username_prompt('FTP %(host)s username: ', 'ftp')
1592
self._check_default_username_prompt(
1593
'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
1594
self._check_default_username_prompt(
1595
'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
1597
def test_username_default_no_prompt(self):
1598
conf = config.AuthenticationConfig()
1599
self.assertEquals(None,
1600
conf.get_user('ftp', 'example.com'))
1601
self.assertEquals("explicitdefault",
1602
conf.get_user('ftp', 'example.com', default="explicitdefault"))
1604
def test_password_default_prompts(self):
1605
# HTTP prompts can't be tested here, see test_http.py
1606
self._check_default_password_prompt(
1607
'FTP %(user)s@%(host)s password: ', 'ftp')
1608
self._check_default_password_prompt(
1609
'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
1610
self._check_default_password_prompt(
1611
'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
1612
# SMTP port handling is a bit special (it's handled if embedded in the
1614
# FIXME: should we: forbid that, extend it to other schemes, leave
1615
# things as they are that's fine thank you ?
1616
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1618
self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1619
'smtp', host='bar.org:10025')
1620
self._check_default_password_prompt(
1621
'SMTP %(user)s@%(host)s:%(port)d password: ',
1624
def test_ssh_password_emits_warning(self):
1625
conf = config.AuthenticationConfig(_file=StringIO(
1633
entered_password = 'typed-by-hand'
1634
stdout = tests.StringIOWrapper()
1635
stderr = tests.StringIOWrapper()
1636
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1637
stdout=stdout, stderr=stderr)
1639
# Since the password defined in the authentication config is ignored,
1640
# the user is prompted
1641
self.assertEquals(entered_password,
1642
conf.get_password('ssh', 'bar.org', user='jim'))
1643
self.assertContainsRe(
1645
'password ignored in section \[ssh with password\]')
1647
def test_ssh_without_password_doesnt_emit_warning(self):
1648
conf = config.AuthenticationConfig(_file=StringIO(
1655
entered_password = 'typed-by-hand'
1656
stdout = tests.StringIOWrapper()
1657
stderr = tests.StringIOWrapper()
1658
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1662
# Since the password defined in the authentication config is ignored,
1663
# the user is prompted
1664
self.assertEquals(entered_password,
1665
conf.get_password('ssh', 'bar.org', user='jim'))
1666
# No warning shoud be emitted since there is no password. We are only
1668
self.assertNotContainsRe(
1670
'password ignored in section \[ssh with password\]')
1672
def test_uses_fallback_stores(self):
1673
self.overrideAttr(config, 'credential_store_registry',
1674
config.CredentialStoreRegistry())
1675
store = StubCredentialStore()
1676
store.add_credentials("http", "example.com", "joe", "secret")
1677
config.credential_store_registry.register("stub", store, fallback=True)
1678
conf = config.AuthenticationConfig(_file=StringIO())
1679
creds = conf.get_credentials("http", "example.com")
1680
self.assertEquals("joe", creds["user"])
1681
self.assertEquals("secret", creds["password"])
1684
class StubCredentialStore(config.CredentialStore):
1690
def add_credentials(self, scheme, host, user, password=None):
1691
self._username[(scheme, host)] = user
1692
self._password[(scheme, host)] = password
1694
def get_credentials(self, scheme, host, port=None, user=None,
1695
path=None, realm=None):
1696
key = (scheme, host)
1697
if not key in self._username:
1699
return { "scheme": scheme, "host": host, "port": port,
1700
"user": self._username[key], "password": self._password[key]}
1703
class CountingCredentialStore(config.CredentialStore):
1708
def get_credentials(self, scheme, host, port=None, user=None,
1709
path=None, realm=None):
1714
class TestCredentialStoreRegistry(tests.TestCase):
1716
def _get_cs_registry(self):
1717
return config.credential_store_registry
1719
def test_default_credential_store(self):
1720
r = self._get_cs_registry()
1721
default = r.get_credential_store(None)
1722
self.assertIsInstance(default, config.PlainTextCredentialStore)
1724
def test_unknown_credential_store(self):
1725
r = self._get_cs_registry()
1726
# It's hard to imagine someone creating a credential store named
1727
# 'unknown' so we use that as an never registered key.
1728
self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1730
def test_fallback_none_registered(self):
1731
r = config.CredentialStoreRegistry()
1732
self.assertEquals(None,
1733
r.get_fallback_credentials("http", "example.com"))
1735
def test_register(self):
1736
r = config.CredentialStoreRegistry()
1737
r.register("stub", StubCredentialStore(), fallback=False)
1738
r.register("another", StubCredentialStore(), fallback=True)
1739
self.assertEquals(["another", "stub"], r.keys())
1741
def test_register_lazy(self):
1742
r = config.CredentialStoreRegistry()
1743
r.register_lazy("stub", "bzrlib.tests.test_config",
1744
"StubCredentialStore", fallback=False)
1745
self.assertEquals(["stub"], r.keys())
1746
self.assertIsInstance(r.get_credential_store("stub"),
1747
StubCredentialStore)
1749
def test_is_fallback(self):
1750
r = config.CredentialStoreRegistry()
1751
r.register("stub1", None, fallback=False)
1752
r.register("stub2", None, fallback=True)
1753
self.assertEquals(False, r.is_fallback("stub1"))
1754
self.assertEquals(True, r.is_fallback("stub2"))
1756
def test_no_fallback(self):
1757
r = config.CredentialStoreRegistry()
1758
store = CountingCredentialStore()
1759
r.register("count", store, fallback=False)
1760
self.assertEquals(None,
1761
r.get_fallback_credentials("http", "example.com"))
1762
self.assertEquals(0, store._calls)
1764
def test_fallback_credentials(self):
1765
r = config.CredentialStoreRegistry()
1766
store = StubCredentialStore()
1767
store.add_credentials("http", "example.com",
1768
"somebody", "geheim")
1769
r.register("stub", store, fallback=True)
1770
creds = r.get_fallback_credentials("http", "example.com")
1771
self.assertEquals("somebody", creds["user"])
1772
self.assertEquals("geheim", creds["password"])
1774
def test_fallback_first_wins(self):
1775
r = config.CredentialStoreRegistry()
1776
stub1 = StubCredentialStore()
1777
stub1.add_credentials("http", "example.com",
1778
"somebody", "stub1")
1779
r.register("stub1", stub1, fallback=True)
1780
stub2 = StubCredentialStore()
1781
stub2.add_credentials("http", "example.com",
1782
"somebody", "stub2")
1783
r.register("stub2", stub1, fallback=True)
1784
creds = r.get_fallback_credentials("http", "example.com")
1785
self.assertEquals("somebody", creds["user"])
1786
self.assertEquals("stub1", creds["password"])
1789
class TestPlainTextCredentialStore(tests.TestCase):
1791
def test_decode_password(self):
1792
r = config.credential_store_registry
1793
plain_text = r.get_credential_store()
1794
decoded = plain_text.decode_password(dict(password='secret'))
1795
self.assertEquals('secret', decoded)
1798
# FIXME: Once we have a way to declare authentication to all test servers, we
1799
# can implement generic tests.
1800
# test_user_password_in_url
1801
# test_user_in_url_password_from_config
1802
# test_user_in_url_password_prompted
1803
# test_user_in_config
1804
# test_user_getpass.getuser
1805
# test_user_prompted ?
1806
class TestAuthenticationRing(tests.TestCaseWithTransport):
115
config._get_user_id(parser = parser))
117
def test_configured_edit(self):
118
config_file = StringIO(sample_config_text)
119
parser = config._get_config_parser(file=config_file)
120
self.assertEqual("vim", config.get_editor(parser = parser))
added
removed
bzrlib/selftest/testconfig.py
