Sync with maint
[git] / t / t1400-update-ref.sh
1 #!/bin/sh
2 #
3 # Copyright (c) 2006 Shawn Pearce
4 #
5
6 test_description='Test git update-ref and basic ref logging'
7 . ./test-lib.sh
8
9 Z=$_z40
10
11 test_expect_success setup '
12
13         for name in A B C D E F
14         do
15                 test_tick &&
16                 T=$(git write-tree) &&
17                 sha1=$(echo $name | git commit-tree $T) &&
18                 eval $name=$sha1
19         done
20
21 '
22
23 m=refs/heads/master
24 n_dir=refs/heads/gu
25 n=$n_dir/fixes
26
27 test_expect_success \
28         "create $m" \
29         "git update-ref $m $A &&
30          test $A"' = $(cat .git/'"$m"')'
31 test_expect_success \
32         "create $m" \
33         "git update-ref $m $B $A &&
34          test $B"' = $(cat .git/'"$m"')'
35 test_expect_success "fail to delete $m with stale ref" '
36         test_must_fail git update-ref -d $m $A &&
37         test $B = "$(cat .git/$m)"
38 '
39 test_expect_success "delete $m" '
40         git update-ref -d $m $B &&
41         ! test -f .git/$m
42 '
43 rm -f .git/$m
44
45 test_expect_success "delete $m without oldvalue verification" "
46         git update-ref $m $A &&
47         test $A = \$(cat .git/$m) &&
48         git update-ref -d $m &&
49         ! test -f .git/$m
50 "
51 rm -f .git/$m
52
53 test_expect_success \
54         "fail to create $n" \
55         "touch .git/$n_dir &&
56          test_must_fail git update-ref $n $A >out 2>err"
57 rm -f .git/$n_dir out err
58
59 test_expect_success \
60         "create $m (by HEAD)" \
61         "git update-ref HEAD $A &&
62          test $A"' = $(cat .git/'"$m"')'
63 test_expect_success \
64         "create $m (by HEAD)" \
65         "git update-ref HEAD $B $A &&
66          test $B"' = $(cat .git/'"$m"')'
67 test_expect_success "fail to delete $m (by HEAD) with stale ref" '
68         test_must_fail git update-ref -d HEAD $A &&
69         test $B = $(cat .git/$m)
70 '
71 test_expect_success "delete $m (by HEAD)" '
72         git update-ref -d HEAD $B &&
73         ! test -f .git/$m
74 '
75 rm -f .git/$m
76
77 test_expect_success \
78         "create $m (by HEAD)" \
79         "git update-ref HEAD $A &&
80          test $A"' = $(cat .git/'"$m"')'
81 test_expect_success \
82         "pack refs" \
83         "git pack-refs --all"
84 test_expect_success \
85         "move $m (by HEAD)" \
86         "git update-ref HEAD $B $A &&
87          test $B"' = $(cat .git/'"$m"')'
88 test_expect_success "delete $m (by HEAD) should remove both packed and loose $m" '
89         git update-ref -d HEAD $B &&
90         ! grep "$m" .git/packed-refs &&
91         ! test -f .git/$m
92 '
93 rm -f .git/$m
94
95 cp -f .git/HEAD .git/HEAD.orig
96 test_expect_success "delete symref without dereference" '
97         git update-ref --no-deref -d HEAD &&
98         ! test -f .git/HEAD
99 '
100 cp -f .git/HEAD.orig .git/HEAD
101
102 test_expect_success "delete symref without dereference when the referred ref is packed" '
103         echo foo >foo.c &&
104         git add foo.c &&
105         git commit -m foo &&
106         git pack-refs --all &&
107         git update-ref --no-deref -d HEAD &&
108         ! test -f .git/HEAD
109 '
110 cp -f .git/HEAD.orig .git/HEAD
111 git update-ref -d $m
112
113 test_expect_success 'update-ref -d is not confused by self-reference' '
114         git symbolic-ref refs/heads/self refs/heads/self &&
115         test_when_finished "rm -f .git/refs/heads/self" &&
116         test_path_is_file .git/refs/heads/self &&
117         test_must_fail git update-ref -d refs/heads/self &&
118         test_path_is_file .git/refs/heads/self
119 '
120
121 test_expect_success 'update-ref --no-deref -d can delete self-reference' '
122         git symbolic-ref refs/heads/self refs/heads/self &&
123         test_when_finished "rm -f .git/refs/heads/self" &&
124         test_path_is_file .git/refs/heads/self &&
125         git update-ref --no-deref -d refs/heads/self &&
126         test_path_is_missing .git/refs/heads/self
127 '
128
129 test_expect_success 'update-ref --no-deref -d can delete reference to bad ref' '
130         >.git/refs/heads/bad &&
131         test_when_finished "rm -f .git/refs/heads/bad" &&
132         git symbolic-ref refs/heads/ref-to-bad refs/heads/bad &&
133         test_when_finished "rm -f .git/refs/heads/ref-to-bad" &&
134         test_path_is_file .git/refs/heads/ref-to-bad &&
135         git update-ref --no-deref -d refs/heads/ref-to-bad &&
136         test_path_is_missing .git/refs/heads/ref-to-bad
137 '
138
139 test_expect_success '(not) create HEAD with old sha1' "
140         test_must_fail git update-ref HEAD $A $B
141 "
142 test_expect_success "(not) prior created .git/$m" "
143         ! test -f .git/$m
144 "
145 rm -f .git/$m
146
147 test_expect_success \
148         "create HEAD" \
149         "git update-ref HEAD $A"
150 test_expect_success '(not) change HEAD with wrong SHA1' "
151         test_must_fail git update-ref HEAD $B $Z
152 "
153 test_expect_success "(not) changed .git/$m" "
154         ! test $B"' = $(cat .git/'"$m"')
155 '
156 rm -f .git/$m
157
158 : a repository with working tree always has reflog these days...
159 : >.git/logs/refs/heads/master
160 test_expect_success \
161         "create $m (logged by touch)" \
162         'GIT_COMMITTER_DATE="2005-05-26 23:30" \
163          git update-ref HEAD '"$A"' -m "Initial Creation" &&
164          test '"$A"' = $(cat .git/'"$m"')'
165 test_expect_success \
166         "update $m (logged by touch)" \
167         'GIT_COMMITTER_DATE="2005-05-26 23:31" \
168          git update-ref HEAD'" $B $A "'-m "Switch" &&
169          test '"$B"' = $(cat .git/'"$m"')'
170 test_expect_success \
171         "set $m (logged by touch)" \
172         'GIT_COMMITTER_DATE="2005-05-26 23:41" \
173          git update-ref HEAD'" $A &&
174          test $A"' = $(cat .git/'"$m"')'
175
176 cat >expect <<EOF
177 $Z $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150200 +0000       Initial Creation
178 $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150260 +0000       Switch
179 $B $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150860 +0000
180 EOF
181 test_expect_success \
182         "verifying $m's log" \
183         "test_cmp expect .git/logs/$m"
184 rm -rf .git/$m .git/logs expect
185
186 test_expect_success \
187         'enable core.logAllRefUpdates' \
188         'git config core.logAllRefUpdates true &&
189          test true = $(git config --bool --get core.logAllRefUpdates)'
190
191 test_expect_success \
192         "create $m (logged by config)" \
193         'GIT_COMMITTER_DATE="2005-05-26 23:32" \
194          git update-ref HEAD'" $A "'-m "Initial Creation" &&
195          test '"$A"' = $(cat .git/'"$m"')'
196 test_expect_success \
197         "update $m (logged by config)" \
198         'GIT_COMMITTER_DATE="2005-05-26 23:33" \
199          git update-ref HEAD'" $B $A "'-m "Switch" &&
200          test '"$B"' = $(cat .git/'"$m"')'
201 test_expect_success \
202         "set $m (logged by config)" \
203         'GIT_COMMITTER_DATE="2005-05-26 23:43" \
204          git update-ref HEAD '"$A &&
205          test $A"' = $(cat .git/'"$m"')'
206
207 cat >expect <<EOF
208 $Z $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150320 +0000       Initial Creation
209 $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150380 +0000       Switch
210 $B $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150980 +0000
211 EOF
212 test_expect_success \
213         "verifying $m's log" \
214         'test_cmp expect .git/logs/$m'
215 rm -f .git/$m .git/logs/$m expect
216
217 git update-ref $m $D
218 cat >.git/logs/$m <<EOF
219 0000000000000000000000000000000000000000 $C $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150320 -0500
220 $C $A $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150350 -0500
221 $A $B $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150380 -0500
222 $F $Z $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150680 -0500
223 $Z $E $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150980 -0500
224 EOF
225
226 ed="Thu, 26 May 2005 18:32:00 -0500"
227 gd="Thu, 26 May 2005 18:33:00 -0500"
228 ld="Thu, 26 May 2005 18:43:00 -0500"
229 test_expect_success \
230         'Query "master@{May 25 2005}" (before history)' \
231         'rm -f o e &&
232          git rev-parse --verify "master@{May 25 2005}" >o 2>e &&
233          test '"$C"' = $(cat o) &&
234          test "warning: Log for '\'master\'' only goes back to $ed." = "$(cat e)"'
235 test_expect_success \
236         "Query master@{2005-05-25} (before history)" \
237         'rm -f o e &&
238          git rev-parse --verify master@{2005-05-25} >o 2>e &&
239          test '"$C"' = $(cat o) &&
240          echo test "warning: Log for '\'master\'' only goes back to $ed." = "$(cat e)"'
241 test_expect_success \
242         'Query "master@{May 26 2005 23:31:59}" (1 second before history)' \
243         'rm -f o e &&
244          git rev-parse --verify "master@{May 26 2005 23:31:59}" >o 2>e &&
245          test '"$C"' = $(cat o) &&
246          test "warning: Log for '\''master'\'' only goes back to $ed." = "$(cat e)"'
247 test_expect_success \
248         'Query "master@{May 26 2005 23:32:00}" (exactly history start)' \
249         'rm -f o e &&
250          git rev-parse --verify "master@{May 26 2005 23:32:00}" >o 2>e &&
251          test '"$C"' = $(cat o) &&
252          test "" = "$(cat e)"'
253 test_expect_success \
254         'Query "master@{May 26 2005 23:32:30}" (first non-creation change)' \
255         'rm -f o e &&
256          git rev-parse --verify "master@{May 26 2005 23:32:30}" >o 2>e &&
257          test '"$A"' = $(cat o) &&
258          test "" = "$(cat e)"'
259 test_expect_success \
260         'Query "master@{2005-05-26 23:33:01}" (middle of history with gap)' \
261         'rm -f o e &&
262          git rev-parse --verify "master@{2005-05-26 23:33:01}" >o 2>e &&
263          test '"$B"' = $(cat o) &&
264          test "warning: Log for ref '"$m has gap after $gd"'." = "$(cat e)"'
265 test_expect_success \
266         'Query "master@{2005-05-26 23:38:00}" (middle of history)' \
267         'rm -f o e &&
268          git rev-parse --verify "master@{2005-05-26 23:38:00}" >o 2>e &&
269          test '"$Z"' = $(cat o) &&
270          test "" = "$(cat e)"'
271 test_expect_success \
272         'Query "master@{2005-05-26 23:43:00}" (exact end of history)' \
273         'rm -f o e &&
274          git rev-parse --verify "master@{2005-05-26 23:43:00}" >o 2>e &&
275          test '"$E"' = $(cat o) &&
276          test "" = "$(cat e)"'
277 test_expect_success \
278         'Query "master@{2005-05-28}" (past end of history)' \
279         'rm -f o e &&
280          git rev-parse --verify "master@{2005-05-28}" >o 2>e &&
281          test '"$D"' = $(cat o) &&
282          test "warning: Log for ref '"$m unexpectedly ended on $ld"'." = "$(cat e)"'
283
284
285 rm -f .git/$m .git/logs/$m expect
286
287 test_expect_success \
288     'creating initial files' \
289     'echo TEST >F &&
290      git add F &&
291          GIT_AUTHOR_DATE="2005-05-26 23:30" \
292          GIT_COMMITTER_DATE="2005-05-26 23:30" git commit -m add -a &&
293          h_TEST=$(git rev-parse --verify HEAD) &&
294          echo The other day this did not work. >M &&
295          echo And then Bob told me how to fix it. >>M &&
296          echo OTHER >F &&
297          GIT_AUTHOR_DATE="2005-05-26 23:41" \
298          GIT_COMMITTER_DATE="2005-05-26 23:41" git commit -F M -a &&
299          h_OTHER=$(git rev-parse --verify HEAD) &&
300          GIT_AUTHOR_DATE="2005-05-26 23:44" \
301          GIT_COMMITTER_DATE="2005-05-26 23:44" git commit --amend &&
302          h_FIXED=$(git rev-parse --verify HEAD) &&
303          echo Merged initial commit and a later commit. >M &&
304          echo $h_TEST >.git/MERGE_HEAD &&
305          GIT_AUTHOR_DATE="2005-05-26 23:45" \
306          GIT_COMMITTER_DATE="2005-05-26 23:45" git commit -F M &&
307          h_MERGED=$(git rev-parse --verify HEAD) &&
308          rm -f M'
309
310 cat >expect <<EOF
311 $Z $h_TEST $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150200 +0000  commit (initial): add
312 $h_TEST $h_OTHER $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117150860 +0000    commit: The other day this did not work.
313 $h_OTHER $h_FIXED $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117151040 +0000   commit (amend): The other day this did not work.
314 $h_FIXED $h_MERGED $GIT_COMMITTER_NAME <$GIT_COMMITTER_EMAIL> 1117151100 +0000  commit (merge): Merged initial commit and a later commit.
315 EOF
316 test_expect_success \
317         'git commit logged updates' \
318         "test_cmp expect .git/logs/$m"
319 unset h_TEST h_OTHER h_FIXED h_MERGED
320
321 test_expect_success \
322         'git cat-file blob master:F (expect OTHER)' \
323         'test OTHER = $(git cat-file blob master:F)'
324 test_expect_success \
325         'git cat-file blob master@{2005-05-26 23:30}:F (expect TEST)' \
326         'test TEST = $(git cat-file blob "master@{2005-05-26 23:30}:F")'
327 test_expect_success \
328         'git cat-file blob master@{2005-05-26 23:42}:F (expect OTHER)' \
329         'test OTHER = $(git cat-file blob "master@{2005-05-26 23:42}:F")'
330
331 a=refs/heads/a
332 b=refs/heads/b
333 c=refs/heads/c
334 E='""'
335 F='%s\0'
336 pws='path with space'
337
338 test_expect_success 'stdin test setup' '
339         echo "$pws" >"$pws" &&
340         git add -- "$pws" &&
341         git commit -m "$pws"
342 '
343
344 test_expect_success '-z fails without --stdin' '
345         test_must_fail git update-ref -z $m $m $m 2>err &&
346         grep "usage: git update-ref" err
347 '
348
349 test_expect_success 'stdin works with no input' '
350         >stdin &&
351         git update-ref --stdin <stdin &&
352         git rev-parse --verify -q $m
353 '
354
355 test_expect_success 'stdin fails on empty line' '
356         echo "" >stdin &&
357         test_must_fail git update-ref --stdin <stdin 2>err &&
358         grep "fatal: empty command in input" err
359 '
360
361 test_expect_success 'stdin fails on only whitespace' '
362         echo " " >stdin &&
363         test_must_fail git update-ref --stdin <stdin 2>err &&
364         grep "fatal: whitespace before command:  " err
365 '
366
367 test_expect_success 'stdin fails on leading whitespace' '
368         echo " create $a $m" >stdin &&
369         test_must_fail git update-ref --stdin <stdin 2>err &&
370         grep "fatal: whitespace before command:  create $a $m" err
371 '
372
373 test_expect_success 'stdin fails on unknown command' '
374         echo "unknown $a" >stdin &&
375         test_must_fail git update-ref --stdin <stdin 2>err &&
376         grep "fatal: unknown command: unknown $a" err
377 '
378
379 test_expect_success 'stdin fails on unbalanced quotes' '
380         echo "create $a \"master" >stdin &&
381         test_must_fail git update-ref --stdin <stdin 2>err &&
382         grep "fatal: badly quoted argument: \\\"master" err
383 '
384
385 test_expect_success 'stdin fails on invalid escape' '
386         echo "create $a \"ma\zter\"" >stdin &&
387         test_must_fail git update-ref --stdin <stdin 2>err &&
388         grep "fatal: badly quoted argument: \\\"ma\\\\zter\\\"" err
389 '
390
391 test_expect_success 'stdin fails on junk after quoted argument' '
392         echo "create \"$a\"master" >stdin &&
393         test_must_fail git update-ref --stdin <stdin 2>err &&
394         grep "fatal: unexpected character after quoted argument: \\\"$a\\\"master" err
395 '
396
397 test_expect_success 'stdin fails create with no ref' '
398         echo "create " >stdin &&
399         test_must_fail git update-ref --stdin <stdin 2>err &&
400         grep "fatal: create: missing <ref>" err
401 '
402
403 test_expect_success 'stdin fails create with no new value' '
404         echo "create $a" >stdin &&
405         test_must_fail git update-ref --stdin <stdin 2>err &&
406         grep "fatal: create $a: missing <newvalue>" err
407 '
408
409 test_expect_success 'stdin fails create with too many arguments' '
410         echo "create $a $m $m" >stdin &&
411         test_must_fail git update-ref --stdin <stdin 2>err &&
412         grep "fatal: create $a: extra input:  $m" err
413 '
414
415 test_expect_success 'stdin fails update with no ref' '
416         echo "update " >stdin &&
417         test_must_fail git update-ref --stdin <stdin 2>err &&
418         grep "fatal: update: missing <ref>" err
419 '
420
421 test_expect_success 'stdin fails update with no new value' '
422         echo "update $a" >stdin &&
423         test_must_fail git update-ref --stdin <stdin 2>err &&
424         grep "fatal: update $a: missing <newvalue>" err
425 '
426
427 test_expect_success 'stdin fails update with too many arguments' '
428         echo "update $a $m $m $m" >stdin &&
429         test_must_fail git update-ref --stdin <stdin 2>err &&
430         grep "fatal: update $a: extra input:  $m" err
431 '
432
433 test_expect_success 'stdin fails delete with no ref' '
434         echo "delete " >stdin &&
435         test_must_fail git update-ref --stdin <stdin 2>err &&
436         grep "fatal: delete: missing <ref>" err
437 '
438
439 test_expect_success 'stdin fails delete with too many arguments' '
440         echo "delete $a $m $m" >stdin &&
441         test_must_fail git update-ref --stdin <stdin 2>err &&
442         grep "fatal: delete $a: extra input:  $m" err
443 '
444
445 test_expect_success 'stdin fails verify with too many arguments' '
446         echo "verify $a $m $m" >stdin &&
447         test_must_fail git update-ref --stdin <stdin 2>err &&
448         grep "fatal: verify $a: extra input:  $m" err
449 '
450
451 test_expect_success 'stdin fails option with unknown name' '
452         echo "option unknown" >stdin &&
453         test_must_fail git update-ref --stdin <stdin 2>err &&
454         grep "fatal: option unknown: unknown" err
455 '
456
457 test_expect_success 'stdin fails with duplicate refs' '
458         cat >stdin <<-EOF &&
459         create $a $m
460         create $b $m
461         create $a $m
462         EOF
463         test_must_fail git update-ref --stdin <stdin 2>err &&
464         grep "fatal: Multiple updates for ref '"'"'$a'"'"' not allowed." err
465 '
466
467 test_expect_success 'stdin create ref works' '
468         echo "create $a $m" >stdin &&
469         git update-ref --stdin <stdin &&
470         git rev-parse $m >expect &&
471         git rev-parse $a >actual &&
472         test_cmp expect actual
473 '
474
475 test_expect_success 'stdin succeeds with quoted argument' '
476         git update-ref -d $a &&
477         echo "create $a \"$m\"" >stdin &&
478         git update-ref --stdin <stdin &&
479         git rev-parse $m >expect &&
480         git rev-parse $a >actual &&
481         test_cmp expect actual
482 '
483
484 test_expect_success 'stdin succeeds with escaped character' '
485         git update-ref -d $a &&
486         echo "create $a \"ma\\163ter\"" >stdin &&
487         git update-ref --stdin <stdin &&
488         git rev-parse $m >expect &&
489         git rev-parse $a >actual &&
490         test_cmp expect actual
491 '
492
493 test_expect_success 'stdin update ref creates with zero old value' '
494         echo "update $b $m $Z" >stdin &&
495         git update-ref --stdin <stdin &&
496         git rev-parse $m >expect &&
497         git rev-parse $b >actual &&
498         test_cmp expect actual &&
499         git update-ref -d $b
500 '
501
502 test_expect_success 'stdin update ref creates with empty old value' '
503         echo "update $b $m $E" >stdin &&
504         git update-ref --stdin <stdin &&
505         git rev-parse $m >expect &&
506         git rev-parse $b >actual &&
507         test_cmp expect actual
508 '
509
510 test_expect_success 'stdin create ref works with path with space to blob' '
511         echo "create refs/blobs/pws \"$m:$pws\"" >stdin &&
512         git update-ref --stdin <stdin &&
513         git rev-parse "$m:$pws" >expect &&
514         git rev-parse refs/blobs/pws >actual &&
515         test_cmp expect actual &&
516         git update-ref -d refs/blobs/pws
517 '
518
519 test_expect_success 'stdin update ref fails with wrong old value' '
520         echo "update $c $m $m~1" >stdin &&
521         test_must_fail git update-ref --stdin <stdin 2>err &&
522         grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err &&
523         test_must_fail git rev-parse --verify -q $c
524 '
525
526 test_expect_success 'stdin update ref fails with bad old value' '
527         echo "update $c $m does-not-exist" >stdin &&
528         test_must_fail git update-ref --stdin <stdin 2>err &&
529         grep "fatal: update $c: invalid <oldvalue>: does-not-exist" err &&
530         test_must_fail git rev-parse --verify -q $c
531 '
532
533 test_expect_success 'stdin create ref fails with bad new value' '
534         echo "create $c does-not-exist" >stdin &&
535         test_must_fail git update-ref --stdin <stdin 2>err &&
536         grep "fatal: create $c: invalid <newvalue>: does-not-exist" err &&
537         test_must_fail git rev-parse --verify -q $c
538 '
539
540 test_expect_success 'stdin create ref fails with zero new value' '
541         echo "create $c " >stdin &&
542         test_must_fail git update-ref --stdin <stdin 2>err &&
543         grep "fatal: create $c: zero <newvalue>" err &&
544         test_must_fail git rev-parse --verify -q $c
545 '
546
547 test_expect_success 'stdin update ref works with right old value' '
548         echo "update $b $m~1 $m" >stdin &&
549         git update-ref --stdin <stdin &&
550         git rev-parse $m~1 >expect &&
551         git rev-parse $b >actual &&
552         test_cmp expect actual
553 '
554
555 test_expect_success 'stdin delete ref fails with wrong old value' '
556         echo "delete $a $m~1" >stdin &&
557         test_must_fail git update-ref --stdin <stdin 2>err &&
558         grep "fatal: Cannot lock the ref '"'"'$a'"'"'" err &&
559         git rev-parse $m >expect &&
560         git rev-parse $a >actual &&
561         test_cmp expect actual
562 '
563
564 test_expect_success 'stdin delete ref fails with zero old value' '
565         echo "delete $a " >stdin &&
566         test_must_fail git update-ref --stdin <stdin 2>err &&
567         grep "fatal: delete $a: zero <oldvalue>" err &&
568         git rev-parse $m >expect &&
569         git rev-parse $a >actual &&
570         test_cmp expect actual
571 '
572
573 test_expect_success 'stdin update symref works option no-deref' '
574         git symbolic-ref TESTSYMREF $b &&
575         cat >stdin <<-EOF &&
576         option no-deref
577         update TESTSYMREF $a $b
578         EOF
579         git update-ref --stdin <stdin &&
580         git rev-parse TESTSYMREF >expect &&
581         git rev-parse $a >actual &&
582         test_cmp expect actual &&
583         git rev-parse $m~1 >expect &&
584         git rev-parse $b >actual &&
585         test_cmp expect actual
586 '
587
588 test_expect_success 'stdin delete symref works option no-deref' '
589         git symbolic-ref TESTSYMREF $b &&
590         cat >stdin <<-EOF &&
591         option no-deref
592         delete TESTSYMREF $b
593         EOF
594         git update-ref --stdin <stdin &&
595         test_must_fail git rev-parse --verify -q TESTSYMREF &&
596         git rev-parse $m~1 >expect &&
597         git rev-parse $b >actual &&
598         test_cmp expect actual
599 '
600
601 test_expect_success 'stdin delete ref works with right old value' '
602         echo "delete $b $m~1" >stdin &&
603         git update-ref --stdin <stdin &&
604         test_must_fail git rev-parse --verify -q $b
605 '
606
607 test_expect_success 'stdin update/create/verify combination works' '
608         cat >stdin <<-EOF &&
609         update $a $m
610         create $b $m
611         verify $c
612         EOF
613         git update-ref --stdin <stdin &&
614         git rev-parse $m >expect &&
615         git rev-parse $a >actual &&
616         test_cmp expect actual &&
617         git rev-parse $b >actual &&
618         test_cmp expect actual &&
619         test_must_fail git rev-parse --verify -q $c
620 '
621
622 test_expect_success 'stdin verify succeeds for correct value' '
623         git rev-parse $m >expect &&
624         echo "verify $m $m" >stdin &&
625         git update-ref --stdin <stdin &&
626         git rev-parse $m >actual &&
627         test_cmp expect actual
628 '
629
630 test_expect_success 'stdin verify succeeds for missing reference' '
631         echo "verify refs/heads/missing $Z" >stdin &&
632         git update-ref --stdin <stdin &&
633         test_must_fail git rev-parse --verify -q refs/heads/missing
634 '
635
636 test_expect_success 'stdin verify treats no value as missing' '
637         echo "verify refs/heads/missing" >stdin &&
638         git update-ref --stdin <stdin &&
639         test_must_fail git rev-parse --verify -q refs/heads/missing
640 '
641
642 test_expect_success 'stdin verify fails for wrong value' '
643         git rev-parse $m >expect &&
644         echo "verify $m $m~1" >stdin &&
645         test_must_fail git update-ref --stdin <stdin &&
646         git rev-parse $m >actual &&
647         test_cmp expect actual
648 '
649
650 test_expect_success 'stdin verify fails for mistaken null value' '
651         git rev-parse $m >expect &&
652         echo "verify $m $Z" >stdin &&
653         test_must_fail git update-ref --stdin <stdin &&
654         git rev-parse $m >actual &&
655         test_cmp expect actual
656 '
657
658 test_expect_success 'stdin verify fails for mistaken empty value' '
659         M=$(git rev-parse $m) &&
660         test_when_finished "git update-ref $m $M" &&
661         git rev-parse $m >expect &&
662         echo "verify $m" >stdin &&
663         test_must_fail git update-ref --stdin <stdin &&
664         git rev-parse $m >actual &&
665         test_cmp expect actual
666 '
667
668 test_expect_success 'stdin update refs works with identity updates' '
669         cat >stdin <<-EOF &&
670         update $a $m $m
671         update $b $m $m
672         update $c $Z $E
673         EOF
674         git update-ref --stdin <stdin &&
675         git rev-parse $m >expect &&
676         git rev-parse $a >actual &&
677         test_cmp expect actual &&
678         git rev-parse $b >actual &&
679         test_cmp expect actual &&
680         test_must_fail git rev-parse --verify -q $c
681 '
682
683 test_expect_success 'stdin update refs fails with wrong old value' '
684         git update-ref $c $m &&
685         cat >stdin <<-EOF &&
686         update $a $m $m
687         update $b $m $m
688         update $c  ''
689         EOF
690         test_must_fail git update-ref --stdin <stdin 2>err &&
691         grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err &&
692         git rev-parse $m >expect &&
693         git rev-parse $a >actual &&
694         test_cmp expect actual &&
695         git rev-parse $b >actual &&
696         test_cmp expect actual &&
697         git rev-parse $c >actual &&
698         test_cmp expect actual
699 '
700
701 test_expect_success 'stdin delete refs works with packed and loose refs' '
702         git pack-refs --all &&
703         git update-ref $c $m~1 &&
704         cat >stdin <<-EOF &&
705         delete $a $m
706         update $b $Z $m
707         update $c $E $m~1
708         EOF
709         git update-ref --stdin <stdin &&
710         test_must_fail git rev-parse --verify -q $a &&
711         test_must_fail git rev-parse --verify -q $b &&
712         test_must_fail git rev-parse --verify -q $c
713 '
714
715 test_expect_success 'stdin -z works on empty input' '
716         >stdin &&
717         git update-ref -z --stdin <stdin &&
718         git rev-parse --verify -q $m
719 '
720
721 test_expect_success 'stdin -z fails on empty line' '
722         echo "" >stdin &&
723         test_must_fail git update-ref -z --stdin <stdin 2>err &&
724         grep "fatal: whitespace before command: " err
725 '
726
727 test_expect_success 'stdin -z fails on empty command' '
728         printf $F "" >stdin &&
729         test_must_fail git update-ref -z --stdin <stdin 2>err &&
730         grep "fatal: empty command in input" err
731 '
732
733 test_expect_success 'stdin -z fails on only whitespace' '
734         printf $F " " >stdin &&
735         test_must_fail git update-ref -z --stdin <stdin 2>err &&
736         grep "fatal: whitespace before command:  " err
737 '
738
739 test_expect_success 'stdin -z fails on leading whitespace' '
740         printf $F " create $a" "$m" >stdin &&
741         test_must_fail git update-ref -z --stdin <stdin 2>err &&
742         grep "fatal: whitespace before command:  create $a" err
743 '
744
745 test_expect_success 'stdin -z fails on unknown command' '
746         printf $F "unknown $a" >stdin &&
747         test_must_fail git update-ref -z --stdin <stdin 2>err &&
748         grep "fatal: unknown command: unknown $a" err
749 '
750
751 test_expect_success 'stdin -z fails create with no ref' '
752         printf $F "create " >stdin &&
753         test_must_fail git update-ref -z --stdin <stdin 2>err &&
754         grep "fatal: create: missing <ref>" err
755 '
756
757 test_expect_success 'stdin -z fails create with no new value' '
758         printf $F "create $a" >stdin &&
759         test_must_fail git update-ref -z --stdin <stdin 2>err &&
760         grep "fatal: create $a: unexpected end of input when reading <newvalue>" err
761 '
762
763 test_expect_success 'stdin -z fails create with too many arguments' '
764         printf $F "create $a" "$m" "$m" >stdin &&
765         test_must_fail git update-ref -z --stdin <stdin 2>err &&
766         grep "fatal: unknown command: $m" err
767 '
768
769 test_expect_success 'stdin -z fails update with no ref' '
770         printf $F "update " >stdin &&
771         test_must_fail git update-ref -z --stdin <stdin 2>err &&
772         grep "fatal: update: missing <ref>" err
773 '
774
775 test_expect_success 'stdin -z fails update with too few args' '
776         printf $F "update $a" "$m" >stdin &&
777         test_must_fail git update-ref -z --stdin <stdin 2>err &&
778         grep "fatal: update $a: unexpected end of input when reading <oldvalue>" err
779 '
780
781 test_expect_success 'stdin -z emits warning with empty new value' '
782         git update-ref $a $m &&
783         printf $F "update $a" "" "" >stdin &&
784         git update-ref -z --stdin <stdin 2>err &&
785         grep "warning: update $a: missing <newvalue>, treating as zero" err &&
786         test_must_fail git rev-parse --verify -q $a
787 '
788
789 test_expect_success 'stdin -z fails update with no new value' '
790         printf $F "update $a" >stdin &&
791         test_must_fail git update-ref -z --stdin <stdin 2>err &&
792         grep "fatal: update $a: unexpected end of input when reading <newvalue>" err
793 '
794
795 test_expect_success 'stdin -z fails update with no old value' '
796         printf $F "update $a" "$m" >stdin &&
797         test_must_fail git update-ref -z --stdin <stdin 2>err &&
798         grep "fatal: update $a: unexpected end of input when reading <oldvalue>" err
799 '
800
801 test_expect_success 'stdin -z fails update with too many arguments' '
802         printf $F "update $a" "$m" "$m" "$m" >stdin &&
803         test_must_fail git update-ref -z --stdin <stdin 2>err &&
804         grep "fatal: unknown command: $m" err
805 '
806
807 test_expect_success 'stdin -z fails delete with no ref' '
808         printf $F "delete " >stdin &&
809         test_must_fail git update-ref -z --stdin <stdin 2>err &&
810         grep "fatal: delete: missing <ref>" err
811 '
812
813 test_expect_success 'stdin -z fails delete with no old value' '
814         printf $F "delete $a" >stdin &&
815         test_must_fail git update-ref -z --stdin <stdin 2>err &&
816         grep "fatal: delete $a: unexpected end of input when reading <oldvalue>" err
817 '
818
819 test_expect_success 'stdin -z fails delete with too many arguments' '
820         printf $F "delete $a" "$m" "$m" >stdin &&
821         test_must_fail git update-ref -z --stdin <stdin 2>err &&
822         grep "fatal: unknown command: $m" err
823 '
824
825 test_expect_success 'stdin -z fails verify with too many arguments' '
826         printf $F "verify $a" "$m" "$m" >stdin &&
827         test_must_fail git update-ref -z --stdin <stdin 2>err &&
828         grep "fatal: unknown command: $m" err
829 '
830
831 test_expect_success 'stdin -z fails verify with no old value' '
832         printf $F "verify $a" >stdin &&
833         test_must_fail git update-ref -z --stdin <stdin 2>err &&
834         grep "fatal: verify $a: unexpected end of input when reading <oldvalue>" err
835 '
836
837 test_expect_success 'stdin -z fails option with unknown name' '
838         printf $F "option unknown" >stdin &&
839         test_must_fail git update-ref -z --stdin <stdin 2>err &&
840         grep "fatal: option unknown: unknown" err
841 '
842
843 test_expect_success 'stdin -z fails with duplicate refs' '
844         printf $F "create $a" "$m" "create $b" "$m" "create $a" "$m" >stdin &&
845         test_must_fail git update-ref -z --stdin <stdin 2>err &&
846         grep "fatal: Multiple updates for ref '"'"'$a'"'"' not allowed." err
847 '
848
849 test_expect_success 'stdin -z create ref works' '
850         printf $F "create $a" "$m" >stdin &&
851         git update-ref -z --stdin <stdin &&
852         git rev-parse $m >expect &&
853         git rev-parse $a >actual &&
854         test_cmp expect actual
855 '
856
857 test_expect_success 'stdin -z update ref creates with zero old value' '
858         printf $F "update $b" "$m" "$Z" >stdin &&
859         git update-ref -z --stdin <stdin &&
860         git rev-parse $m >expect &&
861         git rev-parse $b >actual &&
862         test_cmp expect actual &&
863         git update-ref -d $b
864 '
865
866 test_expect_success 'stdin -z update ref creates with empty old value' '
867         printf $F "update $b" "$m" "" >stdin &&
868         git update-ref -z --stdin <stdin &&
869         git rev-parse $m >expect &&
870         git rev-parse $b >actual &&
871         test_cmp expect actual
872 '
873
874 test_expect_success 'stdin -z create ref works with path with space to blob' '
875         printf $F "create refs/blobs/pws" "$m:$pws" >stdin &&
876         git update-ref -z --stdin <stdin &&
877         git rev-parse "$m:$pws" >expect &&
878         git rev-parse refs/blobs/pws >actual &&
879         test_cmp expect actual &&
880         git update-ref -d refs/blobs/pws
881 '
882
883 test_expect_success 'stdin -z update ref fails with wrong old value' '
884         printf $F "update $c" "$m" "$m~1" >stdin &&
885         test_must_fail git update-ref -z --stdin <stdin 2>err &&
886         grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err &&
887         test_must_fail git rev-parse --verify -q $c
888 '
889
890 test_expect_success 'stdin -z update ref fails with bad old value' '
891         printf $F "update $c" "$m" "does-not-exist" >stdin &&
892         test_must_fail git update-ref -z --stdin <stdin 2>err &&
893         grep "fatal: update $c: invalid <oldvalue>: does-not-exist" err &&
894         test_must_fail git rev-parse --verify -q $c
895 '
896
897 test_expect_success 'stdin -z create ref fails when ref exists' '
898         git update-ref $c $m &&
899         git rev-parse "$c" >expect &&
900         printf $F "create $c" "$m~1" >stdin &&
901         test_must_fail git update-ref -z --stdin <stdin 2>err &&
902         grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err &&
903         git rev-parse "$c" >actual &&
904         test_cmp expect actual
905 '
906
907 test_expect_success 'stdin -z create ref fails with bad new value' '
908         git update-ref -d "$c" &&
909         printf $F "create $c" "does-not-exist" >stdin &&
910         test_must_fail git update-ref -z --stdin <stdin 2>err &&
911         grep "fatal: create $c: invalid <newvalue>: does-not-exist" err &&
912         test_must_fail git rev-parse --verify -q $c
913 '
914
915 test_expect_success 'stdin -z create ref fails with empty new value' '
916         printf $F "create $c" "" >stdin &&
917         test_must_fail git update-ref -z --stdin <stdin 2>err &&
918         grep "fatal: create $c: missing <newvalue>" err &&
919         test_must_fail git rev-parse --verify -q $c
920 '
921
922 test_expect_success 'stdin -z update ref works with right old value' '
923         printf $F "update $b" "$m~1" "$m" >stdin &&
924         git update-ref -z --stdin <stdin &&
925         git rev-parse $m~1 >expect &&
926         git rev-parse $b >actual &&
927         test_cmp expect actual
928 '
929
930 test_expect_success 'stdin -z delete ref fails with wrong old value' '
931         printf $F "delete $a" "$m~1" >stdin &&
932         test_must_fail git update-ref -z --stdin <stdin 2>err &&
933         grep "fatal: Cannot lock the ref '"'"'$a'"'"'" err &&
934         git rev-parse $m >expect &&
935         git rev-parse $a >actual &&
936         test_cmp expect actual
937 '
938
939 test_expect_success 'stdin -z delete ref fails with zero old value' '
940         printf $F "delete $a" "$Z" >stdin &&
941         test_must_fail git update-ref -z --stdin <stdin 2>err &&
942         grep "fatal: delete $a: zero <oldvalue>" err &&
943         git rev-parse $m >expect &&
944         git rev-parse $a >actual &&
945         test_cmp expect actual
946 '
947
948 test_expect_success 'stdin -z update symref works option no-deref' '
949         git symbolic-ref TESTSYMREF $b &&
950         printf $F "option no-deref" "update TESTSYMREF" "$a" "$b" >stdin &&
951         git update-ref -z --stdin <stdin &&
952         git rev-parse TESTSYMREF >expect &&
953         git rev-parse $a >actual &&
954         test_cmp expect actual &&
955         git rev-parse $m~1 >expect &&
956         git rev-parse $b >actual &&
957         test_cmp expect actual
958 '
959
960 test_expect_success 'stdin -z delete symref works option no-deref' '
961         git symbolic-ref TESTSYMREF $b &&
962         printf $F "option no-deref" "delete TESTSYMREF" "$b" >stdin &&
963         git update-ref -z --stdin <stdin &&
964         test_must_fail git rev-parse --verify -q TESTSYMREF &&
965         git rev-parse $m~1 >expect &&
966         git rev-parse $b >actual &&
967         test_cmp expect actual
968 '
969
970 test_expect_success 'stdin -z delete ref works with right old value' '
971         printf $F "delete $b" "$m~1" >stdin &&
972         git update-ref -z --stdin <stdin &&
973         test_must_fail git rev-parse --verify -q $b
974 '
975
976 test_expect_success 'stdin -z update/create/verify combination works' '
977         printf $F "update $a" "$m" "" "create $b" "$m" "verify $c" "" >stdin &&
978         git update-ref -z --stdin <stdin &&
979         git rev-parse $m >expect &&
980         git rev-parse $a >actual &&
981         test_cmp expect actual &&
982         git rev-parse $b >actual &&
983         test_cmp expect actual &&
984         test_must_fail git rev-parse --verify -q $c
985 '
986
987 test_expect_success 'stdin -z verify succeeds for correct value' '
988         git rev-parse $m >expect &&
989         printf $F "verify $m" "$m" >stdin &&
990         git update-ref -z --stdin <stdin &&
991         git rev-parse $m >actual &&
992         test_cmp expect actual
993 '
994
995 test_expect_success 'stdin -z verify succeeds for missing reference' '
996         printf $F "verify refs/heads/missing" "$Z" >stdin &&
997         git update-ref -z --stdin <stdin &&
998         test_must_fail git rev-parse --verify -q refs/heads/missing
999 '
1000
1001 test_expect_success 'stdin -z verify treats no value as missing' '
1002         printf $F "verify refs/heads/missing" "" >stdin &&
1003         git update-ref -z --stdin <stdin &&
1004         test_must_fail git rev-parse --verify -q refs/heads/missing
1005 '
1006
1007 test_expect_success 'stdin -z verify fails for wrong value' '
1008         git rev-parse $m >expect &&
1009         printf $F "verify $m" "$m~1" >stdin &&
1010         test_must_fail git update-ref -z --stdin <stdin &&
1011         git rev-parse $m >actual &&
1012         test_cmp expect actual
1013 '
1014
1015 test_expect_success 'stdin -z verify fails for mistaken null value' '
1016         git rev-parse $m >expect &&
1017         printf $F "verify $m" "$Z" >stdin &&
1018         test_must_fail git update-ref -z --stdin <stdin &&
1019         git rev-parse $m >actual &&
1020         test_cmp expect actual
1021 '
1022
1023 test_expect_success 'stdin -z verify fails for mistaken empty value' '
1024         M=$(git rev-parse $m) &&
1025         test_when_finished "git update-ref $m $M" &&
1026         git rev-parse $m >expect &&
1027         printf $F "verify $m" "" >stdin &&
1028         test_must_fail git update-ref -z --stdin <stdin &&
1029         git rev-parse $m >actual &&
1030         test_cmp expect actual
1031 '
1032
1033 test_expect_success 'stdin -z update refs works with identity updates' '
1034         printf $F "update $a" "$m" "$m" "update $b" "$m" "$m" "update $c" "$Z" "" >stdin &&
1035         git update-ref -z --stdin <stdin &&
1036         git rev-parse $m >expect &&
1037         git rev-parse $a >actual &&
1038         test_cmp expect actual &&
1039         git rev-parse $b >actual &&
1040         test_cmp expect actual &&
1041         test_must_fail git rev-parse --verify -q $c
1042 '
1043
1044 test_expect_success 'stdin -z update refs fails with wrong old value' '
1045         git update-ref $c $m &&
1046         printf $F "update $a" "$m" "$m" "update $b" "$m" "$m" "update $c" "$m" "$Z" >stdin &&
1047         test_must_fail git update-ref -z --stdin <stdin 2>err &&
1048         grep "fatal: Cannot lock the ref '"'"'$c'"'"'" err &&
1049         git rev-parse $m >expect &&
1050         git rev-parse $a >actual &&
1051         test_cmp expect actual &&
1052         git rev-parse $b >actual &&
1053         test_cmp expect actual &&
1054         git rev-parse $c >actual &&
1055         test_cmp expect actual
1056 '
1057
1058 test_expect_success 'stdin -z delete refs works with packed and loose refs' '
1059         git pack-refs --all &&
1060         git update-ref $c $m~1 &&
1061         printf $F "delete $a" "$m" "update $b" "$Z" "$m" "update $c" "" "$m~1" >stdin &&
1062         git update-ref -z --stdin <stdin &&
1063         test_must_fail git rev-parse --verify -q $a &&
1064         test_must_fail git rev-parse --verify -q $b &&
1065         test_must_fail git rev-parse --verify -q $c
1066 '
1067
1068 test_done