/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-19 19:15:58 UTC
  • mfrom: (6388 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6404.
  • Revision ID: jelmer@canonical.com-20111219191558-p1k7cvhjq8l6v2gm
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
328
328
 
329
329
class FakeBranch(object):
330
330
 
331
 
    def __init__(self, base=None, user_id=None):
 
331
    def __init__(self, base=None):
332
332
        if base is None:
333
333
            self.base = "http://example.com/branches/demo"
334
334
        else:
335
335
            self.base = base
336
336
        self._transport = self.control_files = \
337
 
            FakeControlFilesAndTransport(user_id=user_id)
 
337
            FakeControlFilesAndTransport()
338
338
 
339
339
    def _get_config(self):
340
340
        return config.TransportConfig(self._transport, 'branch.conf')
348
348
 
349
349
class FakeControlFilesAndTransport(object):
350
350
 
351
 
    def __init__(self, user_id=None):
 
351
    def __init__(self):
352
352
        self.files = {}
353
 
        if user_id:
354
 
            self.files['email'] = user_id
355
353
        self._transport = self
356
354
 
357
 
    def get_utf8(self, filename):
358
 
        # from LockableFiles
359
 
        raise AssertionError("get_utf8 should no longer be used")
360
 
 
361
355
    def get(self, filename):
362
356
        # from Transport
363
357
        try:
500
494
 
501
495
    def test_signatures_default(self):
502
496
        my_config = config.Config()
503
 
        self.assertFalse(my_config.signature_needed())
 
497
        self.assertFalse(
 
498
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
499
                my_config.signature_needed))
504
500
        self.assertEqual(config.CHECK_IF_POSSIBLE,
505
 
                         my_config.signature_checking())
 
501
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
502
                my_config.signature_checking))
506
503
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
507
 
                         my_config.signing_policy())
 
504
                self.applyDeprecated(deprecated_in((2, 5, 0)),
 
505
                    my_config.signing_policy))
508
506
 
509
507
    def test_signatures_template_method(self):
510
508
        my_config = InstrumentedConfig()
511
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
 
509
        self.assertEqual(config.CHECK_NEVER,
 
510
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
511
                my_config.signature_checking))
512
512
        self.assertEqual(['_get_signature_checking'], my_config._calls)
513
513
 
514
514
    def test_signatures_template_method_none(self):
515
515
        my_config = InstrumentedConfig()
516
516
        my_config._signatures = None
517
517
        self.assertEqual(config.CHECK_IF_POSSIBLE,
518
 
                         my_config.signature_checking())
 
518
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
519
                             my_config.signature_checking))
519
520
        self.assertEqual(['_get_signature_checking'], my_config._calls)
520
521
 
521
522
    def test_gpg_signing_command_default(self):
522
523
        my_config = config.Config()
523
 
        self.assertEqual('gpg', my_config.gpg_signing_command())
 
524
        self.assertEqual('gpg',
 
525
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
526
                my_config.gpg_signing_command))
524
527
 
525
528
    def test_get_user_option_default(self):
526
529
        my_config = config.Config()
528
531
 
529
532
    def test_post_commit_default(self):
530
533
        my_config = config.Config()
531
 
        self.assertEqual(None, my_config.post_commit())
 
534
        self.assertEqual(None, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
535
                                                    my_config.post_commit))
 
536
 
532
537
 
533
538
    def test_log_format_default(self):
534
539
        my_config = config.Config()
535
 
        self.assertEqual('long', my_config.log_format())
 
540
        self.assertEqual('long',
 
541
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
542
                                              my_config.log_format))
536
543
 
537
544
    def test_acceptable_keys_default(self):
538
545
        my_config = config.Config()
539
 
        self.assertEqual(None, my_config.acceptable_keys())
 
546
        self.assertEqual(None, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
547
            my_config.acceptable_keys))
540
548
 
541
549
    def test_validate_signatures_in_log_default(self):
542
550
        my_config = config.Config()
