~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-09 04:51:05 UTC
  • Revision ID: mbp@sourcefrog.net-20050309045105-d02cd410a115da2c
import all docs from arch

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#
4
 
# This program is free software; you can redistribute it and/or modify
5
 
# it under the terms of the GNU General Public License as published by
6
 
# the Free Software Foundation; either version 2 of the License, or
7
 
# (at your option) any later version.
8
 
#
9
 
# This program is distributed in the hope that it will be useful,
10
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
# GNU General Public License for more details.
13
 
#
14
 
# You should have received a copy of the GNU General Public License
15
 
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
18
 
"""Tests for finding and reading the bzr config file[s]."""
19
 
# import system imports here
20
 
from bzrlib.util.configobj.configobj import ConfigObj, ConfigObjError
21
 
from cStringIO import StringIO
22
 
import os
23
 
import sys
24
 
 
25
 
#import bzrlib specific imports here
26
 
import bzrlib.config as config
27
 
import bzrlib.errors as errors
28
 
from bzrlib.tests import TestCase, TestCaseInTempDir
29
 
 
30
 
 
31
 
sample_long_alias="log -r-15..-1 --line"
32
 
sample_config_text = ("[DEFAULT]\n"
33
 
                      u"email=Erik B\u00e5gfors <erik@bagfors.nu>\n"
34
 
                      "editor=vim\n"
35
 
                      "gpg_signing_command=gnome-gpg\n"
36
 
                      "log_format=short\n"
37
 
                      "user_global_option=something\n"
38
 
                      "[ALIASES]\n"
39
 
                      "h=help\n"
40
 
                      "ll=" + sample_long_alias + "\n")
41
 
 
42
 
 
43
 
sample_always_signatures = ("[DEFAULT]\n"
44
 
                            "check_signatures=ignore\n"
45
 
                            "create_signatures=always")
46
 
 
47
 
 
48
 
sample_ignore_signatures = ("[DEFAULT]\n"
49
 
                            "check_signatures=require\n"
50
 
                            "create_signatures=never")
51
 
 
52
 
 
53
 
sample_maybe_signatures = ("[DEFAULT]\n"
54
 
                            "check_signatures=ignore\n"
55
 
                            "create_signatures=when-required")
56
 
 
57
 
 
58
 
sample_branches_text = ("[http://www.example.com]\n"
59
 
                        "# Top level policy\n"
60
 
                        "email=Robert Collins <robertc@example.org>\n"
61
 
                        "[http://www.example.com/useglobal]\n"
62
 
                        "# different project, forces global lookup\n"
63
 
                        "recurse=false\n"
64
 
                        "[/b/]\n"
65
 
                        "check_signatures=require\n"
66
 
                        "# test trailing / matching with no children\n"
67
 
                        "[/a/]\n"
68
 
                        "check_signatures=check-available\n"
69
 
                        "gpg_signing_command=false\n"
70
 
                        "user_local_option=local\n"
71
 
                        "# test trailing / matching\n"
72
 
                        "[/a/*]\n"
73
 
                        "#subdirs will match but not the parent\n"
74
 
                        "recurse=False\n"
75
 
                        "[/a/c]\n"
76
 
                        "check_signatures=ignore\n"
77
 
                        "post_commit=bzrlib.tests.test_config.post_commit\n"
78
 
                        "#testing explicit beats globs\n")
79
 
 
80
 
 
81
 
 
82
 
class InstrumentedConfigObj(object):
83
 
    """A config obj look-enough-alike to record calls made to it."""
84
 
 
85
 
    def __contains__(self, thing):
86
 
        self._calls.append(('__contains__', thing))
87
 
        return False
88
 
 
89
 
    def __getitem__(self, key):
90
 
        self._calls.append(('__getitem__', key))
91
 
        return self
92
 
 
93
 
    def __init__(self, input, encoding=None):
94
 
        self._calls = [('__init__', input, encoding)]
95
 
 
96
 
    def __setitem__(self, key, value):
97
 
        self._calls.append(('__setitem__', key, value))
98
 
 
99
 
    def write(self, arg):
100
 
        self._calls.append(('write',))
101
 
 
102
 
 
103
 
class FakeBranch(object):
104
 
 
105
 
    def __init__(self):
