]>
Commit | Line | Data |
---|---|---|
ef5a6fb5 CR |
1 | #!/bin/sh |
2 | # | |
3 | # Copyright (c) 2007 Carlos Rica | |
4 | # | |
5 | ||
6 | test_description='git-tag | |
7 | ||
62e09ce9 | 8 | Tests for operations with tags.' |
ef5a6fb5 CR |
9 | |
10 | . ./test-lib.sh | |
11 | ||
12 | # creating and listing lightweight tags: | |
13 | ||
14 | tag_exists () { | |
15 | git show-ref --quiet --verify refs/tags/"$1" | |
16 | } | |
17 | ||
18 | # todo: git tag -l now returns always zero, when fixed, change this test | |
62e09ce9 CR |
19 | test_expect_success 'listing all tags in an empty tree should succeed' ' |
20 | git tag -l && | |
21 | git tag | |
22 | ' | |
ef5a6fb5 | 23 | |
62e09ce9 CR |
24 | test_expect_success 'listing all tags in an empty tree should output nothing' ' |
25 | test `git-tag -l | wc -l` -eq 0 && | |
26 | test `git-tag | wc -l` -eq 0 | |
27 | ' | |
ef5a6fb5 CR |
28 | |
29 | test_expect_failure 'looking for a tag in an empty tree should fail' \ | |
30 | 'tag_exists mytag' | |
31 | ||
32 | test_expect_success 'creating a tag in an empty tree should fail' ' | |
33 | ! git-tag mynotag && | |
34 | ! tag_exists mynotag | |
35 | ' | |
36 | ||
37 | test_expect_success 'creating a tag for HEAD in an empty tree should fail' ' | |
38 | ! git-tag mytaghead HEAD && | |
39 | ! tag_exists mytaghead | |
40 | ' | |
41 | ||
42 | test_expect_success 'creating a tag for an unknown revision should fail' ' | |
43 | ! git-tag mytagnorev aaaaaaaaaaa && | |
44 | ! tag_exists mytagnorev | |
45 | ' | |
46 | ||
47 | # commit used in the tests, test_tick is also called here to freeze the date: | |
48 | test_expect_success 'creating a tag using default HEAD should succeed' ' | |
49 | test_tick && | |
50 | echo foo >foo && | |
51 | git add foo && | |
52 | git commit -m Foo && | |
53 | git tag mytag | |
54 | ' | |
55 | ||
62e09ce9 CR |
56 | test_expect_success 'listing all tags if one exists should succeed' ' |
57 | git-tag -l && | |
58 | git-tag | |
59 | ' | |
ef5a6fb5 | 60 | |
62e09ce9 CR |
61 | test_expect_success 'listing all tags if one exists should output that tag' ' |
62 | test `git-tag -l` = mytag && | |
63 | test `git-tag` = mytag | |
64 | ' | |
ef5a6fb5 CR |
65 | |
66 | # pattern matching: | |
67 | ||
68 | test_expect_success 'listing a tag using a matching pattern should succeed' \ | |
69 | 'git-tag -l mytag' | |
70 | ||
71 | test_expect_success \ | |
72 | 'listing a tag using a matching pattern should output that tag' \ | |
73 | 'test `git-tag -l mytag` = mytag' | |
74 | ||
75 | # todo: git tag -l now returns always zero, when fixed, change this test | |
76 | test_expect_success \ | |
77 | 'listing tags using a non-matching pattern should suceed' \ | |
78 | 'git-tag -l xxx' | |
79 | ||
80 | test_expect_success \ | |
81 | 'listing tags using a non-matching pattern should output nothing' \ | |
82 | 'test `git-tag -l xxx | wc -l` -eq 0' | |
83 | ||
84 | # special cases for creating tags: | |
85 | ||
86 | test_expect_failure \ | |
87 | 'trying to create a tag with the name of one existing should fail' \ | |
88 | 'git tag mytag' | |
89 | ||
90 | test_expect_success \ | |
91 | 'trying to create a tag with a non-valid name should fail' ' | |
92 | test `git-tag -l | wc -l` -eq 1 && | |
93 | ! git tag "" && | |
94 | ! git tag .othertag && | |
95 | ! git tag "other tag" && | |
96 | ! git tag "othertag^" && | |
97 | ! git tag "other~tag" && | |
98 | test `git-tag -l | wc -l` -eq 1 | |
99 | ' | |
100 | ||
101 | test_expect_success 'creating a tag using HEAD directly should succeed' ' | |
102 | git tag myhead HEAD && | |
103 | tag_exists myhead | |
104 | ' | |
105 | ||
106 | # deleting tags: | |
107 | ||
108 | test_expect_success 'trying to delete an unknown tag should fail' ' | |
109 | ! tag_exists unknown-tag && | |
110 | ! git-tag -d unknown-tag | |
111 | ' | |
112 | ||
113 | cat >expect <<EOF | |
114 | myhead | |
115 | mytag | |
116 | EOF | |
117 | test_expect_success \ | |
118 | 'trying to delete tags without params should succeed and do nothing' ' | |
119 | git tag -l > actual && git diff expect actual && | |
120 | git-tag -d && | |
121 | git tag -l > actual && git diff expect actual | |
122 | ' | |
123 | ||
124 | test_expect_success \ | |
125 | 'deleting two existing tags in one command should succeed' ' | |
126 | tag_exists mytag && | |
127 | tag_exists myhead && | |
128 | git-tag -d mytag myhead && | |
129 | ! tag_exists mytag && | |
130 | ! tag_exists myhead | |
131 | ' | |
132 | ||
133 | test_expect_success \ | |
134 | 'creating a tag with the name of another deleted one should succeed' ' | |
135 | ! tag_exists mytag && | |
136 | git-tag mytag && | |
137 | tag_exists mytag | |
138 | ' | |
139 | ||
140 | test_expect_success \ | |
141 | 'trying to delete two tags, existing and not, should fail in the 2nd' ' | |
142 | tag_exists mytag && | |
143 | ! tag_exists myhead && | |
144 | ! git-tag -d mytag anothertag && | |
145 | ! tag_exists mytag && | |
146 | ! tag_exists myhead | |
147 | ' | |
148 | ||
149 | test_expect_failure 'trying to delete an already deleted tag should fail' \ | |
150 | 'git-tag -d mytag' | |
151 | ||
152 | # listing various tags with pattern matching: | |
153 | ||
154 | cat >expect <<EOF | |
155 | a1 | |
156 | aa1 | |
157 | cba | |
158 | t210 | |
159 | t211 | |
160 | v0.2.1 | |
161 | v1.0 | |
162 | v1.0.1 | |
163 | v1.1.3 | |
164 | EOF | |
165 | test_expect_success 'listing all tags should print them ordered' ' | |
166 | git tag v1.0.1 && | |
167 | git tag t211 && | |
168 | git tag aa1 && | |
169 | git tag v0.2.1 && | |
170 | git tag v1.1.3 && | |
171 | git tag cba && | |
172 | git tag a1 && | |
173 | git tag v1.0 && | |
174 | git tag t210 && | |
5206d130 | 175 | git tag -l > actual && |
62e09ce9 CR |
176 | git diff expect actual && |
177 | git tag > actual && | |
ef5a6fb5 CR |
178 | git diff expect actual |
179 | ' | |
180 | ||
181 | cat >expect <<EOF | |
182 | a1 | |
183 | aa1 | |
184 | cba | |
185 | EOF | |
186 | test_expect_success \ | |
187 | 'listing tags with substring as pattern must print those matching' ' | |
18e32b5b | 188 | git-tag -l "*a*" > actual && |
5be60078 | 189 | git diff expect actual |
ef5a6fb5 CR |
190 | ' |
191 | ||
192 | cat >expect <<EOF | |
193 | v0.2.1 | |
194 | v1.0.1 | |
ef5a6fb5 CR |
195 | EOF |
196 | test_expect_success \ | |
18e32b5b CR |
197 | 'listing tags with a suffix as pattern must print those matching' ' |
198 | git-tag -l "*.1" > actual && | |
5be60078 | 199 | git diff expect actual |
ef5a6fb5 CR |
200 | ' |
201 | ||
202 | cat >expect <<EOF | |
203 | t210 | |
204 | t211 | |
205 | EOF | |
206 | test_expect_success \ | |
18e32b5b CR |
207 | 'listing tags with a prefix as pattern must print those matching' ' |
208 | git-tag -l "t21*" > actual && | |
5be60078 | 209 | git diff expect actual |
ef5a6fb5 CR |
210 | ' |
211 | ||
212 | cat >expect <<EOF | |
213 | a1 | |
ef5a6fb5 CR |
214 | EOF |
215 | test_expect_success \ | |
18e32b5b | 216 | 'listing tags using a name as pattern must print that one matching' ' |
ef5a6fb5 | 217 | git-tag -l a1 > actual && |
5be60078 | 218 | git diff expect actual |
ef5a6fb5 CR |
219 | ' |
220 | ||
221 | cat >expect <<EOF | |
222 | v1.0 | |
ef5a6fb5 CR |
223 | EOF |
224 | test_expect_success \ | |
18e32b5b | 225 | 'listing tags using a name as pattern must print that one matching' ' |
ef5a6fb5 | 226 | git-tag -l v1.0 > actual && |
5be60078 | 227 | git diff expect actual |
ef5a6fb5 CR |
228 | ' |
229 | ||
230 | cat >expect <<EOF | |
18e32b5b | 231 | v1.0.1 |
ef5a6fb5 CR |
232 | v1.1.3 |
233 | EOF | |
234 | test_expect_success \ | |
235 | 'listing tags with ? in the pattern should print those matching' ' | |
18e32b5b | 236 | git-tag -l "v1.?.?" > actual && |
5be60078 | 237 | git diff expect actual |
ef5a6fb5 CR |
238 | ' |
239 | ||
240 | >expect | |
241 | test_expect_success \ | |
242 | 'listing tags using v.* should print nothing because none have v.' ' | |
243 | git-tag -l "v.*" > actual && | |
5be60078 | 244 | git diff expect actual |
ef5a6fb5 CR |
245 | ' |
246 | ||
247 | cat >expect <<EOF | |
248 | v0.2.1 | |
249 | v1.0 | |
250 | v1.0.1 | |
251 | v1.1.3 | |
252 | EOF | |
253 | test_expect_success \ | |
254 | 'listing tags using v* should print only those having v' ' | |
255 | git-tag -l "v*" > actual && | |
5be60078 | 256 | git diff expect actual |
ef5a6fb5 CR |
257 | ' |
258 | ||
259 | # creating and verifying lightweight tags: | |
260 | ||
261 | test_expect_success \ | |
262 | 'a non-annotated tag created without parameters should point to HEAD' ' | |
263 | git-tag non-annotated-tag && | |
5be60078 JH |
264 | test $(git cat-file -t non-annotated-tag) = commit && |
265 | test $(git rev-parse non-annotated-tag) = $(git rev-parse HEAD) | |
ef5a6fb5 CR |
266 | ' |
267 | ||
268 | test_expect_failure 'trying to verify an unknown tag should fail' \ | |
269 | 'git-tag -v unknown-tag' | |
270 | ||
271 | test_expect_failure \ | |
272 | 'trying to verify a non-annotated and non-signed tag should fail' \ | |
273 | 'git-tag -v non-annotated-tag' | |
274 | ||
62e09ce9 CR |
275 | test_expect_failure \ |
276 | 'trying to verify many non-annotated or unknown tags, should fail' \ | |
277 | 'git-tag -v unknown-tag1 non-annotated-tag unknown-tag2' | |
278 | ||
ef5a6fb5 CR |
279 | # creating annotated tags: |
280 | ||
281 | get_tag_msg () { | |
282 | git cat-file tag "$1" | sed -e "/BEGIN PGP/q" | |
283 | } | |
284 | ||
285 | # run test_tick before committing always gives the time in that timezone | |
286 | get_tag_header () { | |
287 | cat <<EOF | |
288 | object $2 | |
289 | type $3 | |
290 | tag $1 | |
291 | tagger C O Mitter <committer@example.com> $4 -0700 | |
292 | ||
293 | EOF | |
294 | } | |
295 | ||
296 | commit=$(git rev-parse HEAD) | |
297 | time=$test_tick | |
298 | ||
299 | get_tag_header annotated-tag $commit commit $time >expect | |
300 | echo "A message" >>expect | |
301 | test_expect_success \ | |
302 | 'creating an annotated tag with -m message should succeed' ' | |
303 | git-tag -m "A message" annotated-tag && | |
304 | get_tag_msg annotated-tag >actual && | |
305 | git diff expect actual | |
306 | ' | |
307 | ||
308 | cat >msgfile <<EOF | |
309 | Another message | |
310 | in a file. | |
311 | EOF | |
312 | get_tag_header file-annotated-tag $commit commit $time >expect | |
313 | cat msgfile >>expect | |
314 | test_expect_success \ | |
315 | 'creating an annotated tag with -F messagefile should succeed' ' | |
316 | git-tag -F msgfile file-annotated-tag && | |
317 | get_tag_msg file-annotated-tag >actual && | |
318 | git diff expect actual | |
319 | ' | |
320 | ||
62e09ce9 CR |
321 | cat >inputmsg <<EOF |
322 | A message from the | |
323 | standard input | |
324 | EOF | |
325 | get_tag_header stdin-annotated-tag $commit commit $time >expect | |
326 | cat inputmsg >>expect | |
327 | test_expect_success 'creating an annotated tag with -F - should succeed' ' | |
328 | git-tag -F - stdin-annotated-tag <inputmsg && | |
329 | get_tag_msg stdin-annotated-tag >actual && | |
330 | git diff expect actual | |
331 | ' | |
332 | ||
e317cfaf CR |
333 | test_expect_success \ |
334 | 'trying to create a tag with a non-existing -F file should fail' ' | |
335 | ! test -f nonexistingfile && | |
336 | ! tag_exists notag && | |
337 | ! git-tag -F nonexistingfile notag && | |
338 | ! tag_exists notag | |
339 | ' | |
340 | ||
341 | test_expect_success \ | |
342 | 'trying to create tags giving many -m or -F options should fail' ' | |
343 | echo "message file 1" >msgfile1 && | |
344 | echo "message file 2" >msgfile2 && | |
345 | ! tag_exists msgtag && | |
346 | ! git-tag -m "message 1" -m "message 2" msgtag && | |
347 | ! tag_exists msgtag && | |
348 | ! git-tag -F msgfile1 -F msgfile2 msgtag && | |
349 | ! tag_exists msgtag && | |
350 | ! git-tag -m "message 1" -F msgfile1 msgtag && | |
351 | ! tag_exists msgtag && | |
352 | ! git-tag -F msgfile1 -m "message 1" msgtag && | |
353 | ! tag_exists msgtag && | |
354 | ! git-tag -F msgfile1 -m "message 1" -F msgfile2 msgtag && | |
355 | ! tag_exists msgtag && | |
356 | ! git-tag -m "message 1" -F msgfile1 -m "message 2" msgtag && | |
357 | ! tag_exists msgtag | |
358 | ' | |
359 | ||
ef5a6fb5 CR |
360 | # blank and empty messages: |
361 | ||
362 | get_tag_header empty-annotated-tag $commit commit $time >expect | |
363 | test_expect_success \ | |
364 | 'creating a tag with an empty -m message should succeed' ' | |
365 | git-tag -m "" empty-annotated-tag && | |
366 | get_tag_msg empty-annotated-tag >actual && | |
367 | git diff expect actual | |
368 | ' | |
369 | ||
370 | >emptyfile | |
371 | get_tag_header emptyfile-annotated-tag $commit commit $time >expect | |
372 | test_expect_success \ | |
373 | 'creating a tag with an empty -F messagefile should succeed' ' | |
374 | git-tag -F emptyfile emptyfile-annotated-tag && | |
375 | get_tag_msg emptyfile-annotated-tag >actual && | |
376 | git diff expect actual | |
377 | ' | |
378 | ||
379 | printf '\n\n \n\t\nLeading blank lines\n' >blanksfile | |
380 | printf '\n\t \t \nRepeated blank lines\n' >>blanksfile | |
381 | printf '\n\n\nTrailing spaces \t \n' >>blanksfile | |
382 | printf '\nTrailing blank lines\n\n\t \n\n' >>blanksfile | |
383 | get_tag_header blanks-annotated-tag $commit commit $time >expect | |
384 | cat >>expect <<EOF | |
385 | Leading blank lines | |
386 | ||
387 | Repeated blank lines | |
388 | ||
389 | Trailing spaces | |
390 | ||
391 | Trailing blank lines | |
392 | EOF | |
393 | test_expect_success \ | |
394 | 'extra blanks in the message for an annotated tag should be removed' ' | |
395 | git-tag -F blanksfile blanks-annotated-tag && | |
396 | get_tag_msg blanks-annotated-tag >actual && | |
397 | git diff expect actual | |
398 | ' | |
399 | ||
400 | get_tag_header blank-annotated-tag $commit commit $time >expect | |
401 | test_expect_success \ | |
402 | 'creating a tag with blank -m message with spaces should succeed' ' | |
403 | git-tag -m " " blank-annotated-tag && | |
404 | get_tag_msg blank-annotated-tag >actual && | |
405 | git diff expect actual | |
406 | ' | |
407 | ||
408 | echo ' ' >blankfile | |
409 | echo '' >>blankfile | |
410 | echo ' ' >>blankfile | |
411 | get_tag_header blankfile-annotated-tag $commit commit $time >expect | |
412 | test_expect_success \ | |
413 | 'creating a tag with blank -F messagefile with spaces should succeed' ' | |
414 | git-tag -F blankfile blankfile-annotated-tag && | |
415 | get_tag_msg blankfile-annotated-tag >actual && | |
416 | git diff expect actual | |
417 | ' | |
418 | ||
419 | printf ' ' >blanknonlfile | |
420 | get_tag_header blanknonlfile-annotated-tag $commit commit $time >expect | |
421 | test_expect_success \ | |
422 | 'creating a tag with -F file of spaces and no newline should succeed' ' | |
423 | git-tag -F blanknonlfile blanknonlfile-annotated-tag && | |
424 | get_tag_msg blanknonlfile-annotated-tag >actual && | |
425 | git diff expect actual | |
426 | ' | |
427 | ||
428 | # messages with commented lines: | |
429 | ||
430 | cat >commentsfile <<EOF | |
431 | # A comment | |
432 | ||
433 | ############ | |
434 | The message. | |
435 | ############ | |
436 | One line. | |
437 | ||
438 | ||
439 | # commented lines | |
440 | # commented lines | |
441 | ||
442 | Another line. | |
443 | # comments | |
444 | ||
445 | Last line. | |
446 | EOF | |
447 | get_tag_header comments-annotated-tag $commit commit $time >expect | |
448 | cat >>expect <<EOF | |
449 | The message. | |
450 | One line. | |
451 | ||
452 | Another line. | |
453 | ||
454 | Last line. | |
455 | EOF | |
456 | test_expect_success \ | |
457 | 'creating a tag using a -F messagefile with #comments should succeed' ' | |
458 | git-tag -F commentsfile comments-annotated-tag && | |
459 | get_tag_msg comments-annotated-tag >actual && | |
460 | git diff expect actual | |
461 | ' | |
462 | ||
463 | get_tag_header comment-annotated-tag $commit commit $time >expect | |
464 | test_expect_success \ | |
465 | 'creating a tag with a #comment in the -m message should succeed' ' | |
466 | git-tag -m "#comment" comment-annotated-tag && | |
467 | get_tag_msg comment-annotated-tag >actual && | |
468 | git diff expect actual | |
469 | ' | |
470 | ||
471 | echo '#comment' >commentfile | |
472 | echo '' >>commentfile | |
473 | echo '####' >>commentfile | |
474 | get_tag_header commentfile-annotated-tag $commit commit $time >expect | |
475 | test_expect_success \ | |
476 | 'creating a tag with #comments in the -F messagefile should succeed' ' | |
477 | git-tag -F commentfile commentfile-annotated-tag && | |
478 | get_tag_msg commentfile-annotated-tag >actual && | |
479 | git diff expect actual | |
480 | ' | |
481 | ||
482 | printf '#comment' >commentnonlfile | |
483 | get_tag_header commentnonlfile-annotated-tag $commit commit $time >expect | |
484 | test_expect_success \ | |
485 | 'creating a tag with a file of #comment and no newline should succeed' ' | |
486 | git-tag -F commentnonlfile commentnonlfile-annotated-tag && | |
487 | get_tag_msg commentnonlfile-annotated-tag >actual && | |
488 | git diff expect actual | |
489 | ' | |
490 | ||
5206d130 CR |
491 | # listing messages for annotated non-signed tags: |
492 | ||
493 | test_expect_success \ | |
494 | 'listing the one-line message of a non-signed tag should succeed' ' | |
495 | git-tag -m "A msg" tag-one-line && | |
496 | ||
497 | echo "tag-one-line" >expect && | |
498 | git-tag -l | grep "^tag-one-line" >actual && | |
499 | git diff expect actual && | |
500 | git-tag -n 0 -l | grep "^tag-one-line" >actual && | |
501 | git diff expect actual && | |
502 | git-tag -n 0 -l tag-one-line >actual && | |
503 | git diff expect actual && | |
504 | ||
505 | echo "tag-one-line A msg" >expect && | |
506 | git-tag -n xxx -l | grep "^tag-one-line" >actual && | |
507 | git diff expect actual && | |
508 | git-tag -n "" -l | grep "^tag-one-line" >actual && | |
509 | git diff expect actual && | |
510 | git-tag -n 1 -l | grep "^tag-one-line" >actual && | |
511 | git diff expect actual && | |
512 | git-tag -n -l | grep "^tag-one-line" >actual && | |
513 | git diff expect actual && | |
514 | git-tag -n 1 -l tag-one-line >actual && | |
515 | git diff expect actual && | |
516 | git-tag -n 2 -l tag-one-line >actual && | |
517 | git diff expect actual && | |
518 | git-tag -n 999 -l tag-one-line >actual && | |
519 | git diff expect actual | |
520 | ' | |
521 | ||
522 | test_expect_success \ | |
523 | 'listing the zero-lines message of a non-signed tag should succeed' ' | |
524 | git-tag -m "" tag-zero-lines && | |
525 | ||
526 | echo "tag-zero-lines" >expect && | |
527 | git-tag -l | grep "^tag-zero-lines" >actual && | |
528 | git diff expect actual && | |
529 | git-tag -n 0 -l | grep "^tag-zero-lines" >actual && | |
530 | git diff expect actual && | |
531 | git-tag -n 0 -l tag-zero-lines >actual && | |
532 | git diff expect actual && | |
533 | ||
534 | echo "tag-zero-lines " >expect && | |
535 | git-tag -n 1 -l | grep "^tag-zero-lines" >actual && | |
536 | git diff expect actual && | |
537 | git-tag -n -l | grep "^tag-zero-lines" >actual && | |
538 | git diff expect actual && | |
539 | git-tag -n 1 -l tag-zero-lines >actual && | |
540 | git diff expect actual && | |
541 | git-tag -n 2 -l tag-zero-lines >actual && | |
542 | git diff expect actual && | |
543 | git-tag -n 999 -l tag-zero-lines >actual && | |
544 | git diff expect actual | |
545 | ' | |
546 | ||
547 | echo 'tag line one' >annotagmsg | |
548 | echo 'tag line two' >>annotagmsg | |
549 | echo 'tag line three' >>annotagmsg | |
550 | test_expect_success \ | |
551 | 'listing many message lines of a non-signed tag should succeed' ' | |
552 | git-tag -F annotagmsg tag-lines && | |
553 | ||
554 | echo "tag-lines" >expect && | |
555 | git-tag -l | grep "^tag-lines" >actual && | |
556 | git diff expect actual && | |
557 | git-tag -n 0 -l | grep "^tag-lines" >actual && | |
558 | git diff expect actual && | |
559 | git-tag -n 0 -l tag-lines >actual && | |
560 | git diff expect actual && | |
561 | ||
562 | echo "tag-lines tag line one" >expect && | |
563 | git-tag -n 1 -l | grep "^tag-lines" >actual && | |
564 | git diff expect actual && | |
565 | git-tag -n -l | grep "^tag-lines" >actual && | |
566 | git diff expect actual && | |
567 | git-tag -n 1 -l tag-lines >actual && | |
568 | git diff expect actual && | |
569 | ||
570 | echo " tag line two" >>expect && | |
571 | git-tag -n 2 -l | grep "^ *tag.line" >actual && | |
572 | git diff expect actual && | |
573 | git-tag -n 2 -l tag-lines >actual && | |
574 | git diff expect actual && | |
575 | ||
576 | echo " tag line three" >>expect && | |
577 | git-tag -n 3 -l | grep "^ *tag.line" >actual && | |
578 | git diff expect actual && | |
579 | git-tag -n 3 -l tag-lines >actual && | |
580 | git diff expect actual && | |
581 | git-tag -n 4 -l | grep "^ *tag.line" >actual && | |
582 | git diff expect actual && | |
583 | git-tag -n 4 -l tag-lines >actual && | |
584 | git diff expect actual && | |
585 | git-tag -n 99 -l | grep "^ *tag.line" >actual && | |
586 | git diff expect actual && | |
587 | git-tag -n 99 -l tag-lines >actual && | |
588 | git diff expect actual | |
589 | ' | |
590 | ||
ef5a6fb5 CR |
591 | # trying to verify annotated non-signed tags: |
592 | ||
593 | test_expect_success \ | |
594 | 'trying to verify an annotated non-signed tag should fail' ' | |
595 | tag_exists annotated-tag && | |
596 | ! git-tag -v annotated-tag | |
597 | ' | |
598 | ||
599 | test_expect_success \ | |
600 | 'trying to verify a file-annotated non-signed tag should fail' ' | |
601 | tag_exists file-annotated-tag && | |
602 | ! git-tag -v file-annotated-tag | |
603 | ' | |
604 | ||
62e09ce9 CR |
605 | test_expect_success \ |
606 | 'trying to verify two annotated non-signed tags should fail' ' | |
607 | tag_exists annotated-tag file-annotated-tag && | |
608 | ! git-tag -v annotated-tag file-annotated-tag | |
609 | ' | |
610 | ||
ef5a6fb5 CR |
611 | # creating and verifying signed tags: |
612 | ||
613 | gpg --version >/dev/null | |
614 | if [ $? -eq 127 ]; then | |
615 | echo "Skipping signed tags tests, because gpg was not found" | |
616 | test_done | |
617 | exit | |
618 | fi | |
619 | ||
797e99a2 CR |
620 | # As said here: http://www.gnupg.org/documentation/faqs.html#q6.19 |
621 | # the gpg version 1.0.6 didn't parse trust packets correctly, so for | |
622 | # that version, creation of signed tags using the generated key fails. | |
623 | case "$(gpg --version)" in | |
624 | 'gpg (GnuPG) 1.0.6'*) | |
625 | echo "Skipping signed tag tests, because a bug in 1.0.6 version" | |
626 | test_done | |
627 | exit | |
628 | ;; | |
629 | esac | |
630 | ||
ef5a6fb5 CR |
631 | # key generation info: gpg --homedir t/t7004 --gen-key |
632 | # Type DSA and Elgamal, size 2048 bits, no expiration date. | |
633 | # Name and email: C O Mitter <committer@example.com> | |
634 | # No password given, to enable non-interactive operation. | |
635 | ||
636 | cp -R ../t7004 ./gpghome | |
637 | chmod 0700 gpghome | |
638 | export GNUPGHOME="$(pwd)/gpghome" | |
639 | ||
640 | get_tag_header signed-tag $commit commit $time >expect | |
641 | echo 'A signed tag message' >>expect | |
642 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
643 | test_expect_success 'creating a signed tag with -m message should succeed' ' | |
644 | git-tag -s -m "A signed tag message" signed-tag && | |
645 | get_tag_msg signed-tag >actual && | |
5be60078 | 646 | git diff expect actual |
ef5a6fb5 CR |
647 | ' |
648 | ||
62e09ce9 CR |
649 | cat >sigmsgfile <<EOF |
650 | Another signed tag | |
651 | message in a file. | |
652 | EOF | |
653 | get_tag_header file-signed-tag $commit commit $time >expect | |
654 | cat sigmsgfile >>expect | |
655 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
656 | test_expect_success \ | |
657 | 'creating a signed tag with -F messagefile should succeed' ' | |
658 | git-tag -s -F sigmsgfile file-signed-tag && | |
659 | get_tag_msg file-signed-tag >actual && | |
660 | git diff expect actual | |
661 | ' | |
662 | ||
663 | cat >siginputmsg <<EOF | |
664 | A signed tag message from | |
665 | the standard input | |
666 | EOF | |
667 | get_tag_header stdin-signed-tag $commit commit $time >expect | |
668 | cat siginputmsg >>expect | |
669 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
670 | test_expect_success 'creating a signed tag with -F - should succeed' ' | |
671 | git-tag -s -F - stdin-signed-tag <siginputmsg && | |
672 | get_tag_msg stdin-signed-tag >actual && | |
673 | git diff expect actual | |
674 | ' | |
675 | ||
e317cfaf CR |
676 | test_expect_success \ |
677 | 'trying to create a signed tag with non-existing -F file should fail' ' | |
678 | ! test -f nonexistingfile && | |
679 | ! tag_exists nosigtag && | |
680 | ! git-tag -s -F nonexistingfile nosigtag && | |
681 | ! tag_exists nosigtag | |
682 | ' | |
683 | ||
ef5a6fb5 CR |
684 | test_expect_success 'verifying a signed tag should succeed' \ |
685 | 'git-tag -v signed-tag' | |
686 | ||
62e09ce9 CR |
687 | test_expect_success 'verifying two signed tags in one command should succeed' \ |
688 | 'git-tag -v signed-tag file-signed-tag' | |
689 | ||
690 | test_expect_success \ | |
691 | 'verifying many signed and non-signed tags should fail' ' | |
692 | ! git-tag -v signed-tag annotated-tag && | |
693 | ! git-tag -v file-annotated-tag file-signed-tag && | |
694 | ! git-tag -v annotated-tag file-signed-tag file-annotated-tag && | |
695 | ! git-tag -v signed-tag annotated-tag file-signed-tag | |
696 | ' | |
697 | ||
ef5a6fb5 CR |
698 | test_expect_success 'verifying a forged tag should fail' ' |
699 | forged=$(git cat-file tag signed-tag | | |
700 | sed -e "s/signed-tag/forged-tag/" | | |
701 | git mktag) && | |
702 | git tag forged-tag $forged && | |
703 | ! git-tag -v forged-tag | |
704 | ' | |
705 | ||
706 | # blank and empty messages for signed tags: | |
707 | ||
708 | get_tag_header empty-signed-tag $commit commit $time >expect | |
709 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
710 | test_expect_success \ | |
711 | 'creating a signed tag with an empty -m message should succeed' ' | |
712 | git-tag -s -m "" empty-signed-tag && | |
713 | get_tag_msg empty-signed-tag >actual && | |
714 | git diff expect actual && | |
715 | git-tag -v empty-signed-tag | |
716 | ' | |
717 | ||
718 | >sigemptyfile | |
719 | get_tag_header emptyfile-signed-tag $commit commit $time >expect | |
720 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
721 | test_expect_success \ | |
722 | 'creating a signed tag with an empty -F messagefile should succeed' ' | |
723 | git-tag -s -F sigemptyfile emptyfile-signed-tag && | |
724 | get_tag_msg emptyfile-signed-tag >actual && | |
725 | git diff expect actual && | |
726 | git-tag -v emptyfile-signed-tag | |
727 | ' | |
728 | ||
729 | printf '\n\n \n\t\nLeading blank lines\n' > sigblanksfile | |
730 | printf '\n\t \t \nRepeated blank lines\n' >>sigblanksfile | |
731 | printf '\n\n\nTrailing spaces \t \n' >>sigblanksfile | |
732 | printf '\nTrailing blank lines\n\n\t \n\n' >>sigblanksfile | |
733 | get_tag_header blanks-signed-tag $commit commit $time >expect | |
734 | cat >>expect <<EOF | |
735 | Leading blank lines | |
736 | ||
737 | Repeated blank lines | |
738 | ||
739 | Trailing spaces | |
740 | ||
741 | Trailing blank lines | |
742 | EOF | |
743 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
744 | test_expect_success \ | |
745 | 'extra blanks in the message for a signed tag should be removed' ' | |
746 | git-tag -s -F sigblanksfile blanks-signed-tag && | |
747 | get_tag_msg blanks-signed-tag >actual && | |
748 | git diff expect actual && | |
749 | git-tag -v blanks-signed-tag | |
750 | ' | |
751 | ||
752 | get_tag_header blank-signed-tag $commit commit $time >expect | |
753 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
754 | test_expect_success \ | |
755 | 'creating a signed tag with a blank -m message should succeed' ' | |
756 | git-tag -s -m " " blank-signed-tag && | |
757 | get_tag_msg blank-signed-tag >actual && | |
758 | git diff expect actual && | |
759 | git-tag -v blank-signed-tag | |
760 | ' | |
761 | ||
762 | echo ' ' >sigblankfile | |
763 | echo '' >>sigblankfile | |
764 | echo ' ' >>sigblankfile | |
765 | get_tag_header blankfile-signed-tag $commit commit $time >expect | |
766 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
767 | test_expect_success \ | |
768 | 'creating a signed tag with blank -F file with spaces should succeed' ' | |
769 | git-tag -s -F sigblankfile blankfile-signed-tag && | |
770 | get_tag_msg blankfile-signed-tag >actual && | |
771 | git diff expect actual && | |
772 | git-tag -v blankfile-signed-tag | |
773 | ' | |
774 | ||
775 | printf ' ' >sigblanknonlfile | |
776 | get_tag_header blanknonlfile-signed-tag $commit commit $time >expect | |
777 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
778 | test_expect_success \ | |
779 | 'creating a signed tag with spaces and no newline should succeed' ' | |
780 | git-tag -s -F sigblanknonlfile blanknonlfile-signed-tag && | |
781 | get_tag_msg blanknonlfile-signed-tag >actual && | |
782 | git diff expect actual && | |
783 | git-tag -v signed-tag | |
784 | ' | |
785 | ||
786 | # messages with commented lines for signed tags: | |
787 | ||
788 | cat >sigcommentsfile <<EOF | |
789 | # A comment | |
790 | ||
791 | ############ | |
792 | The message. | |
793 | ############ | |
794 | One line. | |
795 | ||
796 | ||
797 | # commented lines | |
798 | # commented lines | |
799 | ||
800 | Another line. | |
801 | # comments | |
802 | ||
803 | Last line. | |
804 | EOF | |
805 | get_tag_header comments-signed-tag $commit commit $time >expect | |
806 | cat >>expect <<EOF | |
807 | The message. | |
808 | One line. | |
809 | ||
810 | Another line. | |
811 | ||
812 | Last line. | |
813 | EOF | |
814 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
815 | test_expect_success \ | |
816 | 'creating a signed tag with a -F file with #comments should succeed' ' | |
817 | git-tag -s -F sigcommentsfile comments-signed-tag && | |
818 | get_tag_msg comments-signed-tag >actual && | |
819 | git diff expect actual && | |
820 | git-tag -v comments-signed-tag | |
821 | ' | |
822 | ||
823 | get_tag_header comment-signed-tag $commit commit $time >expect | |
824 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
825 | test_expect_success \ | |
826 | 'creating a signed tag with #commented -m message should succeed' ' | |
827 | git-tag -s -m "#comment" comment-signed-tag && | |
828 | get_tag_msg comment-signed-tag >actual && | |
829 | git diff expect actual && | |
830 | git-tag -v comment-signed-tag | |
831 | ' | |
832 | ||
833 | echo '#comment' >sigcommentfile | |
834 | echo '' >>sigcommentfile | |
835 | echo '####' >>sigcommentfile | |
836 | get_tag_header commentfile-signed-tag $commit commit $time >expect | |
837 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
838 | test_expect_success \ | |
839 | 'creating a signed tag with #commented -F messagefile should succeed' ' | |
840 | git-tag -s -F sigcommentfile commentfile-signed-tag && | |
841 | get_tag_msg commentfile-signed-tag >actual && | |
842 | git diff expect actual && | |
843 | git-tag -v commentfile-signed-tag | |
844 | ' | |
845 | ||
846 | printf '#comment' >sigcommentnonlfile | |
847 | get_tag_header commentnonlfile-signed-tag $commit commit $time >expect | |
848 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
849 | test_expect_success \ | |
850 | 'creating a signed tag with a #comment and no newline should succeed' ' | |
851 | git-tag -s -F sigcommentnonlfile commentnonlfile-signed-tag && | |
852 | get_tag_msg commentnonlfile-signed-tag >actual && | |
853 | git diff expect actual && | |
854 | git-tag -v commentnonlfile-signed-tag | |
855 | ' | |
856 | ||
5206d130 CR |
857 | # listing messages for signed tags: |
858 | ||
859 | test_expect_success \ | |
860 | 'listing the one-line message of a signed tag should succeed' ' | |
861 | git-tag -s -m "A message line signed" stag-one-line && | |
862 | ||
863 | echo "stag-one-line" >expect && | |
864 | git-tag -l | grep "^stag-one-line" >actual && | |
865 | git diff expect actual && | |
866 | git-tag -n 0 -l | grep "^stag-one-line" >actual && | |
867 | git diff expect actual && | |
868 | git-tag -n 0 -l stag-one-line >actual && | |
869 | git diff expect actual && | |
870 | ||
871 | echo "stag-one-line A message line signed" >expect && | |
872 | git-tag -n xxx -l | grep "^stag-one-line" >actual && | |
873 | git diff expect actual && | |
874 | git-tag -n "" -l | grep "^stag-one-line" >actual && | |
875 | git diff expect actual && | |
876 | git-tag -n 1 -l | grep "^stag-one-line" >actual && | |
877 | git diff expect actual && | |
878 | git-tag -n -l | grep "^stag-one-line" >actual && | |
879 | git diff expect actual && | |
880 | git-tag -n 1 -l stag-one-line >actual && | |
881 | git diff expect actual && | |
882 | git-tag -n 2 -l stag-one-line >actual && | |
883 | git diff expect actual && | |
884 | git-tag -n 999 -l stag-one-line >actual && | |
885 | git diff expect actual | |
886 | ' | |
887 | ||
888 | test_expect_success \ | |
889 | 'listing the zero-lines message of a signed tag should succeed' ' | |
890 | git-tag -s -m "" stag-zero-lines && | |
891 | ||
892 | echo "stag-zero-lines" >expect && | |
893 | git-tag -l | grep "^stag-zero-lines" >actual && | |
894 | git diff expect actual && | |
895 | git-tag -n 0 -l | grep "^stag-zero-lines" >actual && | |
896 | git diff expect actual && | |
897 | git-tag -n 0 -l stag-zero-lines >actual && | |
898 | git diff expect actual && | |
899 | ||
900 | echo "stag-zero-lines " >expect && | |
901 | git-tag -n 1 -l | grep "^stag-zero-lines" >actual && | |
902 | git diff expect actual && | |
903 | git-tag -n -l | grep "^stag-zero-lines" >actual && | |
904 | git diff expect actual && | |
905 | git-tag -n 1 -l stag-zero-lines >actual && | |
906 | git diff expect actual && | |
907 | git-tag -n 2 -l stag-zero-lines >actual && | |
908 | git diff expect actual && | |
909 | git-tag -n 999 -l stag-zero-lines >actual && | |
910 | git diff expect actual | |
911 | ' | |
912 | ||
913 | echo 'stag line one' >sigtagmsg | |
914 | echo 'stag line two' >>sigtagmsg | |
915 | echo 'stag line three' >>sigtagmsg | |
916 | test_expect_success \ | |
917 | 'listing many message lines of a signed tag should succeed' ' | |
918 | git-tag -s -F sigtagmsg stag-lines && | |
919 | ||
920 | echo "stag-lines" >expect && | |
921 | git-tag -l | grep "^stag-lines" >actual && | |
922 | git diff expect actual && | |
923 | git-tag -n 0 -l | grep "^stag-lines" >actual && | |
924 | git diff expect actual && | |
925 | git-tag -n 0 -l stag-lines >actual && | |
926 | git diff expect actual && | |
927 | ||
928 | echo "stag-lines stag line one" >expect && | |
929 | git-tag -n 1 -l | grep "^stag-lines" >actual && | |
930 | git diff expect actual && | |
931 | git-tag -n -l | grep "^stag-lines" >actual && | |
932 | git diff expect actual && | |
933 | git-tag -n 1 -l stag-lines >actual && | |
934 | git diff expect actual && | |
935 | ||
936 | echo " stag line two" >>expect && | |
937 | git-tag -n 2 -l | grep "^ *stag.line" >actual && | |
938 | git diff expect actual && | |
939 | git-tag -n 2 -l stag-lines >actual && | |
940 | git diff expect actual && | |
941 | ||
942 | echo " stag line three" >>expect && | |
943 | git-tag -n 3 -l | grep "^ *stag.line" >actual && | |
944 | git diff expect actual && | |
945 | git-tag -n 3 -l stag-lines >actual && | |
946 | git diff expect actual && | |
947 | git-tag -n 4 -l | grep "^ *stag.line" >actual && | |
948 | git diff expect actual && | |
949 | git-tag -n 4 -l stag-lines >actual && | |
950 | git diff expect actual && | |
951 | git-tag -n 99 -l | grep "^ *stag.line" >actual && | |
952 | git diff expect actual && | |
953 | git-tag -n 99 -l stag-lines >actual && | |
954 | git diff expect actual | |
955 | ' | |
956 | ||
ef5a6fb5 CR |
957 | # tags pointing to objects different from commits: |
958 | ||
959 | tree=$(git rev-parse HEAD^{tree}) | |
960 | blob=$(git rev-parse HEAD:foo) | |
961 | tag=$(git rev-parse signed-tag) | |
962 | ||
963 | get_tag_header tree-signed-tag $tree tree $time >expect | |
964 | echo "A message for a tree" >>expect | |
965 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
966 | test_expect_success \ | |
967 | 'creating a signed tag pointing to a tree should succeed' ' | |
968 | git-tag -s -m "A message for a tree" tree-signed-tag HEAD^{tree} && | |
969 | get_tag_msg tree-signed-tag >actual && | |
970 | git diff expect actual | |
971 | ' | |
972 | ||
973 | get_tag_header blob-signed-tag $blob blob $time >expect | |
974 | echo "A message for a blob" >>expect | |
975 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
976 | test_expect_success \ | |
977 | 'creating a signed tag pointing to a blob should succeed' ' | |
978 | git-tag -s -m "A message for a blob" blob-signed-tag HEAD:foo && | |
979 | get_tag_msg blob-signed-tag >actual && | |
980 | git diff expect actual | |
981 | ' | |
982 | ||
983 | get_tag_header tag-signed-tag $tag tag $time >expect | |
984 | echo "A message for another tag" >>expect | |
985 | echo '-----BEGIN PGP SIGNATURE-----' >>expect | |
986 | test_expect_success \ | |
987 | 'creating a signed tag pointing to another tag should succeed' ' | |
988 | git-tag -s -m "A message for another tag" tag-signed-tag signed-tag && | |
989 | get_tag_msg tag-signed-tag >actual && | |
990 | git diff expect actual | |
991 | ' | |
992 | ||
993 | # try to verify without gpg: | |
994 | ||
995 | rm -rf gpghome | |
996 | test_expect_failure \ | |
997 | 'verify signed tag fails when public key is not present' \ | |
998 | 'git-tag -v signed-tag' | |
999 | ||
1000 | test_done |