← Back to branch summary

~bzr/ubuntu/hardy/bzr/beta-ppa

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Max Bowsher
  • Date: 2011-04-30 17:14:51 UTC
  • mfrom: (3876.1.10 jaunty)
  • Revision ID: maxb@f2s.com-20110430171451-74ydto59tdotsxa6
Merge 2.4.0~beta2-2

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
42
42
    )
43
43
from bzrlib.tests import (
44
44
    features,
 
45
    TestSkipped,
45
46
    scenarios,
46
47
    )
47
48
from bzrlib.util.configobj import configobj
509
510
    def test_cached(self):
510
511
        my_config = config.IniBasedConfig.from_string(sample_config_text)
511
512
        parser = my_config._get_parser()
512
 
        self.failUnless(my_config._get_parser() is parser)
 
513
        self.assertTrue(my_config._get_parser() is parser)
513
514
 
514
515
    def _dummy_chown(self, path, uid, gid):
515
516
        self.path, self.uid, self.gid = path, uid, gid
961
962
            parser = my_config._get_parser()
962
963
        finally:
963
964
            config.ConfigObj = oldparserclass
964
 
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
 
965
        self.assertIsInstance(parser, InstrumentedConfigObj)
965
966
        self.assertEqual(parser._calls, [('__init__', config.config_filename(),
966
967
                                          'utf-8')])
967
968
 
978
979
        my_config = config.BranchConfig(branch)
979
980
        location_config = my_config._get_location_config()
980
981
        self.assertEqual(branch.base, location_config.location)
981
 
        self.failUnless(location_config is my_config._get_location_config())
 
982
        self.assertIs(location_config, my_config._get_location_config())
982
983
 
983
984
    def test_get_config(self):
984
985
        """The Branch.get_config method works properly"""
1252
1253
            parser = my_config._get_parser()
1253
1254
        finally:
1254
1255
            config.ConfigObj = oldparserclass
1255
 
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
 
1256
        self.assertIsInstance(parser, InstrumentedConfigObj)
1256
1257
        self.assertEqual(parser._calls,
1257
1258
                         [('__init__', config.locations_config_filename(),
1258
1259
                           'utf-8')])
1260
1261
    def test_get_global_config(self):
1261
1262
        my_config = config.BranchConfig(FakeBranch('http://example.com'))
1262
1263
        global_config = my_config._get_global_config()
1263
 
        self.failUnless(isinstance(global_config, config.GlobalConfig))
1264
 
        self.failUnless(global_config is my_config._get_global_config())
 
1264
        self.assertIsInstance(global_config, config.GlobalConfig)
 
1265
        self.assertIs(global_config, my_config._get_global_config())
 
1266
 
 
1267
    def assertLocationMatching(self, expected):
 
1268
        self.assertEqual(expected,
 
1269
                         list(self.my_location_config._get_matching_sections()))
1265
1270
 
1266
1271
    def test__get_matching_sections_no_match(self):
1267
1272
        self.get_branch_config('/')
1268
 
        self.assertEqual([], self.my_location_config._get_matching_sections())
 
1273
        self.assertLocationMatching([])
1269
1274
 
1270
1275
    def test__get_matching_sections_exact(self):
1271
1276
        self.get_branch_config('http://www.example.com')
1272
 
        self.assertEqual([('http://www.example.com', '')],
1273
 
                         self.my_location_config._get_matching_sections())
 
1277
        self.assertLocationMatching([('http://www.example.com', '')])
1274
1278
 
1275
1279
    def test__get_matching_sections_suffix_does_not(self):
1276
1280
        self.get_branch_config('http://www.example.com-com')
1277
 
        self.assertEqual([], self.my_location_config._get_matching_sections())
 
1281
        self.assertLocationMatching([])
1278
1282
 
1279
1283
    def test__get_matching_sections_subdir_recursive(self):
1280
1284
        self.get_branch_config('http://www.example.com/com')
1281
 
        self.assertEqual([('http://www.example.com', 'com')],
1282
 
                         self.my_location_config._get_matching_sections())
 
1285
        self.assertLocationMatching([('http://www.example.com', 'com')])
