1
# Copyright (C) 2005, 2006 Canonical Ltd
2
# Authors: Robert Collins <robert.collins@canonical.com>
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.
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.
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
18
"""Tests for finding and reading the bzr config file[s]."""
19
# import system imports here
20
from cStringIO import StringIO
24
#import bzrlib specific imports here
38
from bzrlib.util.configobj import configobj
41
sample_long_alias="log -r-15..-1 --line"
42
sample_config_text = u"""
44
email=Erik B\u00e5gfors <erik@bagfors.nu>
46
gpg_signing_command=gnome-gpg
48
user_global_option=something
51
ll=""" + sample_long_alias + "\n"
54
sample_always_signatures = """
56
check_signatures=ignore
57
create_signatures=always
60
sample_ignore_signatures = """
62
check_signatures=require
63
create_signatures=never
66
sample_maybe_signatures = """
68
check_signatures=ignore
69
create_signatures=when-required
72
sample_branches_text = """
73
[http://www.example.com]
75
email=Robert Collins <robertc@example.org>
76
normal_option = normal
77
appendpath_option = append
78
appendpath_option:policy = appendpath
79
norecurse_option = norecurse
80
norecurse_option:policy = norecurse
81
[http://www.example.com/ignoreparent]
82
# different project: ignore parent dir config
84
[http://www.example.com/norecurse]
85
# configuration items that only apply to this dir
87
normal_option = norecurse
88
[http://www.example.com/dir]
89
appendpath_option = normal
91
check_signatures=require
92
# test trailing / matching with no children
94
check_signatures=check-available
95
gpg_signing_command=false
96
user_local_option=local
97
# test trailing / matching
99
#subdirs will match but not the parent
101
check_signatures=ignore
102
post_commit=bzrlib.tests.test_config.post_commit
103
#testing explicit beats globs
107
class InstrumentedConfigObj(object):
108
"""A config obj look-enough-alike to record calls made to it."""
110
def __contains__(self, thing):
111
self._calls.append(('__contains__', thing))
114
def __getitem__(self, key):
115
self._calls.append(('__getitem__', key))
118
def __init__(self, input, encoding=None):
119
self._calls = [('__init__', input, encoding)]
121
def __setitem__(self, key, value):
122
self._calls.append(('__setitem__', key, value))
124
def __delitem__(self, key):
125
self._calls.append(('__delitem__', key))
128
self._calls.append(('keys',))
131
def write(self, arg):
132
self._calls.append(('write',))
134
def as_bool(self, value):
135
self._calls.append(('as_bool', value))
138
def get_value(self, section, name):
139
self._calls.append(('get_value', section, name))
143
class FakeBranch(object):
145
def __init__(self, base=None, user_id=None):
147
self.base = "http://example.com/branches/demo"
150
self._transport = self.control_files = \
151
FakeControlFilesAndTransport(user_id=user_id)
153
def lock_write(self):
160
class FakeControlFilesAndTransport(object):
162
def __init__(self, user_id=None):
165
self.files['email'] = user_id
166
self._transport = self
168
def get_utf8(self, filename):
170
raise AssertionError("get_utf8 should no longer be used")
172
def get(self, filename):
175
return StringIO(self.files[filename])
177
raise errors.NoSuchFile(filename)
179
def get_bytes(self, filename):
182
return self.files[filename]
184
raise errors.NoSuchFile(filename)
186
def put(self, filename, fileobj):
187
self.files[filename] = fileobj.read()
189
def put_file(self, filename, fileobj):
190
return self.put(filename, fileobj)
193
class InstrumentedConfig(config.Config):
194
"""An instrumented config that supplies stubs for template methods."""
197
super(InstrumentedConfig, self).__init__()
199
self._signatures = config.CHECK_NEVER
201
def _get_user_id(self):
202
self._calls.append('_get_user_id')
203
return "Robert Collins <robert.collins@example.org>"
205
def _get_signature_checking(self):
206
self._calls.append('_get_signature_checking')
207
return self._signatures
210
bool_config = """[DEFAULT]
219
class TestConfigObj(tests.TestCase):
221
def test_get_bool(self):
222
co = config.ConfigObj(StringIO(bool_config))
223
self.assertIs(co.get_bool('DEFAULT', 'active'), True)
224
self.assertIs(co.get_bool('DEFAULT', 'inactive'), False)
225
self.assertIs(co.get_bool('UPPERCASE', 'active'), True)
226
self.assertIs(co.get_bool('UPPERCASE', 'nonactive'), False)
228
def test_hash_sign_in_value(self):
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)
233
co = config.ConfigObj()
234
co['test'] = 'foo#bar'
236
self.assertEqual(lines, ['test = "foo#bar"'])
237
co2 = config.ConfigObj(lines)
238
self.assertEqual(co2['test'], 'foo#bar')
241
erroneous_config = """[section] # line 1
244
whocares=notme # line 4
248
class TestConfigObjErrors(tests.TestCase):
250
def test_duplicate_section_name_error_line(self):
252
co = configobj.ConfigObj(StringIO(erroneous_config),
254
except config.configobj.DuplicateError, e:
255
self.assertEqual(3, e.line_number)
257
self.fail('Error in config file not detected')
260
class TestConfig(tests.TestCase):
262
def test_constructs(self):
265
def test_no_default_editor(self):
266
self.assertRaises(NotImplementedError, config.Config().get_editor)
268
def test_user_email(self):
269
my_config = InstrumentedConfig()
270
self.assertEqual('robert.collins@example.org', my_config.user_email())
271
self.assertEqual(['_get_user_id'], my_config._calls)
273
def test_username(self):
274
my_config = InstrumentedConfig()
275
self.assertEqual('Robert Collins <robert.collins@example.org>',
276
my_config.username())
277
self.assertEqual(['_get_user_id'], my_config._calls)
279
def test_signatures_default(self):
280
my_config = config.Config()
281
self.assertFalse(my_config.signature_needed())
282
self.assertEqual(config.CHECK_IF_POSSIBLE,
283
my_config.signature_checking())
284
self.assertEqual(config.SIGN_WHEN_REQUIRED,
285
my_config.signing_policy())
287
def test_signatures_template_method(self):
288
my_config = InstrumentedConfig()
289
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
290
self.assertEqual(['_get_signature_checking'], my_config._calls)
292
def test_signatures_template_method_none(self):
293
my_config = InstrumentedConfig()
294
my_config._signatures = None
295
self.assertEqual(config.CHECK_IF_POSSIBLE,
296
my_config.signature_checking())
297
self.assertEqual(['_get_signature_checking'], my_config._calls)
299
def test_gpg_signing_command_default(self):
300
my_config = config.Config()
301
self.assertEqual('gpg', my_config.gpg_signing_command())
303
def test_get_user_option_default(self):
304
my_config = config.Config()
305
self.assertEqual(None, my_config.get_user_option('no_option'))
307
def test_post_commit_default(self):
308
my_config = config.Config()
309
self.assertEqual(None, my_config.post_commit())
311
def test_log_format_default(self):
312
my_config = config.Config()
313
self.assertEqual('long', my_config.log_format())
316
class TestConfigPath(tests.TestCase):
319
super(TestConfigPath, self).setUp()
320
os.environ['HOME'] = '/home/bogus'
321
if sys.platform == 'win32':
322
os.environ['BZR_HOME'] = \
323
r'C:\Documents and Settings\bogus\Application Data'
325
'C:/Documents and Settings/bogus/Application Data/bazaar/2.0'
327
self.bzr_home = '/home/bogus/.bazaar'
329
def test_config_dir(self):
330
self.assertEqual(config.config_dir(), self.bzr_home)
332
def test_config_filename(self):
333
self.assertEqual(config.config_filename(),
334
self.bzr_home + '/bazaar.conf')
336
def test_branches_config_filename(self):
337
self.assertEqual(config.branches_config_filename(),
338
self.bzr_home + '/branches.conf')
340
def test_locations_config_filename(self):
341
self.assertEqual(config.locations_config_filename(),
342
self.bzr_home + '/locations.conf')
344
def test_authentication_config_filename(self):
345
self.assertEqual(config.authentication_config_filename(),
346
self.bzr_home + '/authentication.conf')
349
class TestIniConfig(tests.TestCase):
351
def test_contructs(self):
352
my_config = config.IniBasedConfig("nothing")
354
def test_from_fp(self):
355
config_file = StringIO(sample_config_text.encode('utf-8'))
356
my_config = config.IniBasedConfig(None)
358
isinstance(my_config._get_parser(file=config_file),
359
configobj.ConfigObj))
361
def test_cached(self):
362
config_file = StringIO(sample_config_text.encode('utf-8'))
363
my_config = config.IniBasedConfig(None)
364
parser = my_config._get_parser(file=config_file)
365
self.failUnless(my_config._get_parser() is parser)
368
class TestGetConfig(tests.TestCase):
370
def test_constructs(self):
371
my_config = config.GlobalConfig()
373
def test_calls_read_filenames(self):
374
# replace the class that is constructed, to check its parameters
375
oldparserclass = config.ConfigObj
376
config.ConfigObj = InstrumentedConfigObj
377
my_config = config.GlobalConfig()
379
parser = my_config._get_parser()
381
config.ConfigObj = oldparserclass
382
self.failUnless(isinstance(parser, InstrumentedConfigObj))
383
self.assertEqual(parser._calls, [('__init__', config.config_filename(),
387
class TestBranchConfig(tests.TestCaseWithTransport):
389
def test_constructs(self):
390
branch = FakeBranch()
391
my_config = config.BranchConfig(branch)
392
self.assertRaises(TypeError, config.BranchConfig)
394
def test_get_location_config(self):
395
branch = FakeBranch()
396
my_config = config.BranchConfig(branch)
397
location_config = my_config._get_location_config()
398
self.assertEqual(branch.base, location_config.location)
399
self.failUnless(location_config is my_config._get_location_config())
401
def test_get_config(self):
402
"""The Branch.get_config method works properly"""
403
b = bzrdir.BzrDir.create_standalone_workingtree('.').branch
404
my_config = b.get_config()
405
self.assertIs(my_config.get_user_option('wacky'), None)
406
my_config.set_user_option('wacky', 'unlikely')
407
self.assertEqual(my_config.get_user_option('wacky'), 'unlikely')
409
# Ensure we get the same thing if we start again
410
b2 = branch.Branch.open('.')
411
my_config2 = b2.get_config()
412
self.assertEqual(my_config2.get_user_option('wacky'), 'unlikely')
414
def test_has_explicit_nickname(self):
415
b = self.make_branch('.')
416
self.assertFalse(b.get_config().has_explicit_nickname())
418
self.assertTrue(b.get_config().has_explicit_nickname())
420
def test_config_url(self):
421
"""The Branch.get_config will use section that uses a local url"""
422
branch = self.make_branch('branch')
423
self.assertEqual('branch', branch.nick)
425
locations = config.locations_config_filename()
426
config.ensure_config_dir_exists()
427
local_url = urlutils.local_path_to_url('branch')
428
open(locations, 'wb').write('[%s]\nnickname = foobar'
430
self.assertEqual('foobar', branch.nick)
432
def test_config_local_path(self):
433
"""The Branch.get_config will use a local system path"""
434
branch = self.make_branch('branch')
435
self.assertEqual('branch', branch.nick)
437
locations = config.locations_config_filename()
438
config.ensure_config_dir_exists()
439
open(locations, 'wb').write('[%s/branch]\nnickname = barry'
440
% (osutils.getcwd().encode('utf8'),))
441
self.assertEqual('barry', branch.nick)
443
def test_config_creates_local(self):
444
"""Creating a new entry in config uses a local path."""
445
branch = self.make_branch('branch', format='knit')
446
branch.set_push_location('http://foobar')
447
locations = config.locations_config_filename()
448
local_path = osutils.getcwd().encode('utf8')
449
# Surprisingly ConfigObj doesn't create a trailing newline
450
self.check_file_contents(locations,
452
'push_location = http://foobar\n'
453
'push_location:policy = norecurse\n'
456
def test_autonick_urlencoded(self):
457
b = self.make_branch('!repo')
458
self.assertEqual('!repo', b.get_config().get_nickname())
460
def test_warn_if_masked(self):
461
_warning = trace.warning
464
warnings.append(args[0] % args[1:])
466
def set_option(store, warn_masked=True):
468
conf.set_user_option('example_option', repr(store), store=store,
469
warn_masked=warn_masked)
470
def assertWarning(warning):
472
self.assertEqual(0, len(warnings))
474
self.assertEqual(1, len(warnings))
475
self.assertEqual(warning, warnings[0])
476
trace.warning = warning
478
branch = self.make_branch('.')
479
conf = branch.get_config()
480
set_option(config.STORE_GLOBAL)
482
set_option(config.STORE_BRANCH)
484
set_option(config.STORE_GLOBAL)
485
assertWarning('Value "4" is masked by "3" from branch.conf')
486
set_option(config.STORE_GLOBAL, warn_masked=False)
488
set_option(config.STORE_LOCATION)
490
set_option(config.STORE_BRANCH)
491
assertWarning('Value "3" is masked by "0" from locations.conf')
492
set_option(config.STORE_BRANCH, warn_masked=False)
495
trace.warning = _warning
498
class TestGlobalConfigItems(tests.TestCase):
500
def test_user_id(self):
501
config_file = StringIO(sample_config_text.encode('utf-8'))
502
my_config = config.GlobalConfig()
503
my_config._parser = my_config._get_parser(file=config_file)
504
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
505
my_config._get_user_id())
507
def test_absent_user_id(self):
508
config_file = StringIO("")
509
my_config = config.GlobalConfig()
510
my_config._parser = my_config._get_parser(file=config_file)
511
self.assertEqual(None, my_config._get_user_id())
513
def test_configured_editor(self):
514
config_file = StringIO(sample_config_text.encode('utf-8'))
515
my_config = config.GlobalConfig()
516
my_config._parser = my_config._get_parser(file=config_file)
517
self.assertEqual("vim", my_config.get_editor())
519
def test_signatures_always(self):
520
config_file = StringIO(sample_always_signatures)
521
my_config = config.GlobalConfig()
522
my_config._parser = my_config._get_parser(file=config_file)
523
self.assertEqual(config.CHECK_NEVER,
524
my_config.signature_checking())
525
self.assertEqual(config.SIGN_ALWAYS,
526
my_config.signing_policy())
527
self.assertEqual(True, my_config.signature_needed())
529
def test_signatures_if_possible(self):
530
config_file = StringIO(sample_maybe_signatures)
531
my_config = config.GlobalConfig()
532
my_config._parser = my_config._get_parser(file=config_file)
533
self.assertEqual(config.CHECK_NEVER,
534
my_config.signature_checking())
535
self.assertEqual(config.SIGN_WHEN_REQUIRED,
536
my_config.signing_policy())
537
self.assertEqual(False, my_config.signature_needed())
539
def test_signatures_ignore(self):
540
config_file = StringIO(sample_ignore_signatures)
541
my_config = config.GlobalConfig()
542
my_config._parser = my_config._get_parser(file=config_file)
543
self.assertEqual(config.CHECK_ALWAYS,
544
my_config.signature_checking())
545
self.assertEqual(config.SIGN_NEVER,
546
my_config.signing_policy())
547
self.assertEqual(False, my_config.signature_needed())
549
def _get_sample_config(self):
550
config_file = StringIO(sample_config_text.encode('utf-8'))
551
my_config = config.GlobalConfig()
552
my_config._parser = my_config._get_parser(file=config_file)
555
def test_gpg_signing_command(self):
556
my_config = self._get_sample_config()
557
self.assertEqual("gnome-gpg", my_config.gpg_signing_command())
558
self.assertEqual(False, my_config.signature_needed())
560
def _get_empty_config(self):
561
config_file = StringIO("")
562
my_config = config.GlobalConfig()
563
my_config._parser = my_config._get_parser(file=config_file)
566
def test_gpg_signing_command_unset(self):
567
my_config = self._get_empty_config()
568
self.assertEqual("gpg", my_config.gpg_signing_command())
570
def test_get_user_option_default(self):
571
my_config = self._get_empty_config()
572
self.assertEqual(None, my_config.get_user_option('no_option'))
574
def test_get_user_option_global(self):
575
my_config = self._get_sample_config()
576
self.assertEqual("something",
577
my_config.get_user_option('user_global_option'))
579
def test_post_commit_default(self):
580
my_config = self._get_sample_config()
581
self.assertEqual(None, my_config.post_commit())
583
def test_configured_logformat(self):
584
my_config = self._get_sample_config()
585
self.assertEqual("short", my_config.log_format())
587
def test_get_alias(self):
588
my_config = self._get_sample_config()
589
self.assertEqual('help', my_config.get_alias('h'))
591
def test_get_no_alias(self):
592
my_config = self._get_sample_config()
593
self.assertEqual(None, my_config.get_alias('foo'))
595
def test_get_long_alias(self):
596
my_config = self._get_sample_config()
597
self.assertEqual(sample_long_alias, my_config.get_alias('ll'))
600
class TestLocationConfig(tests.TestCaseInTempDir):
602
def test_constructs(self):
603
my_config = config.LocationConfig('http://example.com')
604
self.assertRaises(TypeError, config.LocationConfig)
606
def test_branch_calls_read_filenames(self):
607
# This is testing the correct file names are provided.
608
# TODO: consolidate with the test for GlobalConfigs filename checks.
610
# replace the class that is constructed, to check its parameters
611
oldparserclass = config.ConfigObj
612
config.ConfigObj = InstrumentedConfigObj
614
my_config = config.LocationConfig('http://www.example.com')
615
parser = my_config._get_parser()
617
config.ConfigObj = oldparserclass
618
self.failUnless(isinstance(parser, InstrumentedConfigObj))
619
self.assertEqual(parser._calls,
620
[('__init__', config.locations_config_filename(),
622
config.ensure_config_dir_exists()
623
#os.mkdir(config.config_dir())
624
f = file(config.branches_config_filename(), 'wb')
627
oldparserclass = config.ConfigObj
628
config.ConfigObj = InstrumentedConfigObj
630
my_config = config.LocationConfig('http://www.example.com')
631
parser = my_config._get_parser()
633
config.ConfigObj = oldparserclass
635
def test_get_global_config(self):
636
my_config = config.BranchConfig(FakeBranch('http://example.com'))
637
global_config = my_config._get_global_config()
638
self.failUnless(isinstance(global_config, config.GlobalConfig))
639
self.failUnless(global_config is my_config._get_global_config())
641
def test__get_matching_sections_no_match(self):
642
self.get_branch_config('/')
643
self.assertEqual([], self.my_location_config._get_matching_sections())
645
def test__get_matching_sections_exact(self):
646
self.get_branch_config('http://www.example.com')
647
self.assertEqual([('http://www.example.com', '')],
648
self.my_location_config._get_matching_sections())
650
def test__get_matching_sections_suffix_does_not(self):
651
self.get_branch_config('http://www.example.com-com')
652
self.assertEqual([], self.my_location_config._get_matching_sections())
654
def test__get_matching_sections_subdir_recursive(self):
655
self.get_branch_config('http://www.example.com/com')
656
self.assertEqual([('http://www.example.com', 'com')],
657
self.my_location_config._get_matching_sections())
659
def test__get_matching_sections_ignoreparent(self):
660
self.get_branch_config('http://www.example.com/ignoreparent')
661
self.assertEqual([('http://www.example.com/ignoreparent', '')],
662
self.my_location_config._get_matching_sections())
664
def test__get_matching_sections_ignoreparent_subdir(self):
665
self.get_branch_config(
666
'http://www.example.com/ignoreparent/childbranch')
667
self.assertEqual([('http://www.example.com/ignoreparent',
669
self.my_location_config._get_matching_sections())
671
def test__get_matching_sections_subdir_trailing_slash(self):
672
self.get_branch_config('/b')
673
self.assertEqual([('/b/', '')],
674
self.my_location_config._get_matching_sections())
676
def test__get_matching_sections_subdir_child(self):
677
self.get_branch_config('/a/foo')
678
self.assertEqual([('/a/*', ''), ('/a/', 'foo')],
679
self.my_location_config._get_matching_sections())
681
def test__get_matching_sections_subdir_child_child(self):
682
self.get_branch_config('/a/foo/bar')
683
self.assertEqual([('/a/*', 'bar'), ('/a/', 'foo/bar')],
684
self.my_location_config._get_matching_sections())
686
def test__get_matching_sections_trailing_slash_with_children(self):
687
self.get_branch_config('/a/')
688
self.assertEqual([('/a/', '')],
689
self.my_location_config._get_matching_sections())
691
def test__get_matching_sections_explicit_over_glob(self):
692
# XXX: 2006-09-08 jamesh
693
# This test only passes because ord('c') > ord('*'). If there
694
# was a config section for '/a/?', it would get precedence
696
self.get_branch_config('/a/c')
697
self.assertEqual([('/a/c', ''), ('/a/*', ''), ('/a/', 'c')],
698
self.my_location_config._get_matching_sections())
700
def test__get_option_policy_normal(self):
701
self.get_branch_config('http://www.example.com')
703
self.my_location_config._get_config_policy(
704
'http://www.example.com', 'normal_option'),
707
def test__get_option_policy_norecurse(self):
708
self.get_branch_config('http://www.example.com')
710
self.my_location_config._get_option_policy(
711
'http://www.example.com', 'norecurse_option'),
712
config.POLICY_NORECURSE)
713
# Test old recurse=False setting:
715
self.my_location_config._get_option_policy(
716
'http://www.example.com/norecurse', 'normal_option'),
717
config.POLICY_NORECURSE)
719
def test__get_option_policy_normal(self):
720
self.get_branch_config('http://www.example.com')
722
self.my_location_config._get_option_policy(
723
'http://www.example.com', 'appendpath_option'),
724
config.POLICY_APPENDPATH)
726
def test_location_without_username(self):
727
self.get_branch_config('http://www.example.com/ignoreparent')
728
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
729
self.my_config.username())
731
def test_location_not_listed(self):
732
"""Test that the global username is used when no location matches"""
733
self.get_branch_config('/home/robertc/sources')
734
self.assertEqual(u'Erik B\u00e5gfors <erik@bagfors.nu>',
735
self.my_config.username())
737
def test_overriding_location(self):
738
self.get_branch_config('http://www.example.com/foo')
739
self.assertEqual('Robert Collins <robertc@example.org>',
740
self.my_config.username())
742
def test_signatures_not_set(self):
743
self.get_branch_config('http://www.example.com',
744
global_config=sample_ignore_signatures)
745
self.assertEqual(config.CHECK_ALWAYS,
746
self.my_config.signature_checking())
747
self.assertEqual(config.SIGN_NEVER,
748
self.my_config.signing_policy())
750
def test_signatures_never(self):
751
self.get_branch_config('/a/c')
752
self.assertEqual(config.CHECK_NEVER,
753
self.my_config.signature_checking())
755
def test_signatures_when_available(self):
756
self.get_branch_config('/a/', global_config=sample_ignore_signatures)
757
self.assertEqual(config.CHECK_IF_POSSIBLE,
758
self.my_config.signature_checking())
760
def test_signatures_always(self):
761
self.get_branch_config('/b')
762
self.assertEqual(config.CHECK_ALWAYS,
763
self.my_config.signature_checking())
765
def test_gpg_signing_command(self):
766
self.get_branch_config('/b')
767
self.assertEqual("gnome-gpg", self.my_config.gpg_signing_command())
769
def test_gpg_signing_command_missing(self):
770
self.get_branch_config('/a')
771
self.assertEqual("false", self.my_config.gpg_signing_command())
773
def test_get_user_option_global(self):
774
self.get_branch_config('/a')
775
self.assertEqual('something',
776
self.my_config.get_user_option('user_global_option'))
778
def test_get_user_option_local(self):
779
self.get_branch_config('/a')
780
self.assertEqual('local',
781
self.my_config.get_user_option('user_local_option'))
783
def test_get_user_option_appendpath(self):
784
# returned as is for the base path:
785
self.get_branch_config('http://www.example.com')
786
self.assertEqual('append',
787
self.my_config.get_user_option('appendpath_option'))
788
# Extra path components get appended:
789
self.get_branch_config('http://www.example.com/a/b/c')
790
self.assertEqual('append/a/b/c',
791
self.my_config.get_user_option('appendpath_option'))
792
# Overriden for http://www.example.com/dir, where it is a
794
self.get_branch_config('http://www.example.com/dir/a/b/c')
795
self.assertEqual('normal',
796
self.my_config.get_user_option('appendpath_option'))
798
def test_get_user_option_norecurse(self):
799
self.get_branch_config('http://www.example.com')
800
self.assertEqual('norecurse',
801
self.my_config.get_user_option('norecurse_option'))
802
self.get_branch_config('http://www.example.com/dir')
803
self.assertEqual(None,
804
self.my_config.get_user_option('norecurse_option'))
805
# http://www.example.com/norecurse is a recurse=False section
806
# that redefines normal_option. Subdirectories do not pick up
808
self.get_branch_config('http://www.example.com/norecurse')
809
self.assertEqual('norecurse',
810
self.my_config.get_user_option('normal_option'))
811
self.get_branch_config('http://www.example.com/norecurse/subdir')
812
self.assertEqual('normal',
813
self.my_config.get_user_option('normal_option'))
815
def test_set_user_option_norecurse(self):
816
self.get_branch_config('http://www.example.com')
817
self.my_config.set_user_option('foo', 'bar',
818
store=config.STORE_LOCATION_NORECURSE)
820
self.my_location_config._get_option_policy(
821
'http://www.example.com', 'foo'),
822
config.POLICY_NORECURSE)
824
def test_set_user_option_appendpath(self):
825
self.get_branch_config('http://www.example.com')
826
self.my_config.set_user_option('foo', 'bar',
827
store=config.STORE_LOCATION_APPENDPATH)
829
self.my_location_config._get_option_policy(
830
'http://www.example.com', 'foo'),
831
config.POLICY_APPENDPATH)
833
def test_set_user_option_change_policy(self):
834
self.get_branch_config('http://www.example.com')
835
self.my_config.set_user_option('norecurse_option', 'normal',
836
store=config.STORE_LOCATION)
838
self.my_location_config._get_option_policy(
839
'http://www.example.com', 'norecurse_option'),
842
def test_set_user_option_recurse_false_section(self):
843
# The following section has recurse=False set. The test is to
844
# make sure that a normal option can be added to the section,
845
# converting recurse=False to the norecurse policy.
846
self.get_branch_config('http://www.example.com/norecurse')
847
self.callDeprecated(['The recurse option is deprecated as of 0.14. '
848
'The section "http://www.example.com/norecurse" '
849
'has been converted to use policies.'],
850
self.my_config.set_user_option,
851
'foo', 'bar', store=config.STORE_LOCATION)
853
self.my_location_config._get_option_policy(
854
'http://www.example.com/norecurse', 'foo'),
856
# The previously existing option is still norecurse:
858
self.my_location_config._get_option_policy(
859
'http://www.example.com/norecurse', 'normal_option'),
860
config.POLICY_NORECURSE)
862
def test_post_commit_default(self):
863
self.get_branch_config('/a/c')
864
self.assertEqual('bzrlib.tests.test_config.post_commit',
865
self.my_config.post_commit())
867
def get_branch_config(self, location, global_config=None):
868
if global_config is None:
869
global_file = StringIO(sample_config_text.encode('utf-8'))
871
global_file = StringIO(global_config.encode('utf-8'))
872
branches_file = StringIO(sample_branches_text.encode('utf-8'))
873
self.my_config = config.BranchConfig(FakeBranch(location))
874
# Force location config to use specified file
875
self.my_location_config = self.my_config._get_location_config()
876
self.my_location_config._get_parser(branches_file)
877
# Force global config to use specified file
878
self.my_config._get_global_config()._get_parser(global_file)
880
def test_set_user_setting_sets_and_saves(self):
881
self.get_branch_config('/a/c')
882
record = InstrumentedConfigObj("foo")
883
self.my_location_config._parser = record
885
real_mkdir = os.mkdir
887
def checked_mkdir(path, mode=0777):
888
self.log('making directory: %s', path)
889
real_mkdir(path, mode)
892
os.mkdir = checked_mkdir
894
self.callDeprecated(['The recurse option is deprecated as of '
895
'0.14. The section "/a/c" has been '
896
'converted to use policies.'],
897
self.my_config.set_user_option,
898
'foo', 'bar', store=config.STORE_LOCATION)
900
os.mkdir = real_mkdir
902
self.failUnless(self.created, 'Failed to create ~/.bazaar')
903
self.assertEqual([('__contains__', '/a/c'),
904
('__contains__', '/a/c/'),
905
('__setitem__', '/a/c', {}),
906
('__getitem__', '/a/c'),
907
('__setitem__', 'foo', 'bar'),
908
('__getitem__', '/a/c'),
909
('as_bool', 'recurse'),
910
('__getitem__', '/a/c'),
911
('__delitem__', 'recurse'),
912
('__getitem__', '/a/c'),
914
('__getitem__', '/a/c'),
915
('__contains__', 'foo:policy'),
919
def test_set_user_setting_sets_and_saves2(self):
920
self.get_branch_config('/a/c')
921
self.assertIs(self.my_config.get_user_option('foo'), None)
922
self.my_config.set_user_option('foo', 'bar')
924
self.my_config.branch.control_files.files['branch.conf'],
926
self.assertEqual(self.my_config.get_user_option('foo'), 'bar')
927
self.my_config.set_user_option('foo', 'baz',
928
store=config.STORE_LOCATION)
929
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
930
self.my_config.set_user_option('foo', 'qux')
931
self.assertEqual(self.my_config.get_user_option('foo'), 'baz')
933
def test_get_bzr_remote_path(self):
934
my_config = config.LocationConfig('/a/c')
935
self.assertEqual('bzr', my_config.get_bzr_remote_path())
936
my_config.set_user_option('bzr_remote_path', '/path-bzr')
937
self.assertEqual('/path-bzr', my_config.get_bzr_remote_path())
938
os.environ['BZR_REMOTE_PATH'] = '/environ-bzr'
939
self.assertEqual('/environ-bzr', my_config.get_bzr_remote_path())
942
precedence_global = 'option = global'
943
precedence_branch = 'option = branch'
944
precedence_location = """
948
[http://example.com/specific]
953
class TestBranchConfigItems(tests.TestCaseInTempDir):
955
def get_branch_config(self, global_config=None, location=None,
956
location_config=None, branch_data_config=None):
957
my_config = config.BranchConfig(FakeBranch(location))
958
if global_config is not None:
959
global_file = StringIO(global_config.encode('utf-8'))
960
my_config._get_global_config()._get_parser(global_file)
961
self.my_location_config = my_config._get_location_config()
962
if location_config is not None:
963
location_file = StringIO(location_config.encode('utf-8'))
964
self.my_location_config._get_parser(location_file)
965
if branch_data_config is not None:
966
my_config.branch.control_files.files['branch.conf'] = \
970
def test_user_id(self):
971
branch = FakeBranch(user_id='Robert Collins <robertc@example.net>')
972
my_config = config.BranchConfig(branch)
973
self.assertEqual("Robert Collins <robertc@example.net>",
974
my_config.username())
975
my_config.branch.control_files.files['email'] = "John"
976
my_config.set_user_option('email',
977
"Robert Collins <robertc@example.org>")
978
self.assertEqual("John", my_config.username())
979
del my_config.branch.control_files.files['email']
980
self.assertEqual("Robert Collins <robertc@example.org>",
981
my_config.username())
983
def test_not_set_in_branch(self):
984
my_config = self.get_branch_config(sample_config_text)
985
self.assertEqual(u"Erik B\u00e5gfors <erik@bagfors.nu>",
986
my_config._get_user_id())
987
my_config.branch.control_files.files['email'] = "John"
988
self.assertEqual("John", my_config._get_user_id())
990
def test_BZR_EMAIL_OVERRIDES(self):
991
os.environ['BZR_EMAIL'] = "Robert Collins <robertc@example.org>"
992
branch = FakeBranch()
993
my_config = config.BranchConfig(branch)
994
self.assertEqual("Robert Collins <robertc@example.org>",
995
my_config.username())
997
def test_signatures_forced(self):
998
my_config = self.get_branch_config(
999
global_config=sample_always_signatures)
1000
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1001
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1002
self.assertTrue(my_config.signature_needed())
1004
def test_signatures_forced_branch(self):
1005
my_config = self.get_branch_config(
1006
global_config=sample_ignore_signatures,
1007
branch_data_config=sample_always_signatures)
1008
self.assertEqual(config.CHECK_NEVER, my_config.signature_checking())
1009
self.assertEqual(config.SIGN_ALWAYS, my_config.signing_policy())
1010
self.assertTrue(my_config.signature_needed())
1012
def test_gpg_signing_command(self):
1013
my_config = self.get_branch_config(
1014
# branch data cannot set gpg_signing_command
1015
branch_data_config="gpg_signing_command=pgp")
1016
config_file = StringIO(sample_config_text.encode('utf-8'))
1017
my_config._get_global_config()._get_parser(config_file)
1018
self.assertEqual('gnome-gpg', my_config.gpg_signing_command())
1020
def test_get_user_option_global(self):
1021
branch = FakeBranch()
1022
my_config = config.BranchConfig(branch)
1023
config_file = StringIO(sample_config_text.encode('utf-8'))
1024
(my_config._get_global_config()._get_parser(config_file))
1025
self.assertEqual('something',
1026
my_config.get_user_option('user_global_option'))
1028
def test_post_commit_default(self):
1029
branch = FakeBranch()
1030
my_config = self.get_branch_config(sample_config_text, '/a/c',
1031
sample_branches_text)
1032
self.assertEqual(my_config.branch.base, '/a/c')
1033
self.assertEqual('bzrlib.tests.test_config.post_commit',
1034
my_config.post_commit())
1035
my_config.set_user_option('post_commit', 'rmtree_root')
1036
# post-commit is ignored when bresent in branch data
1037
self.assertEqual('bzrlib.tests.test_config.post_commit',
1038
my_config.post_commit())
1039
my_config.set_user_option('post_commit', 'rmtree_root',
1040
store=config.STORE_LOCATION)
1041
self.assertEqual('rmtree_root', my_config.post_commit())
1043
def test_config_precedence(self):
1044
my_config = self.get_branch_config(global_config=precedence_global)
1045
self.assertEqual(my_config.get_user_option('option'), 'global')
1046
my_config = self.get_branch_config(global_config=precedence_global,
1047
branch_data_config=precedence_branch)
1048
self.assertEqual(my_config.get_user_option('option'), 'branch')
1049
my_config = self.get_branch_config(global_config=precedence_global,
1050
branch_data_config=precedence_branch,
1051
location_config=precedence_location)
1052
self.assertEqual(my_config.get_user_option('option'), 'recurse')
1053
my_config = self.get_branch_config(global_config=precedence_global,
1054
branch_data_config=precedence_branch,
1055
location_config=precedence_location,
1056
location='http://example.com/specific')
1057
self.assertEqual(my_config.get_user_option('option'), 'exact')
1059
def test_get_mail_client(self):
1060
config = self.get_branch_config()
1061
client = config.get_mail_client()
1062
self.assertIsInstance(client, mail_client.DefaultMail)
1065
config.set_user_option('mail_client', 'evolution')
1066
client = config.get_mail_client()
1067
self.assertIsInstance(client, mail_client.Evolution)
1069
config.set_user_option('mail_client', 'kmail')
1070
client = config.get_mail_client()
1071
self.assertIsInstance(client, mail_client.KMail)
1073
config.set_user_option('mail_client', 'mutt')
1074
client = config.get_mail_client()
1075
self.assertIsInstance(client, mail_client.Mutt)
1077
config.set_user_option('mail_client', 'thunderbird')
1078
client = config.get_mail_client()
1079
self.assertIsInstance(client, mail_client.Thunderbird)
1082
config.set_user_option('mail_client', 'default')
1083
client = config.get_mail_client()
1084
self.assertIsInstance(client, mail_client.DefaultMail)
1086
config.set_user_option('mail_client', 'editor')
1087
client = config.get_mail_client()
1088
self.assertIsInstance(client, mail_client.Editor)
1090
config.set_user_option('mail_client', 'mapi')
1091
client = config.get_mail_client()
1092
self.assertIsInstance(client, mail_client.MAPIClient)
1094
config.set_user_option('mail_client', 'xdg-email')
1095
client = config.get_mail_client()
1096
self.assertIsInstance(client, mail_client.XDGEmail)
1098
config.set_user_option('mail_client', 'firebird')
1099
self.assertRaises(errors.UnknownMailClient, config.get_mail_client)
1102
class TestMailAddressExtraction(tests.TestCase):
1104
def test_extract_email_address(self):
1105
self.assertEqual('jane@test.com',
1106
config.extract_email_address('Jane <jane@test.com>'))
1107
self.assertRaises(errors.NoEmailInUsername,
1108
config.extract_email_address, 'Jane Tester')
1110
def test_parse_username(self):
1111
self.assertEqual(('', 'jdoe@example.com'),
1112
config.parse_username('jdoe@example.com'))
1113
self.assertEqual(('', 'jdoe@example.com'),
1114
config.parse_username('<jdoe@example.com>'))
1115
self.assertEqual(('John Doe', 'jdoe@example.com'),
1116
config.parse_username('John Doe <jdoe@example.com>'))
1117
self.assertEqual(('John Doe', ''),
1118
config.parse_username('John Doe'))
1119
self.assertEqual(('John Doe', 'jdoe@example.com'),
1120
config.parse_username('John Doe jdoe@example.com'))
1122
class TestTreeConfig(tests.TestCaseWithTransport):
1124
def test_get_value(self):
1125
"""Test that retreiving a value from a section is possible"""
1126
branch = self.make_branch('.')
1127
tree_config = config.TreeConfig(branch)
1128
tree_config.set_option('value', 'key', 'SECTION')
1129
tree_config.set_option('value2', 'key2')
1130
tree_config.set_option('value3-top', 'key3')
1131
tree_config.set_option('value3-section', 'key3', 'SECTION')
1132
value = tree_config.get_option('key', 'SECTION')
1133
self.assertEqual(value, 'value')
1134
value = tree_config.get_option('key2')
1135
self.assertEqual(value, 'value2')
1136
self.assertEqual(tree_config.get_option('non-existant'), None)
1137
value = tree_config.get_option('non-existant', 'SECTION')
1138
self.assertEqual(value, None)
1139
value = tree_config.get_option('non-existant', default='default')
1140
self.assertEqual(value, 'default')
1141
self.assertEqual(tree_config.get_option('key2', 'NOSECTION'), None)
1142
value = tree_config.get_option('key2', 'NOSECTION', default='default')
1143
self.assertEqual(value, 'default')
1144
value = tree_config.get_option('key3')
1145
self.assertEqual(value, 'value3-top')
1146
value = tree_config.get_option('key3', 'SECTION')
1147
self.assertEqual(value, 'value3-section')
1150
class TestTransportConfig(tests.TestCaseWithTransport):
1152
def test_get_value(self):
1153
"""Test that retreiving a value from a section is possible"""
1154
bzrdir_config = config.TransportConfig(transport.get_transport('.'),
1156
bzrdir_config.set_option('value', 'key', 'SECTION')
1157
bzrdir_config.set_option('value2', 'key2')
1158
bzrdir_config.set_option('value3-top', 'key3')
1159
bzrdir_config.set_option('value3-section', 'key3', 'SECTION')
1160
value = bzrdir_config.get_option('key', 'SECTION')
1161
self.assertEqual(value, 'value')
1162
value = bzrdir_config.get_option('key2')
1163
self.assertEqual(value, 'value2')
1164
self.assertEqual(bzrdir_config.get_option('non-existant'), None)
1165
value = bzrdir_config.get_option('non-existant', 'SECTION')
1166
self.assertEqual(value, None)
1167
value = bzrdir_config.get_option('non-existant', default='default')
1168
self.assertEqual(value, 'default')
1169
self.assertEqual(bzrdir_config.get_option('key2', 'NOSECTION'), None)
1170
value = bzrdir_config.get_option('key2', 'NOSECTION',
1172
self.assertEqual(value, 'default')
1173
value = bzrdir_config.get_option('key3')
1174
self.assertEqual(value, 'value3-top')
1175
value = bzrdir_config.get_option('key3', 'SECTION')
1176
self.assertEqual(value, 'value3-section')
1179
class TestAuthenticationConfigFile(tests.TestCase):
1180
"""Test the authentication.conf file matching"""
1182
def _got_user_passwd(self, expected_user, expected_password,
1183
config, *args, **kwargs):
1184
credentials = config.get_credentials(*args, **kwargs)
1185
if credentials is None:
1189
user = credentials['user']
1190
password = credentials['password']
1191
self.assertEquals(expected_user, user)
1192
self.assertEquals(expected_password, password)
1194
def test_empty_config(self):
1195
conf = config.AuthenticationConfig(_file=StringIO())
1196
self.assertEquals({}, conf._get_config())
1197
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1199
def test_missing_auth_section_header(self):
1200
conf = config.AuthenticationConfig(_file=StringIO('foo = bar'))
1201
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1203
def test_auth_section_header_not_closed(self):
1204
conf = config.AuthenticationConfig(_file=StringIO('[DEF'))
1205
self.assertRaises(errors.ParseConfigError, conf._get_config)
1207
def test_auth_value_not_boolean(self):
1208
conf = config.AuthenticationConfig(_file=StringIO(
1212
verify_certificates=askme # Error: Not a boolean
1214
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1216
def test_auth_value_not_int(self):
1217
conf = config.AuthenticationConfig(_file=StringIO(
1221
port=port # Error: Not an int
1223
self.assertRaises(ValueError, conf.get_credentials, 'ftp', 'foo.net')
1225
def test_credentials_for_scheme_host(self):
1226
conf = config.AuthenticationConfig(_file=StringIO(
1227
"""# Identity on foo.net
1232
password=secret-pass
1235
self._got_user_passwd('joe', 'secret-pass', conf, 'ftp', 'foo.net')
1237
self._got_user_passwd(None, None, conf, 'http', 'foo.net')
1239
self._got_user_passwd(None, None, conf, 'ftp', 'bar.net')
1241
def test_credentials_for_host_port(self):
1242
conf = config.AuthenticationConfig(_file=StringIO(
1243
"""# Identity on foo.net
1249
password=secret-pass
1252
self._got_user_passwd('joe', 'secret-pass',
1253
conf, 'ftp', 'foo.net', port=10021)
1255
self._got_user_passwd(None, None, conf, 'ftp', 'foo.net')
1257
def test_for_matching_host(self):
1258
conf = config.AuthenticationConfig(_file=StringIO(
1259
"""# Identity on foo.net
1265
[sourceforge domain]
1272
self._got_user_passwd('georges', 'bendover',
1273
conf, 'bzr', 'foo.bzr.sf.net')
1275
self._got_user_passwd(None, None,
1276
conf, 'bzr', 'bbzr.sf.net')
1278
def test_for_matching_host_None(self):
1279
conf = config.AuthenticationConfig(_file=StringIO(
1280
"""# Identity on foo.net
1290
self._got_user_passwd('joe', 'joepass',
1291
conf, 'bzr', 'quux.net')
1292
# no host but different scheme
1293
self._got_user_passwd('georges', 'bendover',
1294
conf, 'ftp', 'quux.net')
1296
def test_credentials_for_path(self):
1297
conf = config.AuthenticationConfig(_file=StringIO(
1313
self._got_user_passwd(None, None,
1314
conf, 'http', host='bar.org', path='/dir3')
1316
self._got_user_passwd('georges', 'bendover',
1317
conf, 'http', host='bar.org', path='/dir2')
1319
self._got_user_passwd('jim', 'jimpass',
1320
conf, 'http', host='bar.org',path='/dir1/subdir')
1322
def test_credentials_for_user(self):
1323
conf = config.AuthenticationConfig(_file=StringIO(
1332
self._got_user_passwd('jim', 'jimpass',
1333
conf, 'http', 'bar.org')
1335
self._got_user_passwd('jim', 'jimpass',
1336
conf, 'http', 'bar.org', user='jim')
1337
# Don't get a different user if one is specified
1338
self._got_user_passwd(None, None,
1339
conf, 'http', 'bar.org', user='georges')
1341
def test_credentials_for_user_without_password(self):
1342
conf = config.AuthenticationConfig(_file=StringIO(
1349
# Get user but no password
1350
self._got_user_passwd('jim', None,
1351
conf, 'http', 'bar.org')
1353
def test_verify_certificates(self):
1354
conf = config.AuthenticationConfig(_file=StringIO(
1361
verify_certificates=False
1368
credentials = conf.get_credentials('https', 'bar.org')
1369
self.assertEquals(False, credentials.get('verify_certificates'))
1370
credentials = conf.get_credentials('https', 'foo.net')
1371
self.assertEquals(True, credentials.get('verify_certificates'))
1374
class TestAuthenticationConfig(tests.TestCase):
1375
"""Test AuthenticationConfig behaviour"""
1377
def _check_default_prompt(self, expected_prompt_format, scheme,
1378
host=None, port=None, realm=None, path=None):
1381
user, password = 'jim', 'precious'
1382
expected_prompt = expected_prompt_format % {
1383
'scheme': scheme, 'host': host, 'port': port,
1384
'user': user, 'realm': realm}
1386
stdout = tests.StringIOWrapper()
1387
ui.ui_factory = tests.TestUIFactory(stdin=password + '\n',
1389
# We use an empty conf so that the user is always prompted
1390
conf = config.AuthenticationConfig()
1391
self.assertEquals(password,
1392
conf.get_password(scheme, host, user, port=port,
1393
realm=realm, path=path))
1394
self.assertEquals(stdout.getvalue(), expected_prompt)
1396
def test_default_prompts(self):
1397
# HTTP prompts can't be tested here, see test_http.py
1398
self._check_default_prompt('FTP %(user)s@%(host)s password: ', 'ftp')
1399
self._check_default_prompt('FTP %(user)s@%(host)s:%(port)d password: ',
1402
self._check_default_prompt('SSH %(user)s@%(host)s:%(port)d password: ',
1404
# SMTP port handling is a bit special (it's handled if embedded in the
1406
# FIXME: should we: forbid that, extend it to other schemes, leave
1407
# things as they are that's fine thank you ?
1408
self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1410
self._check_default_prompt('SMTP %(user)s@%(host)s password: ',
1411
'smtp', host='bar.org:10025')
1412
self._check_default_prompt(
1413
'SMTP %(user)s@%(host)s:%(port)d password: ',
1416
def test_ssh_password_emits_warning(self):
1417
conf = config.AuthenticationConfig(_file=StringIO(
1425
entered_password = 'typed-by-hand'
1426
stdout = tests.StringIOWrapper()
1427
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1430
# Since the password defined in the authentication config is ignored,
1431
# the user is prompted
1432
self.assertEquals(entered_password,
1433
conf.get_password('ssh', 'bar.org', user='jim'))
1434
self.assertContainsRe(
1435
self._get_log(keep_log_file=True),
1436
'password ignored in section \[ssh with password\]')
1438
def test_ssh_without_password_doesnt_emit_warning(self):
1439
conf = config.AuthenticationConfig(_file=StringIO(
1446
entered_password = 'typed-by-hand'
1447
stdout = tests.StringIOWrapper()
1448
ui.ui_factory = tests.TestUIFactory(stdin=entered_password + '\n',
1451
# Since the password defined in the authentication config is ignored,
1452
# the user is prompted
1453
self.assertEquals(entered_password,
1454
conf.get_password('ssh', 'bar.org', user='jim'))
1455
# No warning shoud be emitted since there is no password. We are only
1457
self.assertNotContainsRe(
1458
self._get_log(keep_log_file=True),
1459
'password ignored in section \[ssh with password\]')
1462
# FIXME: Once we have a way to declare authentication to all test servers, we
1463
# can implement generic tests.
1464
# test_user_password_in_url
1465
# test_user_in_url_password_from_config
1466
# test_user_in_url_password_prompted
1467
# test_user_in_config
1468
# test_user_getpass.getuser
1469
# test_user_prompted ?
1470
class TestAuthenticationRing(tests.TestCaseWithTransport):
added
removed
bzrlib/tests/test_config.py
