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