← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-01-24 17:06:02 UTC
  • mfrom: (2193.4.3 miss.last-file-location)
  • Revision ID: pqm@pqm.ubuntu.com-20070124170602-5f008e922b3dd800
(bialix) 'bzr missing' show remembered location unescaped,and show
 file URL as filepath not a URL.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
12
13
#
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
16
17
 
17
18
"""Tests for finding and reading the bzr config file[s]."""
18
19
# import system imports here
 
20
from bzrlib.util.configobj.configobj import ConfigObj, ConfigObjError
19
21
from cStringIO import StringIO
20
22
import os
21
23
import sys
22
24
 
23
25
#import bzrlib specific imports here
24
26
from bzrlib import (
25
 
    branch,
26
 
    bzrdir,
27
27
    config,
28
 
    diff,
29
28
    errors,
30
29
    osutils,
31
 
    mail_client,
32
 
    ui,
33
30
    urlutils,
34
 
    tests,
35
 
    trace,
36
 
    transport,
37
31
    )
38
 
from bzrlib.util.configobj import configobj
 
32
from bzrlib.branch import Branch
 
33
from bzrlib.bzrdir import BzrDir
 
34
from bzrlib.tests import TestCase, TestCaseInTempDir, TestCaseWithTransport
39
35
 
40
36
 
41
37
sample_long_alias="log -r-15..-1 --line"
43
39
[DEFAULT]
44
40
email=Erik B\u00e5gfors <erik@bagfors.nu>
45
41
editor=vim
46
 
change_editor=vimdiff -of @new_path @old_path
47
42
gpg_signing_command=gnome-gpg
48
43
log_format=short
49
44
user_global_option=something
148
143
            self.base = "http://example.com/branches/demo"
149
144
        else:
150
145
            self.base = base
151
 
        self._transport = self.control_files = \
152
 
            FakeControlFilesAndTransport(user_id=user_id)
153
 
 
154
 
    def _get_config(self):
155
 
        return config.TransportConfig(self._transport, 'branch.conf')
 
146
        self.control_files = FakeControlFiles(user_id=user_id)
156
147
 
157
148
    def lock_write(self):
158
149
        pass
161
152
        pass
162
153
 
163
154
 
164
 
class FakeControlFilesAndTransport(object):
 
155
class FakeControlFiles(object):
165
156
 
166
157
    def __init__(self, user_id=None):
 
158
        self.email = user_id
167
159
        self.files = {}
168
 
        if user_id:
169
 
            self.files['email'] = user_id
170
 
        self._transport = self
171
160
 
172
161
    def get_utf8(self, filename):
173
 
        # from LockableFiles
174
 
        raise AssertionError("get_utf8 should no longer be used")
 
162
        if filename != 'email':
 
163
            raise NotImplementedError
 
164
        if self.email is not None:
 
165
            return StringIO(self.email)
 
166
        raise errors.NoSuchFile(filename)
175
167
 
176
168
    def get(self, filename):
177
 
        # from Transport
178
169
        try:
179
170
            return StringIO(self.files[filename])
180
171
        except KeyError:
181
172
            raise errors.NoSuchFile(filename)
182
173
 
183
 
    def get_bytes(self, filename):
184
 
        # from Transport
185
 
        try:
186
 
            return self.files[filename]
187
 
        except KeyError:
188
 
            raise errors.NoSuchFile(filename)
189
 
 
190
174
    def put(self, filename, fileobj):
191
175
        self.files[filename] = fileobj.read()
192
176
 
193
 
    def put_file(self, filename, fileobj):
194
 
        return self.put(filename, fileobj)
195
 
 
196
177
 
197
178
class InstrumentedConfig(config.Config):
198
179
    """An instrumented config that supplies stubs for template methods."""
199
 
 
 
180
    
200
181
    def __init__(self):
201
182
        super(InstrumentedConfig, self).__init__()
202
183
        self._calls = []
210
191
        self._calls.append('_get_signature_checking')
211
192
        return self._signatures
212
193
 
213
 
    def _get_change_editor(self):
214
 
        self._calls.append('_get_change_editor')
215
 
        return 'vimdiff -fo @new_path @old_path'
216
 
 
217
194
 
218
195
bool_config = """[DEFAULT]
219
196
active = true
222
199
active = True
223
200
nonactive = False
224
201
"""
225
 
 
226
 
 
227
 
class TestConfigObj(tests.TestCase):
228
 
 
 
202
class TestConfigObj(TestCase):
229
203
    def test_get_bool(self):
230
 
        co = config.ConfigObj(StringIO(bool_config))
 
204
        from bzrlib.config import ConfigObj
 
205
        co = ConfigObj(StringIO(bool_config))
231
206
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
232
207
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
233
208
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
234
209
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
235
210
 
236
 
    def test_hash_sign_in_value(self):
237
 
        """
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)
240
 
        """
241
 
        co = config.ConfigObj()
242
 
        co['test'] = 'foo#bar'
243
 
        lines = co.write()
244
 
        self.assertEqual(lines, ['test = "foo#bar"'])
245
 
        co2 = config.ConfigObj(lines)
246
 
        self.assertEqual(co2['test'], 'foo#bar')
247
 
 
248
 
 
249
 
erroneous_config = """[section] # line 1
250
 
good=good # line 2
251
 
[section] # line 3
252
 
whocares=notme # line 4
253
 
"""
254
 
 
255
 
 
256
 
class TestConfigObjErrors(tests.TestCase):
257
 
 
258
 
    def test_duplicate_section_name_error_line(self):
259
 
        try:
260
 
            co = configobj.ConfigObj(StringIO(erroneous_config),
261
 
                                     raise_errors=True)
262
 
        except config.configobj.DuplicateError, e:
263
 
            self.assertEqual(3, e.line_number)
264
 
        else:
265
 
            self.fail('Error in config file not detected')
266
 
 
267
 
 
268
 
class TestConfig(tests.TestCase):
 
211
 
 
212
class TestConfig(TestCase):
269
213
 
270
214
    def test_constructs(self):
271
215
        config.Config()
272
 
 
 
216
 
273
217
    def test_no_default_editor(self):
274
218
        self.assertRaises(NotImplementedError, config.Config().get_editor)
275
219
 
320
264
        my_config = config.Config()
321
265
        self.assertEqual('long', my_config.log_format())
322
266
 
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)
330
 
 
331
 
 
332
 
class TestConfigPath(tests.TestCase):
 
267
 
 
268
class TestConfigPath(TestCase):
333
269
 
334
270
    def setUp(self):
335
271
        super(TestConfigPath, self).setUp()
 
272
        self.old_home = os.environ.get('HOME', None)
 
273
        self.old_appdata = os.environ.get('APPDATA', None)
336
274
        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'
341
 
            self.bzr_home = \
342
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
343
 
        else:
344
 
            self.bzr_home = '/home/bogus/.bazaar'
 
275
        os.environ['APPDATA'] = \
 
276
            r'C:\Documents and Settings\bogus\Application Data'
345
277
 
 
278
    def tearDown(self):
 
279
        if self.old_home is None:
 
280
            del os.environ['HOME']
 
