← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-12-20 16:16:34 UTC
  • mfrom: (3123.5.18 hardlinks)
  • Revision ID: pqm@pqm.ubuntu.com-20071220161634-2kcjb650o21ydko4
Accelerate build_tree using similar workingtrees (abentley)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_config.py
33
33
    urlutils,
34
34
    tests,
35
35
    trace,
36
 
    transport,
37
36
    )
38
37
from bzrlib.util.configobj import configobj
39
38
 
147
146
            self.base = "http://example.com/branches/demo"
148
147
        else:
149
148
            self.base = base
150
 
        self._transport = self.control_files = \
151
 
            FakeControlFilesAndTransport(user_id=user_id)
 
149
        self.control_files = FakeControlFiles(user_id=user_id)
152
150
 
153
151
    def lock_write(self):
154
152
        pass
157
155
        pass
158
156
 
159
157
 
160
 
class FakeControlFilesAndTransport(object):
 
158
class FakeControlFiles(object):
161
159
 
162
160
    def __init__(self, user_id=None):
 
161
        self.email = user_id
163
162
        self.files = {}
164
 
        if user_id:
165
 
            self.files['email'] = user_id
166
 
        self._transport = self
167
163
 
168
164
    def get_utf8(self, filename):
169
 
        # from LockableFiles
170
 
        raise AssertionError("get_utf8 should no longer be used")
 
165
        if filename != 'email':
 
166
            raise NotImplementedError
 
167
        if self.email is not None:
 
168
            return StringIO(self.email)
 
169
        raise errors.NoSuchFile(filename)
171
170
 
172
171
    def get(self, filename):
173
 
        # from Transport
174
172
        try:
175
173
            return StringIO(self.files[filename])
176
174
        except KeyError:
177
175
            raise errors.NoSuchFile(filename)
178
176
 
179
 
    def get_bytes(self, filename):
180
 
        # from Transport
181
 
        try:
182
 
            return self.files[filename]
183
 
        except KeyError:
184
 
            raise errors.NoSuchFile(filename)
185
 
 
186
177
    def put(self, filename, fileobj):
187
178
        self.files[filename] = fileobj.read()
188
179
 
189
 
    def put_file(self, filename, fileobj):
190
 
        return self.put(filename, fileobj)
191
 
 
192
180
 
193
181
class InstrumentedConfig(config.Config):
194
182
    """An instrumented config that supplies stubs for template methods."""
217
205
 
218
206
 
219
207
class TestConfigObj(tests.TestCase):
220
 
 
221
208
    def test_get_bool(self):
222
209
        co = config.ConfigObj(StringIO(bool_config))
223
210
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
225
212
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
226
213
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
227
214
 
228
 
    def test_hash_sign_in_value(self):
229
 
        """
230
 
        Before 4.5.0, ConfigObj did not quote # signs in values, so they'd be
231
 
        treated as comments when read in again. (#86838)
232
 
        """
233
 
        co = config.ConfigObj()
234
 
        co['test'] = 'foo#bar'
235
 
        lines = co.write()
236
 
        self.assertEqual(lines, ['test = "foo#bar"'])
237
 
        co2 = config.ConfigObj(lines)
238
 
        self.assertEqual(co2['test'], 'foo#bar')
239
 
 
240
215
 