1063
1071
si_g = 5g,
1064
1072
si_gb = 5gB,
1065
1073
""")
1066
 
        get_si = conf.get_user_option_as_int_from_SI
 
1074
        def get_si(s, default=None):
 
1075
            return self.applyDeprecated(
 
1076
                deprecated_in((2, 5, 0)),
 
1077
                conf.get_user_option_as_int_from_SI, s, default)
1067
1078
        self.assertEqual(100, get_si('plain'))
1068
1079
        self.assertEqual(5000, get_si('si_k'))
1069
1080
        self.assertEqual(5000, get_si('si_kb'))
1074
1085
        self.assertEqual(None, get_si('non-exist'))
1075
1086
        self.assertEqual(42, get_si('non-exist-with-default',  42))
1076
1087
 
 
1088
 
1077
1089
class TestSupressWarning(TestIniConfig):
1078
1090
 
1079
1091
    def make_warnings_config(self, s):
1235
1247
    def test_signatures_always(self):
1236
1248
        my_config = config.GlobalConfig.from_string(sample_always_signatures)
1237
1249
        self.assertEqual(config.CHECK_NEVER,
1238
 
                         my_config.signature_checking())
 
1250
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1251
                             my_config.signature_checking))
1239
1252
        self.assertEqual(config.SIGN_ALWAYS,
1240
 
                         my_config.signing_policy())
1241
 
        self.assertEqual(True, my_config.signature_needed())
 
1253
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1254
                             my_config.signing_policy))
 
1255
        self.assertEqual(True,
 
1256
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1257
                my_config.signature_needed))
1242
1258
 
1243
1259
    def test_signatures_if_possible(self):
1244
1260
        my_config = config.GlobalConfig.from_string(sample_maybe_signatures)
1245
1261
        self.assertEqual(config.CHECK_NEVER,
1246
 
                         my_config.signature_checking())
 
1262
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1263
                             my_config.signature_checking))
1247
1264
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
1248
 
                         my_config.signing_policy())
1249
 
        self.assertEqual(False, my_config.signature_needed())
 
1265
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1266
                             my_config.signing_policy))
 
1267
        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1268
            my_config.signature_needed))
1250
1269
 
1251
1270
    def test_signatures_ignore(self):
1252
1271
        my_config = config.GlobalConfig.from_string(sample_ignore_signatures)
1253
1272
        self.assertEqual(config.CHECK_ALWAYS,
1254
 
                         my_config.signature_checking())
 
1273
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1274
                             my_config.signature_checking))
1255
1275
        self.assertEqual(config.SIGN_NEVER,
1256
 
                         my_config.signing_policy())
1257
 
        self.assertEqual(False, my_config.signature_needed())
 
1276
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1277
                             my_config.signing_policy))
 
1278
        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1279
            my_config.signature_needed))
1258
1280
 
1259
1281
    def _get_sample_config(self):
1260
1282
        my_config = config.GlobalConfig.from_string(sample_config_text)
1262
1284
 
1263
1285
    def test_gpg_signing_command(self):
1264
1286
        my_config = self._get_sample_config()
1265
 
        self.assertEqual("gnome-gpg", my_config.gpg_signing_command())
1266
 
        self.assertEqual(False, my_config.signature_needed())
 
1287
        self.assertEqual("gnome-gpg",
 
1288
            self.applyDeprecated(
 
1289
                deprecated_in((2, 5, 0)), my_config.gpg_signing_command))
 
1290
        self.assertEqual(False, self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1291
            my_config.signature_needed))
1267
1292
 
1268
1293
    def test_gpg_signing_key(self):
1269
1294
        my_config = self._get_sample_config()
1270
 
        self.assertEqual("DD4D5088", my_config.gpg_signing_key())
 
1295
        self.assertEqual("DD4D5088",
 
1296
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1297
                my_config.gpg_signing_key))
1271
1298
 
1272
1299
    def _get_empty_config(self):
1273
1300
        my_config = config.GlobalConfig()
1275
1302
 
1276
1303
    def test_gpg_signing_command_unset(self):
1277
1304
        my_config = self._get_empty_config()
1278
 
        self.assertEqual("gpg", my_config.gpg_signing_command())
 
1305
        self.assertEqual("gpg",
 
1306
            self.applyDeprecated(
 
1307
                deprecated_in((2, 5, 0)), my_config.gpg_signing_command))
1279
1308
 
1280
1309
    def test_get_user_option_default(self):
1281
1310
        my_config = self._get_empty_config()
1288
1317
 
1289
1318
    def test_post_commit_default(self):
1290
1319
        my_config = self._get_sample_config()
1291
 
        self.assertEqual(None, my_config.post_commit())
 
1320
        self.assertEqual(None,
 
1321
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1322
                                              my_config.post_commit))
1292
1323
 
1293
1324
    def test_configured_logformat(self):
1294
1325
        my_config = self._get_sample_config()
1295
 
        self.assertEqual("short", my_config.log_format())
 
1326
        self.assertEqual("short",
 
1327
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1328
                                              my_config.log_format))
1296
1329
 
1297
1330
    def test_configured_acceptable_keys(self):
1298
1331
        my_config = self._get_sample_config()
1299
 
        self.assertEqual("amy", my_config.acceptable_keys())
 
1332
        self.assertEqual("amy",
 
1333
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1334
                my_config.acceptable_keys))
1300
1335
 
1301
1336
    def test_configured_validate_signatures_in_log(self):
1302
1337
        my_config = self._get_sample_config()
1538
1573
        self.get_branch_config('http://www.example.com',
1539
1574
                                 global_config=sample_ignore_signatures)
1540
1575
        self.assertEqual(config.CHECK_ALWAYS,
1541
 
                         self.my_config.signature_checking())
 
1576
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1577
                             self.my_config.signature_checking))
1542
1578
        self.assertEqual(config.SIGN_NEVER,
1543
 
                         self.my_config.signing_policy())
 
1579
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1580
                             self.my_config.signing_policy))
1544
1581
 
1545
1582
    def test_signatures_never(self):
1546
1583
        self.get_branch_config('/a/c')
1547
1584
        self.assertEqual(config.CHECK_NEVER,
1548
 
                         self.my_config.signature_checking())
 
1585
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1586
                             self.my_config.signature_checking))
1549
1587
 
1550
1588
    def test_signatures_when_available(self):
1551
1589
        self.get_branch_config('/a/', global_config=sample_ignore_signatures)
1552
1590
        self.assertEqual(config.CHECK_IF_POSSIBLE,
1553
 
                         self.my_config.signature_checking())
 
1591
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1592
                             self.my_config.signature_checking))
1554
1593
 
1555
1594
    def test_signatures_always(self):
1556
1595
        self.get_branch_config('/b')
1557
1596
        self.assertEqual(config.CHECK_ALWAYS,
1558
 
                         self.my_config.signature_checking())
 
1597
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1598
                         self.my_config.signature_checking))
1559
1599
 
1560
1600
    def test_gpg_signing_command(self):
1561
1601
        self.get_branch_config('/b')
1562
 
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
 
1602
        self.assertEqual("gnome-gpg",
 
1603
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1604
                self.my_config.gpg_signing_command))
1563
1605
 
1564
1606
    def test_gpg_signing_command_missing(self):
1565
1607
        self.get_branch_config('/a')
1566
 
        self.assertEqual("false", self.my_config.gpg_signing_command())
 
1608
        self.assertEqual("false",
 
1609
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1610
                self.my_config.gpg_signing_command))
1567
1611
 
1568
1612
    def test_gpg_signing_key(self):
1569
1613
        self.get_branch_config('/b')
1570
 
        self.assertEqual("DD4D5088", self.my_config.gpg_signing_key())
 
1614
        self.assertEqual("DD4D5088", self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1615
            self.my_config.gpg_signing_key))
1571
1616
 
1572
1617
    def test_gpg_signing_key_default(self):
1573
1618
        self.get_branch_config('/a')
1574
 
        self.assertEqual("erik@bagfors.nu", self.my_config.gpg_signing_key())
 
1619
        self.assertEqual("erik@bagfors.nu",
 
1620
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1621
                self.my_config.gpg_signing_key))
1575
1622
 
1576
1623
    def test_get_user_option_global(self):
1577
1624
        self.get_branch_config('/a')
1665
1712
    def test_post_commit_default(self):
1666
1713
        self.get_branch_config('/a/c')
1667
1714
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1668
 
                         self.my_config.post_commit())
 
1715
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1716
                                              self.my_config.post_commit))
1669
1717
 
1670
1718
    def get_branch_config(self, location, global_config=None,
1671
1719
                          location_config=None):
1761
1809
        return my_config
1762
1810
 
1763
1811
    def test_user_id(self):
1764
 
        branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
 
1812
        branch = FakeBranch()
1765
1813
        my_config = config.BranchConfig(branch)
1766
 
        self.assertEqual("Robert Collins <robertc@example.net>",
1767
 
                         my_config.username())
 
1814
        self.assertIsNot(None, my_config.username())
1768
1815
        my_config.branch.control_files.files['email'] = "John"
1769
1816
        my_config.set_user_option('email',
1770
1817
                                  "Robert Collins <robertc@example.org>")
1771
 
        self.assertEqual("John", my_config.username())
1772
 
        del my_config.branch.control_files.files['email']
1773
1818
        self.assertEqual("Robert Collins <robertc@example.org>",
1774
 
                         my_config.username())
1775
 
 
1776
 
    def test_not_set_in_branch(self):
1777
 
        my_config = self.get_branch_config(global_config=sample_config_text)
1778
 
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1779
 
                         my_config._get_user_id())
1780
 
        my_config.branch.control_files.files['email'] = "John"
1781
 
        self.assertEqual("John", my_config._get_user_id())
 
1819
                        my_config.username())
1782
1820
 
1783
1821
    def test_BZR_EMAIL_OVERRIDES(self):
1784
1822
        self.overrideEnv('BZR_EMAIL', "Robert Collins <robertc@example.org>")
1790
1828
    def test_signatures_forced(self):
1791
1829
        my_config = self.get_branch_config(
1792
1830
            global_config=sample_always_signatures)
1793
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1794
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1795
 
        self.assertTrue(my_config.signature_needed())
 
1831
        self.assertEqual(config.CHECK_NEVER,
 
1832
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1833
                my_config.signature_checking))
 
1834
        self.assertEqual(config.SIGN_ALWAYS,
 
1835
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1836
                my_config.signing_policy))
 
1837
        self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1838
            my_config.signature_needed))
1796
1839
 
1797
1840
    def test_signatures_forced_branch(self):
1798
1841
        my_config = self.get_branch_config(
1799
1842
            global_config=sample_ignore_signatures,
1800
1843
            branch_data_config=sample_always_signatures)
1801
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1802
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1803
 
        self.assertTrue(my_config.signature_needed())
 
1844
        self.assertEqual(config.CHECK_NEVER,
 
1845
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1846
                my_config.signature_checking))
 
1847
        self.assertEqual(config.SIGN_ALWAYS,
 
1848
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1849
                my_config.signing_policy))
 
1850
        self.assertTrue(self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1851
            my_config.signature_needed))
1804
1852
 
1805
1853
    def test_gpg_signing_command(self):
1806
1854
        my_config = self.get_branch_config(
1807
1855
            global_config=sample_config_text,
1808
1856
            # branch data cannot set gpg_signing_command
1809
1857
            branch_data_config="gpg_signing_command=pgp")
1810
 
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
 
1858
        self.assertEqual('gnome-gpg',
 
1859
            self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1860
                my_config.gpg_signing_command))
1811
1861
 
1812
1862
    def test_get_user_option_global(self):
1813
1863
        my_config = self.get_branch_config(global_config=sample_config_text)
1820
1870
                                      location_config=sample_branches_text)
1821
1871
        self.assertEqual(my_config.branch.base, '/a/c')
1822
1872
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1823
 
                         my_config.post_commit())
 
1873
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1874
                                              my_config.post_commit))
1824
1875
        my_config.set_user_option('post_commit', 'rmtree_root')
1825
1876
        # post-commit is ignored when present in branch data
1826
1877
        self.assertEqual('bzrlib.tests.test_config.post_commit',
1827
 
                         my_config.post_commit())
 
1878
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1879
                                              my_config.post_commit))
1828
1880
        my_config.set_user_option('post_commit', 'rmtree_root',
1829
1881
                                  store=config.STORE_LOCATION)
1830
 
        self.assertEqual('rmtree_root', my_config.post_commit())
 
1882
        self.assertEqual('rmtree_root',
 
1883
                         self.applyDeprecated(deprecated_in((2, 5, 0)),
 
1884
                                              my_config.post_commit))
1831
1885
 
1832
1886
    def test_config_precedence(self):
1833
1887
        # FIXME: eager test, luckily no persitent config file makes it fail
2312
2366
class TestOptionConverterMixin(object):
2313
2367
 
2314
2368
    def assertConverted(self, expected, opt, value):
2315
 
        self.assertEquals(expected, opt.convert_from_unicode(value))
 
2369
        self.assertEquals(expected, opt.convert_from_unicode(value),
 
2370
                          'Expecting %s, got %s' % (expected, value,))
2316
2371
 
2317
2372
    def assertWarns(self, opt, value):
2318
2373
        warnings = []
2331
2386
 
2332
2387
    def assertConvertInvalid(self, opt, invalid_value):
2333
2388
        opt.invalid = None
2334
 
        self.assertEquals(None, opt.convert_from_unicode(invalid_value))
 
2389
        self.assertEquals(None, opt.convert_from_unicode(invalid_value),
 
2390
                          '%s is not None' % (invalid_value,))
2335
2391
        opt.invalid = 'warning'
2336
2392
        self.assertWarns(opt, invalid_value)
2337
2393
        opt.invalid = 'error'
2376
2432
        self.assertConverted(16, opt, u'16')
2377
2433
 
2378
2434
 
 
2435
class TestOptionWithSIUnitConverter(tests.TestCase, TestOptionConverterMixin):
 
2436
 
 
2437
    def get_option(self):
 
2438
        return config.Option('foo', help='An integer in SI units.',
 
2439
                             from_unicode=config.int_SI_from_store)
 
2440
 
 
2441
    def test_convert_invalid(self):
 
2442
        opt = self.get_option()
 
2443
        self.assertConvertInvalid(opt, u'not-a-unit')
 
2444
        self.assertConvertInvalid(opt, u'Gb') # Forgot the int
 
2445
        self.assertConvertInvalid(opt, u'1b') # Forgot the unit
 
2446
        self.assertConvertInvalid(opt, u'1GG')
 
2447
        self.assertConvertInvalid(opt, u'1Mbb')
 
2448
        self.assertConvertInvalid(opt, u'1MM')
 
2449
 
 
2450
    def test_convert_valid(self):
 
2451
        opt = self.get_option()
 
2452
        self.assertConverted(int(5e3), opt, u'5kb')
 
2453
        self.assertConverted(int(5e6), opt, u'5M')
 
2454
        self.assertConverted(int(5e6), opt, u'5MB')
 
2455
        self.assertConverted(int(5e9), opt, u'5g')
 
2456
        self.assertConverted(int(5e9), opt, u'5gB')
 
2457
        self.assertConverted(100, opt, u'100')
 
2458
 
 
2459
 
2379
2460
class TestOptionWithListConverter(tests.TestCase, TestOptionConverterMixin):
2380
2461
 
2381
2462
    def get_option(self):
4493
4574
 
4494
4575
    def test_auto_user_id(self):
4495
4576
        """Automatic inference of user name.