281
        else:
 
282
            os.environ['HOME'] = self.old_home
 
283
        if self.old_appdata is None:
 
284
            del os.environ['APPDATA']
 
285
        else:
 
286
            os.environ['APPDATA'] = self.old_appdata
 
287
        super(TestConfigPath, self).tearDown()
 
288
    
346
289
    def test_config_dir(self):
347
 
        self.assertEqual(config.config_dir(), self.bzr_home)
 
290
        if sys.platform == 'win32':
 
291
            self.assertEqual(config.config_dir(), 
 
292
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
 
293
        else:
 
294
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
348
295
 
349
296
    def test_config_filename(self):
350
 
        self.assertEqual(config.config_filename(),
351
 
                         self.bzr_home + '/bazaar.conf')
 
297
        if sys.platform == 'win32':
 
298
            self.assertEqual(config.config_filename(), 
 
299
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
 
300
        else:
 
301
            self.assertEqual(config.config_filename(),
 
302
                             '/home/bogus/.bazaar/bazaar.conf')
352
303
 
353
304
    def test_branches_config_filename(self):
354
 
        self.assertEqual(config.branches_config_filename(),
355
 
                         self.bzr_home + '/branches.conf')
 
305
        if sys.platform == 'win32':
 
306
            self.assertEqual(config.branches_config_filename(), 
 
307
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
 
308
        else:
 
309
            self.assertEqual(config.branches_config_filename(),
 
310
                             '/home/bogus/.bazaar/branches.conf')
356
311
 
357
312
    def test_locations_config_filename(self):
358
 
        self.assertEqual(config.locations_config_filename(),
359
 
                         self.bzr_home + '/locations.conf')
360
 
 
361
 
    def test_authentication_config_filename(self):
362
 
        self.assertEqual(config.authentication_config_filename(),
363
 
                         self.bzr_home + '/authentication.conf')
364
 
 
365
 
    def test_xdg_cache_dir(self):
366
 
        self.assertEqual(config.xdg_cache_dir(),
367
 
            '/home/bogus/.cache')
368
 
 
369
 
 
370
 
class TestIniConfig(tests.TestCase):
371
 
 
372
 
    def make_config_parser(self, s):
373
 
        conf = config.IniBasedConfig(None)
374
 
        parser = conf._get_parser(file=StringIO(s.encode('utf-8')))
375
 
        return conf, parser
376
 
 
377
 
 
378
 
class TestIniConfigBuilding(TestIniConfig):
 
313
        if sys.platform == 'win32':
 
314
            self.assertEqual(config.locations_config_filename(), 
 
315
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
 
316
        else:
 
317
            self.assertEqual(config.locations_config_filename(),
 
318
                             '/home/bogus/.bazaar/locations.conf')
 
319
 
 
320
class TestIniConfig(TestCase):
379
321
 
380
322
    def test_contructs(self):
381
323
        my_config = config.IniBasedConfig("nothing")
385
327
        my_config = config.IniBasedConfig(None)
386
328
        self.failUnless(
387
329
            isinstance(my_config._get_parser(file=config_file),
388
 
                        configobj.ConfigObj))
 
330
                        ConfigObj))
389
331
 
390
332
    def test_cached(self):
391
333
        config_file = StringIO(sample_config_text.encode('utf-8'))
394
336
        self.failUnless(my_config._get_parser() is parser)
395
337
 
396
338
 
397
 
class TestGetUserOptionAs(TestIniConfig):
398
 
 
399
 
    def test_get_user_option_as_bool(self):
400
 
        conf, parser = self.make_config_parser("""
401
 
a_true_bool = true
402
 
a_false_bool = 0
403
 
an_invalid_bool = maybe
404
 
a_list = hmm, who knows ? # This is interpreted as a list !
405
 
""")
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
 
        warnings = []
410
 
        def warning(*args):
411
 
            warnings.append(args[0] % args[1:])
412
 
        self.overrideAttr(trace, 'warning', warning)
413
 
        msg = 'Value "%s" is not a boolean for "%s"'
414
 
        self.assertIs(None, get_bool('an_invalid_bool'))
415
 
        self.assertEquals(msg % ('maybe', 'an_invalid_bool'), warnings[0])
416
 
        warnings = []
417
 
        self.assertIs(None, get_bool('not_defined_in_this_config'))
418
 
        self.assertEquals([], warnings)
419
 
 
420
 
    def test_get_user_option_as_list(self):
421
 
        conf, parser = self.make_config_parser("""
422
 
a_list = a,b,c
423
 
length_1 = 1,
424
 
one_item = x
425
 
""")
426
 
        get_list = conf.get_user_option_as_list
427
 
        self.assertEqual(['a', 'b', 'c'], get_list('a_list'))
428
 
        self.assertEqual(['1'], get_list('length_1'))
429
 
        self.assertEqual('x', conf.get_user_option('one_item'))
430
 
        # automatically cast to list
431
 
        self.assertEqual(['x'], get_list('one_item'))
432
 
 
433
 
 
434
 
class TestSupressWarning(TestIniConfig):
435
 
 
436
 
    def make_warnings_config(self, s):
437
 
        conf, parser = self.make_config_parser(s)
438
 
        return conf.suppress_warning
439
 
 
440
 
    def test_suppress_warning_unknown(self):
441
 
        suppress_warning = self.make_warnings_config('')
442
 
        self.assertEqual(False, suppress_warning('unknown_warning'))
443
 
 
444
 
    def test_suppress_warning_known(self):
445
 
        suppress_warning = self.make_warnings_config('suppress_warnings=a,b')
446
 
        self.assertEqual(False, suppress_warning('c'))
447
 
        self.assertEqual(True, suppress_warning('a'))
448
 
        self.assertEqual(True, suppress_warning('b'))
449
 
 
450
 
 
451
 
class TestGetConfig(tests.TestCase):
 
339
class TestGetConfig(TestCase):
452
340
 
453
341
    def test_constructs(self):
454
342
        my_config = config.GlobalConfig()
455
343
 
456
344
    def test_calls_read_filenames(self):
457
 
        # replace the class that is constructed, to check its parameters
 
345
        # replace the class that is constructured, to check its parameters
458
346
        oldparserclass = config.ConfigObj
459
347
        config.ConfigObj = InstrumentedConfigObj
460
348
        my_config = config.GlobalConfig()
467
355
                                          'utf-8')])
468
356
 
469
357
 
470
 
class TestBranchConfig(tests.TestCaseWithTransport):
 
358
class TestBranchConfig(TestCaseWithTransport):
471
359
 
472
360
    def test_constructs(self):
473
361
        branch = FakeBranch()
483
371
 
484
372
    def test_get_config(self):
485
373
        """The Branch.get_config method works properly"""
486
 
        b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
 
374
        b = BzrDir.create_standalone_workingtree('.').branch
487
375
        my_config = b.get_config()
488
376
        self.assertIs(my_config.get_user_option('wacky'), None)
489
377
        my_config.set_user_option('wacky', 'unlikely')
490
378
        self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
491
379
 
492
380
        # Ensure we get the same thing if we start again
493
 
        b2 = branch.Branch.open('.')
 
