Repository navigation
Expand file tree
/
Copy pathtest_config.py
More file actions
1299 lines (1118 loc) · 58.8 KB
/
Copy pathtest_config.py
File metadata and controls
1299 lines (1118 loc) · 58.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
#
# This module is part of GitPython and is released under the
# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
import glob
import io
import os
import os.path as osp
import subprocess
import sys
import time
from unittest import mock
import pytest
from git import GitConfigParser, Repo
from git.compat import defenc
from git.config import _OMD, cp
from git.util import cwd, rmfile
from test.lib import SkipTest, TestCase, fixture_path, with_rw_directory
_tc_lock_fpaths = osp.join(osp.dirname(__file__), "fixtures/*.lock")
def _rm_lock_files():
for lfp in glob.glob(_tc_lock_fpaths):
rmfile(lfp)
class TestBase(TestCase):
def setUp(self):
_rm_lock_files()
def tearDown(self):
for lfp in glob.glob(_tc_lock_fpaths):
if osp.isfile(lfp):
raise AssertionError("Previous TC left hanging git-lock file: {}".format(lfp))
def _to_memcache(self, file_path):
with open(file_path, "rb") as fp:
sio = io.BytesIO(fp.read())
sio.name = file_path
return sio
def test_read_write(self):
# The writer must create the exact same file as the one read before.
for filename in ("git_config", "git_config_global"):
file_obj = self._to_memcache(fixture_path(filename))
with GitConfigParser(file_obj, read_only=False) as w_config:
w_config.read() # Enforce reading.
assert w_config._sections
w_config.write() # Enforce writing.
# We stripped lines when reading, so the results differ.
assert file_obj.getvalue()
self.assertEqual(
file_obj.getvalue(),
self._to_memcache(fixture_path(filename)).getvalue(),
)
# Creating an additional config writer must fail due to exclusive
# access.
with self.assertRaises(IOError):
GitConfigParser(file_obj, read_only=False)
# Should still have a lock and be able to make changes.
assert w_config._lock._has_lock()
# Changes should be written right away.
sname = "my_section"
oname = "mykey"
val = "myvalue"
w_config.add_section(sname)
assert w_config.has_section(sname)
w_config.set(sname, oname, val)
assert w_config.has_option(sname, oname)
assert w_config.get(sname, oname) == val
sname_new = "new_section"
oname_new = "new_key"
ival = 10
w_config.set_value(sname_new, oname_new, ival)
assert w_config.get_value(sname_new, oname_new) == ival
file_obj.seek(0)
r_config = GitConfigParser(file_obj, read_only=True)
assert r_config.has_section(sname)
assert r_config.has_option(sname, oname)
assert r_config.get(sname, oname) == val
# END for each filename
def test_includes_order(self):
with GitConfigParser(list(map(fixture_path, ("git_config", "git_config_global")))) as r_config:
r_config.read() # Enforce reading.
# Simple inclusions, again checking them taking precedence.
assert r_config.get_value("sec", "var0") == "value0_included"
# This one should take the git_config_global value since included values
# must be considered as soon as they get them.
assert r_config.get_value("diff", "tool") == "meld"
try:
# FIXME: Split this assertion out somehow and mark it xfail (or fix it).
assert r_config.get_value("sec", "var1") == "value1_main"
except AssertionError as e:
raise SkipTest("Known failure -- included values are not in effect right away") from e
@with_rw_directory
def test_case_insensitive_names(self, rw_dir):
config_path = osp.join(rw_dir, "config")
with open(config_path, "wb") as config_file:
config_file.write(
b"[core]\n\tBigName = 1\n"
b"[CoRe]\n\tbigname = 2\n\tFlag\n"
b'[REMOTE "Origin"]\n\tUrl = upper\n'
b'[remote "origin"]\n\tURL = lower\n'
)
with GitConfigParser(config_path) as config:
for section in ("core", "CORE", "CoRe"):
for option in ("BigName", "bigname", "BIGNAME"):
self.assertTrue(config.has_section(section))
self.assertTrue(config.has_option(section, option))
self.assertEqual(config.get(section, option), "2")
self.assertEqual(config.getint(section, option), 2)
self.assertEqual(config.get_value(section, option), 2)
self.assertEqual(config.get_values(section, option), [1, 2])
self.assertIs(config.getboolean(section, "FLAG"), True)
self.assertEqual(config.sections(), ["core", 'REMOTE "Origin"', 'remote "origin"'])
self.assertEqual(config.items("CORE"), [("BigName", "2"), ("Flag", None)])
self.assertEqual(config.items_all("CORE"), [("BigName", ["1", "2"]), ("Flag", [None])])
self.assertIn("BigName", config.options("CORE"))
self.assertEqual(config.get('remote "Origin"', "URL"), "upper")
self.assertEqual(config.get('REMOTE "origin"', "url"), "lower")
self.assertFalse(config.has_section('remote "ORIGIN"'))
with self.assertRaises(cp.NoSectionError):
config.get('remote "ORIGIN"', "url")
git_config = ["git", "config", "--file", config_path]
self.assertEqual(subprocess.check_output(git_config + ["--get-all", "CORE.BIGNAME"]), b"1\n2\n")
self.assertEqual(subprocess.check_output(git_config + ["--get", "remote.Origin.URL"]), b"upper\n")
self.assertEqual(subprocess.check_output(git_config + ["--get", "REMOTE.origin.url"]), b"lower\n")
@with_rw_directory
def test_case_insensitive_writes_preserve_spelling(self, rw_dir):
config_path = osp.join(rw_dir, "config")
content = b'[CoRe]\n\tBigName = 1\n[REMOTE "Origin"]\n\tUrl = upper\n'
with open(config_path, "wb") as config_file:
config_file.write(content)
with GitConfigParser(config_path, read_only=False) as config:
config.set_value("core", "bigname", 1)
with open(config_path, "rb") as config_file:
self.assertEqual(config_file.read(), content)
with self.assertRaises(cp.DuplicateSectionError):
config.add_section("CORE")
config.set("CORE", "BIGNAME", "3")
config.add_value("core", "bigname", 4)
config.set_value("CORE", "NewKey", "new")
self.assertEqual(config.items_all("core"), [("BigName", ["3", "4"]), ("NewKey", ["new"])])
self.assertEqual(config.get_values("CORE", "BIGNAME"), [3, 4])
self.assertTrue(config.remove_option("CORE", "NEWKEY"))
self.assertFalse(config.has_option("core", "newkey"))
config.set_value("core", "newkey", "again")
self.assertIn(("newkey", "again"), config.items("CORE"))
self.assertTrue(config.remove_option("CORE", "NEWKEY"))
config.rename_section('remote "Origin"', 'Remote "Other"')
self.assertEqual(config.get('REMOTE "Other"', "URL"), "upper")
self.assertTrue(config.remove_section('REMOTE "Other"'))
with open(config_path, "rb") as config_file:
self.assertEqual(config_file.read(), b"[CoRe]\n\tBigName = 3\n\tBigName = 4\n")
with GitConfigParser(config_path) as config:
self.assertEqual(config.get_values("CORE", "bigname"), [3, 4])
@with_rw_directory
def test_case_insensitive_includes_and_remotes(self, rw_dir):
with Repo.init(rw_dir) as repo:
config_path = osp.join(repo.git_dir, "config")
with open(config_path, "ab") as config_file:
config_file.write(
b'[REMOTE "Origin"]\n\tURL = upper\n'
b'[Remote "origin"]\n\tUrl = lower\n'
b"[core]\n\tBigName = 1\n"
b"[INCLUDE]\n\tPaTh = included\n"
b'[INCLUDEIF "onbranch:*"]\n\tPATH = conditional\n'
b'[INCLUDEIF "ONBRANCH:*"]\n\tpath = wrong-case\n'
)
for filename, content in (
("included", b"[CORE]\n\tBIGNAME = 2\n"),
("conditional", b"[core]\n\tBranchName = 3\n"),
("wrong-case", b"[core]\n\tbigname = 4\n"),
):
with open(osp.join(repo.git_dir, filename), "wb") as config_file:
config_file.write(content)
with repo.config_reader("repository") as config:
self.assertEqual(config.get_values("CORE", "bigname"), [1, 2])
self.assertEqual(config.get_value("CORE", "branchname"), 3)
self.assertEqual([remote.name for remote in repo.remotes], ["Origin", "origin"])
self.assertEqual(repo.remote("Origin").config_reader.get("url"), "upper")
self.assertEqual(repo.remote("origin").config_reader.get("URL"), "lower")
@with_rw_directory
def test_lock_reentry(self, rw_dir):
fpl = osp.join(rw_dir, "l")
gcp = GitConfigParser(fpl, read_only=False)
with gcp as cw:
cw.set_value("include", "some_value", "a")
# Entering again locks the file again...
with gcp as cw:
cw.set_value("include", "some_other_value", "b")
# ...so creating an additional config writer must fail due to exclusive
# access.
with self.assertRaises(IOError):
GitConfigParser(fpl, read_only=False)
# but work when the lock is removed
with GitConfigParser(fpl, read_only=False):
assert osp.exists(fpl)
# Reentering with an existing lock must fail due to exclusive access.
with self.assertRaises(IOError):
gcp.__enter__()
def test_multi_line_config(self):
file_obj = self._to_memcache(fixture_path("git_config_with_comments"))
with GitConfigParser(file_obj, read_only=False) as config:
ev = "ruby -e '\n"
ev += " system %(git), %(merge-file), %(--marker-size=%L), %(%A), %(%O), %(%B)\n"
ev += " b = File.read(%(%A))\n"
ev += " b.sub!(/^<+ .*\\nActiveRecord::Schema\\.define.:version => (\\d+). do\\n=+\\nActiveRecord::Schema\\." # noqa: E501
ev += "define.:version => (\\d+). do\\n>+ .*/) do\n"
ev += " %(ActiveRecord::Schema.define(:version => #{[$1, $2].max}) do)\n"
ev += " end\n"
ev += " File.open(%(%A), %(w)) {|f| f.write(b)}\n"
ev += " exit 1 if b.include?(%(<)*%L)'"
self.assertEqual(config.get('merge "railsschema"', "driver"), ev)
self.assertEqual(
config.get("alias", "lg"),
"log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr)%Creset'"
" --abbrev-commit --date=relative",
)
self.assertEqual(len(config.sections()), 23)
def test_inline_comments_are_stripped_like_git(self):
"""A `#` or `;` outside quotes starts a comment, with or without a space
before it, and whether or not the value is quoted. Expectations are what
`git config -f <file> --get a.k` prints on git 2.50.1."""
cases = [
(b"[a]\n\tk = value # comment\n", "value"),
(b"[a]\n\tk = value ; comment\n", "value"),
(b"[a]\n\tk = value#nospace\n", "value"),
(b"[a]\n\tk = value;nospace\n", "value"),
(b"[a]\n\tk = a # b ; c\n", "a"),
(b'[a]\n\tk = "quoted" # after\n', "quoted"),
# A comment character inside quotes is literal.
(b'[a]\n\tk = "has # inside"\n', "has # inside"),
(b'[a]\n\tk = "has ; inside"\n', "has ; inside"),
]
for content, expected in cases:
config_file = io.BytesIO(content)
config_file.name = "inline_comment.config"
config = GitConfigParser(config_file)
config.read()
with self.subTest(content=content):
self.assertEqual(config.get_value("a", "k"), expected)
def test_option_line_with_long_whitespace_run_is_not_quadratic(self):
"""A key followed by a long whitespace run and no indicator must not make
the option regex backtrack quadratically.
`.gitmodules` and other config files are fully controlled by any repository
that is inspected, so a crafted line must stay cheap to parse. Keys that come
before the malformed line are still read.
"""
malformed = b'[submodule "x"]\n\tpath = x\n\tbranch' + b" " * 200_000 + b"\n"
config_file = io.BytesIO(malformed)
config_file.name = ".gitmodules"
config = GitConfigParser(config_file)
start = time.process_time()
config.read()
elapsed = time.process_time() - start
# Leave ample CPU time for slow runners, but catch quadratic backtracking.
self.assertLess(elapsed, 1.0)
self.assertEqual(config.get_value('submodule "x"', "path"), "x")
@with_rw_directory
def test_inline_comments_preserve_balanced_quotes_and_following_settings(self, rw_dir):
config_path = osp.join(rw_dir, "config")
values = (b'"foo"bar', b'"foo\\"bar"baz', b'"foo#;bar"baz')
for value in values:
for comment in (b' # "note"', b' ; "note"'):
with self.subTest(value=value, comment=comment):
with open(config_path, "wb") as config_file:
config_file.write(b"[a]\n\tk = " + value + comment + b"\n\tx = keep\n[b]\n\ty = stay\n")
with GitConfigParser(config_path, read_only=False) as config:
self.assertEqual(config.get_value("a", "k"), value.decode(defenc))
self.assertEqual(config.get_value("a", "x"), "keep")
self.assertEqual(config.get_value("b", "y"), "stay")
config.set_value("other", "value", "updated")
with GitConfigParser(config_path) as config:
self.assertEqual(config.get_value("a", "k"), value.decode(defenc))
self.assertEqual(config.get_value("a", "x"), "keep")
self.assertEqual(config.get_value("b", "y"), "stay")
self.assertEqual(config.get_value("other", "value"), "updated")
def test_backslash_line_continuation(self):
"""An unquoted value ending in a backslash continues on the next line,
exactly as git config parses it: the final backslash and the newline
are removed before the complete logical value is parsed."""
cases = [
(b"[a]\n\tk = line1\\\n line2\n", "line1 line2"),
(b"[a]\n\tk = one\\\n two\\\n three\n", "one two three"),
(b"[a]\n\tk = one\\\n two \n", "one two"),
(b"[a]\n\tk = one\\\n two ; ignored\n", "one two"),
(b'[a]\n\tk = one\\\n "two"\n', "one two"),
(b"[a]\n\tk = one\\\n two\\tthree\n", "one two\tthree"),
(b"[a]\n\tk = val\\\\\n next\n", "val\\\\"),
(b"[a]\n\tk = end\\\n", "end"),
(b"[alias]\n\tco = checkout \\\n\t\t-v\n", "checkout \t\t-v"),
]
for content, expected in cases:
config_file = io.BytesIO(content)
config_file.name = "backslash_continuation.config"
config = GitConfigParser(config_file)
config.read()
section = "alias" if b"[alias]" in content else "a"
key = "co" if section == "alias" else "k"
self.assertEqual(config.get_value(section, key), expected)
def test_get_value_reads_git_boolean_spellings(self):
# git accepts yes/no and on/off as well as true/false, and getboolean on
# this class already did. get_value returned them as strings, so "no" and
# "off" arrived as non-empty (truthy) values for a caller testing them.
cases = [
(b"true", True),
(b"TRUE", True),
(b"yes", True),
(b"Yes", True),
(b"on", True),
(b"On", True),
(b"false", False),
(b"no", False),
(b"off", False),
(b"Off", False),
]
for raw, expected in cases:
config_file = io.BytesIO(b"[core]\n\tflag = " + raw + b"\n")
config_file.name = "boolean_spellings.config"
config = GitConfigParser(config_file)
config.read()
self.assertIs(config.get_value("core", "flag"), expected, raw.decode())
# The two accessors must not disagree about the same value.
self.assertIs(config.getboolean("core", "flag"), expected, raw.decode())
# A value that is not a boolean at all still comes back untouched.
config_file = io.BytesIO(b"[core]\n\tflag = meld\n")
config_file.name = "boolean_spellings.config"
config = GitConfigParser(config_file)
config.read()
self.assertEqual(config.get_value("core", "flag"), "meld")
@with_rw_directory
def test_comment_backslash_does_not_continue_value(self, rw_dir):
config_path = osp.join(rw_dir, "config")
with open(config_path, "wb") as config_file:
config_file.write(b"[a]\n\tk = one\\\n two ; ignored \\\n\tx = two\n")
with GitConfigParser(config_path, read_only=False) as config:
self.assertEqual(config.get_value("a", "k"), "one two")
self.assertEqual(config.get_value("a", "x"), "two")
config.set_value("a", "added", "three")
with GitConfigParser(config_path) as config:
self.assertEqual(config.get_value("a", "x"), "two")
def test_utf8_bom_is_skipped_like_git(self):
"""git skips a UTF-8 BOM at the start of a config file, so one written by
a Windows editor still parses. Expectations are what
`git config -f <file> --list` prints on git 2.47.3."""
content = b"\xef\xbb\xbf[core]\n\tbare = true\n"
config_file = io.BytesIO(content)
config_file.name = "bom.config"
config = GitConfigParser(config_file)
config.read()
self.assertIs(config.get_value("core", "bare"), True)
def test_config_value_with_trailing_new_line(self):
config_content = b'[section-header]\nkey:"value\n"'
config_file = io.BytesIO(config_content)
config_file.name = "multiline_value.config"
git_config = GitConfigParser(config_file)
git_config.read() # This should not throw an exception
@with_rw_directory
def test_rewriting_multiline_value_does_not_create_option(self, rw_dir):
config_path = osp.join(rw_dir, "config")
with open(config_path, "wb") as config_file:
config_file.write(b'[core]\n\tzzz = "A\\nhooksPath = ../evil-hooks\\\n"\n')
with GitConfigParser(config_path, read_only=False) as git_config:
self.assertEqual(git_config.get_value("core", "zzz"), "A\nhooksPath = ../evil-hooks")
git_config.set_value("user", "name", "Test User")
with GitConfigParser(config_path, read_only=True) as git_config:
self.assertEqual(git_config.get_value("core", "zzz"), "A\nhooksPath = ../evil-hooks")
self.assertFalse(git_config.has_option("core", "hooksPath"))
self.assertEqual(
subprocess.run(["git", "config", "--file", config_path, "--get", "core.hooksPath"]).returncode, 1
)
@with_rw_directory
def test_writer_escapes_special_characters_without_newline(self, rw_dir):
config_path = osp.join(rw_dir, "config")
values = {
"tab": "\tvalue\t",
"backspace": "a\bb",
"quote": 'a"b',
"backslash": "a\\qb",
"hash": "value#fragment",
"semicolon": "value;fragment",
"leading": " value",
"trailing": "value ",
}
with GitConfigParser(config_path, read_only=False) as git_config:
for key, value in values.items():
git_config.set_value("section", key, value)
with GitConfigParser(config_path, read_only=True) as git_config:
for key, value in values.items():
self.assertEqual(git_config.get_value("section", key), value)
self.assertEqual(
subprocess.run(
["git", "config", "--file", config_path, "--get", "section.%s" % key],
stdout=subprocess.PIPE,
check=True,
).stdout,
value.encode(defenc) + b"\n",
)
with open(config_path, "rb") as config_file:
self.assertNotIn(b"\x08", config_file.read())
@with_rw_directory
def test_writer_preserves_escaped_and_non_ascii_values_safely(self, rw_dir):
config_path = osp.join(rw_dir, "config")
with open(config_path, "wb") as config_file:
config_file.write(
(
'[section]\nnewline = "first\\nsecond"\nquote = "a\\"b"\nbackslash = "a\\\\b"\n'
'unicode = "café\\\\path"\n'
).encode(defenc)
)
with GitConfigParser(config_path, read_only=False) as config:
config.set_value("unrelated", "key", "value")
expected = {
"newline": "first\nsecond",
"quote": 'a"b',
"backslash": "a\\b",
"unicode": "café\\path",
}
with GitConfigParser(config_path, read_only=True) as config:
for key, value in expected.items():
self.assertEqual(
config.get_value("section", key),
value,
"GitPython should preserve values when rewriting unrelated entries",
)
self.assertEqual(
subprocess.run(
["git", "config", "--file", config_path, "--get", "section.%s" % key],
stdout=subprocess.PIPE,
check=True,
).stdout,
value.encode(defenc) + b"\n",
"git should read rewritten values with the same semantics",
)
with open(config_path, "rb") as config_file:
contents = config_file.read()
self.assertNotIn(b"\r", contents, "the writer should never emit carriage returns")
self.assertNotIn(b"\x00", contents, "the writer should never emit NUL bytes")
for name, value in (("return", b"first\\rsecond"), ("nul", b"first\x00second")):
unsafe_path = osp.join(rw_dir, "%s-config" % name)
unsafe_contents = b'[section]\nvalue = "' + value + b'"\n'
with open(unsafe_path, "wb") as config_file:
config_file.write(unsafe_contents)
with self.assertRaisesRegex(
ValueError,
"CR or NUL",
msg="unsafe existing values should abort rewrites",
):
with GitConfigParser(unsafe_path, read_only=False) as config:
config.set_value("unrelated", "key", "value")
with open(unsafe_path, "rb") as config_file:
self.assertEqual(
config_file.read(),
unsafe_contents,
"rejected rewrites should leave the original file unchanged",
)
@with_rw_directory
def test_set_value_rejects_config_injection(self, rw_dir):
config_path = osp.join(rw_dir, "config")
payload = "foo\n[core]\nhooksPath=/tmp/hooks"
with GitConfigParser(config_path, read_only=False) as git_config:
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.set_value("user", "name", payload)
with GitConfigParser(config_path, read_only=True) as git_config:
self.assertFalse(git_config.has_section("user"))
self.assertFalse(git_config.has_section("core"))
@with_rw_directory
def test_set_value_rejects_unsafe_section_and_option_names(self, rw_dir):
config_path = osp.join(rw_dir, "config")
bad_keys = ("user]\n[core", "user]\r[core", "user]\x00[core")
with GitConfigParser(config_path, read_only=False) as git_config:
git_config.add_section("user")
for bad_key in bad_keys:
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.add_section(bad_key)
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.set(bad_key, "hooksPath", "/tmp/hooks")
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.set("user", bad_key, "/tmp/hooks")
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.set_value(bad_key, "hooksPath", "/tmp/hooks")
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.set_value("user", bad_key, "/tmp/hooks")
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.add_value(bad_key, "hooksPath", "/tmp/hooks")
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.add_value("user", bad_key, "/tmp/hooks")
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.rename_section("user", bad_key)
git_config.set_value("user", "name", "safe")
with GitConfigParser(config_path, read_only=True) as git_config:
self.assertEqual(git_config.get_value("user", "name"), "safe")
self.assertFalse(git_config.has_section("core"))
@with_rw_directory
def test_writer_rejects_invalid_option_names(self, rw_dir):
config_path = osp.join(rw_dir, "config")
bad_options = (
"name=value",
"name#comment",
"name;comment",
"name with space",
"name\twith-tab",
"name[section",
"name]section",
"name:colon",
'name"quote',
"name\\escape",
)
with GitConfigParser(config_path, read_only=False) as git_config:
git_config.add_section("user")
for bad_option in bad_options:
with pytest.raises(ValueError, match="option name"):
git_config.set("user", bad_option, "unsafe")
with pytest.raises(ValueError, match="option name"):
git_config.set_value("user", bad_option, "unsafe")
with pytest.raises(ValueError, match="option name"):
git_config.add_value("user", bad_option, "unsafe")
git_config.set_value("user", "safe-option1", "safe")
git_config.set_value("user", "safe_option2", "safe")
git_config.set_value("user", "3safe_option", "safe")
git_config.set_value("user", "safe.option3", "safe")
with GitConfigParser(config_path, read_only=True) as git_config:
self.assertEqual(git_config.get_value("user", "safe-option1"), "safe")
self.assertEqual(git_config.get_value("user", "safe_option2"), "safe")
self.assertEqual(git_config.get_value("user", "3safe_option"), "safe")
self.assertEqual(git_config.get_value("user", "safe.option3"), "safe")
@with_rw_directory
def test_writer_rejects_unquoted_section_terminators(self, rw_dir):
config_path = osp.join(rw_dir, "config")
bad_sections = (
"user] [other",
'user"] [other"',
'submodule "docs"] [other',
'submodule "docs] [other',
'submodule "docs] [other\\',
)
safe_section = 'submodule "docs]archive"'
with GitConfigParser(config_path, read_only=False) as git_config:
git_config.add_section("user")
for bad_section in bad_sections:
with pytest.raises(ValueError, match="section name"):
git_config.add_section(bad_section)
with pytest.raises(ValueError, match="section name"):
git_config.set(bad_section, "name", "value")
with pytest.raises(ValueError, match="section name"):
git_config.set_value(bad_section, "name", "value")
with pytest.raises(ValueError, match="section name"):
git_config.add_value(bad_section, "name", "value")
with pytest.raises(ValueError, match="section name"):
git_config.rename_section("user", bad_section)
git_config.set_value("user", "name", "safe")
git_config.set_value(safe_section, "name", "safe")
self.assertEqual(git_config.get_value(safe_section, "name"), "safe")
# A closing bracket inside a quoted subsection name is data, not a section terminator.
with open(config_path, "rb") as config_file:
self.assertIn(
b'[submodule "docs]archive"]\n',
config_file.read(),
"a closing bracket within a quoted subsection name should be preserved",
)
# Reparse the file to verify that rejected names did not inject an [other] section.
with GitConfigParser(config_path, read_only=True) as git_config:
self.assertEqual(
git_config.get_value("user", "name"),
"safe",
"rejected section names corrupted the existing section",
)
self.assertFalse(git_config.has_section("other"), "an unsafe section name injected an [other] section")
@with_rw_directory
def test_set_and_add_value_reject_unsafe_value_characters(self, rw_dir):
config_path = osp.join(rw_dir, "config")
bad_values = ("foo\rbar", "foo\nbar", "foo\x00bar", b"foo\nbar")
with GitConfigParser(config_path, read_only=False) as git_config:
git_config.add_section("user")
for bad_value in bad_values:
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.set("user", "name", bad_value)
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.set_value("user", "name", bad_value)
with pytest.raises(ValueError, match="CR, LF, or NUL"):
git_config.add_value("user", "name", bad_value)
git_config.set_value("user", "name", "safe")
with GitConfigParser(config_path, read_only=True) as git_config:
self.assertEqual(git_config.get_value("user", "name"), "safe")
def test_base(self):
path_repo = fixture_path("git_config")
path_global = fixture_path("git_config_global")
r_config = GitConfigParser([path_repo, path_global], read_only=True)
assert r_config.read_only
num_sections = 0
num_options = 0
# Test reader methods.
assert r_config._is_initialized is False
for section in r_config.sections():
num_sections += 1
for option in r_config.options(section):
num_options += 1
val = r_config.get(section, option)
val_typed = r_config.get_value(section, option)
assert isinstance(val_typed, (bool, int, float, str))
assert val
assert "\n" not in option
assert "\n" not in val
# Writing must fail.
with self.assertRaises(IOError):
r_config.set(section, option, None)
with self.assertRaises(IOError):
r_config.remove_option(section, option)
# END for each option
with self.assertRaises(IOError):
r_config.remove_section(section)
# END for each section
assert num_sections and num_options
assert r_config._is_initialized is True
# Get value which doesn't exist, with default.
default = "my default value"
assert r_config.get_value("doesnt", "exist", default) == default
# It raises if there is no default though.
with self.assertRaises(cp.NoSectionError):
r_config.get_value("doesnt", "exist")
@with_rw_directory
def test_config_include(self, rw_dir):
def write_test_value(cw, value):
cw.set_value(value, "value", value)
def check_test_value(cr, value):
assert cr.get_value(value, "value") == value
# PREPARE CONFIG FILE A
fpa = osp.join(rw_dir, "a")
with GitConfigParser(fpa, read_only=False) as cw:
write_test_value(cw, "a")
fpb = osp.join(rw_dir, "b")
fpc = osp.join(rw_dir, "c")
cw.set_value("include", "relative_path_b", "b")
cw.set_value("include", "doesntexist", "foobar")
cw.set_value("include", "relative_cycle_a_a", "a")
cw.set_value("include", "absolute_cycle_a_a", fpa)
assert osp.exists(fpa)
# PREPARE CONFIG FILE B
with GitConfigParser(fpb, read_only=False) as cw:
write_test_value(cw, "b")
cw.set_value("include", "relative_cycle_b_a", "a")
cw.set_value("include", "absolute_cycle_b_a", fpa)
cw.set_value("include", "relative_path_c", "c")
cw.set_value("include", "absolute_path_c", fpc)
# PREPARE CONFIG FILE C
with GitConfigParser(fpc, read_only=False) as cw:
write_test_value(cw, "c")
with GitConfigParser(fpa, read_only=True) as cr:
for tv in ("a", "b", "c"):
check_test_value(cr, tv)
# END for each test to verify
assert len(cr.items("include")) == 8, "Expected all include sections to be merged"
# Test writable config writers - assure write-back doesn't involve includes.
with GitConfigParser(fpa, read_only=False, merge_includes=True) as cw:
tv = "x"
write_test_value(cw, tv)
with GitConfigParser(fpa, read_only=True) as cr:
with self.assertRaises(cp.NoSectionError):
check_test_value(cr, tv)
# But can make it skip includes altogether, and thus allow write-backs.
with GitConfigParser(fpa, read_only=False, merge_includes=False) as cw:
write_test_value(cw, tv)
with GitConfigParser(fpa, read_only=True) as cr:
check_test_value(cr, tv)
@with_rw_directory
def test_config_relative_path_include(self, rw_dir):
included_path = osp.join(rw_dir, "included")
with GitConfigParser(included_path, read_only=False) as cw:
cw.set_value("included", "value", "included")
config_path = osp.join(rw_dir, "config")
with GitConfigParser(config_path, read_only=False) as cw:
cw.set_value("include", "path", "included")
if osp.splitdrive(config_path)[0] != osp.splitdrive(os.getcwd())[0]:
pytest.skip("The temporary directory and checkout are on different drives")
relative_config_path = osp.relpath(config_path)
with GitConfigParser(relative_config_path, read_only=True) as cr:
assert cr.get_value("included", "value") == "included"
@pytest.mark.skipif(os.name != "nt", reason="Specifically for Windows drive-rooted paths.")
@with_rw_directory
def test_config_drive_rooted_path_include(self, rw_dir):
with cwd(rw_dir):
included_path = osp.join(rw_dir, "included")
with GitConfigParser(included_path, read_only=False) as cw:
cw.set_value("included", "value", "included")
_drive, rooted_included_path = osp.splitdrive(included_path)
config_path = osp.join(rw_dir, "config")
with GitConfigParser(config_path, read_only=False) as cw:
cw.set_value("include", "path", rooted_included_path)
with GitConfigParser(config_path, read_only=True) as cr:
assert cr.get_value("included", "value") == "included"
@with_rw_directory
def test_multiple_include_paths_with_same_key(self, rw_dir):
"""Test that multiple 'path' entries under [include] are all respected.
Regression test for https://github.com/gitpython-developers/GitPython/issues/2099.
Git config allows multiple ``path`` values under ``[include]``, e.g.::
[include]
path = file1
path = file2
Previously only one of these was included because _OMD.items() returns
only the last value for each key.
"""
# Create two config files to be included.
fp_inc1 = osp.join(rw_dir, "inc1.cfg")
fp_inc2 = osp.join(rw_dir, "inc2.cfg")
fp_main = osp.join(rw_dir, "main.cfg")
with GitConfigParser(fp_inc1, read_only=False) as cw:
cw.set_value("user", "name", "from-inc1")
with GitConfigParser(fp_inc2, read_only=False) as cw:
cw.set_value("core", "bar", "from-inc2")
# Write a config with two path entries under a single [include] section.
# We write it manually because set_value would overwrite the key.
with open(fp_main, "w") as f:
f.write("[include]\n")
f.write(f"\tpath = {fp_inc1}\n")
f.write(f"\tpath = {fp_inc2}\n")
with GitConfigParser(fp_main, read_only=True) as cr:
# Both included files should be loaded.
assert cr.get_value("user", "name") == "from-inc1"
assert cr.get_value("core", "bar") == "from-inc2"
@with_rw_directory
def test_conditional_includes_from_git_dir(self, rw_dir):
# Initiate repository path.
git_dir = osp.join(rw_dir, "target1", "repo1")
git_dir_pattern = git_dir.replace("\\", "/")
os.makedirs(git_dir)
# Initiate mocked repository.
repo = mock.Mock(git_dir=git_dir)
# Initiate config files.
path1 = osp.join(rw_dir, "config1")
path2 = osp.join(rw_dir, "config2")
template = '[includeIf "{}:{}"]\n path={}\n'
with open(path1, "w") as stream:
# on Windows, this writes a backslash pattern.
stream.write(template.format("gitdir", git_dir, path2))
# Ensure that config is ignored if no repo is set.
with GitConfigParser(path1) as config:
assert not config._has_includes()
assert config._included_paths() == []
# Git uses forward slashes in gitdir patterns on every platform:
# backslashes escape the next pattern character rather than separate
# path components. On Windows, GitPython therefore normalizes git_dir
# to forward slashes but leaves this backslash pattern unchanged, so
# the two do not match and no path is included.
with GitConfigParser(path1, repo=repo, merge_includes=False) as config:
expected_paths = [] if sys.platform == "win32" else [("path", path2)]
assert config._included_paths() == expected_paths
# Ensure that Git's forward-slash syntax matches native Windows paths.
with open(path1, "w") as stream:
stream.write(template.format("gitdir", git_dir_pattern, path2))
with GitConfigParser(path1, repo=repo) as config:
assert config._has_includes()
assert config._included_paths() == [("path", path2)]
# Ensure that config is ignored if case is incorrect.
with open(path1, "w") as stream:
stream.write(template.format("gitdir", git_dir_pattern.upper(), path2))
with GitConfigParser(path1, repo=repo) as config:
assert not config._has_includes()
assert config._included_paths() == []
# Ensure that config is included if case is ignored.
with open(path1, "w") as stream:
stream.write(template.format("gitdir/i", git_dir_pattern.upper(), path2))
with GitConfigParser(path1, repo=repo) as config:
assert config._has_includes()
assert config._included_paths() == [("path", path2)]
# Ensure that config is included with path using glob pattern.
with open(path1, "w") as stream:
stream.write(template.format("gitdir", "**/repo1", path2))
with GitConfigParser(path1, repo=repo) as config:
assert config._has_includes()
assert config._included_paths() == [("path", path2)]
# Ensure that config is ignored if path is not matching git_dir.
with open(path1, "w") as stream:
stream.write(template.format("gitdir", "incorrect", path2))
with GitConfigParser(path1, repo=repo) as config:
assert not config._has_includes()
assert config._included_paths() == []
# Ensure that config is included if path in hierarchy.
with open(path1, "w") as stream:
stream.write(template.format("gitdir", "target1/", path2))
with GitConfigParser(path1, repo=repo) as config:
assert config._has_includes()
assert config._included_paths() == [("path", path2)]
@with_rw_directory
def test_conditional_includes_do_not_treat_backslashes_as_separators(self, rw_dir):
git_dir = osp.join(rw_dir, "target", "repo")
repo = mock.Mock(git_dir=git_dir)
config_path = osp.join(rw_dir, "config")
included_path = osp.join(rw_dir, "included")
pattern = git_dir.replace("\\", "/").replace("/target/repo", R"/target\repo")
with open(config_path, "w") as stream:
stream.write(f'[includeIf "gitdir:{pattern}"]\n path={included_path}\n')
with GitConfigParser(config_path, repo=repo, merge_includes=False) as config:
assert config._included_paths() == []
@with_rw_directory
def test_conditional_includes_from_branch_name(self, rw_dir):
# Initiate mocked branch.
branch = mock.Mock()
type(branch).name = mock.PropertyMock(return_value="/foo/branch")
# Initiate mocked repository.
repo = mock.Mock(active_branch=branch)
# Initiate config files.
path1 = osp.join(rw_dir, "config1")
path2 = osp.join(rw_dir, "config2")
template = '[includeIf "onbranch:{}"]\n path={}\n'
# Ensure that config is included is branch is correct.
with open(path1, "w") as stream:
stream.write(template.format("/foo/branch", path2))
with GitConfigParser(path1, repo=repo) as config:
assert config._has_includes()
assert config._included_paths() == [("path", path2)]
# Ensure that config is included is branch is incorrect.
with open(path1, "w") as stream:
stream.write(template.format("incorrect", path2))
with GitConfigParser(path1, repo=repo) as config:
assert not config._has_includes()
assert config._included_paths() == []
# Ensure that config is included with branch using glob pattern.
with open(path1, "w") as stream:
stream.write(template.format("/foo/**", path2))
with GitConfigParser(path1, repo=repo) as config:
assert config._has_includes()
assert config._included_paths() == [("path", path2)]
@with_rw_directory
def test_conditional_includes_from_branch_name_error(self, rw_dir):
# Initiate mocked repository to raise an error if HEAD is detached.
repo = mock.Mock()
type(repo).active_branch = mock.PropertyMock(side_effect=TypeError)
# Initiate config file.
path1 = osp.join(rw_dir, "config1")
# Ensure that config is ignored when active branch cannot be found.
with open(path1, "w") as stream:
stream.write('[includeIf "onbranch:foo"]\n path=/path\n')
with GitConfigParser(path1, repo=repo) as config:
assert not config._has_includes()
assert config._included_paths() == []
@with_rw_directory
def test_conditional_includes_remote_url(self, rw_dir):
# Initiate mocked repository.
repo = mock.Mock()
repo.remotes = [mock.Mock(url="https://github.com/foo/repo")]
# Initiate config files.
path1 = osp.join(rw_dir, "config1")
path2 = osp.join(rw_dir, "config2")
template = '[includeIf "hasconfig:remote.*.url:{}"]\n path={}\n'
# Ensure that config with hasconfig and full url is correct.
with open(path1, "w") as stream:
stream.write(template.format("https://github.com/foo/repo", path2))
with GitConfigParser(path1, repo=repo) as config:
assert config._has_includes()
assert config._included_paths() == [("path", path2)]
# Ensure that config with hasconfig and incorrect url is incorrect.
with open(path1, "w") as stream:
stream.write(template.format("incorrect", path2))
with GitConfigParser(path1, repo=repo) as config:
assert not config._has_includes()
assert config._included_paths() == []
# Ensure that config with hasconfig and url using glob pattern is correct.
with open(path1, "w") as stream:
stream.write(template.format("**/**github.com*/**", path2))