106
 
        self.base = "http://example.com/branches/demo"
107
 
        self.control_files = FakeControlFiles()
108
 
 
109
 
 
110
 
class FakeControlFiles(object):
111
 
 
112
 
    def __init__(self):
113
 
        self.email = 'Robert Collins <robertc@example.net>\n'
114
 
 
115
 
    def get_utf8(self, filename):
116
 
        if filename != 'email':
117
 
            raise NotImplementedError
118
 
        if self.email is not None:
119
 
            return StringIO(self.email)
120
 
        raise errors.NoSuchFile(filename)
121
 
 
122
 
 
123
 
class InstrumentedConfig(config.Config):
124
 
    """An instrumented config that supplies stubs for template methods."""
125
 
    
126
 
    def __init__(self):
127
 
        super(InstrumentedConfig, self).__init__()
128
 
        self._calls = []
129
 
        self._signatures = config.CHECK_NEVER
130
 
 
131
 
    def _get_user_id(self):
132
 
        self._calls.append('_get_user_id')
133
 
        return "Robert Collins <robert.collins@example.org>"
134
 
 
135
 
    def _get_signature_checking(self):
136
 
        self._calls.append('_get_signature_checking')
137
 
        return self._signatures
138
 
 
139
 
 
140
 
bool_config = """[DEFAULT]
141
 
active = true
142
 
inactive = false
143
 
[UPPERCASE]
144
 
active = True
145
 
nonactive = False
146
 
"""
147
 
class TestConfigObj(TestCase):
148
 
    def test_get_bool(self):
149
 
        from bzrlib.config import ConfigObj
150
 
        co = ConfigObj(StringIO(bool_config))
151
 
        self.assertIs(co.get_bool('DEFAULT', 'active'), True)
152
 
        self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
153
 
        self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
154
 
        self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
155
 
 
156
 
 
157
 
class TestConfig(TestCase):
158
 
 
159
 
    def test_constructs(self):
160
 
        config.Config()
161
 
 
162
 
    def test_no_default_editor(self):
163
 
        self.assertRaises(NotImplementedError, config.Config().get_editor)
164
 
 
165
 
    def test_user_email(self):
166
 
        my_config = InstrumentedConfig()
167
 
        self.assertEqual('robert.collins@example.org', my_config.user_email())
168
 
        self.assertEqual(['_get_user_id'], my_config._calls)
169
 
 
170
 
    def test_username(self):
171
 
        my_config = InstrumentedConfig()
172
 
        self.assertEqual('Robert Collins <robert.collins@example.org>',
173
 
                         my_config.username())
174
 
        self.assertEqual(['_get_user_id'], my_config._calls)
175
 
 
176
 
    def test_signatures_default(self):
177
 
        my_config = config.Config()
178
 
        self.assertFalse(my_config.signature_needed())
179
 
        self.assertEqual(config.CHECK_IF_POSSIBLE,
180
 
                         my_config.signature_checking())
181
 
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
182
 
                         my_config.signing_policy())
183
 
 
184
 
    def test_signatures_template_method(self):
185
 
        my_config = InstrumentedConfig()
186
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
187
 
        self.assertEqual(['_get_signature_checking'], my_config._calls)
188
 
 
189
 
    def test_signatures_template_method_none(self):
190
 
        my_config = InstrumentedConfig()
191
 
        my_config._signatures = None
192
 
        self.assertEqual(config.CHECK_IF_POSSIBLE,
193
 
                         my_config.signature_checking())
194
 
        self.assertEqual(['_get_signature_checking'], my_config._calls)
195
 
 
196
 
    def test_gpg_signing_command_default(self):
197
 
        my_config = config.Config()
198
 
        self.assertEqual('gpg', my_config.gpg_signing_command())
199
 
 
200
 
    def test_get_user_option_default(self):
201
 
        my_config = config.Config()
202
 
        self.assertEqual(None, my_config.get_user_option('no_option'))
203
 
 
204
 
    def test_post_commit_default(self):
205
 
        my_config = config.Config()
206
 
        self.assertEqual(None, my_config.post_commit())
207
 
 
208
 
    def test_log_format_default(self):
209
 
        my_config = config.Config()
210
 
        self.assertEqual('long', my_config.log_format())
