406
1377
# This is testing the correct file names are provided.
407
1378
# TODO: consolidate with the test for GlobalConfigs filename checks.
409
# replace the class that is constructured, to check its parameters
1380
# replace the class that is constructed, to check its parameters
410
1381
oldparserclass = config.ConfigObj
411
1382
config.ConfigObj = InstrumentedConfigObj
412
my_config = config.LocationConfig('http://www.example.com')
1384
my_config = config.LocationConfig('http://www.example.com')
414
1385
parser = my_config._get_parser()
416
1387
config.ConfigObj = oldparserclass
417
self.failUnless(isinstance(parser, InstrumentedConfigObj))
1388
self.assertIsInstance(parser, InstrumentedConfigObj)
418
1389
self.assertEqual(parser._calls,
419
[('__init__', config.branches_config_filename())])
1390
[('__init__', config.locations_config_filename(),
421
1393
def test_get_global_config(self):
422
my_config = config.LocationConfig('http://example.com')
1394
my_config = config.BranchConfig(FakeBranch('http://example.com'))
423
1395
global_config = my_config._get_global_config()
424
self.failUnless(isinstance(global_config, config.GlobalConfig))
425
self.failUnless(global_config is my_config._get_global_config())
427
def test__get_section_no_match(self):
428
self.get_location_config('/')
429
self.assertEqual(None, self.my_config._get_section())
431
def test__get_section_exact(self):
432
self.get_location_config('http://www.example.com')
433
self.assertEqual('http://www.example.com',
434
self.my_config._get_section())
436
def test__get_section_suffix_does_not(self):
437
self.get_location_config('http://www.example.com-com')
438
self.assertEqual(None, self.my_config._get_section())
440
def test__get_section_subdir_recursive(self):
441
self.get_location_config('http://www.example.com/com')
442
self.assertEqual('http://www.example.com',
443
self.my_config._get_section())
445
def test__get_section_subdir_matches(self):
446
self.get_location_config('http://www.example.com/useglobal')
447
self.assertEqual('http://www.example.com/useglobal',
448
self.my_config._get_section())
450
def test__get_section_subdir_nonrecursive(self):
451
self.get_location_config(
452
'http://www.example.com/useglobal/childbranch')
453
self.assertEqual('http://www.example.com',
454
self.my_config._get_section())
456
def test__get_section_subdir_trailing_slash(self):
457
self.get_location_config('/b')
458
self.assertEqual('/b/', self.my_config._get_section())
460
def test__get_section_subdir_child(self):
461
self.get_location_config('/a/foo')
462
self.assertEqual('/a/*', self.my_config._get_section())
464
def test__get_section_subdir_child_child(self):
465
self.get_location_config('/a/foo/bar')
466
self.assertEqual('/a/', self.my_config._get_section())
468
def test__get_section_trailing_slash_with_children(self):
469
self.get_location_config('/a/')
470
self.assertEqual('/a/', self.my_config._get_section())
472
def test__get_section_explicit_over_glob(self):
473
self.get_location_config('/a/c')
474
self.assertEqual('/a/c', self.my_config._get_section())
476
def get_location_config(self, location, global_config=None):
477
if global_config is None:
478
global_file = StringIO(sample_config_text)
480
global_file = StringIO(global_config)
481
branches_file = StringIO(sample_branches_text)
482
self.my_config = config.LocationConfig(location)
483
self.my_config._get_parser(branches_file)
484
self.my_config._get_global_config()._get_parser(global_file)
1396
self.assertIsInstance(global_config, config.GlobalConfig)
1397
self.assertIs(global_config, my_config._get_global_config())
1399
def assertLocationMatching(self, expected):
1400
self.assertEqual(expected,
1401
list(self.my_location_config._get_matching_sections()))
1403
def test__get_matching_sections_no_match(self):
1404
self.get_branch_config('/')
1405
self.assertLocationMatching([])
1407
def test__get_matching_sections_exact(self):
1408
self.get_branch_config('http://www.example.com')
1409
self.assertLocationMatching([('http://www.example.com', '')])
1411
def test__get_matching_sections_suffix_does_not(self):
1412
self.get_branch_config('http://www.example.com-com')
1413
self.assertLocationMatching([])
1415
def test__get_matching_sections_subdir_recursive(self):
1416
self.get_branch_config('http://www.example.com/com')
1417
self.assertLocationMatching([('http://www.example.com', 'com')])
1419
def test__get_matching_sections_ignoreparent(self):
1420
self.get_branch_config('http://www.example.com/ignoreparent')
1421
self.assertLocationMatching([('http://www.example.com/ignoreparent',
1424
def test__get_matching_sections_ignoreparent_subdir(self):
1425
self.get_branch_config(
1426
'http://www.example.com/ignoreparent/childbranch')
1427
self.assertLocationMatching([('http://www.example.com/ignoreparent',
1430
def test__get_matching_sections_subdir_trailing_slash(self):
1431
self.get_branch_config('/b')
1432
self.assertLocationMatching([('/b/', '')])
1434
def test__get_matching_sections_subdir_child(self):
1435
self.get_branch_config('/a/foo')
1436
self.assertLocationMatching([('/a/*', ''), ('/a/', 'foo')])
1438
def test__get_matching_sections_subdir_child_child(self):
1439
self.get_branch_config('/a/foo/bar')
1440
self.assertLocationMatching([('/a/*', 'bar'), ('/a/', 'foo/bar')])
1442
def test__get_matching_sections_trailing_slash_with_children(self):
1443
self.get_branch_config('/a/')
1444
self.assertLocationMatching([('/a/', '')])
1446
def test__get_matching_sections_explicit_over_glob(self):
1447
# XXX: 2006-09-08 jamesh
1448
# This test only passes because ord('c') > ord('*'). If there
1449
# was a config section for '/a/?', it would get precedence
1451
self.get_branch_config('/a/c')
1452
self.assertLocationMatching([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')])
1454
def test__get_option_policy_normal(self):
1455
self.get_branch_config('http://www.example.com')
1457
self.my_location_config._get_config_policy(
1458
'http://www.example.com', 'normal_option'),
1461
def test__get_option_policy_norecurse(self):
1462
self.get_branch_config('http://www.example.com')
1464
self.my_location_config._get_option_policy(
1465
'http://www.example.com', 'norecurse_option'),
1466
config.POLICY_NORECURSE)
1467
# Test old recurse=False setting:
1469
self.my_location_config._get_option_policy(
1470
'http://www.example.com/norecurse', 'normal_option'),
1471
config.POLICY_NORECURSE)
1473
def test__get_option_policy_normal(self):
1474
self.get_branch_config('http://www.example.com')
1476
self.my_location_config._get_option_policy(
1477
'http://www.example.com', 'appendpath_option'),
1478
config.POLICY_APPENDPATH)
1480
def test__get_options_with_policy(self):
1481
self.get_branch_config('/dir/subdir',
1482
location_config="""\
1484
other_url = /other-dir
1485
other_url:policy = appendpath
1487
other_url = /other-subdir
1490
[(u'other_url', u'/other-subdir', u'/dir/subdir', 'locations'),
1491
(u'other_url', u'/other-dir', u'/dir', 'locations'),
1492
(u'other_url:policy', u'appendpath', u'/dir', 'locations')],
1493
self.my_location_config)
486
1495
def test_location_without_username(self):
487
self.get_location_config('http://www.example.com/useglobal')
488
self.assertEqual('Robert Collins <robertc@example.com>',
1496
self.get_branch_config('http://www.example.com/ignoreparent')
1497
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
489
1498
self.my_config.username())
491
1500
def test_location_not_listed(self):
492
self.get_location_config('/home/robertc/sources')
493
self.assertEqual('Robert Collins <robertc@example.com>',
1501
"""Test that the global username is used when no location matches"""
1502
self.get_branch_config('/home/robertc/sources')
1503
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
494
1504
self.my_config.username())
496
1506
def test_overriding_location(self):
497
self.get_location_config('http://www.example.com/foo')
1507
self.get_branch_config('http://www.example.com/foo')
498
1508
self.assertEqual('Robert Collins <robertc@example.org>',
499
1509
self.my_config.username())
501
1511
def test_signatures_not_set(self):
502
self.get_location_config('http://www.example.com',
1512
self.get_branch_config('http://www.example.com',
503
1513
global_config=sample_ignore_signatures)
504
self.assertEqual(config.CHECK_NEVER,
505
self.my_config.signature_checking())
1514
self.assertEqual(config.CHECK_ALWAYS,
1515
self.applyDeprecated(deprecated_in((2, 5, 0)),
1516
self.my_config.signature_checking))
1517
self.assertEqual(config.SIGN_NEVER,
1518
self.applyDeprecated(deprecated_in((2, 5, 0)),
1519
self.my_config.signing_policy))
507
1521
def test_signatures_never(self):
508
self.get_location_config('/a/c')
1522
self.get_branch_config('/a/c')
509
1523
self.assertEqual(config.CHECK_NEVER,
510
self.my_config.signature_checking())
1524
self.applyDeprecated(deprecated_in((2, 5, 0)),
1525
self.my_config.signature_checking))
512
1527
def test_signatures_when_available(self):
513
self.get_location_config('/a/', global_config=sample_ignore_signatures)
1528
self.get_branch_config('/a/', global_config=sample_ignore_signatures)
514
1529
self.assertEqual(config.CHECK_IF_POSSIBLE,
515
self.my_config.signature_checking())
1530
self.applyDeprecated(deprecated_in((2, 5, 0)),
1531
self.my_config.signature_checking))
517
1533
def test_signatures_always(self):
518
self.get_location_config('/b')
1534
self.get_branch_config('/b')
519
1535
self.assertEqual(config.CHECK_ALWAYS,
520
self.my_config.signature_checking())
1536
self.applyDeprecated(deprecated_in((2, 5, 0)),
1537
self.my_config.signature_checking))
522
1539
def test_gpg_signing_command(self):
523
self.get_location_config('/b')
524
self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
1540
self.get_branch_config('/b')
1541
self.assertEqual("gnome-gpg",
1542
self.applyDeprecated(deprecated_in((2, 5, 0)),
1543
self.my_config.gpg_signing_command))
526
1545
def test_gpg_signing_command_missing(self):
527
self.get_location_config('/a')
528
self.assertEqual("false", self.my_config.gpg_signing_command())
1546
self.get_branch_config('/a')
1547
self.assertEqual("false",
1548
self.applyDeprecated(deprecated_in((2, 5, 0)),
1549
self.my_config.gpg_signing_command))
1551
def test_gpg_signing_key(self):
1552
self.get_branch_config('/b')
1553
self.assertEqual("DD4D5088", self.applyDeprecated(deprecated_in((2, 5, 0)),
1554
self.my_config.gpg_signing_key))
1556
def test_gpg_signing_key_default(self):
1557
self.get_branch_config('/a')
1558
self.assertEqual("erik@bagfors.nu",
1559
self.applyDeprecated(deprecated_in((2, 5, 0)),
1560
self.my_config.gpg_signing_key))
530
1562
def test_get_user_option_global(self):
531
self.get_location_config('/a')
1563
self.get_branch_config('/a')
532
1564
self.assertEqual('something',
533
1565
self.my_config.get_user_option('user_global_option'))
535
1567
def test_get_user_option_local(self):
536
self.get_location_config('/a')
1568
self.get_branch_config('/a')
537
1569
self.assertEqual('local',
538
1570
self.my_config.get_user_option('user_local_option'))
1572
def test_get_user_option_appendpath(self):
1573
# returned as is for the base path:
1574
self.get_branch_config('http://www.example.com')
1575
self.assertEqual('append',
1576
self.my_config.get_user_option('appendpath_option'))
1577
# Extra path components get appended:
1578
self.get_branch_config('http://www.example.com/a/b/c')
1579
self.assertEqual('append/a/b/c',
1580
self.my_config.get_user_option('appendpath_option'))
1581
# Overriden for http://www.example.com/dir, where it is a
1583
self.get_branch_config('http://www.example.com/dir/a/b/c')
1584
self.assertEqual('normal',
1585
self.my_config.get_user_option('appendpath_option'))
1587
def test_get_user_option_norecurse(self):
1588
self.get_branch_config('http://www.example.com')
1589
self.assertEqual('norecurse',
1590
self.my_config.get_user_option('norecurse_option'))
1591
self.get_branch_config('http://www.example.com/dir')
1592
self.assertEqual(None,
1593
self.my_config.get_user_option('norecurse_option'))
1594
# http://www.example.com/norecurse is a recurse=False section
1595
# that redefines normal_option. Subdirectories do not pick up
1596
# this redefinition.
1597
self.get_branch_config('http://www.example.com/norecurse')
1598
self.assertEqual('norecurse',
1599
self.my_config.get_user_option('normal_option'))
1600
self.get_branch_config('http://www.example.com/norecurse/subdir')
1601
self.assertEqual('normal',
1602
self.my_config.get_user_option('normal_option'))
1604
def test_set_user_option_norecurse(self):
1605
self.get_branch_config('http://www.example.com')
1606
self.my_config.set_user_option('foo', 'bar',
1607
store=config.STORE_LOCATION_NORECURSE)
1609
self.my_location_config._get_option_policy(
1610
'http://www.example.com', 'foo'),
1611
config.POLICY_NORECURSE)
1613
def test_set_user_option_appendpath(self):
1614
self.get_branch_config('http://www.example.com')
1615
self.my_config.set_user_option('foo', 'bar',
1616
store=config.STORE_LOCATION_APPENDPATH)
1618
self.my_location_config._get_option_policy(
1619
'http://www.example.com', 'foo'),
1620
config.POLICY_APPENDPATH)
1622
def test_set_user_option_change_policy(self):
1623
self.get_branch_config('http://www.example.com')
1624
self.my_config.set_user_option('norecurse_option', 'normal',
1625
store=config.STORE_LOCATION)
1627
self.my_location_config._get_option_policy(
1628
'http://www.example.com', 'norecurse_option'),
1631
def test_set_user_option_recurse_false_section(self):
1632
# The following section has recurse=False set. The test is to
1633
# make sure that a normal option can be added to the section,
1634
# converting recurse=False to the norecurse policy.
1635
self.get_branch_config('http://www.example.com/norecurse')
1636
self.callDeprecated(['The recurse option is deprecated as of 0.14. '
1637
'The section "http://www.example.com/norecurse" '
1638
'has been converted to use policies.'],
1639
self.my_config.set_user_option,
1640
'foo', 'bar', store=config.STORE_LOCATION)
1642
self.my_location_config._get_option_policy(
1643
'http://www.example.com/norecurse', 'foo'),
1645
# The previously existing option is still norecurse:
1647
self.my_location_config._get_option_policy(
1648
'http://www.example.com/norecurse', 'normal_option'),
1649
config.POLICY_NORECURSE)
540
1651
def test_post_commit_default(self):
541
self.get_location_config('/a/c')
1652
self.get_branch_config('/a/c')
542
1653
self.assertEqual('bzrlib.tests.test_config.post_commit',
543
self.my_config.post_commit())
546
class TestLocationConfig(TestCaseInTempDir):
548
def get_location_config(self, location, global_config=None):
1654
self.applyDeprecated(deprecated_in((2, 5, 0)),
1655
self.my_config.post_commit))
1657
def get_branch_config(self, location, global_config=None,
1658
location_config=None):
1659
my_branch = FakeBranch(location)
549
1660
if global_config is None:
550
global_file = StringIO(sample_config_text.encode('utf-8'))
552
global_file = StringIO(global_config.encode('utf-8'))
553
branches_file = StringIO(sample_branches_text.encode('utf-8'))
554
self.my_config = config.LocationConfig(location)
555
self.my_config._get_parser(branches_file)
556
self.my_config._get_global_config()._get_parser(global_file)
1661
global_config = sample_config_text
1662
if location_config is None:
1663
location_config = sample_branches_text
1665
my_global_config = config.GlobalConfig.from_string(global_config,
1667
my_location_config = config.LocationConfig.from_string(
1668
location_config, my_branch.base, save=True)
1669
my_config = config.BranchConfig(my_branch)
1670
self.my_config = my_config
1671
self.my_location_config = my_config._get_location_config()
558
1673
def test_set_user_setting_sets_and_saves(self):
559
self.get_location_config('/a/c')
1674
self.get_branch_config('/a/c')
560
1675
record = InstrumentedConfigObj("foo")
561
self.my_config._parser = record
563
real_mkdir = os.mkdir
565
def checked_mkdir(path, mode=0777):
566
self.log('making directory: %s', path)
567
real_mkdir(path, mode)
570
os.mkdir = checked_mkdir
572
self.my_config.set_user_option('foo', 'bar')
574
os.mkdir = real_mkdir
576
self.failUnless(self.created, 'Failed to create ~/.bazaar')
577
self.assertEqual([('__contains__', '/a/c'),
1676
self.my_location_config._parser = record
1678
self.callDeprecated(['The recurse option is deprecated as of '
1679
'0.14. The section "/a/c" has been '
1680
'converted to use policies.'],
1681
self.my_config.set_user_option,
1682
'foo', 'bar', store=config.STORE_LOCATION)
1683
self.assertEqual([('reload',),
1684
('__contains__', '/a/c'),
578
1685
('__contains__', '/a/c/'),
579
1686
('__setitem__', '/a/c', {}),
580
1687
('__getitem__', '/a/c'),
581
1688
('__setitem__', 'foo', 'bar'),
1689
('__getitem__', '/a/c'),
1690
('as_bool', 'recurse'),
1691
('__getitem__', '/a/c'),
1692
('__delitem__', 'recurse'),
1693
('__getitem__', '/a/c'),
1695
('__getitem__', '/a/c'),
1696
('__contains__', 'foo:policy'),
583
1698
record._calls[1:])
586
class TestBranchConfigItems(TestCase):
1700
def test_set_user_setting_sets_and_saves2(self):
1701
self.get_branch_config('/a/c')
1702
self.assertIs(self.my_config.get_user_option('foo'), None)
1703
self.my_config.set_user_option('foo', 'bar')
1705
self.my_config.branch.control_files.files['branch.conf'].strip(),
1707
self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
1708
self.my_config.set_user_option('foo', 'baz',
1709
store=config.STORE_LOCATION)
1710
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1711
self.my_config.set_user_option('foo', 'qux')
1712
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
1714
def test_get_bzr_remote_path(self):
1715
my_config = config.LocationConfig('/a/c')
1716
self.assertEqual('bzr', my_config.get_bzr_remote_path())
1717
my_config.set_user_option('bzr_remote_path', '/path-bzr')
1718
self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
1719
self.overrideEnv('BZR_REMOTE_PATH', '/environ-bzr')
1720
self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
1723
precedence_global = 'option = global'
1724
precedence_branch = 'option = branch'
1725
precedence_location = """
1729
[http://example.com/specific]
1733
class TestBranchConfigItems(tests.TestCaseInTempDir):
1735
def get_branch_config(self, global_config=None, location=None,
1736
location_config=None, branch_data_config=None):
1737
my_branch = FakeBranch(location)
1738
if global_config is not None:
1739
my_global_config = config.GlobalConfig.from_string(global_config,
1741
if location_config is not None:
1742
my_location_config = config.LocationConfig.from_string(
1743
location_config, my_branch.base, save=True)
1744
my_config = config.BranchConfig(my_branch)
1745
if branch_data_config is not None:
1746
my_config.branch.control_files.files['branch.conf'] = \
588
1750
def test_user_id(self):
589
1751
branch = FakeBranch()
590
1752
my_config = config.BranchConfig(branch)
591
self.assertEqual("Robert Collins <robertc@example.net>",
592
my_config._get_user_id())
593
branch.control_files.email = "John"
594
self.assertEqual("John", my_config._get_user_id())
596
def test_not_set_in_branch(self):
597
branch = FakeBranch()
598
my_config = config.BranchConfig(branch)
599
branch.control_files.email = None
600
config_file = StringIO(sample_config_text.encode('utf-8'))
601
(my_config._get_location_config().
602
_get_global_config()._get_parser(config_file))
603
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
604
my_config._get_user_id())
605
branch.control_files.email = "John"
606
self.assertEqual("John", my_config._get_user_id())
608
def test_BZREMAIL_OVERRIDES(self):
609
os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
1753
self.assertIsNot(None, my_config.username())
1754
my_config.branch.control_files.files['email'] = "John"
1755
my_config.set_user_option('email',
1756
"Robert Collins <robertc@example.org>")
1757
self.assertEqual("Robert Collins <robertc@example.org>",
1758
my_config.username())
1760
def test_BZR_EMAIL_OVERRIDES(self):
1761
self.overrideEnv('BZR_EMAIL', "Robert Collins <robertc@example.org>")
610
1762
branch = FakeBranch()
611
1763
my_config = config.BranchConfig(branch)
612
1764
self.assertEqual("Robert Collins <robertc@example.org>",
613
1765
my_config.username())
615
1767
def test_signatures_forced(self):
616
branch = FakeBranch()
617
my_config = config.BranchConfig(branch)
618
config_file = StringIO(sample_always_signatures)
619
(my_config._get_location_config().
620
_get_global_config()._get_parser(config_file))
621
self.assertEqual(config.CHECK_ALWAYS, my_config.signature_checking())
1768
my_config = self.get_branch_config(
1769
global_config=sample_always_signatures)
1770
self.assertEqual(config.CHECK_NEVER,
1771
self.applyDeprecated(deprecated_in((2, 5, 0)),
1772
my_config.signature_checking))
1773
self.assertEqual(config.SIGN_ALWAYS,
1774
self.applyDeprecated(deprecated_in((2, 5, 0)),
1775
my_config.signing_policy))
1776
self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),
1777
my_config.signature_needed))
1779
def test_signatures_forced_branch(self):
1780
my_config = self.get_branch_config(
1781
global_config=sample_ignore_signatures,
1782
branch_data_config=sample_always_signatures)
1783
self.assertEqual(config.CHECK_NEVER,
1784
self.applyDeprecated(deprecated_in((2, 5, 0)),
1785
my_config.signature_checking))
1786
self.assertEqual(config.SIGN_ALWAYS,
1787
self.applyDeprecated(deprecated_in((2, 5, 0)),
1788
my_config.signing_policy))
1789
self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),
1790
my_config.signature_needed))
623
1792
def test_gpg_signing_command(self):
624
branch = FakeBranch()
625
my_config = config.BranchConfig(branch)
626
config_file = StringIO(sample_config_text.encode('utf-8'))
627
(my_config._get_location_config().
628
_get_global_config()._get_parser(config_file))
629
self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1793
my_config = self.get_branch_config(
1794
global_config=sample_config_text,
1795
# branch data cannot set gpg_signing_command
1796
branch_data_config="gpg_signing_command=pgp")
1797
self.assertEqual('gnome-gpg',
1798
self.applyDeprecated(deprecated_in((2, 5, 0)),
1799
my_config.gpg_signing_command))
631
1801
def test_get_user_option_global(self):
632
branch = FakeBranch()
633
my_config = config.BranchConfig(branch)
634
config_file = StringIO(sample_config_text.encode('utf-8'))
635
(my_config._get_location_config().
636
_get_global_config()._get_parser(config_file))
1802
my_config = self.get_branch_config(global_config=sample_config_text)
637
1803
self.assertEqual('something',
638
1804
my_config.get_user_option('user_global_option'))
640
1806
def test_post_commit_default(self):
641
branch = FakeBranch()
643
my_config = config.BranchConfig(branch)
644
config_file = StringIO(sample_config_text.encode('utf-8'))
645
(my_config._get_location_config().
646
_get_global_config()._get_parser(config_file))
647
branch_file = StringIO(sample_branches_text)
648
my_config._get_location_config()._get_parser(branch_file)
649
self.assertEqual('bzrlib.tests.test_config.post_commit',
650
my_config.post_commit())
653
class TestMailAddressExtraction(TestCase):
1807
my_config = self.get_branch_config(global_config=sample_config_text,
1809
location_config=sample_branches_text)
1810
self.assertEqual(my_config.branch.base, '/a/c')
1811
self.assertEqual('bzrlib.tests.test_config.post_commit',
1812
self.applyDeprecated(deprecated_in((2, 5, 0)),
1813
my_config.post_commit))
1814
my_config.set_user_option('post_commit', 'rmtree_root')
1815
# post-commit is ignored when present in branch data
1816
self.assertEqual('bzrlib.tests.test_config.post_commit',
1817
self.applyDeprecated(deprecated_in((2, 5, 0)),
1818
my_config.post_commit))
1819
my_config.set_user_option('post_commit', 'rmtree_root',
1820
store=config.STORE_LOCATION)
1821
self.assertEqual('rmtree_root',
1822
self.applyDeprecated(deprecated_in((2, 5, 0)),
1823
my_config.post_commit))
1825
def test_config_precedence(self):
1826
# FIXME: eager test, luckily no persitent config file makes it fail
1828
my_config = self.get_branch_config(global_config=precedence_global)
1829
self.assertEqual(my_config.get_user_option('option'), 'global')
1830
my_config = self.get_branch_config(global_config=precedence_global,
1831
branch_data_config=precedence_branch)
1832
self.assertEqual(my_config.get_user_option('option'), 'branch')
1833
my_config = self.get_branch_config(
1834
global_config=precedence_global,
1835
branch_data_config=precedence_branch,
1836
location_config=precedence_location)
1837
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1838
my_config = self.get_branch_config(
1839
global_config=precedence_global,
1840
branch_data_config=precedence_branch,
1841
location_config=precedence_location,
1842
location='http://example.com/specific')
1843
self.assertEqual(my_config.get_user_option('option'), 'exact')
1846
class TestMailAddressExtraction(tests.TestCase):
655
1848
def test_extract_email_address(self):
656
1849
self.assertEqual('jane@test.com',
657
1850
config.extract_email_address('Jane <jane@test.com>'))
658
self.assertRaises(errors.BzrError,
1851
self.assertRaises(errors.NoEmailInUsername,
659
1852
config.extract_email_address, 'Jane Tester')
1854
def test_parse_username(self):
1855
self.assertEqual(('', 'jdoe@example.com'),
1856
config.parse_username('jdoe@example.com'))
1857
self.assertEqual(('', 'jdoe@example.com'),
1858
config.parse_username('<jdoe@example.com>'))
1859
self.assertEqual(('John Doe', 'jdoe@example.com'),
1860
config.parse_username('John Doe <jdoe@example.com>'))
1861
self.assertEqual(('John Doe', ''),
1862
config.parse_username('John Doe'))
1863
self.assertEqual(('John Doe', 'jdoe@example.com'),
1864
config.parse_username('John Doe jdoe@example.com'))
1866
class TestTreeConfig(tests.TestCaseWithTransport):
1868
def test_get_value(self):
1869
"""Test that retreiving a value from a section is possible"""
1870
branch = self.make_branch('.')
1871
tree_config = config.TreeConfig(branch)
1872
tree_config.set_option('value', 'key', 'SECTION')
1873
tree_config.set_option('value2', 'key2')
1874
tree_config.set_option('value3-top', 'key3')
1875
tree_config.set_option('value3-section', 'key3', 'SECTION')
1876
value = tree_config.get_option('key', 'SECTION')
1877
self.assertEqual(value, 'value')
1878
value = tree_config.get_option('key2')
1879
self.assertEqual(value, 'value2')
1880
self.assertEqual(tree_config.get_option('non-existant'), None)
1881
value = tree_config.get_option('non-existant', 'SECTION')
1882
self.assertEqual(value, None)
1883
value = tree_config.get_option('non-existant', default='default')
1884
self.assertEqual(value, 'default')
1885
self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1886
value = tree_config.get_option('key2', 'NOSECTION', default='default')
1887
self.assertEqual(value, 'default')
1888
value = tree_config.get_option('key3')
1889
self.assertEqual(value, 'value3-top')
1890
value = tree_config.get_option('key3', 'SECTION')
1891
self.assertEqual(value, 'value3-section')
1894
class TestTransportConfig(tests.TestCaseWithTransport):
1896
def test_load_utf8(self):
1897
"""Ensure we can load an utf8-encoded file."""
1898
t = self.get_transport()
1899
unicode_user = u'b\N{Euro Sign}ar'
1900
unicode_content = u'user=%s' % (unicode_user,)
1901
utf8_content = unicode_content.encode('utf8')
1902
# Store the raw content in the config file
1903
t.put_bytes('foo.conf', utf8_content)
1904
conf = config.TransportConfig(t, 'foo.conf')
1905
self.assertEquals(unicode_user, conf.get_option('user'))
1907
def test_load_non_ascii(self):
1908
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
1909
t = self.get_transport()
1910
t.put_bytes('foo.conf', 'user=foo\n#\xff\n')
1911
conf = config.TransportConfig(t, 'foo.conf')
1912
self.assertRaises(errors.ConfigContentError, conf._get_configobj)
1914
def test_load_erroneous_content(self):
1915
"""Ensure we display a proper error on content that can't be parsed."""
1916
t = self.get_transport()
1917
t.put_bytes('foo.conf', '[open_section\n')
1918
conf = config.TransportConfig(t, 'foo.conf')
1919
self.assertRaises(errors.ParseConfigError, conf._get_configobj)
1921
def test_load_permission_denied(self):
1922
"""Ensure we get an empty config file if the file is inaccessible."""
1925
warnings.append(args[0] % args[1:])
1926
self.overrideAttr(trace, 'warning', warning)
1928
class DenyingTransport(object):
1930
def __init__(self, base):
1933
def get_bytes(self, relpath):
1934
raise errors.PermissionDenied(relpath, "")
1936
cfg = config.TransportConfig(
1937
DenyingTransport("nonexisting://"), 'control.conf')
1938
self.assertIs(None, cfg.get_option('non-existant', 'SECTION'))
1941
[u'Permission denied while trying to open configuration file '
1942
u'nonexisting:///control.conf.'])
1944
def test_get_value(self):
1945
"""Test that retreiving a value from a section is possible"""
1946
bzrdir_config = config.TransportConfig(self.get_transport('.'),
1948
bzrdir_config.set_option('value', 'key', 'SECTION')
1949
bzrdir_config.set_option('value2', 'key2')
1950
bzrdir_config.set_option('value3-top', 'key3')
1951
bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1952
value = bzrdir_config.get_option('key', 'SECTION')
1953
self.assertEqual(value, 'value')
1954
value = bzrdir_config.get_option('key2')
1955
self.assertEqual(value, 'value2')
1956
self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1957
value = bzrdir_config.get_option('non-existant', 'SECTION')
1958
self.assertEqual(value, None)
1959
value = bzrdir_config.get_option('non-existant', default='default')
1960
self.assertEqual(value, 'default')
1961
self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1962
value = bzrdir_config.get_option('key2', 'NOSECTION',
1964
self.assertEqual(value, 'default')
1965
value = bzrdir_config.get_option('key3')
1966
self.assertEqual(value, 'value3-top')
1967
value = bzrdir_config.get_option('key3', 'SECTION')
1968
self.assertEqual(value, 'value3-section')
1970
def test_set_unset_default_stack_on(self):
1971
my_dir = self.make_bzrdir('.')
1972
bzrdir_config = config.BzrDirConfig(my_dir)
1973
self.assertIs(None, bzrdir_config.get_default_stack_on())
1974
bzrdir_config.set_default_stack_on('Foo')
1975
self.assertEqual('Foo', bzrdir_config._config.get_option(
1976
'default_stack_on'))
1977
self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1978
bzrdir_config.set_default_stack_on(None)
1979
self.assertIs(None, bzrdir_config.get_default_stack_on())
1982
class TestOldConfigHooks(tests.TestCaseWithTransport):
1985
super(TestOldConfigHooks, self).setUp()
1986
create_configs_with_file_option(self)
1988
def assertGetHook(self, conf, name, value):
1992
config.OldConfigHooks.install_named_hook('get', hook, None)
1994
config.OldConfigHooks.uninstall_named_hook, 'get', None)
1995
self.assertLength(0, calls)
1996
actual_value = conf.get_user_option(name)
1997
self.assertEquals(value, actual_value)
1998
self.assertLength(1, calls)
1999
self.assertEquals((conf, name, value), calls[0])
2001
def test_get_hook_bazaar(self):
2002
self.assertGetHook(self.bazaar_config, 'file', 'bazaar')
2004
def test_get_hook_locations(self):
2005
self.assertGetHook(self.locations_config, 'file', 'locations')
2007
def test_get_hook_branch(self):
2008
# Since locations masks branch, we define a different option
2009
self.branch_config.set_user_option('file2', 'branch')
2010
self.assertGetHook(self.branch_config, 'file2', 'branch')
2012
def assertSetHook(self, conf, name, value):
2016
config.OldConfigHooks.install_named_hook('set', hook, None)
2018
config.OldConfigHooks.uninstall_named_hook, 'set', None)
2019
self.assertLength(0, calls)
2020
conf.set_user_option(name, value)
2021
self.assertLength(1, calls)
2022
# We can't assert the conf object below as different configs use
2023
# different means to implement set_user_option and we care only about
2025
self.assertEquals((name, value), calls[0][1:])
2027
def test_set_hook_bazaar(self):
2028
self.assertSetHook(self.bazaar_config, 'foo', 'bazaar')
2030
def test_set_hook_locations(self):
2031
self.assertSetHook(self.locations_config, 'foo', 'locations')
2033
def test_set_hook_branch(self):
2034
self.assertSetHook(self.branch_config, 'foo', 'branch')
2036
def assertRemoveHook(self, conf, name, section_name=None):
2040
config.OldConfigHooks.install_named_hook('remove', hook, None)
2042
config.OldConfigHooks.uninstall_named_hook, 'remove', None)
2043
self.assertLength(0, calls)
2044
conf.remove_user_option(name, section_name)
2045
self.assertLength(1, calls)
2046
# We can't assert the conf object below as different configs use
2047
# different means to implement remove_user_option and we care only about
2049
self.assertEquals((name,), calls[0][1:])
2051
def test_remove_hook_bazaar(self):
2052
self.assertRemoveHook(self.bazaar_config, 'file')
2054
def test_remove_hook_locations(self):
2055
self.assertRemoveHook(self.locations_config, 'file',
2056
self.locations_config.location)
2058
def test_remove_hook_branch(self):
2059
self.assertRemoveHook(self.branch_config, 'file')
2061
def assertLoadHook(self, name, conf_class, *conf_args):
2065
config.OldConfigHooks.install_named_hook('load', hook, None)
2067
config.OldConfigHooks.uninstall_named_hook, 'load', None)
2068
self.assertLength(0, calls)
2070
conf = conf_class(*conf_args)
2071
# Access an option to trigger a load
2072
conf.get_user_option(name)
2073
self.assertLength(1, calls)
2074
# Since we can't assert about conf, we just use the number of calls ;-/
2076
def test_load_hook_bazaar(self):
2077
self.assertLoadHook('file', config.GlobalConfig)
2079
def test_load_hook_locations(self):
2080
self.assertLoadHook('file', config.LocationConfig, self.tree.basedir)
2082
def test_load_hook_branch(self):
2083
self.assertLoadHook('file', config.BranchConfig, self.tree.branch)
2085
def assertSaveHook(self, conf):
2089
config.OldConfigHooks.install_named_hook('save', hook, None)
2091
config.OldConfigHooks.uninstall_named_hook, 'save', None)
2092
self.assertLength(0, calls)
2093
# Setting an option triggers a save
2094
conf.set_user_option('foo', 'bar')
2095
self.assertLength(1, calls)
2096
# Since we can't assert about conf, we just use the number of calls ;-/
2098
def test_save_hook_bazaar(self):
2099
self.assertSaveHook(self.bazaar_config)
2101
def test_save_hook_locations(self):
2102
self.assertSaveHook(self.locations_config)
2104
def test_save_hook_branch(self):
2105
self.assertSaveHook(self.branch_config)
2108
class TestOldConfigHooksForRemote(tests.TestCaseWithTransport):
2109
"""Tests config hooks for remote configs.
2111
No tests for the remove hook as this is not implemented there.
2115
super(TestOldConfigHooksForRemote, self).setUp()
2116
self.transport_server = test_server.SmartTCPServer_for_testing
2117
create_configs_with_file_option(self)
2119
def assertGetHook(self, conf, name, value):
2123
config.OldConfigHooks.install_named_hook('get', hook, None)
2125
config.OldConfigHooks.uninstall_named_hook, 'get', None)
2126
self.assertLength(0, calls)
2127
actual_value = conf.get_option(name)
2128
self.assertEquals(value, actual_value)
2129
self.assertLength(1, calls)
2130
self.assertEquals((conf, name, value), calls[0])
2132
def test_get_hook_remote_branch(self):
2133
remote_branch = branch.Branch.open(self.get_url('tree'))
2134
self.assertGetHook(remote_branch._get_config(), 'file', 'branch')
2136
def test_get_hook_remote_bzrdir(self):
2137
remote_bzrdir = controldir.ControlDir.open(self.get_url('tree'))
2138
conf = remote_bzrdir._get_config()
2139
conf.set_option('remotedir', 'file')
2140
self.assertGetHook(conf, 'file', 'remotedir')
2142
def assertSetHook(self, conf, name, value):
2146
config.OldConfigHooks.install_named_hook('set', hook, None)
2148
config.OldConfigHooks.uninstall_named_hook, 'set', None)
2149
self.assertLength(0, calls)
2150
conf.set_option(value, name)
2151
self.assertLength(1, calls)
2152
# We can't assert the conf object below as different configs use
2153
# different means to implement set_user_option and we care only about
2155
self.assertEquals((name, value), calls[0][1:])
2157
def test_set_hook_remote_branch(self):
2158
remote_branch = branch.Branch.open(self.get_url('tree'))
2159
self.addCleanup(remote_branch.lock_write().unlock)
2160
self.assertSetHook(remote_branch._get_config(), 'file', 'remote')
2162
def test_set_hook_remote_bzrdir(self):
2163
remote_branch = branch.Branch.open(self.get_url('tree'))
2164
self.addCleanup(remote_branch.lock_write().unlock)
2165
remote_bzrdir = controldir.ControlDir.open(self.get_url('tree'))
2166
self.assertSetHook(remote_bzrdir._get_config(), 'file', 'remotedir')
2168
def assertLoadHook(self, expected_nb_calls, name, conf_class, *conf_args):
2172
config.OldConfigHooks.install_named_hook('load', hook, None)
2174
config.OldConfigHooks.uninstall_named_hook, 'load', None)
2175
self.assertLength(0, calls)
2177
conf = conf_class(*conf_args)
2178
# Access an option to trigger a load
2179
conf.get_option(name)
2180
self.assertLength(expected_nb_calls, calls)
2181
# Since we can't assert about conf, we just use the number of calls ;-/
2183
def test_load_hook_remote_branch(self):
2184
remote_branch = branch.Branch.open(self.get_url('tree'))
2185
self.assertLoadHook(1, 'file', remote.RemoteBranchConfig, remote_branch)
2187
def test_load_hook_remote_bzrdir(self):
2188
remote_bzrdir = controldir.ControlDir.open(self.get_url('tree'))
2189
# The config file doesn't exist, set an option to force its creation
2190
conf = remote_bzrdir._get_config()
2191
conf.set_option('remotedir', 'file')
2192
# We get one call for the server and one call for the client, this is
2193
# caused by the differences in implementations betwen
2194
# SmartServerBzrDirRequestConfigFile (in smart/bzrdir.py) and
2195
# SmartServerBranchGetConfigFile (in smart/branch.py)
2196
self.assertLoadHook(2 ,'file', remote.RemoteBzrDirConfig, remote_bzrdir)
2198
def assertSaveHook(self, conf):
2202
config.OldConfigHooks.install_named_hook('save', hook, None)
2204
config.OldConfigHooks.uninstall_named_hook, 'save', None)
2205
self.assertLength(0, calls)
2206
# Setting an option triggers a save
2207
conf.set_option('foo', 'bar')
2208
self.assertLength(1, calls)
2209
# Since we can't assert about conf, we just use the number of calls ;-/
2211
def test_save_hook_remote_branch(self):
2212
remote_branch = branch.Branch.open(self.get_url('tree'))
2213
self.addCleanup(remote_branch.lock_write().unlock)
2214
self.assertSaveHook(remote_branch._get_config())
2216
def test_save_hook_remote_bzrdir(self):
2217
remote_branch = branch.Branch.open(self.get_url('tree'))
2218
self.addCleanup(remote_branch.lock_write().unlock)
2219
remote_bzrdir = controldir.ControlDir.open(self.get_url('tree'))
2220
self.assertSaveHook(remote_bzrdir._get_config())
2223
class TestOption(tests.TestCase):
2225
def test_default_value(self):
2226
opt = config.Option('foo', default='bar')
2227
self.assertEquals('bar', opt.get_default())
2229
def test_callable_default_value(self):
2230
def bar_as_unicode():
2232
opt = config.Option('foo', default=bar_as_unicode)
2233
self.assertEquals('bar', opt.get_default())
2235
def test_default_value_from_env(self):
2236
opt = config.Option('foo', default='bar', default_from_env=['FOO'])
2237
self.overrideEnv('FOO', 'quux')
2238
# Env variable provides a default taking over the option one
2239
self.assertEquals('quux', opt.get_default())
2241
def test_first_default_value_from_env_wins(self):
2242
opt = config.Option('foo', default='bar',
2243
default_from_env=['NO_VALUE', 'FOO', 'BAZ'])
2244
self.overrideEnv('FOO', 'foo')
2245
self.overrideEnv('BAZ', 'baz')
2246
# The first env var set wins
2247
self.assertEquals('foo', opt.get_default())
2249
def test_not_supported_list_default_value(self):
2250
self.assertRaises(AssertionError, config.Option, 'foo', default=[1])
2252
def test_not_supported_object_default_value(self):
2253
self.assertRaises(AssertionError, config.Option, 'foo',
2256
def test_not_supported_callable_default_value_not_unicode(self):
2257
def bar_not_unicode():
2259
opt = config.Option('foo', default=bar_not_unicode)
2260
self.assertRaises(AssertionError, opt.get_default)
2262
def test_get_help_topic(self):
2263
opt = config.Option('foo')
2264
self.assertEquals('foo', opt.get_help_topic())
2267
class TestOptionConverterMixin(object):
2269
def assertConverted(self, expected, opt, value):
2270
self.assertEquals(expected, opt.convert_from_unicode(None, value))
2272
def assertWarns(self, opt, value):
2275
warnings.append(args[0] % args[1:])
2276
self.overrideAttr(trace, 'warning', warning)
2277
self.assertEquals(None, opt.convert_from_unicode(None, value))
2278
self.assertLength(1, warnings)
2280
'Value "%s" is not valid for "%s"' % (value, opt.name),
2283
def assertErrors(self, opt, value):
2284
self.assertRaises(errors.ConfigOptionValueError,
2285
opt.convert_from_unicode, None, value)
2287
def assertConvertInvalid(self, opt, invalid_value):
2289
self.assertEquals(None, opt.convert_from_unicode(None, invalid_value))
2290
opt.invalid = 'warning'
2291
self.assertWarns(opt, invalid_value)
2292
opt.invalid = 'error'
2293
self.assertErrors(opt, invalid_value)
2296
class TestOptionWithBooleanConverter(tests.TestCase, TestOptionConverterMixin):
2298
def get_option(self):
2299
return config.Option('foo', help='A boolean.',
2300
from_unicode=config.bool_from_store)
2302
def test_convert_invalid(self):
2303
opt = self.get_option()
2304
# A string that is not recognized as a boolean
2305
self.assertConvertInvalid(opt, u'invalid-boolean')
2306
# A list of strings is never recognized as a boolean
2307
self.assertConvertInvalid(opt, [u'not', u'a', u'boolean'])
2309
def test_convert_valid(self):
2310
opt = self.get_option()
2311
self.assertConverted(True, opt, u'True')
2312
self.assertConverted(True, opt, u'1')
2313
self.assertConverted(False, opt, u'False')
2316
class TestOptionWithIntegerConverter(tests.TestCase, TestOptionConverterMixin):
2318
def get_option(self):
2319
return config.Option('foo', help='An integer.',
2320
from_unicode=config.int_from_store)
2322
def test_convert_invalid(self):
2323
opt = self.get_option()
2324
# A string that is not recognized as an integer
2325
self.assertConvertInvalid(opt, u'forty-two')
2326
# A list of strings is never recognized as an integer
2327
self.assertConvertInvalid(opt, [u'a', u'list'])
2329
def test_convert_valid(self):
2330
opt = self.get_option()
2331
self.assertConverted(16, opt, u'16')
2334
class TestOptionWithSIUnitConverter(tests.TestCase, TestOptionConverterMixin):
2336
def get_option(self):
2337
return config.Option('foo', help='An integer in SI units.',
2338
from_unicode=config.int_SI_from_store)
2340
def test_convert_invalid(self):
2341
opt = self.get_option()
2342
self.assertConvertInvalid(opt, u'not-a-unit')
2343
self.assertConvertInvalid(opt, u'Gb') # Forgot the int
2344
self.assertConvertInvalid(opt, u'1b') # Forgot the unit
2345
self.assertConvertInvalid(opt, u'1GG')
2346
self.assertConvertInvalid(opt, u'1Mbb')
2347
self.assertConvertInvalid(opt, u'1MM')
2349
def test_convert_valid(self):
2350
opt = self.get_option()
2351
self.assertConverted(int(5e3), opt, u'5kb')
2352
self.assertConverted(int(5e6), opt, u'5M')
2353
self.assertConverted(int(5e6), opt, u'5MB')
2354
self.assertConverted(int(5e9), opt, u'5g')
2355
self.assertConverted(int(5e9), opt, u'5gB')
2356
self.assertConverted(100, opt, u'100')
2359
class TestListOption(tests.TestCase, TestOptionConverterMixin):
2361
def get_option(self):
2362
return config.ListOption('foo', help='A list.')
2364
def test_convert_invalid(self):
2365
opt = self.get_option()
2366
# We don't even try to convert a list into a list, we only expect
2368
self.assertConvertInvalid(opt, [1])
2369
# No string is invalid as all forms can be converted to a list
2371
def test_convert_valid(self):
2372
opt = self.get_option()
2373
# An empty string is an empty list
2374
self.assertConverted([], opt, '') # Using a bare str() just in case
2375
self.assertConverted([], opt, u'')
2377
self.assertConverted([u'True'], opt, u'True')
2379
self.assertConverted([u'42'], opt, u'42')
2381
self.assertConverted([u'bar'], opt, u'bar')
2384
class TestRegistryOption(tests.TestCase, TestOptionConverterMixin):
2386
def get_option(self, registry):
2387
return config.RegistryOption('foo', registry,
2388
help='A registry option.')
2390
def test_convert_invalid(self):
2391
registry = _mod_registry.Registry()
2392
opt = self.get_option(registry)
2393
self.assertConvertInvalid(opt, [1])
2394
self.assertConvertInvalid(opt, u"notregistered")
2396
def test_convert_valid(self):
2397
registry = _mod_registry.Registry()
2398
registry.register("someval", 1234)
2399
opt = self.get_option(registry)
2400
# Using a bare str() just in case
2401
self.assertConverted(1234, opt, "someval")
2402
self.assertConverted(1234, opt, u'someval')
2403
self.assertConverted(None, opt, None)
2405
def test_help(self):
2406
registry = _mod_registry.Registry()
2407
registry.register("someval", 1234, help="some option")
2408
registry.register("dunno", 1234, help="some other option")
2409
opt = self.get_option(registry)
2411
'A registry option.\n'
2413
'The following values are supported:\n'
2414
' dunno - some other option\n'
2415
' someval - some option\n',
2418
def test_get_help_text(self):
2419
registry = _mod_registry.Registry()
2420
registry.register("someval", 1234, help="some option")
2421
registry.register("dunno", 1234, help="some other option")
2422
opt = self.get_option(registry)
2424
'A registry option.\n'
2426
'The following values are supported:\n'
2427
' dunno - some other option\n'
2428
' someval - some option\n',
2429
opt.get_help_text())
2432
class TestOptionRegistry(tests.TestCase):
2435
super(TestOptionRegistry, self).setUp()
2436
# Always start with an empty registry
2437
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
2438
self.registry = config.option_registry
2440
def test_register(self):
2441
opt = config.Option('foo')
2442
self.registry.register(opt)
2443
self.assertIs(opt, self.registry.get('foo'))
2445
def test_registered_help(self):
2446
opt = config.Option('foo', help='A simple option')
2447
self.registry.register(opt)
2448
self.assertEquals('A simple option', self.registry.get_help('foo'))
2450
lazy_option = config.Option('lazy_foo', help='Lazy help')
2452
def test_register_lazy(self):
2453
self.registry.register_lazy('lazy_foo', self.__module__,
2454
'TestOptionRegistry.lazy_option')
2455
self.assertIs(self.lazy_option, self.registry.get('lazy_foo'))
2457
def test_registered_lazy_help(self):
2458
self.registry.register_lazy('lazy_foo', self.__module__,
2459
'TestOptionRegistry.lazy_option')
2460
self.assertEquals('Lazy help', self.registry.get_help('lazy_foo'))
2463
class TestRegisteredOptions(tests.TestCase):
2464
"""All registered options should verify some constraints."""
2466
scenarios = [(key, {'option_name': key, 'option': option}) for key, option
2467
in config.option_registry.iteritems()]
2470
super(TestRegisteredOptions, self).setUp()
2471
self.registry = config.option_registry
2473
def test_proper_name(self):
2474
# An option should be registered under its own name, this can't be
2475
# checked at registration time for the lazy ones.
2476
self.assertEquals(self.option_name, self.option.name)
2478
def test_help_is_set(self):
2479
option_help = self.registry.get_help(self.option_name)
2480
# Come on, think about the user, he really wants to know what the
2482
self.assertIsNot(None, option_help)
2483
self.assertNotEquals('', option_help)
2486
class TestSection(tests.TestCase):
2488
# FIXME: Parametrize so that all sections produced by Stores run these
2489
# tests -- vila 2011-04-01
2491
def test_get_a_value(self):
2492
a_dict = dict(foo='bar')
2493
section = config.Section('myID', a_dict)
2494
self.assertEquals('bar', section.get('foo'))
2496
def test_get_unknown_option(self):
2498
section = config.Section(None, a_dict)
2499
self.assertEquals('out of thin air',
2500
section.get('foo', 'out of thin air'))
2502
def test_options_is_shared(self):
2504
section = config.Section(None, a_dict)
2505
self.assertIs(a_dict, section.options)
2508
class TestMutableSection(tests.TestCase):
2510
scenarios = [('mutable',
2512
lambda opts: config.MutableSection('myID', opts)},),
2516
a_dict = dict(foo='bar')
2517
section = self.get_section(a_dict)
2518
section.set('foo', 'new_value')
2519
self.assertEquals('new_value', section.get('foo'))
2520
# The change appears in the shared section
2521
self.assertEquals('new_value', a_dict.get('foo'))
2522
# We keep track of the change
2523
self.assertTrue('foo' in section.orig)
2524
self.assertEquals('bar', section.orig.get('foo'))
2526
def test_set_preserve_original_once(self):
2527
a_dict = dict(foo='bar')
2528
section = self.get_section(a_dict)
2529
section.set('foo', 'first_value')
2530
section.set('foo', 'second_value')
2531
# We keep track of the original value
2532
self.assertTrue('foo' in section.orig)
2533
self.assertEquals('bar', section.orig.get('foo'))
2535
def test_remove(self):
2536
a_dict = dict(foo='bar')
2537
section = self.get_section(a_dict)
2538
section.remove('foo')
2539
# We get None for unknown options via the default value
2540
self.assertEquals(None, section.get('foo'))
2541
# Or we just get the default value
2542
self.assertEquals('unknown', section.get('foo', 'unknown'))
2543
self.assertFalse('foo' in section.options)
2544
# We keep track of the deletion
2545
self.assertTrue('foo' in section.orig)
2546
self.assertEquals('bar', section.orig.get('foo'))
2548
def test_remove_new_option(self):
2550
section = self.get_section(a_dict)
2551
section.set('foo', 'bar')
2552
section.remove('foo')
2553
self.assertFalse('foo' in section.options)
2554
# The option didn't exist initially so it we need to keep track of it
2555
# with a special value
2556
self.assertTrue('foo' in section.orig)
2557
self.assertEquals(config._NewlyCreatedOption, section.orig['foo'])
2560
class TestCommandLineStore(tests.TestCase):
2563
super(TestCommandLineStore, self).setUp()
2564
self.store = config.CommandLineStore()
2565
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
2567
def get_section(self):
2568
"""Get the unique section for the command line overrides."""
2569
sections = list(self.store.get_sections())
2570
self.assertLength(1, sections)
2571
store, section = sections[0]
2572
self.assertEquals(self.store, store)
2575
def test_no_override(self):
2576
self.store._from_cmdline([])
2577
section = self.get_section()
2578
self.assertLength(0, list(section.iter_option_names()))
2580
def test_simple_override(self):
2581
self.store._from_cmdline(['a=b'])
2582
section = self.get_section()
2583
self.assertEqual('b', section.get('a'))
2585
def test_list_override(self):
2586
opt = config.ListOption('l')
2587
config.option_registry.register(opt)
2588
self.store._from_cmdline(['l=1,2,3'])
2589
val = self.get_section().get('l')
2590
self.assertEqual('1,2,3', val)
2591
# Reminder: lists should be registered as such explicitely, otherwise
2592
# the conversion needs to be done afterwards.
2593
self.assertEqual(['1', '2', '3'],
2594
opt.convert_from_unicode(self.store, val))
2596
def test_multiple_overrides(self):
2597
self.store._from_cmdline(['a=b', 'x=y'])
2598
section = self.get_section()
2599
self.assertEquals('b', section.get('a'))
2600
self.assertEquals('y', section.get('x'))
2602
def test_wrong_syntax(self):
2603
self.assertRaises(errors.BzrCommandError,
2604
self.store._from_cmdline, ['a=b', 'c'])
2606
class TestStoreMinimalAPI(tests.TestCaseWithTransport):
2608
scenarios = [(key, {'get_store': builder}) for key, builder
2609
in config.test_store_builder_registry.iteritems()] + [
2610
('cmdline', {'get_store': lambda test: config.CommandLineStore()})]
2613
store = self.get_store(self)
2614
if type(store) == config.TransportIniFileStore:
2615
raise tests.TestNotApplicable(
2616
"%s is not a concrete Store implementation"
2617
" so it doesn't need an id" % (store.__class__.__name__,))
2618
self.assertIsNot(None, store.id)
2621
class TestStore(tests.TestCaseWithTransport):
2623
def assertSectionContent(self, expected, (store, section)):
2624
"""Assert that some options have the proper values in a section."""
2625
expected_name, expected_options = expected
2626
self.assertEquals(expected_name, section.id)
2629
dict([(k, section.get(k)) for k in expected_options.keys()]))
2632
class TestReadonlyStore(TestStore):
2634
scenarios = [(key, {'get_store': builder}) for key, builder
2635
in config.test_store_builder_registry.iteritems()]
2637
def test_building_delays_load(self):
2638
store = self.get_store(self)
2639
self.assertEquals(False, store.is_loaded())
2640
store._load_from_string('')
2641
self.assertEquals(True, store.is_loaded())
2643
def test_get_no_sections_for_empty(self):
2644
store = self.get_store(self)
2645
store._load_from_string('')
2646
self.assertEquals([], list(store.get_sections()))
2648
def test_get_default_section(self):
2649
store = self.get_store(self)
2650
store._load_from_string('foo=bar')
2651
sections = list(store.get_sections())
2652
self.assertLength(1, sections)
2653
self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2655
def test_get_named_section(self):
2656
store = self.get_store(self)
2657
store._load_from_string('[baz]\nfoo=bar')
2658
sections = list(store.get_sections())
2659
self.assertLength(1, sections)
2660
self.assertSectionContent(('baz', {'foo': 'bar'}), sections[0])
2662
def test_load_from_string_fails_for_non_empty_store(self):
2663
store = self.get_store(self)
2664
store._load_from_string('foo=bar')
2665
self.assertRaises(AssertionError, store._load_from_string, 'bar=baz')
2668
class TestStoreQuoting(TestStore):
2670
scenarios = [(key, {'get_store': builder}) for key, builder
2671
in config.test_store_builder_registry.iteritems()]
2674
super(TestStoreQuoting, self).setUp()
2675
self.store = self.get_store(self)
2676
# We need a loaded store but any content will do
2677
self.store._load_from_string('')
2679
def assertIdempotent(self, s):
2680
"""Assert that quoting an unquoted string is a no-op and vice-versa.
2682
What matters here is that option values, as they appear in a store, can
2683
be safely round-tripped out of the store and back.
2685
:param s: A string, quoted if required.
2687
self.assertEquals(s, self.store.quote(self.store.unquote(s)))
2688
self.assertEquals(s, self.store.unquote(self.store.quote(s)))
2690
def test_empty_string(self):
2691
if isinstance(self.store, config.IniFileStore):
2692
# configobj._quote doesn't handle empty values
2693
self.assertRaises(AssertionError,
2694
self.assertIdempotent, '')
2696
self.assertIdempotent('')
2697
# But quoted empty strings are ok
2698
self.assertIdempotent('""')
2700
def test_embedded_spaces(self):
2701
self.assertIdempotent('" a b c "')
2703
def test_embedded_commas(self):
2704
self.assertIdempotent('" a , b c "')
2706
def test_simple_comma(self):
2707
if isinstance(self.store, config.IniFileStore):
2708
# configobj requires that lists are special-cased
2709
self.assertRaises(AssertionError,
2710
self.assertIdempotent, ',')
2712
self.assertIdempotent(',')
2713
# When a single comma is required, quoting is also required
2714
self.assertIdempotent('","')
2716
def test_list(self):
2717
if isinstance(self.store, config.IniFileStore):
2718
# configobj requires that lists are special-cased
2719
self.assertRaises(AssertionError,
2720
self.assertIdempotent, 'a,b')
2722
self.assertIdempotent('a,b')
2725
class TestDictFromStore(tests.TestCase):
2727
def test_unquote_not_string(self):
2728
conf = config.MemoryStack('x=2\n[a_section]\na=1\n')
2729
value = conf.get('a_section')
2730
# Urgh, despite 'conf' asking for the no-name section, we get the
2731
# content of another section as a dict o_O
2732
self.assertEquals({'a': '1'}, value)
2733
unquoted = conf.store.unquote(value)
2734
# Which cannot be unquoted but shouldn't crash either (the use cases
2735
# are getting the value or displaying it. In the later case, '%s' will
2737
self.assertEquals({'a': '1'}, unquoted)
2738
self.assertEquals("{u'a': u'1'}", '%s' % (unquoted,))
2741
class TestIniFileStoreContent(tests.TestCaseWithTransport):
2742
"""Simulate loading a config store with content of various encodings.
2744
All files produced by bzr are in utf8 content.
2746
Users may modify them manually and end up with a file that can't be
2747
loaded. We need to issue proper error messages in this case.
2750
invalid_utf8_char = '\xff'
2752
def test_load_utf8(self):
2753
"""Ensure we can load an utf8-encoded file."""
2754
t = self.get_transport()
2755
# From http://pad.lv/799212
2756
unicode_user = u'b\N{Euro Sign}ar'
2757
unicode_content = u'user=%s' % (unicode_user,)
2758
utf8_content = unicode_content.encode('utf8')
2759
# Store the raw content in the config file
2760
t.put_bytes('foo.conf', utf8_content)
2761
store = config.TransportIniFileStore(t, 'foo.conf')
2763
stack = config.Stack([store.get_sections], store)
2764
self.assertEquals(unicode_user, stack.get('user'))
2766
def test_load_non_ascii(self):
2767
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
2768
t = self.get_transport()
2769
t.put_bytes('foo.conf', 'user=foo\n#%s\n' % (self.invalid_utf8_char,))
2770
store = config.TransportIniFileStore(t, 'foo.conf')
2771
self.assertRaises(errors.ConfigContentError, store.load)
2773
def test_load_erroneous_content(self):
2774
"""Ensure we display a proper error on content that can't be parsed."""
2775
t = self.get_transport()
2776
t.put_bytes('foo.conf', '[open_section\n')
2777
store = config.TransportIniFileStore(t, 'foo.conf')
2778
self.assertRaises(errors.ParseConfigError, store.load)
2780
def test_load_permission_denied(self):
2781
"""Ensure we get warned when trying to load an inaccessible file."""
2784
warnings.append(args[0] % args[1:])
2785
self.overrideAttr(trace, 'warning', warning)
2787
t = self.get_transport()
2789
def get_bytes(relpath):
2790
raise errors.PermissionDenied(relpath, "")
2791
t.get_bytes = get_bytes
2792
store = config.TransportIniFileStore(t, 'foo.conf')
2793
self.assertRaises(errors.PermissionDenied, store.load)
2796
[u'Permission denied while trying to load configuration store %s.'
2797
% store.external_url()])
2800
class TestIniConfigContent(tests.TestCaseWithTransport):
2801
"""Simulate loading a IniBasedConfig with content of various encodings.
2803
All files produced by bzr are in utf8 content.
2805
Users may modify them manually and end up with a file that can't be
2806
loaded. We need to issue proper error messages in this case.
2809
invalid_utf8_char = '\xff'
2811
def test_load_utf8(self):
2812
"""Ensure we can load an utf8-encoded file."""
2813
# From http://pad.lv/799212
2814
unicode_user = u'b\N{Euro Sign}ar'
2815
unicode_content = u'user=%s' % (unicode_user,)
2816
utf8_content = unicode_content.encode('utf8')
2817
# Store the raw content in the config file
2818
with open('foo.conf', 'wb') as f:
2819
f.write(utf8_content)
2820
conf = config.IniBasedConfig(file_name='foo.conf')
2821
self.assertEquals(unicode_user, conf.get_user_option('user'))
2823
def test_load_badly_encoded_content(self):
2824
"""Ensure we display a proper error on non-ascii, non utf-8 content."""
2825
with open('foo.conf', 'wb') as f:
2826
f.write('user=foo\n#%s\n' % (self.invalid_utf8_char,))
2827
conf = config.IniBasedConfig(file_name='foo.conf')
2828
self.assertRaises(errors.ConfigContentError, conf._get_parser)
2830
def test_load_erroneous_content(self):
2831
"""Ensure we display a proper error on content that can't be parsed."""
2832
with open('foo.conf', 'wb') as f:
2833
f.write('[open_section\n')
2834
conf = config.IniBasedConfig(file_name='foo.conf')
2835
self.assertRaises(errors.ParseConfigError, conf._get_parser)
2838
class TestMutableStore(TestStore):
2840
scenarios = [(key, {'store_id': key, 'get_store': builder}) for key, builder
2841
in config.test_store_builder_registry.iteritems()]
2844
super(TestMutableStore, self).setUp()
2845
self.transport = self.get_transport()
2847
def has_store(self, store):
2848
store_basename = urlutils.relative_url(self.transport.external_url(),
2849
store.external_url())
2850
return self.transport.has(store_basename)
2852
def test_save_empty_creates_no_file(self):
2853
# FIXME: There should be a better way than relying on the test
2854
# parametrization to identify branch.conf -- vila 2011-0526
2855
if self.store_id in ('branch', 'remote_branch'):
2856
raise tests.TestNotApplicable(
2857
'branch.conf is *always* created when a branch is initialized')
2858
store = self.get_store(self)
2860
self.assertEquals(False, self.has_store(store))
2862
def test_mutable_section_shared(self):
2863
store = self.get_store(self)
2864
store._load_from_string('foo=bar\n')
2865
# FIXME: There should be a better way than relying on the test
2866
# parametrization to identify branch.conf -- vila 2011-0526
2867
if self.store_id in ('branch', 'remote_branch'):
2868
# branch stores requires write locked branches
2869
self.addCleanup(store.branch.lock_write().unlock)
2870
section1 = store.get_mutable_section(None)
2871
section2 = store.get_mutable_section(None)
2872
# If we get different sections, different callers won't share the
2874
self.assertIs(section1, section2)
2876
def test_save_emptied_succeeds(self):
2877
store = self.get_store(self)
2878
store._load_from_string('foo=bar\n')
2879
# FIXME: There should be a better way than relying on the test
2880
# parametrization to identify branch.conf -- vila 2011-0526
2881
if self.store_id in ('branch', 'remote_branch'):
2882
# branch stores requires write locked branches
2883
self.addCleanup(store.branch.lock_write().unlock)
2884
section = store.get_mutable_section(None)
2885
section.remove('foo')
2887
self.assertEquals(True, self.has_store(store))
2888
modified_store = self.get_store(self)
2889
sections = list(modified_store.get_sections())
2890
self.assertLength(0, sections)
2892
def test_save_with_content_succeeds(self):
2893
# FIXME: There should be a better way than relying on the test
2894
# parametrization to identify branch.conf -- vila 2011-0526
2895
if self.store_id in ('branch', 'remote_branch'):
2896
raise tests.TestNotApplicable(
2897
'branch.conf is *always* created when a branch is initialized')
2898
store = self.get_store(self)
2899
store._load_from_string('foo=bar\n')
2900
self.assertEquals(False, self.has_store(store))
2902
self.assertEquals(True, self.has_store(store))
2903
modified_store = self.get_store(self)
2904
sections = list(modified_store.get_sections())
2905
self.assertLength(1, sections)
2906
self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2908
def test_set_option_in_empty_store(self):
2909
store = self.get_store(self)
2910
# FIXME: There should be a better way than relying on the test
2911
# parametrization to identify branch.conf -- vila 2011-0526
2912
if self.store_id in ('branch', 'remote_branch'):
2913
# branch stores requires write locked branches
2914
self.addCleanup(store.branch.lock_write().unlock)
2915
section = store.get_mutable_section(None)
2916
section.set('foo', 'bar')
2918
modified_store = self.get_store(self)
2919
sections = list(modified_store.get_sections())
2920
self.assertLength(1, sections)
2921
self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2923
def test_set_option_in_default_section(self):
2924
store = self.get_store(self)
2925
store._load_from_string('')
2926
# FIXME: There should be a better way than relying on the test
2927
# parametrization to identify branch.conf -- vila 2011-0526
2928
if self.store_id in ('branch', 'remote_branch'):
2929
# branch stores requires write locked branches
2930
self.addCleanup(store.branch.lock_write().unlock)
2931
section = store.get_mutable_section(None)
2932
section.set('foo', 'bar')
2934
modified_store = self.get_store(self)
2935
sections = list(modified_store.get_sections())
2936
self.assertLength(1, sections)
2937
self.assertSectionContent((None, {'foo': 'bar'}), sections[0])
2939
def test_set_option_in_named_section(self):
2940
store = self.get_store(self)
2941
store._load_from_string('')
2942
# FIXME: There should be a better way than relying on the test
2943
# parametrization to identify branch.conf -- vila 2011-0526
2944
if self.store_id in ('branch', 'remote_branch'):
2945
# branch stores requires write locked branches
2946
self.addCleanup(store.branch.lock_write().unlock)
2947
section = store.get_mutable_section('baz')
2948
section.set('foo', 'bar')
2950
modified_store = self.get_store(self)
2951
sections = list(modified_store.get_sections())
2952
self.assertLength(1, sections)
2953
self.assertSectionContent(('baz', {'foo': 'bar'}), sections[0])
2955
def test_load_hook(self):
2956
# First, we need to ensure that the store exists
2957
store = self.get_store(self)
2958
# FIXME: There should be a better way than relying on the test
2959
# parametrization to identify branch.conf -- vila 2011-0526
2960
if self.store_id in ('branch', 'remote_branch'):
2961
# branch stores requires write locked branches
2962
self.addCleanup(store.branch.lock_write().unlock)
2963
section = store.get_mutable_section('baz')
2964
section.set('foo', 'bar')
2966
# Now we can try to load it
2967
store = self.get_store(self)
2971
config.ConfigHooks.install_named_hook('load', hook, None)
2972
self.assertLength(0, calls)
2974
self.assertLength(1, calls)
2975
self.assertEquals((store,), calls[0])
2977
def test_save_hook(self):
2981
config.ConfigHooks.install_named_hook('save', hook, None)
2982
self.assertLength(0, calls)
2983
store = self.get_store(self)
2984
# FIXME: There should be a better way than relying on the test
2985
# parametrization to identify branch.conf -- vila 2011-0526
2986
if self.store_id in ('branch', 'remote_branch'):
2987
# branch stores requires write locked branches
2988
self.addCleanup(store.branch.lock_write().unlock)
2989
section = store.get_mutable_section('baz')
2990
section.set('foo', 'bar')
2992
self.assertLength(1, calls)
2993
self.assertEquals((store,), calls[0])
2995
def test_set_mark_dirty(self):
2996
stack = config.MemoryStack('')
2997
self.assertLength(0, stack.store.dirty_sections)
2998
stack.set('foo', 'baz')
2999
self.assertLength(1, stack.store.dirty_sections)
3000
self.assertTrue(stack.store._need_saving())
3002
def test_remove_mark_dirty(self):
3003
stack = config.MemoryStack('foo=bar')
3004
self.assertLength(0, stack.store.dirty_sections)
3006
self.assertLength(1, stack.store.dirty_sections)
3007
self.assertTrue(stack.store._need_saving())
3010
class TestStoreSaveChanges(tests.TestCaseWithTransport):
3011
"""Tests that config changes are kept in memory and saved on-demand."""
3014
super(TestStoreSaveChanges, self).setUp()
3015
self.transport = self.get_transport()
3016
# Most of the tests involve two stores pointing to the same persistent
3017
# storage to observe the effects of concurrent changes
3018
self.st1 = config.TransportIniFileStore(self.transport, 'foo.conf')
3019
self.st2 = config.TransportIniFileStore(self.transport, 'foo.conf')
3022
self.warnings.append(args[0] % args[1:])
3023
self.overrideAttr(trace, 'warning', warning)
3025
def has_store(self, store):
3026
store_basename = urlutils.relative_url(self.transport.external_url(),
3027
store.external_url())
3028
return self.transport.has(store_basename)
3030
def get_stack(self, store):
3031
# Any stack will do as long as it uses the right store, just a single
3032
# no-name section is enough
3033
return config.Stack([store.get_sections], store)
3035
def test_no_changes_no_save(self):
3036
s = self.get_stack(self.st1)
3037
s.store.save_changes()
3038
self.assertEquals(False, self.has_store(self.st1))
3040
def test_unrelated_concurrent_update(self):
3041
s1 = self.get_stack(self.st1)
3042
s2 = self.get_stack(self.st2)
3043
s1.set('foo', 'bar')
3044
s2.set('baz', 'quux')
3046
# Changes don't propagate magically
3047
self.assertEquals(None, s1.get('baz'))
3048
s2.store.save_changes()
3049
self.assertEquals('quux', s2.get('baz'))
3050
# Changes are acquired when saving
3051
self.assertEquals('bar', s2.get('foo'))
3052
# Since there is no overlap, no warnings are emitted
3053
self.assertLength(0, self.warnings)
3055
def test_concurrent_update_modified(self):
3056
s1 = self.get_stack(self.st1)
3057
s2 = self.get_stack(self.st2)
3058
s1.set('foo', 'bar')
3059
s2.set('foo', 'baz')
3062
s2.store.save_changes()
3063
self.assertEquals('baz', s2.get('foo'))
3064
# But the user get a warning
3065
self.assertLength(1, self.warnings)
3066
warning = self.warnings[0]
3067
self.assertStartsWith(warning, 'Option foo in section None')
3068
self.assertEndsWith(warning, 'was changed from <CREATED> to bar.'
3069
' The baz value will be saved.')
3071
def test_concurrent_deletion(self):
3072
self.st1._load_from_string('foo=bar')
3074
s1 = self.get_stack(self.st1)
3075
s2 = self.get_stack(self.st2)
3078
s1.store.save_changes()
3080
self.assertLength(0, self.warnings)
3081
s2.store.save_changes()
3083
self.assertLength(1, self.warnings)
3084
warning = self.warnings[0]
3085
self.assertStartsWith(warning, 'Option foo in section None')
3086
self.assertEndsWith(warning, 'was changed from bar to <CREATED>.'
3087
' The <DELETED> value will be saved.')
3090
class TestQuotingIniFileStore(tests.TestCaseWithTransport):
3092
def get_store(self):
3093
return config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3095
def test_get_quoted_string(self):
3096
store = self.get_store()
3097
store._load_from_string('foo= " abc "')
3098
stack = config.Stack([store.get_sections])
3099
self.assertEquals(' abc ', stack.get('foo'))
3101
def test_set_quoted_string(self):
3102
store = self.get_store()
3103
stack = config.Stack([store.get_sections], store)
3104
stack.set('foo', ' a b c ')
3106
self.assertFileEqual('foo = " a b c "' + os.linesep, 'foo.conf')
3109
class TestTransportIniFileStore(TestStore):
3111
def test_loading_unknown_file_fails(self):
3112
store = config.TransportIniFileStore(self.get_transport(),
3114
self.assertRaises(errors.NoSuchFile, store.load)
3116
def test_invalid_content(self):
3117
store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3118
self.assertEquals(False, store.is_loaded())
3119
exc = self.assertRaises(
3120
errors.ParseConfigError, store._load_from_string,
3121
'this is invalid !')
3122
self.assertEndsWith(exc.filename, 'foo.conf')
3123
# And the load failed
3124
self.assertEquals(False, store.is_loaded())
3126
def test_get_embedded_sections(self):
3127
# A more complicated example (which also shows that section names and
3128
# option names share the same name space...)
3129
# FIXME: This should be fixed by forbidding dicts as values ?
3130
# -- vila 2011-04-05
3131
store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3132
store._load_from_string('''
3136
foo_in_DEFAULT=foo_DEFAULT
3144
sections = list(store.get_sections())
3145
self.assertLength(4, sections)
3146
# The default section has no name.
3147
# List values are provided as strings and need to be explicitly
3148
# converted by specifying from_unicode=list_from_store at option
3150
self.assertSectionContent((None, {'foo': 'bar', 'l': u'1,2'}),
3152
self.assertSectionContent(
3153
('DEFAULT', {'foo_in_DEFAULT': 'foo_DEFAULT'}), sections[1])
3154
self.assertSectionContent(
3155
('bar', {'foo_in_bar': 'barbar'}), sections[2])
3156
# sub sections are provided as embedded dicts.
3157
self.assertSectionContent(
3158
('baz', {'foo_in_baz': 'barbaz', 'qux': {'foo_in_qux': 'quux'}}),
3162
class TestLockableIniFileStore(TestStore):
3164
def test_create_store_in_created_dir(self):
3165
self.assertPathDoesNotExist('dir')
3166
t = self.get_transport('dir/subdir')
3167
store = config.LockableIniFileStore(t, 'foo.conf')
3168
store.get_mutable_section(None).set('foo', 'bar')
3170
self.assertPathExists('dir/subdir')
3173
class TestConcurrentStoreUpdates(TestStore):
3174
"""Test that Stores properly handle conccurent updates.
3176
New Store implementation may fail some of these tests but until such
3177
implementations exist it's hard to properly filter them from the scenarios
3178
applied here. If you encounter such a case, contact the bzr devs.
3181
scenarios = [(key, {'get_stack': builder}) for key, builder
3182
in config.test_stack_builder_registry.iteritems()]
3185
super(TestConcurrentStoreUpdates, self).setUp()
3186
self.stack = self.get_stack(self)
3187
if not isinstance(self.stack, config._CompatibleStack):
3188
raise tests.TestNotApplicable(
3189
'%s is not meant to be compatible with the old config design'
3191
self.stack.set('one', '1')
3192
self.stack.set('two', '2')
3194
self.stack.store.save()
3196
def test_simple_read_access(self):
3197
self.assertEquals('1', self.stack.get('one'))
3199
def test_simple_write_access(self):
3200
self.stack.set('one', 'one')
3201
self.assertEquals('one', self.stack.get('one'))
3203
def test_listen_to_the_last_speaker(self):
3205
c2 = self.get_stack(self)
3206
c1.set('one', 'ONE')
3207
c2.set('two', 'TWO')
3208
self.assertEquals('ONE', c1.get('one'))
3209
self.assertEquals('TWO', c2.get('two'))
3210
# The second update respect the first one
3211
self.assertEquals('ONE', c2.get('one'))
3213
def test_last_speaker_wins(self):
3214
# If the same config is not shared, the same variable modified twice
3215
# can only see a single result.
3217
c2 = self.get_stack(self)
3220
self.assertEquals('c2', c2.get('one'))
3221
# The first modification is still available until another refresh
3223
self.assertEquals('c1', c1.get('one'))
3224
c1.set('two', 'done')
3225
self.assertEquals('c2', c1.get('one'))
3227
def test_writes_are_serialized(self):
3229
c2 = self.get_stack(self)
3231
# We spawn a thread that will pause *during* the config saving.
3232
before_writing = threading.Event()
3233
after_writing = threading.Event()
3234
writing_done = threading.Event()
3235
c1_save_without_locking_orig = c1.store.save_without_locking
3236
def c1_save_without_locking():
3237
before_writing.set()
3238
c1_save_without_locking_orig()
3239
# The lock is held. We wait for the main thread to decide when to
3241
after_writing.wait()
3242
c1.store.save_without_locking = c1_save_without_locking
3246
t1 = threading.Thread(target=c1_set)
3247
# Collect the thread after the test
3248
self.addCleanup(t1.join)
3249
# Be ready to unblock the thread if the test goes wrong
3250
self.addCleanup(after_writing.set)
3252
before_writing.wait()
3253
self.assertRaises(errors.LockContention,
3254
c2.set, 'one', 'c2')
3255
self.assertEquals('c1', c1.get('one'))
3256
# Let the lock be released
3260
self.assertEquals('c2', c2.get('one'))
3262
def test_read_while_writing(self):
3264
# We spawn a thread that will pause *during* the write
3265
ready_to_write = threading.Event()
3266
do_writing = threading.Event()
3267
writing_done = threading.Event()
3268
# We override the _save implementation so we know the store is locked
3269
c1_save_without_locking_orig = c1.store.save_without_locking
3270
def c1_save_without_locking():
3271
ready_to_write.set()
3272
# The lock is held. We wait for the main thread to decide when to
3275
c1_save_without_locking_orig()
3277
c1.store.save_without_locking = c1_save_without_locking
3280
t1 = threading.Thread(target=c1_set)
3281
# Collect the thread after the test
3282
self.addCleanup(t1.join)
3283
# Be ready to unblock the thread if the test goes wrong
3284
self.addCleanup(do_writing.set)
3286
# Ensure the thread is ready to write
3287
ready_to_write.wait()
3288
self.assertEquals('c1', c1.get('one'))
3289
# If we read during the write, we get the old value
3290
c2 = self.get_stack(self)
3291
self.assertEquals('1', c2.get('one'))
3292
# Let the writing occur and ensure it occurred
3295
# Now we get the updated value
3296
c3 = self.get_stack(self)
3297
self.assertEquals('c1', c3.get('one'))
3299
# FIXME: It may be worth looking into removing the lock dir when it's not
3300
# needed anymore and look at possible fallouts for concurrent lockers. This
3301
# will matter if/when we use config files outside of bazaar directories
3302
# (.bazaar or .bzr) -- vila 20110-04-111
3305
class TestSectionMatcher(TestStore):
3307
scenarios = [('location', {'matcher': config.LocationMatcher}),
3308
('id', {'matcher': config.NameMatcher}),]
3311
super(TestSectionMatcher, self).setUp()
3312
# Any simple store is good enough
3313
self.get_store = config.test_store_builder_registry.get('configobj')
3315
def test_no_matches_for_empty_stores(self):
3316
store = self.get_store(self)
3317
store._load_from_string('')
3318
matcher = self.matcher(store, '/bar')
3319
self.assertEquals([], list(matcher.get_sections()))
3321
def test_build_doesnt_load_store(self):
3322
store = self.get_store(self)
3323
matcher = self.matcher(store, '/bar')
3324
self.assertFalse(store.is_loaded())
3327
class TestLocationSection(tests.TestCase):
3329
def get_section(self, options, extra_path):
3330
section = config.Section('foo', options)
3331
return config.LocationSection(section, extra_path)
3333
def test_simple_option(self):
3334
section = self.get_section({'foo': 'bar'}, '')
3335
self.assertEquals('bar', section.get('foo'))
3337
def test_option_with_extra_path(self):
3338
section = self.get_section({'foo': 'bar', 'foo:policy': 'appendpath'},
3340
self.assertEquals('bar/baz', section.get('foo'))
3342
def test_invalid_policy(self):
3343
section = self.get_section({'foo': 'bar', 'foo:policy': 'die'},
3345
# invalid policies are ignored
3346
self.assertEquals('bar', section.get('foo'))
3349
class TestLocationMatcher(TestStore):
3352
super(TestLocationMatcher, self).setUp()
3353
# Any simple store is good enough
3354
self.get_store = config.test_store_builder_registry.get('configobj')
3356
def test_unrelated_section_excluded(self):
3357
store = self.get_store(self)
3358
store._load_from_string('''
3366
section=/foo/bar/baz
3370
self.assertEquals(['/foo', '/foo/baz', '/foo/bar', '/foo/bar/baz',
3372
[section.id for _, section in store.get_sections()])
3373
matcher = config.LocationMatcher(store, '/foo/bar/quux')
3374
sections = [section for _, section in matcher.get_sections()]
3375
self.assertEquals(['/foo/bar', '/foo'],
3376
[section.id for section in sections])
3377
self.assertEquals(['quux', 'bar/quux'],
3378
[section.extra_path for section in sections])
3380
def test_more_specific_sections_first(self):
3381
store = self.get_store(self)
3382
store._load_from_string('''
3388
self.assertEquals(['/foo', '/foo/bar'],
3389
[section.id for _, section in store.get_sections()])
3390
matcher = config.LocationMatcher(store, '/foo/bar/baz')
3391
sections = [section for _, section in matcher.get_sections()]
3392
self.assertEquals(['/foo/bar', '/foo'],
3393
[section.id for section in sections])
3394
self.assertEquals(['baz', 'bar/baz'],
3395
[section.extra_path for section in sections])
3397
def test_appendpath_in_no_name_section(self):
3398
# It's a bit weird to allow appendpath in a no-name section, but
3399
# someone may found a use for it
3400
store = self.get_store(self)
3401
store._load_from_string('''
3403
foo:policy = appendpath
3405
matcher = config.LocationMatcher(store, 'dir/subdir')
3406
sections = list(matcher.get_sections())
3407
self.assertLength(1, sections)
3408
self.assertEquals('bar/dir/subdir', sections[0][1].get('foo'))
3410
def test_file_urls_are_normalized(self):
3411
store = self.get_store(self)
3412
if sys.platform == 'win32':
3413
expected_url = 'file:///C:/dir/subdir'
3414
expected_location = 'C:/dir/subdir'
3416
expected_url = 'file:///dir/subdir'
3417
expected_location = '/dir/subdir'
3418
matcher = config.LocationMatcher(store, expected_url)
3419
self.assertEquals(expected_location, matcher.location)
3421
def test_branch_name_colo(self):
3422
store = self.get_store(self)
3423
store._load_from_string(dedent("""\
3425
push_location=my{branchname}
3427
matcher = config.LocationMatcher(store, 'file:///,branch=example%3c')
3428
self.assertEqual('example<', matcher.branch_name)
3429
((_, section),) = matcher.get_sections()
3430
self.assertEqual('example<', section.locals['branchname'])
3432
def test_branch_name_basename(self):
3433
store = self.get_store(self)
3434
store._load_from_string(dedent("""\
3436
push_location=my{branchname}
3438
matcher = config.LocationMatcher(store, 'file:///parent/example%3c')
3439
self.assertEqual('example<', matcher.branch_name)
3440
((_, section),) = matcher.get_sections()
3441
self.assertEqual('example<', section.locals['branchname'])
3444
class TestStartingPathMatcher(TestStore):
3447
super(TestStartingPathMatcher, self).setUp()
3448
# Any simple store is good enough
3449
self.store = config.IniFileStore()
3451
def assertSectionIDs(self, expected, location, content):
3452
self.store._load_from_string(content)
3453
matcher = config.StartingPathMatcher(self.store, location)
3454
sections = list(matcher.get_sections())
3455
self.assertLength(len(expected), sections)
3456
self.assertEqual(expected, [section.id for _, section in sections])
3459
def test_empty(self):
3460
self.assertSectionIDs([], self.get_url(), '')
3462
def test_url_vs_local_paths(self):
3463
# The matcher location is an url and the section names are local paths
3464
sections = self.assertSectionIDs(['/foo/bar', '/foo'],
3465
'file:///foo/bar/baz', '''\
3470
def test_local_path_vs_url(self):
3471
# The matcher location is a local path and the section names are urls
3472
sections = self.assertSectionIDs(['file:///foo/bar', 'file:///foo'],
3473
'/foo/bar/baz', '''\
3479
def test_no_name_section_included_when_present(self):
3480
# Note that other tests will cover the case where the no-name section
3481
# is empty and as such, not included.
3482
sections = self.assertSectionIDs(['/foo/bar', '/foo', None],
3483
'/foo/bar/baz', '''\
3484
option = defined so the no-name section exists
3488
self.assertEquals(['baz', 'bar/baz', '/foo/bar/baz'],
3489
[s.locals['relpath'] for _, s in sections])
3491
def test_order_reversed(self):
3492
self.assertSectionIDs(['/foo/bar', '/foo'], '/foo/bar/baz', '''\
3497
def test_unrelated_section_excluded(self):
3498
self.assertSectionIDs(['/foo/bar', '/foo'], '/foo/bar/baz', '''\
3504
def test_glob_included(self):
3505
sections = self.assertSectionIDs(['/foo/*/baz', '/foo/b*', '/foo'],
3506
'/foo/bar/baz', '''\
3512
# Note that 'baz' as a relpath for /foo/b* is not fully correct, but
3513
# nothing really is... as far using {relpath} to append it to something
3514
# else, this seems good enough though.
3515
self.assertEquals(['', 'baz', 'bar/baz'],
3516
[s.locals['relpath'] for _, s in sections])
3518
def test_respect_order(self):
3519
self.assertSectionIDs(['/foo', '/foo/b*', '/foo/*/baz'],
3520
'/foo/bar/baz', '''\
3528
class TestNameMatcher(TestStore):
3531
super(TestNameMatcher, self).setUp()
3532
self.matcher = config.NameMatcher
3533
# Any simple store is good enough
3534
self.get_store = config.test_store_builder_registry.get('configobj')
3536
def get_matching_sections(self, name):
3537
store = self.get_store(self)
3538
store._load_from_string('''
3546
matcher = self.matcher(store, name)
3547
return list(matcher.get_sections())
3549
def test_matching(self):
3550
sections = self.get_matching_sections('foo')
3551
self.assertLength(1, sections)
3552
self.assertSectionContent(('foo', {'option': 'foo'}), sections[0])
3554
def test_not_matching(self):
3555
sections = self.get_matching_sections('baz')
3556
self.assertLength(0, sections)
3559
class TestBaseStackGet(tests.TestCase):
3562
super(TestBaseStackGet, self).setUp()
3563
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
3565
def test_get_first_definition(self):
3566
store1 = config.IniFileStore()
3567
store1._load_from_string('foo=bar')
3568
store2 = config.IniFileStore()
3569
store2._load_from_string('foo=baz')
3570
conf = config.Stack([store1.get_sections, store2.get_sections])
3571
self.assertEquals('bar', conf.get('foo'))
3573
def test_get_with_registered_default_value(self):
3574
config.option_registry.register(config.Option('foo', default='bar'))
3575
conf_stack = config.Stack([])
3576
self.assertEquals('bar', conf_stack.get('foo'))
3578
def test_get_without_registered_default_value(self):
3579
config.option_registry.register(config.Option('foo'))
3580
conf_stack = config.Stack([])
3581
self.assertEquals(None, conf_stack.get('foo'))
3583
def test_get_without_default_value_for_not_registered(self):
3584
conf_stack = config.Stack([])
3585
self.assertEquals(None, conf_stack.get('foo'))
3587
def test_get_for_empty_section_callable(self):
3588
conf_stack = config.Stack([lambda : []])
3589
self.assertEquals(None, conf_stack.get('foo'))
3591
def test_get_for_broken_callable(self):
3592
# Trying to use and invalid callable raises an exception on first use
3593
conf_stack = config.Stack([object])
3594
self.assertRaises(TypeError, conf_stack.get, 'foo')
3597
class TestStackWithSimpleStore(tests.TestCase):
3600
super(TestStackWithSimpleStore, self).setUp()
3601
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
3602
self.registry = config.option_registry
3604
def get_conf(self, content=None):
3605
return config.MemoryStack(content)
3607
def test_override_value_from_env(self):
3608
self.overrideEnv('FOO', None)
3609
self.registry.register(
3610
config.Option('foo', default='bar', override_from_env=['FOO']))
3611
self.overrideEnv('FOO', 'quux')
3612
# Env variable provides a default taking over the option one
3613
conf = self.get_conf('foo=store')
3614
self.assertEquals('quux', conf.get('foo'))
3616
def test_first_override_value_from_env_wins(self):
3617
self.overrideEnv('NO_VALUE', None)
3618
self.overrideEnv('FOO', None)
3619
self.overrideEnv('BAZ', None)
3620
self.registry.register(
3621
config.Option('foo', default='bar',
3622
override_from_env=['NO_VALUE', 'FOO', 'BAZ']))
3623
self.overrideEnv('FOO', 'foo')
3624
self.overrideEnv('BAZ', 'baz')
3625
# The first env var set wins
3626
conf = self.get_conf('foo=store')
3627
self.assertEquals('foo', conf.get('foo'))
3630
class TestMemoryStack(tests.TestCase):
3633
conf = config.MemoryStack('foo=bar')
3634
self.assertEquals('bar', conf.get('foo'))
3637
conf = config.MemoryStack('foo=bar')
3638
conf.set('foo', 'baz')
3639
self.assertEquals('baz', conf.get('foo'))
3641
def test_no_content(self):
3642
conf = config.MemoryStack()
3643
# No content means no loading
3644
self.assertFalse(conf.store.is_loaded())
3645
self.assertRaises(NotImplementedError, conf.get, 'foo')
3646
# But a content can still be provided
3647
conf.store._load_from_string('foo=bar')
3648
self.assertEquals('bar', conf.get('foo'))
3651
class TestStackIterSections(tests.TestCase):
3653
def test_empty_stack(self):
3654
conf = config.Stack([])
3655
sections = list(conf.iter_sections())
3656
self.assertLength(0, sections)
3658
def test_empty_store(self):
3659
store = config.IniFileStore()
3660
store._load_from_string('')
3661
conf = config.Stack([store.get_sections])
3662
sections = list(conf.iter_sections())
3663
self.assertLength(0, sections)
3665
def test_simple_store(self):
3666
store = config.IniFileStore()
3667
store._load_from_string('foo=bar')
3668
conf = config.Stack([store.get_sections])
3669
tuples = list(conf.iter_sections())
3670
self.assertLength(1, tuples)
3671
(found_store, found_section) = tuples[0]
3672
self.assertIs(store, found_store)
3674
def test_two_stores(self):
3675
store1 = config.IniFileStore()
3676
store1._load_from_string('foo=bar')
3677
store2 = config.IniFileStore()
3678
store2._load_from_string('bar=qux')
3679
conf = config.Stack([store1.get_sections, store2.get_sections])
3680
tuples = list(conf.iter_sections())
3681
self.assertLength(2, tuples)
3682
self.assertIs(store1, tuples[0][0])
3683
self.assertIs(store2, tuples[1][0])
3686
class TestStackWithTransport(tests.TestCaseWithTransport):
3688
scenarios = [(key, {'get_stack': builder}) for key, builder
3689
in config.test_stack_builder_registry.iteritems()]
3692
class TestConcreteStacks(TestStackWithTransport):
3694
def test_build_stack(self):
3695
# Just a smoke test to help debug builders
3696
stack = self.get_stack(self)
3699
class TestStackGet(TestStackWithTransport):
3702
super(TestStackGet, self).setUp()
3703
self.conf = self.get_stack(self)
3705
def test_get_for_empty_stack(self):
3706
self.assertEquals(None, self.conf.get('foo'))
3708
def test_get_hook(self):
3709
self.conf.set('foo', 'bar')
3713
config.ConfigHooks.install_named_hook('get', hook, None)
3714
self.assertLength(0, calls)
3715
value = self.conf.get('foo')
3716
self.assertEquals('bar', value)
3717
self.assertLength(1, calls)
3718
self.assertEquals((self.conf, 'foo', 'bar'), calls[0])
3721
class TestStackGetWithConverter(tests.TestCase):
3724
super(TestStackGetWithConverter, self).setUp()
3725
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
3726
self.registry = config.option_registry
3728
def get_conf(self, content=None):
3729
return config.MemoryStack(content)
3731
def register_bool_option(self, name, default=None, default_from_env=None):
3732
b = config.Option(name, help='A boolean.',
3733
default=default, default_from_env=default_from_env,
3734
from_unicode=config.bool_from_store)
3735
self.registry.register(b)
3737
def test_get_default_bool_None(self):
3738
self.register_bool_option('foo')
3739
conf = self.get_conf('')
3740
self.assertEquals(None, conf.get('foo'))
3742
def test_get_default_bool_True(self):
3743
self.register_bool_option('foo', u'True')
3744
conf = self.get_conf('')
3745
self.assertEquals(True, conf.get('foo'))
3747
def test_get_default_bool_False(self):
3748
self.register_bool_option('foo', False)
3749
conf = self.get_conf('')
3750
self.assertEquals(False, conf.get('foo'))
3752
def test_get_default_bool_False_as_string(self):
3753
self.register_bool_option('foo', u'False')
3754
conf = self.get_conf('')
3755
self.assertEquals(False, conf.get('foo'))
3757
def test_get_default_bool_from_env_converted(self):
3758
self.register_bool_option('foo', u'True', default_from_env=['FOO'])
3759
self.overrideEnv('FOO', 'False')
3760
conf = self.get_conf('')
3761
self.assertEquals(False, conf.get('foo'))
3763
def test_get_default_bool_when_conversion_fails(self):
3764
self.register_bool_option('foo', default='True')
3765
conf = self.get_conf('foo=invalid boolean')
3766
self.assertEquals(True, conf.get('foo'))
3768
def register_integer_option(self, name,
3769
default=None, default_from_env=None):
3770
i = config.Option(name, help='An integer.',
3771
default=default, default_from_env=default_from_env,
3772
from_unicode=config.int_from_store)
3773
self.registry.register(i)
3775
def test_get_default_integer_None(self):
3776
self.register_integer_option('foo')
3777
conf = self.get_conf('')
3778
self.assertEquals(None, conf.get('foo'))
3780
def test_get_default_integer(self):
3781
self.register_integer_option('foo', 42)
3782
conf = self.get_conf('')
3783
self.assertEquals(42, conf.get('foo'))
3785
def test_get_default_integer_as_string(self):
3786
self.register_integer_option('foo', u'42')
3787
conf = self.get_conf('')
3788
self.assertEquals(42, conf.get('foo'))
3790
def test_get_default_integer_from_env(self):
3791
self.register_integer_option('foo', default_from_env=['FOO'])
3792
self.overrideEnv('FOO', '18')
3793
conf = self.get_conf('')
3794
self.assertEquals(18, conf.get('foo'))
3796
def test_get_default_integer_when_conversion_fails(self):
3797
self.register_integer_option('foo', default='12')
3798
conf = self.get_conf('foo=invalid integer')
3799
self.assertEquals(12, conf.get('foo'))
3801
def register_list_option(self, name, default=None, default_from_env=None):
3802
l = config.ListOption(name, help='A list.', default=default,
3803
default_from_env=default_from_env)
3804
self.registry.register(l)
3806
def test_get_default_list_None(self):
3807
self.register_list_option('foo')
3808
conf = self.get_conf('')
3809
self.assertEquals(None, conf.get('foo'))
3811
def test_get_default_list_empty(self):
3812
self.register_list_option('foo', '')
3813
conf = self.get_conf('')
3814
self.assertEquals([], conf.get('foo'))
3816
def test_get_default_list_from_env(self):
3817
self.register_list_option('foo', default_from_env=['FOO'])
3818
self.overrideEnv('FOO', '')
3819
conf = self.get_conf('')
3820
self.assertEquals([], conf.get('foo'))
3822
def test_get_with_list_converter_no_item(self):
3823
self.register_list_option('foo', None)
3824
conf = self.get_conf('foo=,')
3825
self.assertEquals([], conf.get('foo'))
3827
def test_get_with_list_converter_many_items(self):
3828
self.register_list_option('foo', None)
3829
conf = self.get_conf('foo=m,o,r,e')
3830
self.assertEquals(['m', 'o', 'r', 'e'], conf.get('foo'))
3832
def test_get_with_list_converter_embedded_spaces_many_items(self):
3833
self.register_list_option('foo', None)
3834
conf = self.get_conf('foo=" bar", "baz "')
3835
self.assertEquals([' bar', 'baz '], conf.get('foo'))
3837
def test_get_with_list_converter_stripped_spaces_many_items(self):
3838
self.register_list_option('foo', None)
3839
conf = self.get_conf('foo= bar , baz ')
3840
self.assertEquals(['bar', 'baz'], conf.get('foo'))
3843
class TestIterOptionRefs(tests.TestCase):
3844
"""iter_option_refs is a bit unusual, document some cases."""
3846
def assertRefs(self, expected, string):
3847
self.assertEquals(expected, list(config.iter_option_refs(string)))
3849
def test_empty(self):
3850
self.assertRefs([(False, '')], '')
3852
def test_no_refs(self):
3853
self.assertRefs([(False, 'foo bar')], 'foo bar')
3855
def test_single_ref(self):
3856
self.assertRefs([(False, ''), (True, '{foo}'), (False, '')], '{foo}')
3858
def test_broken_ref(self):
3859
self.assertRefs([(False, '{foo')], '{foo')
3861
def test_embedded_ref(self):
3862
self.assertRefs([(False, '{'), (True, '{foo}'), (False, '}')],
3865
def test_two_refs(self):
3866
self.assertRefs([(False, ''), (True, '{foo}'),
3867
(False, ''), (True, '{bar}'),
3871
def test_newline_in_refs_are_not_matched(self):
3872
self.assertRefs([(False, '{\nxx}{xx\n}{{\n}}')], '{\nxx}{xx\n}{{\n}}')
3875
class TestStackExpandOptions(tests.TestCaseWithTransport):
3878
super(TestStackExpandOptions, self).setUp()
3879
self.overrideAttr(config, 'option_registry', config.OptionRegistry())
3880
self.registry = config.option_registry
3881
store = config.TransportIniFileStore(self.get_transport(), 'foo.conf')
3882
self.conf = config.Stack([store.get_sections], store)
3884
def assertExpansion(self, expected, string, env=None):
3885
self.assertEquals(expected, self.conf.expand_options(string, env))
3887
def test_no_expansion(self):
3888
self.assertExpansion('foo', 'foo')
3890
def test_expand_default_value(self):
3891
self.conf.store._load_from_string('bar=baz')
3892
self.registry.register(config.Option('foo', default=u'{bar}'))
3893
self.assertEquals('baz', self.conf.get('foo', expand=True))
3895
def test_expand_default_from_env(self):
3896
self.conf.store._load_from_string('bar=baz')
3897
self.registry.register(config.Option('foo', default_from_env=['FOO']))
3898
self.overrideEnv('FOO', '{bar}')
3899
self.assertEquals('baz', self.conf.get('foo', expand=True))
3901
def test_expand_default_on_failed_conversion(self):
3902
self.conf.store._load_from_string('baz=bogus\nbar=42\nfoo={baz}')
3903
self.registry.register(
3904
config.Option('foo', default=u'{bar}',
3905
from_unicode=config.int_from_store))
3906
self.assertEquals(42, self.conf.get('foo', expand=True))
3908
def test_env_adding_options(self):
3909
self.assertExpansion('bar', '{foo}', {'foo': 'bar'})
3911
def test_env_overriding_options(self):
3912
self.conf.store._load_from_string('foo=baz')
3913
self.assertExpansion('bar', '{foo}', {'foo': 'bar'})
3915
def test_simple_ref(self):
3916
self.conf.store._load_from_string('foo=xxx')
3917
self.assertExpansion('xxx', '{foo}')
3919
def test_unknown_ref(self):
3920
self.assertRaises(errors.ExpandingUnknownOption,
3921
self.conf.expand_options, '{foo}')
3923
def test_indirect_ref(self):
3924
self.conf.store._load_from_string('''
3928
self.assertExpansion('xxx', '{bar}')
3930
def test_embedded_ref(self):
3931
self.conf.store._load_from_string('''
3935
self.assertExpansion('xxx', '{{bar}}')
3937
def test_simple_loop(self):
3938
self.conf.store._load_from_string('foo={foo}')
3939
self.assertRaises(errors.OptionExpansionLoop,
3940
self.conf.expand_options, '{foo}')
3942
def test_indirect_loop(self):
3943
self.conf.store._load_from_string('''
3947
e = self.assertRaises(errors.OptionExpansionLoop,
3948
self.conf.expand_options, '{foo}')
3949
self.assertEquals('foo->bar->baz', e.refs)
3950
self.assertEquals('{foo}', e.string)
3952
def test_list(self):
3953
self.conf.store._load_from_string('''
3957
list={foo},{bar},{baz}
3959
self.registry.register(
3960
config.ListOption('list'))
3961
self.assertEquals(['start', 'middle', 'end'],
3962
self.conf.get('list', expand=True))
3964
def test_cascading_list(self):
3965
self.conf.store._load_from_string('''
3971
self.registry.register(config.ListOption('list'))
3972
# Register an intermediate option as a list to ensure no conversion
3973
# happen while expanding. Conversion should only occur for the original
3974
# option ('list' here).
3975
self.registry.register(config.ListOption('baz'))
3976
self.assertEquals(['start', 'middle', 'end'],
3977
self.conf.get('list', expand=True))
3979
def test_pathologically_hidden_list(self):
3980
self.conf.store._load_from_string('''
3986
hidden={start}{middle}{end}
3988
# What matters is what the registration says, the conversion happens
3989
# only after all expansions have been performed
3990
self.registry.register(config.ListOption('hidden'))
3991
self.assertEquals(['bin', 'go'],
3992
self.conf.get('hidden', expand=True))
3995
class TestStackCrossSectionsExpand(tests.TestCaseWithTransport):
3998
super(TestStackCrossSectionsExpand, self).setUp()
4000
def get_config(self, location, string):
4003
# Since we don't save the config we won't strictly require to inherit
4004
# from TestCaseInTempDir, but an error occurs so quickly...
4005
c = config.LocationStack(location)
4006
c.store._load_from_string(string)
4009
def test_dont_cross_unrelated_section(self):
4010
c = self.get_config('/another/branch/path','''
4015
[/another/branch/path]
4018
self.assertRaises(errors.ExpandingUnknownOption,
4019
c.get, 'bar', expand=True)
4021
def test_cross_related_sections(self):
4022
c = self.get_config('/project/branch/path','''
4026
[/project/branch/path]
4029
self.assertEquals('quux', c.get('bar', expand=True))
4032
class TestStackCrossStoresExpand(tests.TestCaseWithTransport):
4034
def test_cross_global_locations(self):
4035
l_store = config.LocationStore()
4036
l_store._load_from_string('''
4042
g_store = config.GlobalStore()
4043
g_store._load_from_string('''
4049
stack = config.LocationStack('/branch')
4050
self.assertEquals('glob-bar', stack.get('lbar', expand=True))
4051
self.assertEquals('loc-foo', stack.get('gfoo', expand=True))
4054
class TestStackExpandSectionLocals(tests.TestCaseWithTransport):
4056
def test_expand_locals_empty(self):
4057
l_store = config.LocationStore()
4058
l_store._load_from_string('''
4059
[/home/user/project]
4064
stack = config.LocationStack('/home/user/project/')
4065
self.assertEquals('', stack.get('base', expand=True))
4066
self.assertEquals('', stack.get('rel', expand=True))
4068
def test_expand_basename_locally(self):
4069
l_store = config.LocationStore()
4070
l_store._load_from_string('''
4071
[/home/user/project]
4075
stack = config.LocationStack('/home/user/project/branch')
4076
self.assertEquals('branch', stack.get('bfoo', expand=True))
4078
def test_expand_basename_locally_longer_path(self):
4079
l_store = config.LocationStore()
4080
l_store._load_from_string('''
4085
stack = config.LocationStack('/home/user/project/dir/branch')
4086
self.assertEquals('branch', stack.get('bfoo', expand=True))
4088
def test_expand_relpath_locally(self):
4089
l_store = config.LocationStore()
4090
l_store._load_from_string('''
4091
[/home/user/project]
4092
lfoo = loc-foo/{relpath}
4095
stack = config.LocationStack('/home/user/project/branch')
4096
self.assertEquals('loc-foo/branch', stack.get('lfoo', expand=True))
4098
def test_expand_relpath_unknonw_in_global(self):
4099
g_store = config.GlobalStore()
4100
g_store._load_from_string('''
4105
stack = config.LocationStack('/home/user/project/branch')
4106
self.assertRaises(errors.ExpandingUnknownOption,
4107
stack.get, 'gfoo', expand=True)
4109
def test_expand_local_option_locally(self):
4110
l_store = config.LocationStore()
4111
l_store._load_from_string('''
4112
[/home/user/project]
4113
lfoo = loc-foo/{relpath}
4117
g_store = config.GlobalStore()
4118
g_store._load_from_string('''
4124
stack = config.LocationStack('/home/user/project/branch')
4125
self.assertEquals('glob-bar', stack.get('lbar', expand=True))
4126
self.assertEquals('loc-foo/branch', stack.get('gfoo', expand=True))
4128
def test_locals_dont_leak(self):
4129
"""Make sure we chose the right local in presence of several sections.
4131
l_store = config.LocationStore()
4132
l_store._load_from_string('''
4134
lfoo = loc-foo/{relpath}
4135
[/home/user/project]
4136
lfoo = loc-foo/{relpath}
4139
stack = config.LocationStack('/home/user/project/branch')
4140
self.assertEquals('loc-foo/branch', stack.get('lfoo', expand=True))
4141
stack = config.LocationStack('/home/user/bar/baz')
4142
self.assertEquals('loc-foo/bar/baz', stack.get('lfoo', expand=True))
4146
class TestStackSet(TestStackWithTransport):
4148
def test_simple_set(self):
4149
conf = self.get_stack(self)
4150
self.assertEquals(None, conf.get('foo'))
4151
conf.set('foo', 'baz')
4152
# Did we get it back ?
4153
self.assertEquals('baz', conf.get('foo'))
4155
def test_set_creates_a_new_section(self):
4156
conf = self.get_stack(self)
4157
conf.set('foo', 'baz')
4158
self.assertEquals, 'baz', conf.get('foo')
4160
def test_set_hook(self):
4164
config.ConfigHooks.install_named_hook('set', hook, None)
4165
self.assertLength(0, calls)
4166
conf = self.get_stack(self)
4167
conf.set('foo', 'bar')
4168
self.assertLength(1, calls)
4169
self.assertEquals((conf, 'foo', 'bar'), calls[0])
4172
class TestStackRemove(TestStackWithTransport):
4174
def test_remove_existing(self):
4175
conf = self.get_stack(self)
4176
conf.set('foo', 'bar')
4177
self.assertEquals('bar', conf.get('foo'))
4179
# Did we get it back ?
4180
self.assertEquals(None, conf.get('foo'))
4182
def test_remove_unknown(self):
4183
conf = self.get_stack(self)
4184
self.assertRaises(KeyError, conf.remove, 'I_do_not_exist')
4186
def test_remove_hook(self):
4190
config.ConfigHooks.install_named_hook('remove', hook, None)
4191
self.assertLength(0, calls)
4192
conf = self.get_stack(self)
4193
conf.set('foo', 'bar')
4195
self.assertLength(1, calls)
4196
self.assertEquals((conf, 'foo'), calls[0])
4199
class TestConfigGetOptions(tests.TestCaseWithTransport, TestOptionsMixin):
4202
super(TestConfigGetOptions, self).setUp()
4203
create_configs(self)
4205
def test_no_variable(self):
4206
# Using branch should query branch, locations and bazaar
4207
self.assertOptions([], self.branch_config)
4209
def test_option_in_bazaar(self):
4210
self.bazaar_config.set_user_option('file', 'bazaar')
4211
self.assertOptions([('file', 'bazaar', 'DEFAULT', 'bazaar')],
4214
def test_option_in_locations(self):
4215
self.locations_config.set_user_option('file', 'locations')
4217
[('file', 'locations', self.tree.basedir, 'locations')],
4218
self.locations_config)
4220
def test_option_in_branch(self):
4221
self.branch_config.set_user_option('file', 'branch')
4222
self.assertOptions([('file', 'branch', 'DEFAULT', 'branch')],
4225
def test_option_in_bazaar_and_branch(self):
4226
self.bazaar_config.set_user_option('file', 'bazaar')
4227
self.branch_config.set_user_option('file', 'branch')
4228
self.assertOptions([('file', 'branch', 'DEFAULT', 'branch'),
4229
('file', 'bazaar', 'DEFAULT', 'bazaar'),],
4232
def test_option_in_branch_and_locations(self):
4233
# Hmm, locations override branch :-/
4234
self.locations_config.set_user_option('file', 'locations')
4235
self.branch_config.set_user_option('file', 'branch')
4237
[('file', 'locations', self.tree.basedir, 'locations'),
4238
('file', 'branch', 'DEFAULT', 'branch'),],
4241
def test_option_in_bazaar_locations_and_branch(self):
4242
self.bazaar_config.set_user_option('file', 'bazaar')
4243
self.locations_config.set_user_option('file', 'locations')
4244
self.branch_config.set_user_option('file', 'branch')
4246
[('file', 'locations', self.tree.basedir, 'locations'),
4247
('file', 'branch', 'DEFAULT', 'branch'),
4248
('file', 'bazaar', 'DEFAULT', 'bazaar'),],
4252
class TestConfigRemoveOption(tests.TestCaseWithTransport, TestOptionsMixin):
4255
super(TestConfigRemoveOption, self).setUp()
4256
create_configs_with_file_option(self)
4258
def test_remove_in_locations(self):
4259
self.locations_config.remove_user_option('file', self.tree.basedir)
4261
[('file', 'branch', 'DEFAULT', 'branch'),
4262
('file', 'bazaar', 'DEFAULT', 'bazaar'),],
4265
def test_remove_in_branch(self):
4266
self.branch_config.remove_user_option('file')
4268
[('file', 'locations', self.tree.basedir, 'locations'),
4269
('file', 'bazaar', 'DEFAULT', 'bazaar'),],
4272
def test_remove_in_bazaar(self):
4273
self.bazaar_config.remove_user_option('file')
4275
[('file', 'locations', self.tree.basedir, 'locations'),
4276
('file', 'branch', 'DEFAULT', 'branch'),],
4280
class TestConfigGetSections(tests.TestCaseWithTransport):
4283
super(TestConfigGetSections, self).setUp()
4284
create_configs(self)
4286
def assertSectionNames(self, expected, conf, name=None):
4287
"""Check which sections are returned for a given config.
4289
If fallback configurations exist their sections can be included.
4291
:param expected: A list of section names.
4293
:param conf: The configuration that will be queried.
4295
:param name: An optional section name that will be passed to
4298
sections = list(conf._get_sections(name))
4299
self.assertLength(len(expected), sections)
4300
self.assertEqual(expected, [name for name, _, _ in sections])
4302
def test_bazaar_default_section(self):
4303
self.assertSectionNames(['DEFAULT'], self.bazaar_config)
4305
def test_locations_default_section(self):
4306
# No sections are defined in an empty file
4307
self.assertSectionNames([], self.locations_config)
4309
def test_locations_named_section(self):
4310
self.locations_config.set_user_option('file', 'locations')
4311
self.assertSectionNames([self.tree.basedir], self.locations_config)
4313
def test_locations_matching_sections(self):
4314
loc_config = self.locations_config
4315
loc_config.set_user_option('file', 'locations')
4316
# We need to cheat a bit here to create an option in sections above and
4317
# below the 'location' one.
4318
parser = loc_config._get_parser()
4319
# locations.cong deals with '/' ignoring native os.sep
4320
location_names = self.tree.basedir.split('/')
4321
parent = '/'.join(location_names[:-1])
4322
child = '/'.join(location_names + ['child'])
4324
parser[parent]['file'] = 'parent'
4326
parser[child]['file'] = 'child'
4327
self.assertSectionNames([self.tree.basedir, parent], loc_config)
4329
def test_branch_data_default_section(self):
4330
self.assertSectionNames([None],
4331
self.branch_config._get_branch_data_config())
4333
def test_branch_default_sections(self):
4334
# No sections are defined in an empty locations file
4335
self.assertSectionNames([None, 'DEFAULT'],
4337
# Unless we define an option
4338
self.branch_config._get_location_config().set_user_option(
4339
'file', 'locations')
4340
self.assertSectionNames([self.tree.basedir, None, 'DEFAULT'],
4343
def test_bazaar_named_section(self):
4344
# We need to cheat as the API doesn't give direct access to sections
4345
# other than DEFAULT.
4346
self.bazaar_config.set_alias('bazaar', 'bzr')
4347
self.assertSectionNames(['ALIASES'], self.bazaar_config, 'ALIASES')
4350
class TestAuthenticationConfigFile(tests.TestCase):
4351
"""Test the authentication.conf file matching"""
4353
def _got_user_passwd(self, expected_user, expected_password,
4354
config, *args, **kwargs):
4355
credentials = config.get_credentials(*args, **kwargs)
4356
if credentials is None:
4360
user = credentials['user']
4361
password = credentials['password']
4362
self.assertEquals(expected_user, user)
4363
self.assertEquals(expected_password, password)
4365
def test_empty_config(self):
4366
conf = config.AuthenticationConfig(_file=StringIO())
4367
self.assertEquals({}, conf._get_config())
4368
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
4370
def test_non_utf8_config(self):
4371
conf = config.AuthenticationConfig(_file=StringIO(
4373
self.assertRaises(errors.ConfigContentError, conf._get_config)
4375
def test_missing_auth_section_header(self):
4376
conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
4377
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
4379
def test_auth_section_header_not_closed(self):
4380
conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
4381
self.assertRaises(errors.ParseConfigError, conf._get_config)
4383
def test_auth_value_not_boolean(self):
4384
conf = config.AuthenticationConfig(_file=StringIO(
4388
verify_certificates=askme # Error: Not a boolean
4390
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
4392
def test_auth_value_not_int(self):
4393
conf = config.AuthenticationConfig(_file=StringIO(
4397
port=port # Error: Not an int
4399
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
4401
def test_unknown_password_encoding(self):
4402
conf = config.AuthenticationConfig(_file=StringIO(
4406
password_encoding=unknown
4408
self.assertRaises(ValueError, conf.get_password,
4409
'ftp', 'foo.net', 'joe')
4411
def test_credentials_for_scheme_host(self):
4412
conf = config.AuthenticationConfig(_file=StringIO(
4413
"""# Identity on foo.net
4418
password=secret-pass
4421
self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
4423
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
4425
self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
4427
def test_credentials_for_host_port(self):
4428
conf = config.AuthenticationConfig(_file=StringIO(
4429
"""# Identity on foo.net
4435
password=secret-pass
4438
self._got_user_passwd('joe', 'secret-pass',
4439
conf, 'ftp', 'foo.net', port=10021)
4441
self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
4443
def test_for_matching_host(self):
4444
conf = config.AuthenticationConfig(_file=StringIO(
4445
"""# Identity on foo.net
4451
[sourceforge domain]
4458
self._got_user_passwd('georges', 'bendover',
4459
conf, 'bzr', 'foo.bzr.sf.net')
4461
self._got_user_passwd(None, None,
4462
conf, 'bzr', 'bbzr.sf.net')
4464
def test_for_matching_host_None(self):
4465
conf = config.AuthenticationConfig(_file=StringIO(
4466
"""# Identity on foo.net
4476
self._got_user_passwd('joe', 'joepass',
4477
conf, 'bzr', 'quux.net')
4478
# no host but different scheme
4479
self._got_user_passwd('georges', 'bendover',
4480
conf, 'ftp', 'quux.net')
4482
def test_credentials_for_path(self):
4483
conf = config.AuthenticationConfig(_file=StringIO(
4499
self._got_user_passwd(None, None,
4500
conf, 'http', host='bar.org', path='/dir3')
4502
self._got_user_passwd('georges', 'bendover',
4503
conf, 'http', host='bar.org', path='/dir2')
4505
self._got_user_passwd('jim', 'jimpass',
4506
conf, 'http', host='bar.org',path='/dir1/subdir')
4508
def test_credentials_for_user(self):
4509
conf = config.AuthenticationConfig(_file=StringIO(
4518
self._got_user_passwd('jim', 'jimpass',
4519
conf, 'http', 'bar.org')
4521
self._got_user_passwd('jim', 'jimpass',
4522
conf, 'http', 'bar.org', user='jim')
4523
# Don't get a different user if one is specified
4524
self._got_user_passwd(None, None,
4525
conf, 'http', 'bar.org', user='georges')
4527
def test_credentials_for_user_without_password(self):
4528
conf = config.AuthenticationConfig(_file=StringIO(
4535
# Get user but no password
4536
self._got_user_passwd('jim', None,
4537
conf, 'http', 'bar.org')
4539
def test_verify_certificates(self):
4540
conf = config.AuthenticationConfig(_file=StringIO(
4547
verify_certificates=False
4554
credentials = conf.get_credentials('https', 'bar.org')
4555
self.assertEquals(False, credentials.get('verify_certificates'))
4556
credentials = conf.get_credentials('https', 'foo.net')
4557
self.assertEquals(True, credentials.get('verify_certificates'))
4560
class TestAuthenticationStorage(tests.TestCaseInTempDir):
4562
def test_set_credentials(self):
4563
conf = config.AuthenticationConfig()
4564
conf.set_credentials('name', 'host', 'user', 'scheme', 'password',
4565
99, path='/foo', verify_certificates=False, realm='realm')
4566
credentials = conf.get_credentials(host='host', scheme='scheme',
4567
port=99, path='/foo',
4569
CREDENTIALS = {'name': 'name', 'user': 'user', 'password': 'password',
4570
'verify_certificates': False, 'scheme': 'scheme',
4571
'host': 'host', 'port': 99, 'path': '/foo',
4573
self.assertEqual(CREDENTIALS, credentials)
4574
credentials_from_disk = config.AuthenticationConfig().get_credentials(
4575
host='host', scheme='scheme', port=99, path='/foo', realm='realm')
4576
self.assertEqual(CREDENTIALS, credentials_from_disk)
4578
def test_reset_credentials_different_name(self):
4579
conf = config.AuthenticationConfig()
4580
conf.set_credentials('name', 'host', 'user', 'scheme', 'password'),
4581
conf.set_credentials('name2', 'host', 'user2', 'scheme', 'password'),
4582
self.assertIs(None, conf._get_config().get('name'))
4583
credentials = conf.get_credentials(host='host', scheme='scheme')
4584
CREDENTIALS = {'name': 'name2', 'user': 'user2', 'password':
4585
'password', 'verify_certificates': True,
4586
'scheme': 'scheme', 'host': 'host', 'port': None,
4587
'path': None, 'realm': None}
4588
self.assertEqual(CREDENTIALS, credentials)
4591
class TestAuthenticationConfig(tests.TestCase):
4592
"""Test AuthenticationConfig behaviour"""
4594
def _check_default_password_prompt(self, expected_prompt_format, scheme,
4595
host=None, port=None, realm=None,
4599
user, password = 'jim', 'precious'
4600
expected_prompt = expected_prompt_format % {
4601
'scheme': scheme, 'host': host, 'port': port,
4602
'user': user, 'realm': realm}
4604
stdout = tests.StringIOWrapper()
4605
stderr = tests.StringIOWrapper()
4606
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
4607
stdout=stdout, stderr=stderr)
4608
# We use an empty conf so that the user is always prompted
4609
conf = config.AuthenticationConfig()
4610
self.assertEquals(password,
4611
conf.get_password(scheme, host, user, port=port,
4612
realm=realm, path=path))
4613
self.assertEquals(expected_prompt, stderr.getvalue())
4614
self.assertEquals('', stdout.getvalue())
4616
def _check_default_username_prompt(self, expected_prompt_format, scheme,
4617
host=None, port=None, realm=None,
4622
expected_prompt = expected_prompt_format % {
4623
'scheme': scheme, 'host': host, 'port': port,
4625
stdout = tests.StringIOWrapper()
4626
stderr = tests.StringIOWrapper()
4627
ui.ui_factory = tests.TestUIFactory(stdin=username+ '\n',
4628
stdout=stdout, stderr=stderr)
4629
# We use an empty conf so that the user is always prompted
4630
conf = config.AuthenticationConfig()
4631
self.assertEquals(username, conf.get_user(scheme, host, port=port,
4632
realm=realm, path=path, ask=True))
4633
self.assertEquals(expected_prompt, stderr.getvalue())
4634
self.assertEquals('', stdout.getvalue())
4636
def test_username_defaults_prompts(self):
4637
# HTTP prompts can't be tested here, see test_http.py
4638
self._check_default_username_prompt(u'FTP %(host)s username: ', 'ftp')
4639
self._check_default_username_prompt(
4640
u'FTP %(host)s:%(port)d username: ', 'ftp', port=10020)
4641
self._check_default_username_prompt(
4642
u'SSH %(host)s:%(port)d username: ', 'ssh', port=12345)
4644
def test_username_default_no_prompt(self):
4645
conf = config.AuthenticationConfig()
4646
self.assertEquals(None,
4647
conf.get_user('ftp', 'example.com'))
4648
self.assertEquals("explicitdefault",
4649
conf.get_user('ftp', 'example.com', default="explicitdefault"))
4651
def test_password_default_prompts(self):
4652
# HTTP prompts can't be tested here, see test_http.py
4653
self._check_default_password_prompt(
4654
u'FTP %(user)s@%(host)s password: ', 'ftp')
4655
self._check_default_password_prompt(
4656
u'FTP %(user)s@%(host)s:%(port)d password: ', 'ftp', port=10020)
4657
self._check_default_password_prompt(
4658
u'SSH %(user)s@%(host)s:%(port)d password: ', 'ssh', port=12345)
4659
# SMTP port handling is a bit special (it's handled if embedded in the
4661
# FIXME: should we: forbid that, extend it to other schemes, leave
4662
# things as they are that's fine thank you ?
4663
self._check_default_password_prompt(
4664
u'SMTP %(user)s@%(host)s password: ', 'smtp')
4665
self._check_default_password_prompt(
4666
u'SMTP %(user)s@%(host)s password: ', 'smtp', host='bar.org:10025')
4667
self._check_default_password_prompt(
4668
u'SMTP %(user)s@%(host)s:%(port)d password: ', 'smtp', port=10025)
4670
def test_ssh_password_emits_warning(self):
4671
conf = config.AuthenticationConfig(_file=StringIO(
4679
entered_password = 'typed-by-hand'
4680
stdout = tests.StringIOWrapper()
4681
stderr = tests.StringIOWrapper()
4682
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
4683
stdout=stdout, stderr=stderr)
4685
# Since the password defined in the authentication config is ignored,
4686
# the user is prompted
4687
self.assertEquals(entered_password,
4688
conf.get_password('ssh', 'bar.org', user='jim'))
4689
self.assertContainsRe(
4691
'password ignored in section \[ssh with password\]')
4693
def test_ssh_without_password_doesnt_emit_warning(self):
4694
conf = config.AuthenticationConfig(_file=StringIO(
4701
entered_password = 'typed-by-hand'
4702
stdout = tests.StringIOWrapper()
4703
stderr = tests.StringIOWrapper()
4704
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
4708
# Since the password defined in the authentication config is ignored,
4709
# the user is prompted
4710
self.assertEquals(entered_password,
4711
conf.get_password('ssh', 'bar.org', user='jim'))
4712
# No warning shoud be emitted since there is no password. We are only
4714
self.assertNotContainsRe(
4716
'password ignored in section \[ssh with password\]')
4718
def test_uses_fallback_stores(self):
4719
self.overrideAttr(config, 'credential_store_registry',
4720
config.CredentialStoreRegistry())
4721
store = StubCredentialStore()
4722
store.add_credentials("http", "example.com", "joe", "secret")
4723
config.credential_store_registry.register("stub", store, fallback=True)
4724
conf = config.AuthenticationConfig(_file=StringIO())
4725
creds = conf.get_credentials("http", "example.com")
4726
self.assertEquals("joe", creds["user"])
4727
self.assertEquals("secret", creds["password"])
4730
class StubCredentialStore(config.CredentialStore):
4736
def add_credentials(self, scheme, host, user, password=None):
4737
self._username[(scheme, host)] = user
4738
self._password[(scheme, host)] = password
4740
def get_credentials(self, scheme, host, port=None, user=None,
4741
path=None, realm=None):
4742
key = (scheme, host)
4743
if not key in self._username:
4745
return { "scheme": scheme, "host": host, "port": port,
4746
"user": self._username[key], "password": self._password[key]}
4749
class CountingCredentialStore(config.CredentialStore):
4754
def get_credentials(self, scheme, host, port=None, user=None,
4755
path=None, realm=None):
4760
class TestCredentialStoreRegistry(tests.TestCase):
4762
def _get_cs_registry(self):
4763
return config.credential_store_registry
4765
def test_default_credential_store(self):
4766
r = self._get_cs_registry()
4767
default = r.get_credential_store(None)
4768
self.assertIsInstance(default, config.PlainTextCredentialStore)
4770
def test_unknown_credential_store(self):
4771
r = self._get_cs_registry()
4772
# It's hard to imagine someone creating a credential store named
4773
# 'unknown' so we use that as an never registered key.
4774
self.assertRaises(KeyError, r.get_credential_store, 'unknown')
4776
def test_fallback_none_registered(self):
4777
r = config.CredentialStoreRegistry()
4778
self.assertEquals(None,
4779
r.get_fallback_credentials("http", "example.com"))
4781
def test_register(self):
4782
r = config.CredentialStoreRegistry()
4783
r.register("stub", StubCredentialStore(), fallback=False)
4784
r.register("another", StubCredentialStore(), fallback=True)
4785
self.assertEquals(["another", "stub"], r.keys())
4787
def test_register_lazy(self):
4788
r = config.CredentialStoreRegistry()
4789
r.register_lazy("stub", "bzrlib.tests.test_config",
4790
"StubCredentialStore", fallback=False)
4791
self.assertEquals(["stub"], r.keys())
4792
self.assertIsInstance(r.get_credential_store("stub"),
4793
StubCredentialStore)
4795
def test_is_fallback(self):
4796
r = config.CredentialStoreRegistry()
4797
r.register("stub1", None, fallback=False)
4798
r.register("stub2", None, fallback=True)
4799
self.assertEquals(False, r.is_fallback("stub1"))
4800
self.assertEquals(True, r.is_fallback("stub2"))
4802
def test_no_fallback(self):
4803
r = config.CredentialStoreRegistry()
4804
store = CountingCredentialStore()
4805
r.register("count", store, fallback=False)
4806
self.assertEquals(None,
4807
r.get_fallback_credentials("http", "example.com"))
4808
self.assertEquals(0, store._calls)
4810
def test_fallback_credentials(self):
4811
r = config.CredentialStoreRegistry()
4812
store = StubCredentialStore()
4813
store.add_credentials("http", "example.com",
4814
"somebody", "geheim")
4815
r.register("stub", store, fallback=True)
4816
creds = r.get_fallback_credentials("http", "example.com")
4817
self.assertEquals("somebody", creds["user"])
4818
self.assertEquals("geheim", creds["password"])
4820
def test_fallback_first_wins(self):
4821
r = config.CredentialStoreRegistry()
4822
stub1 = StubCredentialStore()
4823
stub1.add_credentials("http", "example.com",
4824
"somebody", "stub1")
4825
r.register("stub1", stub1, fallback=True)
4826
stub2 = StubCredentialStore()
4827
stub2.add_credentials("http", "example.com",
4828
"somebody", "stub2")
4829
r.register("stub2", stub1, fallback=True)
4830
creds = r.get_fallback_credentials("http", "example.com")
4831
self.assertEquals("somebody", creds["user"])
4832
self.assertEquals("stub1", creds["password"])
4835
class TestPlainTextCredentialStore(tests.TestCase):
4837
def test_decode_password(self):
4838
r = config.credential_store_registry
4839
plain_text = r.get_credential_store()
4840
decoded = plain_text.decode_password(dict(password='secret'))
4841
self.assertEquals('secret', decoded)
4844
class TestBase64CredentialStore(tests.TestCase):
4846
def test_decode_password(self):
4847
r = config.credential_store_registry
4848
plain_text = r.get_credential_store('base64')
4849
decoded = plain_text.decode_password(dict(password='c2VjcmV0'))
4850
self.assertEquals('secret', decoded)
4853
# FIXME: Once we have a way to declare authentication to all test servers, we
4854
# can implement generic tests.
4855
# test_user_password_in_url
4856
# test_user_in_url_password_from_config
4857
# test_user_in_url_password_prompted
4858
# test_user_in_config
4859
# test_user_getpass.getuser
4860
# test_user_prompted ?
4861
class TestAuthenticationRing(tests.TestCaseWithTransport):
4865
class TestAutoUserId(tests.TestCase):
4866
"""Test inferring an automatic user name."""
4868
def test_auto_user_id(self):
4869
"""Automatic inference of user name.
4871
This is a bit hard to test in an isolated way, because it depends on
4872
system functions that go direct to /etc or perhaps somewhere else.
4873
But it's reasonable to say that on Unix, with an /etc/mailname, we ought
4874
to be able to choose a user name with no configuration.
4876
if sys.platform == 'win32':
4877
raise tests.TestSkipped(
4878
"User name inference not implemented on win32")
4879
realname, address = config._auto_user_id()
4880
if os.path.exists('/etc/mailname'):
4881
self.assertIsNot(None, realname)
4882
self.assertIsNot(None, address)
4884
self.assertEquals((None, None), (realname, address))
4887
class TestDefaultMailDomain(tests.TestCaseInTempDir):
4888
"""Test retrieving default domain from mailname file"""
4890
def test_default_mail_domain_simple(self):
4891
f = file('simple', 'w')
4893
f.write("domainname.com\n")
4896
r = config._get_default_mail_domain('simple')
4897
self.assertEquals('domainname.com', r)
4899
def test_default_mail_domain_no_eol(self):
4900
f = file('no_eol', 'w')
4902
f.write("domainname.com")
4905
r = config._get_default_mail_domain('no_eol')
4906
self.assertEquals('domainname.com', r)
4908
def test_default_mail_domain_multiple_lines(self):
4909
f = file('multiple_lines', 'w')
4911
f.write("domainname.com\nsome other text\n")
4914
r = config._get_default_mail_domain('multiple_lines')
4915
self.assertEquals('domainname.com', r)
4918
class EmailOptionTests(tests.TestCase):
4920
def test_default_email_uses_BZR_EMAIL(self):
4921
conf = config.MemoryStack('email=jelmer@debian.org')
4922
# BZR_EMAIL takes precedence over EMAIL
4923
self.overrideEnv('BZR_EMAIL', 'jelmer@samba.org')
4924
self.overrideEnv('EMAIL', 'jelmer@apache.org')
4925
self.assertEquals('jelmer@samba.org', conf.get('email'))
4927
def test_default_email_uses_EMAIL(self):
4928
conf = config.MemoryStack('')
4929
self.overrideEnv('BZR_EMAIL', None)
4930
self.overrideEnv('EMAIL', 'jelmer@apache.org')
4931
self.assertEquals('jelmer@apache.org', conf.get('email'))
4933
def test_BZR_EMAIL_overrides(self):
4934
conf = config.MemoryStack('email=jelmer@debian.org')
4935
self.overrideEnv('BZR_EMAIL', 'jelmer@apache.org')
4936
self.assertEquals('jelmer@apache.org', conf.get('email'))
4937
self.overrideEnv('BZR_EMAIL', None)
4938
self.overrideEnv('EMAIL', 'jelmer@samba.org')
4939
self.assertEquals('jelmer@debian.org', conf.get('email'))
4942
class MailClientOptionTests(tests.TestCase):
4944
def test_default(self):
4945
conf = config.MemoryStack('')
4946
client = conf.get('mail_client')
4947
self.assertIs(client, mail_client.DefaultMail)
4949
def test_evolution(self):
4950
conf = config.MemoryStack('mail_client=evolution')
4951
client = conf.get('mail_client')
4952
self.assertIs(client, mail_client.Evolution)
4954
def test_kmail(self):
4955
conf = config.MemoryStack('mail_client=kmail')
4956
client = conf.get('mail_client')
4957
self.assertIs(client, mail_client.KMail)
4959
def test_mutt(self):
4960
conf = config.MemoryStack('mail_client=mutt')
4961
client = conf.get('mail_client')
4962
self.assertIs(client, mail_client.Mutt)
4964
def test_thunderbird(self):
4965
conf = config.MemoryStack('mail_client=thunderbird')
4966
client = conf.get('mail_client')
4967
self.assertIs(client, mail_client.Thunderbird)
4969
def test_explicit_default(self):
4970
conf = config.MemoryStack('mail_client=default')
4971
client = conf.get('mail_client')
4972
self.assertIs(client, mail_client.DefaultMail)
4974
def test_editor(self):
4975
conf = config.MemoryStack('mail_client=editor')
4976
client = conf.get('mail_client')
4977
self.assertIs(client, mail_client.Editor)
4979
def test_mapi(self):
4980
conf = config.MemoryStack('mail_client=mapi')
4981
client = conf.get('mail_client')
4982
self.assertIs(client, mail_client.MAPIClient)
4984
def test_xdg_email(self):
4985
conf = config.MemoryStack('mail_client=xdg-email')
4986
client = conf.get('mail_client')
4987
self.assertIs(client, mail_client.XDGEmail)
4989
def test_unknown(self):
4990
conf = config.MemoryStack('mail_client=firebird')
4991
self.assertRaises(errors.ConfigOptionValueError, conf.get,
added
removed
bzrlib/tests/test_config.py