381
        b2 = Branch.open('.')
494
382
        my_config2 = b2.get_config()
495
383
        self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
496
384
 
508
396
        locations = config.locations_config_filename()
509
397
        config.ensure_config_dir_exists()
510
398
        local_url = urlutils.local_path_to_url('branch')
511
 
        open(locations, 'wb').write('[%s]\nnickname = foobar'
 
399
        open(locations, 'wb').write('[%s]\nnickname = foobar' 
512
400
                                    % (local_url,))
513
401
        self.assertEqual('foobar', branch.nick)
514
402
 
519
407
 
520
408
        locations = config.locations_config_filename()
521
409
        config.ensure_config_dir_exists()
522
 
        open(locations, 'wb').write('[%s/branch]\nnickname = barry'
 
410
        open(locations, 'wb').write('[%s/branch]\nnickname = barry' 
523
411
                                    % (osutils.getcwd().encode('utf8'),))
524
412
        self.assertEqual('barry', branch.nick)
525
413
 
526
414
    def test_config_creates_local(self):
527
415
        """Creating a new entry in config uses a local path."""
528
 
        branch = self.make_branch('branch', format='knit')
 
416
        branch = self.make_branch('branch')
529
417
        branch.set_push_location('http://foobar')
530
418
        locations = config.locations_config_filename()
531
419
        local_path = osutils.getcwd().encode('utf8')
532
420
        # Surprisingly ConfigObj doesn't create a trailing newline
533
421
        self.check_file_contents(locations,
534
 
                                 '[%s/branch]\n'
535
 
                                 'push_location = http://foobar\n'
536
 
                                 'push_location:policy = norecurse\n'
537
 
                                 % (local_path,))
 
422
            '[%s/branch]\npush_location = http://foobar\npush_location:policy = norecurse' % (local_path,))
538
423
 
539
424
    def test_autonick_urlencoded(self):
540
425
        b = self.make_branch('!repo')
541
426
        self.assertEqual('!repo', b.get_config().get_nickname())
542
427
 
543
 
    def test_warn_if_masked(self):
544
 
        _warning = trace.warning
545
 
        warnings = []
546
 
        def warning(*args):
547
 
            warnings.append(args[0] % args[1:])
548
 
 
549
 
        def set_option(store, warn_masked=True):
550
 
            warnings[:] = []
551
 
            conf.set_user_option('example_option', repr(store), store=store,
552
 
                                 warn_masked=warn_masked)
553
 
        def assertWarning(warning):
554
 
            if warning is None:
555
 
                self.assertEqual(0, len(warnings))
556
 
            else:
557
 
                self.assertEqual(1, len(warnings))
558
 
                self.assertEqual(warning, warnings[0])
559
 
        trace.warning = warning
560
 
        try:
561
 
            branch = self.make_branch('.')
562
 
            conf = branch.get_config()
563
 
            set_option(config.STORE_GLOBAL)
564
 
            assertWarning(None)
565
 
            set_option(config.STORE_BRANCH)
566
 
            assertWarning(None)
567
 
            set_option(config.STORE_GLOBAL)
568
 
            assertWarning('Value "4" is masked by "3" from branch.conf')
569
 
            set_option(config.STORE_GLOBAL, warn_masked=False)
570
 
            assertWarning(None)
571
 
            set_option(config.STORE_LOCATION)
572
 
            assertWarning(None)
573
 
            set_option(config.STORE_BRANCH)
574
 
            assertWarning('Value "3" is masked by "0" from locations.conf')
575
 
            set_option(config.STORE_BRANCH, warn_masked=False)
576
 
            assertWarning(None)
577
 
        finally:
578
 
            trace.warning = _warning
579
 
 
580
 
 
581
 
class TestGlobalConfigItems(tests.TestCase):
 
428
 
 
429
class TestGlobalConfigItems(TestCase):
582
430
 
583
431
    def test_user_id(self):
584
432
        config_file = StringIO(sample_config_text.encode('utf-8'))
658
506
        my_config = self._get_sample_config()
659
507
        self.assertEqual("something",
660
508
                         my_config.get_user_option('user_global_option'))
661
 
 
 
509
        
662
510
    def test_post_commit_default(self):
663
511
        my_config = self._get_sample_config()
664
512
        self.assertEqual(None, my_config.post_commit())
671
519
        my_config = self._get_sample_config()
672
520
        self.assertEqual('help', my_config.get_alias('h'))
673
521
 
674
 
    def test_get_aliases(self):
675
 
        my_config = self._get_sample_config()
676
 
        aliases = my_config.get_aliases()
677
 
        self.assertEqual(2, len(aliases))
678
 
        sorted_keys = sorted(aliases)
679
 
        self.assertEqual('help', aliases[sorted_keys[0]])
680
 
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
681
 
 
682
522
    def test_get_no_alias(self):
683
523
        my_config = self._get_sample_config()
684
524
        self.assertEqual(None, my_config.get_alias('foo'))
687
527
        my_config = self._get_sample_config()
688
528
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
689
529
 
690
 
    def test_get_change_editor(self):
691
 
        my_config = self._get_sample_config()
692
 
        change_editor = my_config.get_change_editor('old', 'new')
693
 
        self.assertIs(diff.DiffFromTool, change_editor.__class__)
694
 
        self.assertEqual('vimdiff -of @new_path @old_path',
695
 
                         ' '.join(change_editor.command_template))
696
 
 
697
 
    def test_get_no_change_editor(self):
698
 
        my_config = self._get_empty_config()
699
 
        change_editor = my_config.get_change_editor('old', 'new')
700
 
        self.assertIs(None, change_editor)
701
 
 
702
 
 
703
 
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
704
 
 
705
 
    def test_empty(self):
706
 
        my_config = config.GlobalConfig()
707
 
        self.assertEqual(0, len(my_config.get_aliases()))
708
 
 
709
 
    def test_set_alias(self):
710
 
        my_config = config.GlobalConfig()
711
 
        alias_value = 'commit --strict'
712
 
        my_config.set_alias('commit', alias_value)
713
 
        new_config = config.GlobalConfig()
714
 
        self.assertEqual(alias_value, new_config.get_alias('commit'))
715
 
 
716
 
    def test_remove_alias(self):
717
 
        my_config = config.GlobalConfig()
718
 
        my_config.set_alias('commit', 'commit --strict')
719
 
        # Now remove the alias again.
720
 
        my_config.unset_alias('commit')
721
 
        new_config = config.GlobalConfig()
722
 
        self.assertIs(None, new_config.get_alias('commit'))
723
 
 
724
 
 
725
 
class TestLocationConfig(tests.TestCaseInTempDir):
 
530
 
 
531
class TestLocationConfig(TestCaseInTempDir):
726
532
 
727
533
    def test_constructs(self):
728
534
        my_config = config.LocationConfig('http://example.com')
732
538
        # This is testing the correct file names are provided.
733
539
        # TODO: consolidate with the test for GlobalConfigs filename checks.
734
540
        #
735
 
        # replace the class that is constructed, to check its parameters
 
541
        # replace the class that is constructured, to check its parameters
736
542
        oldparserclass = config.ConfigObj
737
543
        config.ConfigObj = InstrumentedConfigObj
738
544
        try:
766
572
    def test__get_matching_sections_no_match(self):
767
573
        self.get_branch_config('/')
768
574
        self.assertEqual([], self.my_location_config._get_matching_sections())
769
 
 
 
575
        
770
576
    def test__get_matching_sections_exact(self):
771
577
        self.get_branch_config('http://www.example.com')
772
578
        self.assertEqual([('http://www.example.com', '')],
773
579
                         self.my_location_config._get_matching_sections())
774
 
 
 
580
   
775
581
    def test__get_matching_sections_suffix_does_not(self):
776
582
        self.get_branch_config('http://www.example.com-com')
777
583
        self.assertEqual([], self.my_location_config._get_matching_sections())
789
595
    def test__get_matching_sections_ignoreparent_subdir(self):
790
596
        self.get_branch_config(
791
597
            'http://www.example.com/ignoreparent/childbranch')
792
 
        self.assertEqual([('http://www.example.com/ignoreparent',
793
 
                           'childbranch')],
 
598
        self.assertEqual([('http://www.example.com/ignoreparent', 'childbranch')],
794
599
                         self.my_location_config._get_matching_sections())
795
600
 
796
601
    def test__get_matching_sections_subdir_trailing_slash(self):
876
681
        self.get_branch_config('/a/c')
877
682
        self.assertEqual(config.CHECK_NEVER,
878
683
                         self.my_config.signature_checking())
879
 
 
 
684
        
880
685
    def test_signatures_when_available(self):
881
686
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
882
687
        self.assertEqual(config.CHECK_IF_POSSIBLE,
883
688
                         self.my_config.signature_checking())
884
 
 
 
689
        
885
690
    def test_signatures_always(self):
886
691
        self.get_branch_config('/b')
887
692
        self.assertEqual(config.CHECK_ALWAYS,
888
693
                         self.my_config.signature_checking())
889
 
 
 
694
        
890
695
    def test_gpg_signing_command(self):
891
696
        self.get_branch_config('/b')
892
697
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
983
788
            self.my_location_config._get_option_policy(
984
789
            'http://www.example.com/norecurse', 'normal_option'),
985
790
            config.POLICY_NORECURSE)
 
791
        
986
792
 
987
793
    def test_post_commit_default(self):
988
794
        self.get_branch_config('/a/c')
1046
852
        self.assertIs(self.my_config.get_user_option('foo'), None)
1047
853
        self.my_config.set_user_option('foo', 'bar')
1048
854
        self.assertEqual(
1049
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
 
855
            self.my_config.branch.control_files.files['branch.conf'], 
1050
856
            'foo = bar')
1051
857
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1052
858
        self.my_config.set_user_option('foo', 'baz',
1054
860
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1055
861
        self.my_config.set_user_option('foo', 'qux')
1056
862
        self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1057
 
 
1058
 
    def test_get_bzr_remote_path(self):
1059
 
        my_config = config.LocationConfig('/a/c')
1060
 
        self.assertEqual('bzr', my_config.get_bzr_remote_path())
1061
 
        my_config.set_user_option('bzr_remote_path', '/path-bzr')
1062
 
        self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
1063
 
        os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
1064
 
        self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
1065
 
 
 
863
        
1066
864
 
1067
865
precedence_global = 'option = global'
1068
866
precedence_branch = 'option = branch'
1075
873
"""
1076
874
 
1077
875
 
1078
 
class TestBranchConfigItems(tests.TestCaseInTempDir):
 
876
class TestBranchConfigItems(TestCaseInTempDir):
1079
877
 
1080
 
    def get_branch_config(self, global_config=None, location=None,
 
878
    def get_branch_config(self, global_config=None, location=None, 
1081
879
                          location_config=None, branch_data_config=None):
1082
880
        my_config = config.BranchConfig(FakeBranch(location))
1083
881
        if global_config is not None:
1097
895
        my_config = config.BranchConfig(branch)
1098
896
        self.assertEqual("Robert Collins <robertc@example.net>",
1099
897
                         my_config.username())
1100
 
        my_config.branch.control_files.files['email'] = "John"
1101
 
        my_config.set_user_option('email',
 
898
        branch.control_files.email = "John"
 
899
        my_config.set_user_option('email', 
1102
900
                                  "Robert Collins <robertc@example.org>")
1103
901
        self.assertEqual("John", my_config.username())
1104
 
        del my_config.branch.control_files.files['email']
 
902
        branch.control_files.email = None
1105
903
        self.assertEqual("Robert Collins <robertc@example.org>",
1106
904
                         my_config.username())
1107
905
 
1108
906
    def test_not_set_in_branch(self):
1109
907
        my_config = self.get_branch_config(sample_config_text)
 
908
        my_config.branch.control_files.email = None
1110
909
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1111
910
                         my_config._get_user_id())
1112
 
        my_config.branch.control_files.files['email'] = "John"
 
911
        my_config.branch.control_files.email = "John"
1113
912
        self.assertEqual("John", my_config._get_user_id())
1114
913
 
1115
914
    def test_BZR_EMAIL_OVERRIDES(self):
1118
917
        my_config = config.BranchConfig(branch)
1119
918
        self.assertEqual("Robert Collins <robertc@example.org>",
1120
919
                         my_config.username())
1121
 
 
 
920
    
1122
921
    def test_signatures_forced(self):
1123
922
        my_config = self.get_branch_config(
1124
923
            global_config=sample_always_signatures)
1168
967
    def test_config_precedence(self):
1169
968
        my_config = self.get_branch_config(global_config=precedence_global)
1170
969
        self.assertEqual(my_config.get_user_option('option'), 'global')
1171
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
970
        my_config = self.get_branch_config(global_config=precedence_global, 
1172
971
                                      branch_data_config=precedence_branch)
1173
972
        self.assertEqual(my_config.get_user_option('option'), 'branch')
1174
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
973
        my_config = self.get_branch_config(global_config=precedence_global, 
1175
974
                                      branch_data_config=precedence_branch,
1176
975
                                      location_config=precedence_location)
1177
976
        self.assertEqual(my_config.get_user_option('option'), 'recurse')
1178
 
        my_config = self.get_branch_config(global_config=precedence_global,
 
977
        my_config = self.get_branch_config(global_config=precedence_global, 
1179
978
                                      branch_data_config=precedence_branch,
1180
979
                                      location_config=precedence_location,
1181
980
                                      location='http://example.com/specific')
1182
981
        self.assertEqual(my_config.get_user_option('option'), 'exact')
1183
982
 
1184
 
    def test_get_mail_client(self):
1185
 
        config = self.get_branch_config()
1186
 
        client = config.get_mail_client()
1187
 
        self.assertIsInstance(client, mail_client.DefaultMail)
1188
 
 
1189
 
        # Specific clients
1190
 
        config.set_user_option('mail_client', 'evolution')
1191
 
        client = config.get_mail_client()
1192
 
        self.assertIsInstance(client, mail_client.Evolution)
1193
 
 
1194
 
        config.set_user_option('mail_client', 'kmail')
1195
 
        client = config.get_mail_client()
1196
 
        self.assertIsInstance(client, mail_client.KMail)
1197
 
 
1198
 
        config.set_user_option('mail_client', 'mutt')
1199
 
        client = config.get_mail_client()
1200
 
        self.assertIsInstance(client, mail_client.Mutt)
1201
 
 
1202
 
        config.set_user_option('mail_client', 'thunderbird')
1203
 
        client = config.get_mail_client()
1204
 
        self.assertIsInstance(client, mail_client.Thunderbird)
1205
 
 
1206
 
        # Generic options
1207
 
        config.set_user_option('mail_client', 'default')
1208
 
        client = config.get_mail_client()
1209
 
        self.assertIsInstance(client, mail_client.DefaultMail)
1210
 
 
1211
 
        config.set_user_option('mail_client', 'editor')
1212
 
        client = config.get_mail_client()
1213
 
        self.assertIsInstance(client, mail_client.Editor)
1214
 
 
1215
 
        config.set_user_option('mail_client', 'mapi')
1216
 
        client = config.get_mail_client()
1217
 
        self.assertIsInstance(client, mail_client.MAPIClient)
1218
 
 
1219
 
        config.set_user_option('mail_client', 'xdg-email')
1220
 
        client = config.get_mail_client()
1221
 
        self.assertIsInstance(client, mail_client.XDGEmail)
1222
 
 
1223
 
        config.set_user_option('mail_client', 'firebird')
1224
 
        self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1225
 
 
1226
 
 
1227
 
class TestMailAddressExtraction(tests.TestCase):
 
983
 
 
984
class TestMailAddressExtraction(TestCase):
1228
985
 
1229
986
    def test_extract_email_address(self):
1230
987
        self.assertEqual('jane@test.com',
1231
988
                         config.extract_email_address('Jane <jane@test.com>'))
1232
989
        self.assertRaises(errors.NoEmailInUsername,
1233
990
                          config.extract_email_address, 'Jane Tester')
1234
 
 
1235
 
    def test_parse_username(self):
1236
 
        self.assertEqual(('', 'jdoe@example.com'),
1237
 
                         config.parse_username('jdoe@example.com'))
1238
 
        self.assertEqual(('', 'jdoe@example.com'),
1239
 
                         config.parse_username('<jdoe@example.com>'))
1240
 
        self.assertEqual(('John Doe', 'jdoe@example.com'),
1241
 
                         config.parse_username('John Doe <jdoe@example.com>'))
1242
 
        self.assertEqual(('John Doe', ''),
1243
 
                         config.parse_username('John Doe'))
1244
 
        self.assertEqual(('John Doe', 'jdoe@example.com'),
1245
 
                         config.parse_username('John Doe jdoe@example.com'))
1246
 
 
1247
 
class TestTreeConfig(tests.TestCaseWithTransport):
1248
 
 
1249
 
    def test_get_value(self):
1250
 
        """Test that retreiving a value from a section is possible"""
1251
 
        branch = self.make_branch('.')
1252
 
        tree_config = config.TreeConfig(branch)
1253
 
        tree_config.set_option('value', 'key', 'SECTION')
1254
 
        tree_config.set_option('value2', 'key2')
1255
 
        tree_config.set_option('value3-top', 'key3')
1256
 
        tree_config.set_option('value3-section', 'key3', 'SECTION')
1257
 
        value = tree_config.get_option('key', 'SECTION')
1258
 
        self.assertEqual(value, 'value')
1259
 
        value = tree_config.get_option('key2')
1260
 
        self.assertEqual(value, 'value2')
1261
 
        self.assertEqual(tree_config.get_option('non-existant'), None)
1262
 
        value = tree_config.get_option('non-existant', 'SECTION')
1263
 
        self.assertEqual(value, None)
1264
 
        value = tree_config.get_option('non-existant', default='default')
1265
 
        self.assertEqual(value, 'default')
1266
 
        self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1267
 
        value = tree_config.get_option('key2', 'NOSECTION', default='default')
1268
 
        self.assertEqual(value, 'default')
1269
 
        value = tree_config.get_option('key3')
1270
 
        self.assertEqual(value, 'value3-top')
1271
 
        value = tree_config.get_option('key3', 'SECTION')
1272
 
        self.assertEqual(value, 'value3-section')
1273
 
 
1274
 
 
1275
 
class TestTransportConfig(tests.TestCaseWithTransport):
1276
 
 
1277
 
    def test_get_value(self):
1278
 
        """Test that retreiving a value from a section is possible"""
1279
 
        bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1280
 
                                               'control.conf')
1281
 
        bzrdir_config.set_option('value', 'key', 'SECTION')
1282
 
        bzrdir_config.set_option('value2', 'key2')
1283
 
        bzrdir_config.set_option('value3-top', 'key3')
1284
 
        bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1285
 
        value = bzrdir_config.get_option('key', 'SECTION')
1286
 
        self.assertEqual(value, 'value')
1287
 
        value = bzrdir_config.get_option('key2')
1288
 
        self.assertEqual(value, 'value2')
1289
 
        self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1290
 
        value = bzrdir_config.get_option('non-existant', 'SECTION')
1291
 
        self.assertEqual(value, None)
1292
 
        value = bzrdir_config.get_option('non-existant', default='default')
1293
 
        self.assertEqual(value, 'default')
1294
 
        self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1295
 
        value = bzrdir_config.get_option('key2', 'NOSECTION',
1296
 
                                         default='default')
1297
 
        self.assertEqual(value, 'default')
1298
 
        value = bzrdir_config.get_option('key3')
1299
 
        self.assertEqual(value, 'value3-top')
1300
 
        value = bzrdir_config.get_option('key3', 'SECTION')
1301
 
        self.assertEqual(value, 'value3-section')
1302
 
 
1303
 
    def test_set_unset_default_stack_on(self):
1304
 
        my_dir = self.make_bzrdir('.')
1305
 
        bzrdir_config = config.BzrDirConfig(my_dir)
1306
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1307
 
        bzrdir_config.set_default_stack_on('Foo')
1308
 
        self.assertEqual('Foo', bzrdir_config._config.get_option(
1309
 
                         'default_stack_on'))
1310
 
        self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1311
 
        bzrdir_config.set_default_stack_on(None)
1312
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1313
 
 
1314
 
 
1315
 
class TestAuthenticationConfigFile(tests.TestCase):
1316
 
    """Test the authentication.conf file matching"""
1317
 
 
1318
 
    def _got_user_passwd(self, expected_user, expected_password,
1319
 
                         config, *args, **kwargs):
1320
 
        credentials = config.get_credentials(*args, **kwargs)
1321
 
        if credentials is None:
1322
 
            user = None
1323
 
            password = None
1324
 
        else:
1325
 
            user = credentials['user']
1326
 
            password = credentials['password']
1327
 
        self.assertEquals(expected_user, user)
1328
 
        self.assertEquals(expected_password, password)
1329
 
 
1330
 
    def test_empty_config(self):
1331
 
        conf = config.AuthenticationConfig(_file=StringIO())
1332
 
        self.assertEquals({}, conf._get_config())
1333
 
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1334
 
 
1335
 
    def test_missing_auth_section_header(self):
1336
 
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1337
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1338
 
 
1339
 
    def test_auth_section_header_not_closed(self):
1340
 
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1341
 
        self.assertRaises(errors.ParseConfigError, conf._get_config)
1342
 
 
1343
 
    def test_auth_value_not_boolean(self):
1344
 
        conf = config.AuthenticationConfig(_file=StringIO(
1345
 
                """[broken]
1346
 
scheme=ftp
1347
 
user=joe
1348
 
verify_certificates=askme # Error: Not a boolean
1349
 
"""))
1350
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1351
 
 
1352
 
    def test_auth_value_not_int(self):
1353
 
        conf = config.AuthenticationConfig(_file=StringIO(
1354
 
                """[broken]
1355
 
scheme=ftp
1356
 
user=joe
1357
 
port=port # Error: Not an int
1358
 
"""))
1359
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1360
 
 
1361
 
    def test_unknown_password_encoding(self):
1362
 
        conf = config.AuthenticationConfig(_file=StringIO(
1363
 
                """[broken]
1364
 
scheme=ftp
1365
 
user=joe
1366
 
password_encoding=unknown
1367
 
"""))
1368
 
        self.assertRaises(ValueError, conf.get_password,
1369
 
                          'ftp', 'foo.net', 'joe')
1370
 
 
1371
 
    def test_credentials_for_scheme_host(self):
1372
 
        conf = config.AuthenticationConfig(_file=StringIO(
1373
 
                """# Identity on foo.net
1374
 
[ftp definition]
1375
 
scheme=ftp
1376
 
host=foo.net
1377
 
user=joe
1378
 
password=secret-pass
1379
 
"""))
1380
 
        # Basic matching
1381
 
        self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1382
 
        # different scheme
1383
 
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1384
 
        # different host
1385
 
        self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1386
 
 
1387
 
    def test_credentials_for_host_port(self):
1388
 
        conf = config.AuthenticationConfig(_file=StringIO(
1389
 
                """# Identity on foo.net
1390
 
[ftp definition]
1391
 
scheme=ftp
1392
 
port=10021
1393
 
host=foo.net
1394
 
user=joe
1395
 
password=secret-pass
1396
 
"""))
1397
 
        # No port
1398
 
        self._got_user_passwd('joe', 'secret-pass',
1399
 
                              conf, 'ftp', 'foo.net', port=10021)
1400
 
        # different port
1401
 
        self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1402
 
 
1403
 
    def test_for_matching_host(self):
1404
 
        conf = config.AuthenticationConfig(_file=StringIO(
1405
 
                """# Identity on foo.net
1406
 
[sourceforge]
1407
 
scheme=bzr
1408
 
host=bzr.sf.net
1409
 
user=joe
1410
 
password=joepass
1411
 
[sourceforge domain]
1412
 
scheme=bzr
1413
 
host=.bzr.sf.net
1414
 
user=georges
1415
 
password=bendover
1416
 
"""))
1417
 
        # matching domain
1418
 
        self._got_user_passwd('georges', 'bendover',
1419
 
                              conf, 'bzr', 'foo.bzr.sf.net')
1420
 
        # phishing attempt
1421
 
        self._got_user_passwd(None, None,
1422
 
                              conf, 'bzr', 'bbzr.sf.net')
1423
 
 
1424
 
    def test_for_matching_host_None(self):
1425
 
        conf = config.AuthenticationConfig(_file=StringIO(
1426
 
                """# Identity on foo.net
1427
 
[catchup bzr]
1428
 
scheme=bzr
1429
 
user=joe
1430
 
password=joepass
1431
 
[DEFAULT]
1432
 
user=georges
1433
 
password=bendover
1434
 
"""))
1435
 
        # match no host
1436
 
        self._got_user_passwd('joe', 'joepass',
1437
 
                              conf, 'bzr', 'quux.net')
1438
 
        # no host but different scheme
1439
 
        self._got_user_passwd('georges', 'bendover',
1440
 
                              conf, 'ftp', 'quux.net')
1441
 
 
1442
 
    def test_credentials_for_path(self):
1443
 
        conf = config.AuthenticationConfig(_file=StringIO(
1444
 
                """
1445
 
[http dir1]
1446
 
scheme=http
1447
 
host=bar.org
1448
 
path=/dir1
1449
 
user=jim
1450
 
password=jimpass
1451
 
[http dir2]
1452
 
scheme=http
1453
 
host=bar.org
1454
 
path=/dir2
1455
 
user=georges
1456
 
password=bendover
1457
 
"""))
1458
 
        # no path no dice
1459
 
        self._got_user_passwd(None, None,
1460
 
                              conf, 'http', host='bar.org', path='/dir3')
1461
 
        # matching path
1462
 
        self._got_user_passwd('georges', 'bendover',
1463
 
                              conf, 'http', host='bar.org', path='/dir2')
1464
 
        # matching subdir
1465
 
        self._got_user_passwd('jim', 'jimpass',
1466
 
                              conf, 'http', host='bar.org',path='/dir1/subdir')
1467
 
 
1468
 
    def test_credentials_for_user(self):
1469
 
        conf = config.AuthenticationConfig(_file=StringIO(
1470
 
                """
1471
 
[with user]
1472
 
scheme=http
1473
 
host=bar.org
1474
 
user=jim
1475
 
password=jimpass
1476
 
"""))
1477
 
        # Get user
1478
 
        self._got_user_passwd('jim', 'jimpass',
1479
 
                              conf, 'http', 'bar.org')
1480
 
        # Get same user
1481
 
        self._got_user_passwd('jim', 'jimpass',
1482
 
                              conf, 'http', 'bar.org', user='jim')
1483
 
        # Don't get a different user if one is specified
1484
 
        self._got_user_passwd(None, None,
1485
 
                              conf, 'http', 'bar.org', user='georges')
1486
 
 
1487
 
    def test_credentials_for_user_without_password(self):
1488
 
        conf = config.AuthenticationConfig(_file=StringIO(
1489
 
                """
1490
 
[without password]
1491
 
scheme=http
1492
 
host=bar.org
1493
 
user=jim
1494
 
"""))
1495
 
        # Get user but no password
1496
 
        self._got_user_passwd('jim', None,
1497
 
                              conf, 'http', 'bar.org')
1498
 
 
1499
 
    def test_verify_certificates(self):
1500
 
        conf = config.AuthenticationConfig(_file=StringIO(
1501
 
                """
1502
 
[self-signed]
1503
 
scheme=https
1504
 
host=bar.org
1505
 
user=jim
1506
 
password=jimpass
1507
 
verify_certificates=False
1508
 
[normal]
1509
 
scheme=https
1510
 
host=foo.net
1511
 
user=georges
1512
 
password=bendover
1513
 
"""))
1514
 
        credentials = conf.get_credentials('https', 'bar.org')
1515
 
        self.assertEquals(False, credentials.get('verify_certificates'))
1516
 
        credentials = conf.get_credentials('https', 'foo.net')
1517
 
        self.assertEquals(True, credentials.get('verify_certificates'))
1518
 
 
1519
 
 
1520
 
class TestAuthenticationStorage(tests.TestCaseInTempDir):
1521
 
 
1522
 
    def test_set_credentials(self):
1523
 
        conf = config.AuthenticationConfig()
1524
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
1525
 
        99, path='/foo', verify_certificates=False, realm='realm')
1526
 
        credentials = conf.get_credentials(host='host', scheme='scheme',
1527
 
                                           port=99, path='/foo',
1528
 
                                           realm='realm')
1529
 
        CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
1530
 
                       'verify_certificates': False, 'scheme': 'scheme', 
1531
 
                       'host': 'host', 'port': 99, 'path': '/foo', 
1532
 
                       'realm': 'realm'}
1533
 
        self.assertEqual(CREDENTIALS, credentials)
1534
 
        credentials_from_disk = config.AuthenticationConfig().get_credentials(
1535
 
            host='host', scheme='scheme', port=99, path='/foo', realm='realm')
1536
 
        self.assertEqual(CREDENTIALS, credentials_from_disk)
1537
 
 
1538
 
    def test_reset_credentials_different_name(self):
1539
 
        conf = config.AuthenticationConfig()
1540
 
        conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
1541
 
        conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
1542
 
        self.assertIs(None, conf._get_config().get('name'))
1543
 
        credentials = conf.get_credentials(host='host', scheme='scheme')
1544
 
        CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
1545
 
                       'password', 'verify_certificates': True, 
1546
 
                       'scheme': 'scheme', 'host': 'host', 'port': None, 
1547
 
                       'path': None, 'realm': None}
1548
 
        self.assertEqual(CREDENTIALS, credentials)
1549
 
 
1550
 
 
1551
 
class TestAuthenticationConfig(tests.TestCase):
1552
 
    """Test AuthenticationConfig behaviour"""
1553
 
 
1554
 
    def _check_default_password_prompt(self, expected_prompt_format, scheme,
1555
 
                                       host=None, port=None, realm=None,
1556
 
                                       path=None):
1557
 
        if host is None:
1558
 
            host = 'bar.org'
1559
 
        user, password = 'jim', 'precious'
1560
 
        expected_prompt = expected_prompt_format % {
1561
 
            'scheme': scheme, 'host': host, 'port': port,
1562
 
            'user': user, 'realm': realm}
1563
 
 
1564
 
        stdout = tests.StringIOWrapper()
1565
 
        stderr = tests.StringIOWrapper()
1566
 
        ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1567
 
                                            stdout=stdout, stderr=stderr)
1568
 
        # We use an empty conf so that the user is always prompted
1569
 
        conf = config.AuthenticationConfig()
1570
 
        self.assertEquals(password,
1571
 
                          conf.get_password(scheme, host, user, port=port,
1572
 
                                            realm=realm, path=path))
1573
 
        self.assertEquals(expected_prompt, stderr.getvalue())
1574
 
        self.assertEquals('', stdout.getvalue())
1575
 
 
1576
 
    def _check_default_username_prompt(self, expected_prompt_format, scheme,
1577
 
                                       host=None, port=None, realm=None,
1578
 
                                       path=None):
1579
 
        if host is None:
1580
 
            host = 'bar.org'
1581
 
        username = 'jim'
1582
 
        expected_prompt = expected_prompt_format % {
1583
 
            'scheme': scheme, 'host': host, 'port': port,
1584
 
            'realm': realm}
1585
 
        stdout = tests.StringIOWrapper()
1586
 
        stderr = tests.StringIOWrapper()
1587
 
        ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
1588
 
                                            stdout=stdout, stderr=stderr)
1589
 
        # We use an empty conf so that the user is always prompted
1590
 
        conf = config.AuthenticationConfig()
1591
 
        self.assertEquals(username, conf.get_user(scheme, host, port=port,
1592
 
                          realm=realm, path=path, ask=True))
1593
 
        self.assertEquals(expected_prompt, stderr.getvalue())
1594
 
        self.assertEquals('', stdout.getvalue())
1595
 
 
1596
 
    def test_username_defaults_prompts(self):
1597
 
        # HTTP prompts can't be tested here, see test_http.py
1598
 
        self._check_default_username_prompt('FTP %(host)s username: ', 'ftp')
1599
 
        self._check_default_username_prompt(
1600
 
            'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
1601
 
        self._check_default_username_prompt(
1602
 
            'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
1603
 
 
1604
 
    def test_username_default_no_prompt(self):
1605
 
        conf = config.AuthenticationConfig()
1606
 
        self.assertEquals(None,
1607
 
            conf.get_user('ftp', 'example.com'))
1608
 
        self.assertEquals("explicitdefault",
1609
 
            conf.get_user('ftp', 'example.com', default="explicitdefault"))
1610
 
 
1611
 
    def test_password_default_prompts(self):
1612
 
        # HTTP prompts can't be tested here, see test_http.py
1613
 
        self._check_default_password_prompt(
1614
 
            'FTP %(user)s@%(host)s password: ', 'ftp')
1615
 
        self._check_default_password_prompt(
1616
 
            'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
1617
 
        self._check_default_password_prompt(
1618
 
            'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
1619
 
        # SMTP port handling is a bit special (it's handled if embedded in the
1620
 
        # host too)
1621
 
        # FIXME: should we: forbid that, extend it to other schemes, leave
1622
 
        # things as they are that's fine thank you ?
1623
 
        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1624
 
                                            'smtp')
1625
 
        self._check_default_password_prompt('SMTP %(user)s@%(host)s password: ',
1626
 
                                            'smtp', host='bar.org:10025')
1627
 
        self._check_default_password_prompt(
1628
 
            'SMTP %(user)s@%(host)s:%(port)d password: ',
1629
 
            'smtp', port=10025)
1630
 
 
1631
 
    def test_ssh_password_emits_warning(self):
1632
 
        conf = config.AuthenticationConfig(_file=StringIO(
1633
 
                """
1634
 
[ssh with password]
1635
 
scheme=ssh
1636
 
host=bar.org
1637
 
user=jim
1638
 
password=jimpass
1639
 
"""))
1640
 
        entered_password = 'typed-by-hand'
1641
 
        stdout = tests.StringIOWrapper()
1642
 
        stderr = tests.StringIOWrapper()
1643
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1644
 
                                            stdout=stdout, stderr=stderr)
1645
 
 
1646
 
        # Since the password defined in the authentication config is ignored,
1647
 
        # the user is prompted
1648
 
        self.assertEquals(entered_password,
1649
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1650
 
        self.assertContainsRe(
1651
 
            self.get_log(),
1652
 
            'password ignored in section \[ssh with password\]')
1653
 
 
1654
 
    def test_ssh_without_password_doesnt_emit_warning(self):
1655
 
        conf = config.AuthenticationConfig(_file=StringIO(
1656
 
                """
1657
 
[ssh with password]
1658
 
scheme=ssh
1659
 
host=bar.org
1660
 
user=jim
1661
 
"""))
1662
 
        entered_password = 'typed-by-hand'
1663
 
        stdout = tests.StringIOWrapper()
1664
 
        stderr = tests.StringIOWrapper()
1665
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1666
 
                                            stdout=stdout,
1667
 
                                            stderr=stderr)
1668
 
 
1669
 
        # Since the password defined in the authentication config is ignored,
1670
 
        # the user is prompted
1671
 
        self.assertEquals(entered_password,
1672
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1673
 
        # No warning shoud be emitted since there is no password. We are only
1674
 
        # providing "user".
1675
 
        self.assertNotContainsRe(
1676
 
            self.get_log(),
1677
 
            'password ignored in section \[ssh with password\]')
1678
 
 
1679
 
    def test_uses_fallback_stores(self):
1680
 
        self.overrideAttr(config, 'credential_store_registry',
1681
 
                          config.CredentialStoreRegistry())
1682
 
        store = StubCredentialStore()
1683
 
        store.add_credentials("http", "example.com", "joe", "secret")
1684
 
        config.credential_store_registry.register("stub", store, fallback=True)
1685
 
        conf = config.AuthenticationConfig(_file=StringIO())
1686
 
        creds = conf.get_credentials("http", "example.com")
1687
 
        self.assertEquals("joe", creds["user"])
1688
 
        self.assertEquals("secret", creds["password"])
1689
 
 
1690
 
 
1691
 
class StubCredentialStore(config.CredentialStore):
1692
 
 
1693
 
    def __init__(self):
1694
 
        self._username = {}
1695
 
        self._password = {}
1696
 
 
1697
 
    def add_credentials(self, scheme, host, user, password=None):
1698
 
        self._username[(scheme, host)] = user
1699
 
        self._password[(scheme, host)] = password
1700
 
 
1701
 
    def get_credentials(self, scheme, host, port=None, user=None,
1702
 
        path=None, realm=None):
1703
 
        key = (scheme, host)
1704
 
        if not key in self._username:
1705
 
            return None
1706
 
        return { "scheme": scheme, "host": host, "port": port,
1707
 
                "user": self._username[key], "password": self._password[key]}
1708
 
 
1709
 
 
1710
 
class CountingCredentialStore(config.CredentialStore):
1711
 
 
1712
 
    def __init__(self):
1713
 
        self._calls = 0
1714
 
 
1715
 
    def get_credentials(self, scheme, host, port=None, user=None,
1716
 
        path=None, realm=None):
1717
 
        self._calls += 1
1718
 
        return None
1719
 
 
1720
 
 
1721
 
class TestCredentialStoreRegistry(tests.TestCase):
1722
 
 
1723
 
    def _get_cs_registry(self):
1724
 
        return config.credential_store_registry
1725
 
 
1726
 
    def test_default_credential_store(self):
1727
 
        r = self._get_cs_registry()
1728
 
        default = r.get_credential_store(None)
1729
 
        self.assertIsInstance(default, config.PlainTextCredentialStore)
1730
 
 
1731
 
    def test_unknown_credential_store(self):
1732
 
        r = self._get_cs_registry()
1733
 
        # It's hard to imagine someone creating a credential store named
1734
 
        # 'unknown' so we use that as an never registered key.
1735
 
        self.assertRaises(KeyError, r.get_credential_store, 'unknown')
1736
 
 
1737
 
    def test_fallback_none_registered(self):
1738
 
        r = config.CredentialStoreRegistry()
1739
 
        self.assertEquals(None,
1740
 
                          r.get_fallback_credentials("http", "example.com"))
1741
 
 
1742
 
    def test_register(self):
1743
 
        r = config.CredentialStoreRegistry()
1744
 
        r.register("stub", StubCredentialStore(), fallback=False)
1745
 
        r.register("another", StubCredentialStore(), fallback=True)
1746
 
        self.assertEquals(["another", "stub"], r.keys())
1747
 
 
1748
 
    def test_register_lazy(self):
1749
 
        r = config.CredentialStoreRegistry()
1750
 
        r.register_lazy("stub", "bzrlib.tests.test_config",
1751
 
                        "StubCredentialStore", fallback=False)
1752
 
        self.assertEquals(["stub"], r.keys())
1753
 
        self.assertIsInstance(r.get_credential_store("stub"),
1754
 
                              StubCredentialStore)
1755
 
 
1756
 
    def test_is_fallback(self):
1757
 
        r = config.CredentialStoreRegistry()
1758
 
        r.register("stub1", None, fallback=False)
1759
 
        r.register("stub2", None, fallback=True)
1760
 
        self.assertEquals(False, r.is_fallback("stub1"))
1761
 
        self.assertEquals(True, r.is_fallback("stub2"))
1762
 
 
1763
 
    def test_no_fallback(self):
1764
 
        r = config.CredentialStoreRegistry()
1765
 
        store = CountingCredentialStore()
1766
 
        r.register("count", store, fallback=False)
1767
 
        self.assertEquals(None,
1768
 
                          r.get_fallback_credentials("http", "example.com"))
1769
 
        self.assertEquals(0, store._calls)
1770
 
 
1771
 
    def test_fallback_credentials(self):
1772
 
        r = config.CredentialStoreRegistry()
1773
 
        store = StubCredentialStore()
1774
 
        store.add_credentials("http", "example.com",
1775
 
                              "somebody", "geheim")
1776
 
        r.register("stub", store, fallback=True)
1777
 
        creds = r.get_fallback_credentials("http", "example.com")
1778
 
        self.assertEquals("somebody", creds["user"])
1779
 
        self.assertEquals("geheim", creds["password"])
1780
 
 
1781
 
    def test_fallback_first_wins(self):
1782
 
        r = config.CredentialStoreRegistry()
1783
 
        stub1 = StubCredentialStore()
1784
 
        stub1.add_credentials("http", "example.com",
1785
 
                              "somebody", "stub1")
1786
 
        r.register("stub1", stub1, fallback=True)
1787
 
        stub2 = StubCredentialStore()
1788
 
        stub2.add_credentials("http", "example.com",
1789
 
                              "somebody", "stub2")
1790
 
        r.register("stub2", stub1, fallback=True)
1791
 
        creds = r.get_fallback_credentials("http", "example.com")
1792
 
        self.assertEquals("somebody", creds["user"])
1793
 
        self.assertEquals("stub1", creds["password"])
1794
 
 
1795
 
 
1796
 
class TestPlainTextCredentialStore(tests.TestCase):
1797
 
 
1798
 
    def test_decode_password(self):
1799
 
        r = config.credential_store_registry
1800
 
        plain_text = r.get_credential_store()
1801
 
        decoded = plain_text.decode_password(dict(password='secret'))
1802
 
        self.assertEquals('secret', decoded)
1803
 
 
1804
 
 
1805
 
# FIXME: Once we have a way to declare authentication to all test servers, we
1806
 
# can implement generic tests.
1807
 
# test_user_password_in_url
1808
 
# test_user_in_url_password_from_config
1809
 
# test_user_in_url_password_prompted
1810
 
# test_user_in_config
1811
 
# test_user_getpass.getuser
1812
 
# test_user_prompted ?
1813
 
class TestAuthenticationRing(tests.TestCaseWithTransport):
1814
 
    pass