211
 
 
212
 
 
213
 
class TestConfigPath(TestCase):
214
 
 
215
 
    def setUp(self):
216
 
        super(TestConfigPath, self).setUp()
217
 
        self.old_home = os.environ.get('HOME', None)
218
 
        self.old_appdata = os.environ.get('APPDATA', None)
219
 
        os.environ['HOME'] = '/home/bogus'
220
 
        os.environ['APPDATA'] = \
221
 
            r'C:\Documents and Settings\bogus\Application Data'
222
 
 
223
 
    def tearDown(self):
224
 
        if self.old_home is None:
225
 
            del os.environ['HOME']
226
 
        else:
227
 
            os.environ['HOME'] = self.old_home
228
 
        if self.old_appdata is None:
229
 
            del os.environ['APPDATA']
230
 
        else:
231
 
            os.environ['APPDATA'] = self.old_appdata
232
 
        super(TestConfigPath, self).tearDown()
233
 
    
234
 
    def test_config_dir(self):
235
 
        if sys.platform == 'win32':
236
 
            self.assertEqual(config.config_dir(), 
237
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0')
238
 
        else:
239
 
            self.assertEqual(config.config_dir(), '/home/bogus/.bazaar')
240
 
 
241
 
    def test_config_filename(self):
242
 
        if sys.platform == 'win32':
243
 
            self.assertEqual(config.config_filename(), 
244
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/bazaar.conf')
245
 
        else:
246
 
            self.assertEqual(config.config_filename(),
247
 
                             '/home/bogus/.bazaar/bazaar.conf')
248
 
 
249
 
    def test_branches_config_filename(self):
250
 
        if sys.platform == 'win32':
251
 
            self.assertEqual(config.branches_config_filename(), 
252
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/branches.conf')
253
 
        else:
254
 
            self.assertEqual(config.branches_config_filename(),
255
 
                             '/home/bogus/.bazaar/branches.conf')
256
 
 
257
 
    def test_locations_config_filename(self):
258
 
        if sys.platform == 'win32':
259
 
            self.assertEqual(config.locations_config_filename(), 
260
 
                'C:/Documents and Settings/bogus/Application Data/bazaar/2.0/locations.conf')
261
 
        else:
262
 
            self.assertEqual(config.locations_config_filename(),
263
 
                             '/home/bogus/.bazaar/locations.conf')
264
 
 
265
 
class TestIniConfig(TestCase):
266
 
 
267
 
    def test_contructs(self):
268
 
        my_config = config.IniBasedConfig("nothing")
269
 
 
270
 
    def test_from_fp(self):
271
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
272
 
        my_config = config.IniBasedConfig(None)
273
 
        self.failUnless(
274
 
            isinstance(my_config._get_parser(file=config_file),
275
 
                        ConfigObj))
276
 
 
277
 
    def test_cached(self):
278
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
279
 
        my_config = config.IniBasedConfig(None)
280
 
        parser = my_config._get_parser(file=config_file)
281
 
        self.failUnless(my_config._get_parser() is parser)
282
 
 
283
 
 
284
 
class TestGetConfig(TestCase):
285
 
 
286
 
    def test_constructs(self):
287
 
        my_config = config.GlobalConfig()
288
 
 
289
 
    def test_calls_read_filenames(self):
290
 
        # replace the class that is constructured, to check its parameters
291
 
        oldparserclass = config.ConfigObj
292
 
        config.ConfigObj = InstrumentedConfigObj
293
 
        my_config = config.GlobalConfig()
294
 
        try:
295
 
            parser = my_config._get_parser()
296
 
        finally:
297
 
            config.ConfigObj = oldparserclass
298
 
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
299
 
        self.assertEqual(parser._calls, [('__init__', config.config_filename(),
300
 
                                          'utf-8')])
301
 
 
302
 
 
303
 
class TestBranchConfig(TestCaseInTempDir):
304
 
 
305
 
    def test_constructs(self):
306
 
        branch = FakeBranch()
307
 
        my_config = config.BranchConfig(branch)
308
 
        self.assertRaises(TypeError, config.BranchConfig)
309
 
 
310
 
    def test_get_location_config(self):
311
 
        branch = FakeBranch()
312
 
        my_config = config.BranchConfig(branch)
313
 
        location_config = my_config._get_location_config()
314
 
        self.assertEqual(branch.base, location_config.location)
315
 
        self.failUnless(location_config is my_config._get_location_config())
316
 
 
317
 
 
318
 
class TestGlobalConfigItems(TestCase):
319
 
 
320
 
    def test_user_id(self):
321
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
322
 
        my_config = config.GlobalConfig()
323
 
        my_config._parser = my_config._get_parser(file=config_file)
324
 
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
325
 
                         my_config._get_user_id())
326
 
 
327
 
    def test_absent_user_id(self):
328
 
        config_file = StringIO("")
329
 
        my_config = config.GlobalConfig()
330
 
        my_config._parser = my_config._get_parser(file=config_file)
331
 
        self.assertEqual(None, my_config._get_user_id())
332
 
 
333
 
    def test_configured_editor(self):
334
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
335
 
        my_config = config.GlobalConfig()
336
 
        my_config._parser = my_config._get_parser(file=config_file)
337
 
        self.assertEqual("vim", my_config.get_editor())
338
 
 
339
 
    def test_signatures_always(self):
340
 
        config_file = StringIO(sample_always_signatures)
341
 
        my_config = config.GlobalConfig()
342
 
        my_config._parser = my_config._get_parser(file=config_file)
343
 
        self.assertEqual(config.CHECK_NEVER,
344
 
                         my_config.signature_checking())
345
 
        self.assertEqual(config.SIGN_ALWAYS,
346
 
                         my_config.signing_policy())
347
 
        self.assertEqual(True, my_config.signature_needed())
348
 
 
349
 
    def test_signatures_if_possible(self):
350
 
        config_file = StringIO(sample_maybe_signatures)
351
 
        my_config = config.GlobalConfig()
352
 
        my_config._parser = my_config._get_parser(file=config_file)
353
 
        self.assertEqual(config.CHECK_NEVER,
354
 
                         my_config.signature_checking())
355
 
        self.assertEqual(config.SIGN_WHEN_REQUIRED,
356
 
                         my_config.signing_policy())
357
 
        self.assertEqual(False, my_config.signature_needed())
358
 
 
359
 
    def test_signatures_ignore(self):
360
 
        config_file = StringIO(sample_ignore_signatures)
361
 
        my_config = config.GlobalConfig()
362
 
        my_config._parser = my_config._get_parser(file=config_file)
363
 
        self.assertEqual(config.CHECK_ALWAYS,
364
 
                         my_config.signature_checking())
365
 
        self.assertEqual(config.SIGN_NEVER,
366
 
                         my_config.signing_policy())
367
 
        self.assertEqual(False, my_config.signature_needed())
368
 
 
369
 
    def _get_sample_config(self):
370
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
371
 
        my_config = config.GlobalConfig()
372
 
        my_config._parser = my_config._get_parser(file=config_file)
373
 
        return my_config
374
 
 
375
 
    def test_gpg_signing_command(self):
376
 
        my_config = self._get_sample_config()
377
 
        self.assertEqual("gnome-gpg", my_config.gpg_signing_command())
378
 
        self.assertEqual(False, my_config.signature_needed())
379
 
 
380
 
    def _get_empty_config(self):
381
 
        config_file = StringIO("")
382
 
        my_config = config.GlobalConfig()
383
 
        my_config._parser = my_config._get_parser(file=config_file)
384
 
        return my_config
385
 
 
386
 
    def test_gpg_signing_command_unset(self):
387
 
        my_config = self._get_empty_config()
388
 
        self.assertEqual("gpg", my_config.gpg_signing_command())
389
 
 
390
 
    def test_get_user_option_default(self):
391
 
        my_config = self._get_empty_config()
392
 
        self.assertEqual(None, my_config.get_user_option('no_option'))
393
 
 
394
 
    def test_get_user_option_global(self):
395
 
        my_config = self._get_sample_config()
396
 
        self.assertEqual("something",
397
 
                         my_config.get_user_option('user_global_option'))
398
 
        
399
 
    def test_post_commit_default(self):
400
 
        my_config = self._get_sample_config()
401
 
        self.assertEqual(None, my_config.post_commit())
402
 
 
403
 
    def test_configured_logformat(self):
404
 
        my_config = self._get_sample_config()
405
 
        self.assertEqual("short", my_config.log_format())
406
 
 
407
 
    def test_get_alias(self):
408
 
        my_config = self._get_sample_config()
409
 
        self.assertEqual('help', my_config.get_alias('h'))
410
 
 
411
 
    def test_get_no_alias(self):
412
 
        my_config = self._get_sample_config()
413
 
        self.assertEqual(None, my_config.get_alias('foo'))
414
 
 
415
 
    def test_get_long_alias(self):
416
 
        my_config = self._get_sample_config()
417
 
        self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
418
 
 
419
 
 
420
 
class TestLocationConfig(TestCaseInTempDir):
421
 
 
422
 
    def test_constructs(self):
423
 
        my_config = config.LocationConfig('http://example.com')
424
 
        self.assertRaises(TypeError, config.LocationConfig)
425
 
 
426
 
    def test_branch_calls_read_filenames(self):
427
 
        # This is testing the correct file names are provided.
428
 
        # TODO: consolidate with the test for GlobalConfigs filename checks.
429
 
        #
430
 
        # replace the class that is constructured, to check its parameters
431
 
        oldparserclass = config.ConfigObj
432
 
        config.ConfigObj = InstrumentedConfigObj
433
 
        try:
434
 
            my_config = config.LocationConfig('http://www.example.com')
435
 
            parser = my_config._get_parser()
436
 
        finally:
437
 
            config.ConfigObj = oldparserclass
438
 
        self.failUnless(isinstance(parser, InstrumentedConfigObj))
439
 
        self.assertEqual(parser._calls,
440
 
                         [('__init__', config.locations_config_filename(),
441
 
                           'utf-8')])
442
 
        os.mkdir(config.config_dir())
443
 
        f = file(config.branches_config_filename(), 'wb')
444
 
        f.write('')
445
 
        f.close()
446
 
        oldparserclass = config.ConfigObj
447
 
        config.ConfigObj = InstrumentedConfigObj
448
 
        try:
449
 
            my_config = config.LocationConfig('http://www.example.com')
450
 
            parser = my_config._get_parser()
451
 
        finally:
452
 
            config.ConfigObj = oldparserclass
453
 
 
454
 
    def test_get_global_config(self):
455
 
        my_config = config.LocationConfig('http://example.com')
456
 
        global_config = my_config._get_global_config()
457
 
        self.failUnless(isinstance(global_config, config.GlobalConfig))
458
 
        self.failUnless(global_config is my_config._get_global_config())
459
 
 
460
 
    def test__get_section_no_match(self):
461
 
        self.get_location_config('/')
462
 
        self.assertEqual(None, self.my_config._get_section())
463
 
        
464
 
    def test__get_section_exact(self):
465
 
        self.get_location_config('http://www.example.com')
466
 
        self.assertEqual('http://www.example.com',
467
 
                         self.my_config._get_section())
468
 
   
469
 
    def test__get_section_suffix_does_not(self):
470
 
        self.get_location_config('http://www.example.com-com')
471
 
        self.assertEqual(None, self.my_config._get_section())
472
 
 
473
 
    def test__get_section_subdir_recursive(self):
474
 
        self.get_location_config('http://www.example.com/com')
475
 
        self.assertEqual('http://www.example.com',
476
 
                         self.my_config._get_section())
477
 
 
478
 
    def test__get_section_subdir_matches(self):
479
 
        self.get_location_config('http://www.example.com/useglobal')
480
 
        self.assertEqual('http://www.example.com/useglobal',
481
 
                         self.my_config._get_section())
482
 
 
483
 
    def test__get_section_subdir_nonrecursive(self):
484
 
        self.get_location_config(
485
 
            'http://www.example.com/useglobal/childbranch')
486
 
        self.assertEqual('http://www.example.com',
487
 
                         self.my_config._get_section())
488
 
 
489
 
    def test__get_section_subdir_trailing_slash(self):
490
 
        self.get_location_config('/b')
491
 
        self.assertEqual('/b/', self.my_config._get_section())
492
 
 
493
 
    def test__get_section_subdir_child(self):
494
 
        self.get_location_config('/a/foo')
495
 
        self.assertEqual('/a/*', self.my_config._get_section())
496
 
 
497
 
    def test__get_section_subdir_child_child(self):
498
 
        self.get_location_config('/a/foo/bar')
499
 
        self.assertEqual('/a/', self.my_config._get_section())
500
 
 
501
 
    def test__get_section_trailing_slash_with_children(self):
502
 
        self.get_location_config('/a/')
503
 
        self.assertEqual('/a/', self.my_config._get_section())
504
 
 
505
 
    def test__get_section_explicit_over_glob(self):
506
 
        self.get_location_config('/a/c')
507
 
        self.assertEqual('/a/c', self.my_config._get_section())
508
 
 
509
 
 
510
 
    def test_location_without_username(self):
511
 
        self.get_location_config('http://www.example.com/useglobal')
512
 
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
513
 
                         self.my_config.username())
514
 
 
515
 
    def test_location_not_listed(self):
516
 
        """Test that the global username is used when no location matches"""
517
 
        self.get_location_config('/home/robertc/sources')
518
 
        self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
519
 
                         self.my_config.username())