1283
1286
 
1284
1287
    def test__get_matching_sections_ignoreparent(self):
1285
1288
        self.get_branch_config('http://www.example.com/ignoreparent')
1286
 
        self.assertEqual([('http://www.example.com/ignoreparent', '')],
1287
 
                         self.my_location_config._get_matching_sections())
 
1289
        self.assertLocationMatching([('http://www.example.com/ignoreparent',
 
1290
                                      '')])
1288
1291
 
1289
1292
    def test__get_matching_sections_ignoreparent_subdir(self):
1290
1293
        self.get_branch_config(
1291
1294
            'http://www.example.com/ignoreparent/childbranch')
1292
 
        self.assertEqual([('http://www.example.com/ignoreparent',
1293
 
                           'childbranch')],
1294
 
                         self.my_location_config._get_matching_sections())
 
1295
        self.assertLocationMatching([('http://www.example.com/ignoreparent',
 
1296
                                      'childbranch')])
1295
1297
 
1296
1298
    def test__get_matching_sections_subdir_trailing_slash(self):
1297
1299
        self.get_branch_config('/b')
1298
 
        self.assertEqual([('/b/', '')],
1299
 
                         self.my_location_config._get_matching_sections())
 
1300
        self.assertLocationMatching([('/b/', '')])
1300
1301
 
1301
1302
    def test__get_matching_sections_subdir_child(self):
1302
1303
        self.get_branch_config('/a/foo')
1303
 
        self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
1304
 
                         self.my_location_config._get_matching_sections())
 
1304
        self.assertLocationMatching([('/a/*', ''), ('/a/', 'foo')])
1305
1305
 
1306
1306
    def test__get_matching_sections_subdir_child_child(self):
1307
1307
        self.get_branch_config('/a/foo/bar')
1308
 
        self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
1309
 
                         self.my_location_config._get_matching_sections())
 
1308
        self.assertLocationMatching([('/a/*', 'bar'), ('/a/', 'foo/bar')])
1310
1309
 
1311
1310
    def test__get_matching_sections_trailing_slash_with_children(self):
1312
1311
        self.get_branch_config('/a/')
1313
 
        self.assertEqual([('/a/', '')],
1314
 
                         self.my_location_config._get_matching_sections())
 
1312
        self.assertLocationMatching([('/a/', '')])
1315
1313
 
1316
1314
    def test__get_matching_sections_explicit_over_glob(self):
1317
1315
        # XXX: 2006-09-08 jamesh
1319
1317
        # was a config section for '/a/?', it would get precedence
1320
1318
        # over '/a/c'.
1321
1319
        self.get_branch_config('/a/c')
1322
 
        self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
1323
 
                         self.my_location_config._get_matching_sections())
 
1320
        self.assertLocationMatching([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')])
1324
1321
 
1325
1322
    def test__get_option_policy_normal(self):
1326
1323
        self.get_branch_config('http://www.example.com')
2469
2466
# test_user_prompted ?
2470
2467
class TestAuthenticationRing(tests.TestCaseWithTransport):
2471
2468
    pass
 
2469
 
 
2470
 
 
2471
class TestAutoUserId(tests.TestCase):
 
2472
    """Test inferring an automatic user name."""
 
2473
 
 
2474
    def test_auto_user_id(self):
 
2475
        """Automatic inference of user name.
 
2476
        
 
2477
        This is a bit hard to test in an isolated way, because it depends on
 
2478
        system functions that go direct to /etc or perhaps somewhere else.
 
2479
        But it's reasonable to say that on Unix, with an /etc/mailname, we ought
 
2480
        to be able to choose a user name with no configuration.
 
2481
        """
 
2482
        if sys.platform == 'win32':
 
2483
            raise TestSkipped("User name inference not implemented on win32")
 
2484
        realname, address = config._auto_user_id()
 
2485
        if os.path.exists('/etc/mailname'):
 
2486
            self.assertTrue(realname)
 
2487
            self.assertTrue(address)
 
2488
        else:
 
2489
            self.assertEquals((None, None), (realname, address))
 
2490