241
216
erroneous_config = """[section] # line 1
242
217
good=good # line 2
450
425
        self.check_file_contents(locations,
451
426
                                 '[%s/branch]\n'
452
427
                                 'push_location = http://foobar\n'
453
 
                                 'push_location:policy = norecurse\n'
 
428
                                 'push_location:policy = norecurse'
454
429
                                 % (local_path,))
455
430
 
456
431
    def test_autonick_urlencoded(self):
588
563
        my_config = self._get_sample_config()
589
564
        self.assertEqual('help', my_config.get_alias('h'))
590
565
 
591
 
    def test_get_aliases(self):
592
 
        my_config = self._get_sample_config()
593
 
        aliases = my_config.get_aliases()
594
 
        self.assertEqual(2, len(aliases))
595
 
        sorted_keys = sorted(aliases)
596
 
        self.assertEqual('help', aliases[sorted_keys[0]])
597
 
        self.assertEqual(sample_long_alias, aliases[sorted_keys[1]])
598
 
 
599
566
    def test_get_no_alias(self):
600
567
        my_config = self._get_sample_config()
601
568
        self.assertEqual(None, my_config.get_alias('foo'))
605
572
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
606
573
 
607
574
 
608
 
class TestGlobalConfigSavingOptions(tests.TestCaseInTempDir):
609
 
 
610
 
    def test_empty(self):
611
 
        my_config = config.GlobalConfig()
612
 
        self.assertEqual(0, len(my_config.get_aliases()))
613
 
 
614
 
    def test_set_alias(self):
615
 
        my_config = config.GlobalConfig()
616
 
        alias_value = 'commit --strict'
617
 
        my_config.set_alias('commit', alias_value)
618
 
        new_config = config.GlobalConfig()
619
 
        self.assertEqual(alias_value, new_config.get_alias('commit'))
620
 
 
621
 
    def test_remove_alias(self):
622
 
        my_config = config.GlobalConfig()
623
 
        my_config.set_alias('commit', 'commit --strict')
624
 
        # Now remove the alias again.
625
 
        my_config.unset_alias('commit')
626
 
        new_config = config.GlobalConfig()
627
 
        self.assertIs(None, new_config.get_alias('commit'))
628
 
 
629
 
 
630
575
class TestLocationConfig(tests.TestCaseInTempDir):
631
576
 
632
577
    def test_constructs(self):
951
896
        self.assertIs(self.my_config.get_user_option('foo'), None)
952
897
        self.my_config.set_user_option('foo', 'bar')
953
898
        self.assertEqual(
954
 
            self.my_config.branch.control_files.files['branch.conf'].strip(),
 
899
            self.my_config.branch.control_files.files['branch.conf'],
955
900
            'foo = bar')
956
901
        self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
957
902
        self.my_config.set_user_option('foo', 'baz',
1002
947
        my_config = config.BranchConfig(branch)
1003
948
        self.assertEqual("Robert Collins <robertc@example.net>",
1004
949
                         my_config.username())
1005
 
        my_config.branch.control_files.files['email'] = "John"
 
950
        branch.control_files.email = "John"
1006
951
        my_config.set_user_option('email',
1007
952
                                  "Robert Collins <robertc@example.org>")
1008
953
        self.assertEqual("John", my_config.username())
1009
 
        del my_config.branch.control_files.files['email']
 
954
        branch.control_files.email = None
1010
955
        self.assertEqual("Robert Collins <robertc@example.org>",
1011
956
                         my_config.username())
1012
957
 
1013
958
    def test_not_set_in_branch(self):
1014
959
        my_config = self.get_branch_config(sample_config_text)
 
960
        my_config.branch.control_files.email = None
1015
961
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
1016
962
                         my_config._get_user_id())
1017
 
        my_config.branch.control_files.files['email'] = "John"
 
963
        my_config.branch.control_files.email = "John"
1018
964
        self.assertEqual("John", my_config._get_user_id())
1019
965
 
1020
966
    def test_BZR_EMAIL_OVERRIDES(self):
1177
1123
        self.assertEqual(value, 'value3-section')
1178
1124
 
1179
1125
 
1180
 
class TestTransportConfig(tests.TestCaseWithTransport):
1181
 
 
1182
 
    def test_get_value(self):
1183
 
        """Test that retreiving a value from a section is possible"""
1184
 
        bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1185
 
                                               'control.conf')
1186
 
        bzrdir_config.set_option('value', 'key', 'SECTION')
1187
 
        bzrdir_config.set_option('value2', 'key2')
1188
 
        bzrdir_config.set_option('value3-top', 'key3')
1189
 
        bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1190
 
        value = bzrdir_config.get_option('key', 'SECTION')
1191
 
        self.assertEqual(value, 'value')
1192
 
        value = bzrdir_config.get_option('key2')
1193
 
        self.assertEqual(value, 'value2')
1194
 
        self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1195
 
        value = bzrdir_config.get_option('non-existant', 'SECTION')
1196
 
        self.assertEqual(value, None)
1197
 
        value = bzrdir_config.get_option('non-existant', default='default')
1198
 
        self.assertEqual(value, 'default')
1199
 
        self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1200
 
        value = bzrdir_config.get_option('key2', 'NOSECTION',
1201
 
                                         default='default')
1202
 
        self.assertEqual(value, 'default')
1203
 
        value = bzrdir_config.get_option('key3')
1204
 
        self.assertEqual(value, 'value3-top')
1205
 
        value = bzrdir_config.get_option('key3', 'SECTION')
1206
 
        self.assertEqual(value, 'value3-section')
1207
 
 
1208
 
    def test_set_unset_default_stack_on(self):
1209
 
        my_dir = self.make_bzrdir('.')
1210
 
        bzrdir_config = config.BzrDirConfig(my_dir.transport)
1211
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1212
 
        bzrdir_config.set_default_stack_on('Foo')
1213
 
        self.assertEqual('Foo', bzrdir_config._config.get_option(
1214
 
                         'default_stack_on'))
1215
 
        self.assertEqual('Foo', bzrdir_config.get_default_stack_on())
1216
 
        bzrdir_config.set_default_stack_on(None)
1217
 
        self.assertIs(None, bzrdir_config.get_default_stack_on())
1218
 
 
1219
 
 
1220
1126
class TestAuthenticationConfigFile(tests.TestCase):
1221
1127
    """Test the authentication.conf file matching"""
1222
1128
 
1237
1143
        self.assertEquals({}, conf._get_config())
1238
1144
        self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1239
1145
 
1240
 
    def test_missing_auth_section_header(self):
1241
 
        conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1242
 
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1243
 
 
1244
 
    def test_auth_section_header_not_closed(self):
 
1146
    def test_broken_config(self):
1245
1147
        conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1246
1148
        self.assertRaises(errors.ParseConfigError, conf._get_config)
1247
1149
 
1248
 
    def test_auth_value_not_boolean(self):
1249
1150
        conf = config.AuthenticationConfig(_file=StringIO(
1250
1151
                """[broken]