520
 
 
521
 
    def test_overriding_location(self):
522
 
        self.get_location_config('http://www.example.com/foo')
523
 
        self.assertEqual('Robert Collins <robertc@example.org>',
524
 
                         self.my_config.username())
525
 
 
526
 
    def test_signatures_not_set(self):
527
 
        self.get_location_config('http://www.example.com',
528
 
                                 global_config=sample_ignore_signatures)
529
 
        self.assertEqual(config.CHECK_ALWAYS,
530
 
                         self.my_config.signature_checking())
531
 
        self.assertEqual(config.SIGN_NEVER,
532
 
                         self.my_config.signing_policy())
533
 
 
534
 
    def test_signatures_never(self):
535
 
        self.get_location_config('/a/c')
536
 
        self.assertEqual(config.CHECK_NEVER,
537
 
                         self.my_config.signature_checking())
538
 
        
539
 
    def test_signatures_when_available(self):
540
 
        self.get_location_config('/a/', global_config=sample_ignore_signatures)
541
 
        self.assertEqual(config.CHECK_IF_POSSIBLE,
542
 
                         self.my_config.signature_checking())
543
 
        
544
 
    def test_signatures_always(self):
545
 
        self.get_location_config('/b')
546
 
        self.assertEqual(config.CHECK_ALWAYS,
547
 
                         self.my_config.signature_checking())