4496
 
        
 
4577
 
4497
4578
        This is a bit hard to test in an isolated way, because it depends on
4498
4579
        system functions that go direct to /etc or perhaps somewhere else.
4499
4580
        But it's reasonable to say that on Unix, with an /etc/mailname, we ought
4509
4590
        else:
4510
4591
            self.assertEquals((None, None), (realname, address))
4511
4592
 
 
4593
 
 
4594
class EmailOptionTests(tests.TestCase):
 
4595
 
 
4596
    def test_default_email_uses_BZR_EMAIL(self):
 
4597
        # BZR_EMAIL takes precedence over EMAIL
 
4598
        self.overrideEnv('BZR_EMAIL', 'jelmer@samba.org')
 
4599
        self.overrideEnv('EMAIL', 'jelmer@apache.org')
 
4600
        self.assertEquals('jelmer@samba.org', config.default_email())
 
4601
 
 
4602
    def test_default_email_uses_EMAIL(self):
 
4603
        self.overrideEnv('BZR_EMAIL', None)
 
4604
        self.overrideEnv('EMAIL', 'jelmer@apache.org')
 
4605
        self.assertEquals('jelmer@apache.org', config.default_email())
 
4606
 
 
4607
    def test_BZR_EMAIL_overrides(self):
 
4608
        self.overrideEnv('BZR_EMAIL', 'jelmer@apache.org')
 
4609
        self.assertEquals('jelmer@apache.org',
 
4610
            config.email_from_store('jelmer@debian.org'))
 
4611
        self.overrideEnv('BZR_EMAIL', None)
 
4612
        self.overrideEnv('EMAIL', 'jelmer@samba.org')
 
4613
        self.assertEquals('jelmer@debian.org',
 
4614
            config.email_from_store('jelmer@debian.org'))