1251
1152
scheme=ftp
1253
1154
verify_certificates=askme # Error: Not a boolean
1254
1155
"""))
1255
1156
        self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1256
 
 
1257
 
    def test_auth_value_not_int(self):
1258
1157
        conf = config.AuthenticationConfig(_file=StringIO(
1259
1158
                """[broken]
1260
1159
scheme=ftp
1379
1278
        self._got_user_passwd(None, None,
1380
1279
                              conf, 'http', 'bar.org', user='georges')
1381
1280
 
1382
 
    def test_credentials_for_user_without_password(self):
1383
 
        conf = config.AuthenticationConfig(_file=StringIO(
1384
 
                """
1385
 
[without password]
1386
 
scheme=http
1387
 
host=bar.org
1388
 
user=jim
1389
 
"""))
1390
 
        # Get user but no password
1391
 
        self._got_user_passwd('jim', None,
1392
 
                              conf, 'http', 'bar.org')
1393
 
 
1394
1281
    def test_verify_certificates(self):
1395
1282
        conf = config.AuthenticationConfig(_file=StringIO(
1396
1283
                """
1454
1341
            'SMTP %(user)s@%(host)s:%(port)d password: ',
1455
1342
            'smtp', port=10025)
1456
1343
 
1457
 
    def test_ssh_password_emits_warning(self):
1458
 
        conf = config.AuthenticationConfig(_file=StringIO(
1459
 
                """
1460
 
[ssh with password]
1461
 
scheme=ssh
1462
 
host=bar.org
1463
 
user=jim
1464
 
password=jimpass
1465
 
"""))
1466
 
        entered_password = 'typed-by-hand'
1467
 
        stdout = tests.StringIOWrapper()
1468
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1469
 
                                            stdout=stdout)
1470
 
 
1471
 
        # Since the password defined in the authentication config is ignored,
1472
 
        # the user is prompted
1473
 
        self.assertEquals(entered_password,
1474
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1475
 
        self.assertContainsRe(
1476
 
            self._get_log(keep_log_file=True),
1477
 
            'password ignored in section \[ssh with password\]')
1478
 
 
1479
 
    def test_ssh_without_password_doesnt_emit_warning(self):
1480
 
        conf = config.AuthenticationConfig(_file=StringIO(
1481
 
                """
1482
 
[ssh with password]
1483
 
scheme=ssh
1484
 
host=bar.org
1485
 
user=jim
1486
 
"""))
1487
 
        entered_password = 'typed-by-hand'
1488
 
        stdout = tests.StringIOWrapper()
1489
 
        ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1490
 
                                            stdout=stdout)
1491
 
 
1492
 
        # Since the password defined in the authentication config is ignored,
1493
 
        # the user is prompted
1494
 
        self.assertEquals(entered_password,
1495
 
                          conf.get_password('ssh', 'bar.org', user='jim'))
1496
 
        # No warning shoud be emitted since there is no password. We are only
1497
 
        # providing "user".
1498
 
        self.assertNotContainsRe(
1499
 
            self._get_log(keep_log_file=True),
1500
 
            'password ignored in section \[ssh with password\]')
1501
 
 
1502
1344
 
1503
1345
# FIXME: Once we have a way to declare authentication to all test servers, we
1504
1346
# can implement generic tests.