548
 
        
549
 
    def test_gpg_signing_command(self):
550
 
        self.get_location_config('/b')
551
 
        self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
552
 
 
553
 
    def test_gpg_signing_command_missing(self):
554
 
        self.get_location_config('/a')
555
 
        self.assertEqual("false", self.my_config.gpg_signing_command())
556
 
 
557
 
    def test_get_user_option_global(self):
558
 
        self.get_location_config('/a')
559
 
        self.assertEqual('something',
560
 
                         self.my_config.get_user_option('user_global_option'))
561
 
 
562
 
    def test_get_user_option_local(self):
563
 
        self.get_location_config('/a')
564
 
        self.assertEqual('local',
565
 
                         self.my_config.get_user_option('user_local_option'))
566
 
        
567
 
    def test_post_commit_default(self):
568
 
        self.get_location_config('/a/c')
569
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
570
 
                         self.my_config.post_commit())
571
 
 
572
 
    def get_location_config(self, location, global_config=None):
573
 
        if global_config is None:
574
 
            global_file = StringIO(sample_config_text.encode('utf-8'))
575
 
        else:
576
 
            global_file = StringIO(global_config.encode('utf-8'))
577
 
        branches_file = StringIO(sample_branches_text.encode('utf-8'))
578
 
        self.my_config = config.LocationConfig(location)
579
 
        self.my_config._get_parser(branches_file)
580
 
        self.my_config._get_global_config()._get_parser(global_file)
581
 
 
582
 
    def test_set_user_setting_sets_and_saves(self):
583
 
        self.get_location_config('/a/c')
584
 
        record = InstrumentedConfigObj("foo")
585
 
        self.my_config._parser = record
586
 
 
587
 
        real_mkdir = os.mkdir
588
 
        self.created = False
589
 
        def checked_mkdir(path, mode=0777):
590
 
            self.log('making directory: %s', path)
591
 
            real_mkdir(path, mode)
592
 
            self.created = True
593
 
 
594
 
        os.mkdir = checked_mkdir
595
 
        try:
596
 
            self.my_config.set_user_option('foo', 'bar')
597
 
        finally:
598
 
            os.mkdir = real_mkdir
599
 
 
600
 
        self.failUnless(self.created, 'Failed to create ~/.bazaar')
601
 
        self.assertEqual([('__contains__', '/a/c'),
602
 
                          ('__contains__', '/a/c/'),
603
 
                          ('__setitem__', '/a/c', {}),
604
 
                          ('__getitem__', '/a/c'),
605
 
                          ('__setitem__', 'foo', 'bar'),
606
 
                          ('write',)],
607
 
                         record._calls[1:])
608
 
 
609
 
 
610
 
class TestBranchConfigItems(TestCase):
611
 
 
612
 
    def test_user_id(self):
613
 
        branch = FakeBranch()
614
 
        my_config = config.BranchConfig(branch)
615
 
        self.assertEqual("Robert Collins <robertc@example.net>",
616
 
                         my_config._get_user_id())
617
 
        branch.control_files.email = "John"
618
 
        self.assertEqual("John", my_config._get_user_id())
619
 
 
620
 
    def test_not_set_in_branch(self):
621
 
        branch = FakeBranch()
622
 
        my_config = config.BranchConfig(branch)
623
 
        branch.control_files.email = None
624
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
625
 
        (my_config._get_location_config().
626
 
            _get_global_config()._get_parser(config_file))
627
 
        self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
628
 
                         my_config._get_user_id())
629
 
        branch.control_files.email = "John"
630
 
        self.assertEqual("John", my_config._get_user_id())
631
 
 
632
 
    def test_BZREMAIL_OVERRIDES(self):
633
 
        os.environ['BZREMAIL'] = "Robert Collins <robertc@example.org>"
634
 
        branch = FakeBranch()
635
 
        my_config = config.BranchConfig(branch)
636
 
        self.assertEqual("Robert Collins <robertc@example.org>",
637
 
                         my_config.username())
638
 
    
639
 
    def test_signatures_forced(self):
640
 
        branch = FakeBranch()
641
 
        my_config = config.BranchConfig(branch)
642
 
        config_file = StringIO(sample_always_signatures)
643
 
        (my_config._get_location_config().
644
 
            _get_global_config()._get_parser(config_file))
645
 
        self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
646
 
        self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
647
 
        self.assertTrue(my_config.signature_needed())
648
 
 
649
 
    def test_gpg_signing_command(self):
650
 
        branch = FakeBranch()
651
 
        my_config = config.BranchConfig(branch)
652
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
653
 
        (my_config._get_location_config().
654
 
            _get_global_config()._get_parser(config_file))
655
 
        self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
656
 
 
657
 
    def test_get_user_option_global(self):
658
 
        branch = FakeBranch()
659
 
        my_config = config.BranchConfig(branch)
660
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
661
 
        (my_config._get_location_config().
662
 
            _get_global_config()._get_parser(config_file))
663
 
        self.assertEqual('something',
664
 
                         my_config.get_user_option('user_global_option'))
665
 
 
666
 
    def test_post_commit_default(self):
667
 
        branch = FakeBranch()
668
 
        branch.base='/a/c'
669
 
        my_config = config.BranchConfig(branch)
670
 
        config_file = StringIO(sample_config_text.encode('utf-8'))
671
 
        (my_config._get_location_config().
672
 
            _get_global_config()._get_parser(config_file))
673
 
        branch_file = StringIO(sample_branches_text)
674
 
        my_config._get_location_config()._get_parser(branch_file)
675
 
        self.assertEqual('bzrlib.tests.test_config.post_commit',
676
 
                         my_config.post_commit())
677
 
 
678
 
 
679
 
class TestMailAddressExtraction(TestCase):
680
 
 
681
 
    def test_extract_email_address(self):
682
 
        self.assertEqual('jane@test.com',
683
 
                         config.extract_email_address('Jane <jane@test.com>'))
684
 
        self.assertRaises(errors.BzrError,
685
 
                          config.extract_email_address, 'Jane Tester')