Merge branch 'cb/maint-report-mount-point-correctly-in-setup'
[git] / t / t9800-git-p4-basic.sh
1 #!/bin/sh
2
3 test_description='git p4 tests'
4
5 . ./lib-git-p4.sh
6
7 test_expect_success 'start p4d' '
8         start_p4d
9 '
10
11 test_expect_success 'add p4 files' '
12         (
13                 cd "$cli" &&
14                 echo file1 >file1 &&
15                 p4 add file1 &&
16                 p4 submit -d "file1" &&
17                 echo file2 >file2 &&
18                 p4 add file2 &&
19                 p4 submit -d "file2"
20         )
21 '
22
23 test_expect_success 'basic git p4 clone' '
24         git p4 clone --dest="$git" //depot &&
25         test_when_finished cleanup_git &&
26         (
27                 cd "$git" &&
28                 git log --oneline >lines &&
29                 test_line_count = 1 lines
30         )
31 '
32
33 test_expect_success 'git p4 clone @all' '
34         git p4 clone --dest="$git" //depot@all &&
35         test_when_finished cleanup_git &&
36         (
37                 cd "$git" &&
38                 git log --oneline >lines &&
39                 test_line_count = 2 lines
40         )
41 '
42
43 test_expect_success 'git p4 sync uninitialized repo' '
44         test_create_repo "$git" &&
45         test_when_finished cleanup_git &&
46         (
47                 cd "$git" &&
48                 test_must_fail git p4 sync
49         )
50 '
51
52 #
53 # Create a git repo by hand.  Add a commit so that HEAD is valid.
54 # Test imports a new p4 repository into a new git branch.
55 #
56 test_expect_success 'git p4 sync new branch' '
57         test_create_repo "$git" &&
58         test_when_finished cleanup_git &&
59         (
60                 cd "$git" &&
61                 test_commit head &&
62                 git p4 sync --branch=refs/remotes/p4/depot //depot@all &&
63                 git log --oneline p4/depot >lines &&
64                 test_line_count = 2 lines
65         )
66 '
67
68 test_expect_success 'clone two dirs' '
69         (
70                 cd "$cli" &&
71                 mkdir sub1 sub2 &&
72                 echo sub1/f1 >sub1/f1 &&
73                 echo sub2/f2 >sub2/f2 &&
74                 p4 add sub1/f1 &&
75                 p4 submit -d "sub1/f1" &&
76                 p4 add sub2/f2 &&
77                 p4 submit -d "sub2/f2"
78         ) &&
79         git p4 clone --dest="$git" //depot/sub1 //depot/sub2 &&
80         test_when_finished cleanup_git &&
81         (
82                 cd "$git" &&
83                 git ls-files >lines &&
84                 test_line_count = 2 lines &&
85                 git log --oneline p4/master >lines &&
86                 test_line_count = 1 lines
87         )
88 '
89
90 test_expect_success 'clone two dirs, @all' '
91         (
92                 cd "$cli" &&
93                 echo sub1/f3 >sub1/f3 &&
94                 p4 add sub1/f3 &&
95                 p4 submit -d "sub1/f3"
96         ) &&
97         git p4 clone --dest="$git" //depot/sub1@all //depot/sub2@all &&
98         test_when_finished cleanup_git &&
99         (
100                 cd "$git" &&
101                 git ls-files >lines &&
102                 test_line_count = 3 lines &&
103                 git log --oneline p4/master >lines &&
104                 test_line_count = 3 lines
105         )
106 '
107
108 test_expect_success 'clone two dirs, @all, conflicting files' '
109         (
110                 cd "$cli" &&
111                 echo sub2/f3 >sub2/f3 &&
112                 p4 add sub2/f3 &&
113                 p4 submit -d "sub2/f3"
114         ) &&
115         git p4 clone --dest="$git" //depot/sub1@all //depot/sub2@all &&
116         test_when_finished cleanup_git &&
117         (
118                 cd "$git" &&
119                 git ls-files >lines &&
120                 test_line_count = 3 lines &&
121                 git log --oneline p4/master >lines &&
122                 test_line_count = 4 lines &&
123                 echo sub2/f3 >expected &&
124                 test_cmp expected f3
125         )
126 '
127
128 test_expect_success 'exit when p4 fails to produce marshaled output' '
129         badp4dir="$TRASH_DIRECTORY/badp4dir" &&
130         mkdir "$badp4dir" &&
131         test_when_finished "rm \"$badp4dir/p4\" && rmdir \"$badp4dir\"" &&
132         cat >"$badp4dir"/p4 <<-EOF &&
133         #!$SHELL_PATH
134         exit 1
135         EOF
136         chmod 755 "$badp4dir"/p4 &&
137         PATH="$badp4dir:$PATH" git p4 clone --dest="$git" //depot >errs 2>&1 ; retval=$? &&
138         test $retval -eq 1 &&
139         test_must_fail grep -q Traceback errs
140 '
141
142 test_expect_success 'add p4 files with wildcards in the names' '
143         (
144                 cd "$cli" &&
145                 echo file-wild-hash >file-wild#hash &&
146                 echo file-wild-star >file-wild\*star &&
147                 echo file-wild-at >file-wild@at &&
148                 echo file-wild-percent >file-wild%percent &&
149                 p4 add -f file-wild* &&
150                 p4 submit -d "file wildcards"
151         )
152 '
153
154 test_expect_success 'wildcard files git p4 clone' '
155         git p4 clone --dest="$git" //depot &&
156         test_when_finished cleanup_git &&
157         (
158                 cd "$git" &&
159                 test -f file-wild#hash &&
160                 test -f file-wild\*star &&
161                 test -f file-wild@at &&
162                 test -f file-wild%percent
163         )
164 '
165
166 test_expect_success 'clone bare' '
167         git p4 clone --dest="$git" --bare //depot &&
168         test_when_finished cleanup_git &&
169         (
170                 cd "$git" &&
171                 test ! -d .git &&
172                 bare=`git config --get core.bare` &&
173                 test "$bare" = true
174         )
175 '
176
177 p4_add_user() {
178         name=$1 fullname=$2 &&
179         p4 user -f -i <<-EOF &&
180         User: $name
181         Email: $name@localhost
182         FullName: $fullname
183         EOF
184         p4 passwd -P secret $name
185 }
186
187 p4_grant_admin() {
188         name=$1 &&
189         {
190                 p4 protect -o &&
191                 echo "    admin user $name * //depot/..."
192         } | p4 protect -i
193 }
194
195 p4_check_commit_author() {
196         file=$1 user=$2 &&
197         p4 changes -m 1 //depot/$file | grep -q $user
198 }
199
200 make_change_by_user() {
201         file=$1 name=$2 email=$3 &&
202         echo "username: a change by $name" >>"$file" &&
203         git add "$file" &&
204         git commit --author "$name <$email>" -m "a change by $name"
205 }
206
207 # Test username support, submitting as user 'alice'
208 test_expect_success 'preserve users' '
209         p4_add_user alice Alice &&
210         p4_add_user bob Bob &&
211         p4_grant_admin alice &&
212         git p4 clone --dest="$git" //depot &&
213         test_when_finished cleanup_git &&
214         (
215                 cd "$git" &&
216                 echo "username: a change by alice" >>file1 &&
217                 echo "username: a change by bob" >>file2 &&
218                 git commit --author "Alice <alice@localhost>" -m "a change by alice" file1 &&
219                 git commit --author "Bob <bob@localhost>" -m "a change by bob" file2 &&
220                 git config git-p4.skipSubmitEditCheck true &&
221                 P4EDITOR=touch P4USER=alice P4PASSWD=secret git p4 commit --preserve-user &&
222                 p4_check_commit_author file1 alice &&
223                 p4_check_commit_author file2 bob
224         )
225 '
226
227 # Test username support, submitting as bob, who lacks admin rights. Should
228 # not submit change to p4 (git diff should show deltas).
229 test_expect_success 'refuse to preserve users without perms' '
230         git p4 clone --dest="$git" //depot &&
231         test_when_finished cleanup_git &&
232         (
233                 cd "$git" &&
234                 git config git-p4.skipSubmitEditCheck true &&
235                 echo "username-noperms: a change by alice" >>file1 &&
236                 git commit --author "Alice <alice@localhost>" -m "perms: a change by alice" file1 &&
237                 P4EDITOR=touch P4USER=bob P4PASSWD=secret &&
238                 export P4EDITOR P4USER P4PASSWD &&
239                 test_must_fail git p4 commit --preserve-user &&
240                 ! git diff --exit-code HEAD..p4/master
241         )
242 '
243
244 # What happens with unknown author? Without allowMissingP4Users it should fail.
245 test_expect_success 'preserve user where author is unknown to p4' '
246         git p4 clone --dest="$git" //depot &&
247         test_when_finished cleanup_git &&
248         (
249                 cd "$git" &&
250                 git config git-p4.skipSubmitEditCheck true &&
251                 echo "username-bob: a change by bob" >>file1 &&
252                 git commit --author "Bob <bob@localhost>" -m "preserve: a change by bob" file1 &&
253                 echo "username-unknown: a change by charlie" >>file1 &&
254                 git commit --author "Charlie <charlie@localhost>" -m "preserve: a change by charlie" file1 &&
255                 P4EDITOR=touch P4USER=alice P4PASSWD=secret &&
256                 export P4EDITOR P4USER P4PASSWD &&
257                 test_must_fail git p4 commit --preserve-user &&
258                 ! git diff --exit-code HEAD..p4/master &&
259
260                 echo "$0: repeat with allowMissingP4Users enabled" &&
261                 git config git-p4.allowMissingP4Users true &&
262                 git config git-p4.preserveUser true &&
263                 git p4 commit &&
264                 git diff --exit-code HEAD..p4/master &&
265                 p4_check_commit_author file1 alice
266         )
267 '
268
269 # If we're *not* using --preserve-user, git p4 should warn if we're submitting
270 # changes that are not all ours.
271 # Test: user in p4 and user unknown to p4.
272 # Test: warning disabled and user is the same.
273 test_expect_success 'not preserving user with mixed authorship' '
274         git p4 clone --dest="$git" //depot &&
275         test_when_finished cleanup_git &&
276         (
277                 cd "$git" &&
278                 git config git-p4.skipSubmitEditCheck true &&
279                 p4_add_user derek Derek &&
280
281                 make_change_by_user usernamefile3 Derek derek@localhost &&
282                 P4EDITOR=cat P4USER=alice P4PASSWD=secret &&
283                 export P4EDITOR P4USER P4PASSWD &&
284                 git p4 commit |\
285                 grep "git author derek@localhost does not match" &&
286
287                 make_change_by_user usernamefile3 Charlie charlie@localhost &&
288                 git p4 commit |\
289                 grep "git author charlie@localhost does not match" &&
290
291                 make_change_by_user usernamefile3 alice alice@localhost &&
292                 git p4 commit |\
293                 test_must_fail grep "git author.*does not match" &&
294
295                 git config git-p4.skipUserNameCheck true &&
296                 make_change_by_user usernamefile3 Charlie charlie@localhost &&
297                 git p4 commit |\
298                 test_must_fail grep "git author.*does not match" &&
299
300                 p4_check_commit_author usernamefile3 alice
301         )
302 '
303
304 marshal_dump() {
305         what=$1
306         "$PYTHON_PATH" -c 'import marshal, sys; d = marshal.load(sys.stdin); print d["'$what'"]'
307 }
308
309 # Sleep a bit so that the top-most p4 change did not happen "now".  Then
310 # import the repo and make sure that the initial import has the same time
311 # as the top-most change.
312 test_expect_success 'initial import time from top change time' '
313         p4change=$(p4 -G changes -m 1 //depot/... | marshal_dump change) &&
314         p4time=$(p4 -G changes -m 1 //depot/... | marshal_dump time) &&
315         sleep 3 &&
316         git p4 clone --dest="$git" //depot &&
317         test_when_finished cleanup_git &&
318         (
319                 cd "$git" &&
320                 gittime=$(git show -s --raw --pretty=format:%at HEAD) &&
321                 echo $p4time $gittime &&
322                 test $p4time = $gittime
323         )
324 '
325
326 # Rename a file and confirm that rename is not detected in P4.
327 # Rename the new file again with detectRenames option enabled and confirm that
328 # this is detected in P4.
329 # Rename the new file again adding an extra line, configure a big threshold in
330 # detectRenames and confirm that rename is not detected in P4.
331 # Repeat, this time with a smaller threshold and confirm that the rename is
332 # detected in P4.
333 test_expect_success 'detect renames' '
334         git p4 clone --dest="$git" //depot@all &&
335         test_when_finished cleanup_git &&
336         (
337                 cd "$git" &&
338                 git config git-p4.skipSubmitEditCheck true &&
339
340                 git mv file1 file4 &&
341                 git commit -a -m "Rename file1 to file4" &&
342                 git diff-tree -r -M HEAD &&
343                 git p4 submit &&
344                 p4 filelog //depot/file4 &&
345                 p4 filelog //depot/file4 | test_must_fail grep -q "branch from" &&
346
347                 git mv file4 file5 &&
348                 git commit -a -m "Rename file4 to file5" &&
349                 git diff-tree -r -M HEAD &&
350                 git config git-p4.detectRenames true &&
351                 git p4 submit &&
352                 p4 filelog //depot/file5 &&
353                 p4 filelog //depot/file5 | grep -q "branch from //depot/file4" &&
354
355                 git mv file5 file6 &&
356                 echo update >>file6 &&
357                 git add file6 &&
358                 git commit -a -m "Rename file5 to file6 with changes" &&
359                 git diff-tree -r -M HEAD &&
360                 level=$(git diff-tree -r -M HEAD | sed 1d | cut -f1 | cut -d" " -f5 | sed "s/R0*//") &&
361                 test -n "$level" && test "$level" -gt 0 && test "$level" -lt 98 &&
362                 git config git-p4.detectRenames $(($level + 2)) &&
363                 git p4 submit &&
364                 p4 filelog //depot/file6 &&
365                 p4 filelog //depot/file6 | test_must_fail grep -q "branch from" &&
366
367                 git mv file6 file7 &&
368                 echo update >>file7 &&
369                 git add file7 &&
370                 git commit -a -m "Rename file6 to file7 with changes" &&
371                 git diff-tree -r -M HEAD &&
372                 level=$(git diff-tree -r -M HEAD | sed 1d | cut -f1 | cut -d" " -f5 | sed "s/R0*//") &&
373                 test -n "$level" && test "$level" -gt 2 && test "$level" -lt 100 &&
374                 git config git-p4.detectRenames $(($level - 2)) &&
375                 git p4 submit &&
376                 p4 filelog //depot/file7 &&
377                 p4 filelog //depot/file7 | grep -q "branch from //depot/file6"
378         )
379 '
380
381 # Copy a file and confirm that copy is not detected in P4.
382 # Copy a file with detectCopies option enabled and confirm that copy is not
383 # detected in P4.
384 # Modify and copy a file with detectCopies option enabled and confirm that copy
385 # is detected in P4.
386 # Copy a file with detectCopies and detectCopiesHarder options enabled and
387 # confirm that copy is detected in P4.
388 # Modify and copy a file, configure a bigger threshold in detectCopies and
389 # confirm that copy is not detected in P4.
390 # Modify and copy a file, configure a smaller threshold in detectCopies and
391 # confirm that copy is detected in P4.
392 test_expect_success 'detect copies' '
393         git p4 clone --dest="$git" //depot@all &&
394         test_when_finished cleanup_git &&
395         (
396                 cd "$git" &&
397                 git config git-p4.skipSubmitEditCheck true &&
398
399                 cp file2 file8 &&
400                 git add file8 &&
401                 git commit -a -m "Copy file2 to file8" &&
402                 git diff-tree -r -C HEAD &&
403                 git p4 submit &&
404                 p4 filelog //depot/file8 &&
405                 p4 filelog //depot/file8 | test_must_fail grep -q "branch from" &&
406
407                 cp file2 file9 &&
408                 git add file9 &&
409                 git commit -a -m "Copy file2 to file9" &&
410                 git diff-tree -r -C HEAD &&
411                 git config git-p4.detectCopies true &&
412                 git p4 submit &&
413                 p4 filelog //depot/file9 &&
414                 p4 filelog //depot/file9 | test_must_fail grep -q "branch from" &&
415
416                 echo "file2" >>file2 &&
417                 cp file2 file10 &&
418                 git add file2 file10 &&
419                 git commit -a -m "Modify and copy file2 to file10" &&
420                 git diff-tree -r -C HEAD &&
421                 git p4 submit &&
422                 p4 filelog //depot/file10 &&
423                 p4 filelog //depot/file10 | grep -q "branch from //depot/file" &&
424
425                 cp file2 file11 &&
426                 git add file11 &&
427                 git commit -a -m "Copy file2 to file11" &&
428                 git diff-tree -r -C --find-copies-harder HEAD &&
429                 src=$(git diff-tree -r -C --find-copies-harder HEAD | sed 1d | cut -f2) &&
430                 test "$src" = file10 &&
431                 git config git-p4.detectCopiesHarder true &&
432                 git p4 submit &&
433                 p4 filelog //depot/file11 &&
434                 p4 filelog //depot/file11 | grep -q "branch from //depot/file" &&
435
436                 cp file2 file12 &&
437                 echo "some text" >>file12 &&
438                 git add file12 &&
439                 git commit -a -m "Copy file2 to file12 with changes" &&
440                 git diff-tree -r -C --find-copies-harder HEAD &&
441                 level=$(git diff-tree -r -C --find-copies-harder HEAD | sed 1d | cut -f1 | cut -d" " -f5 | sed "s/C0*//") &&
442                 test -n "$level" && test "$level" -gt 0 && test "$level" -lt 98 &&
443                 src=$(git diff-tree -r -C --find-copies-harder HEAD | sed 1d | cut -f2) &&
444                 test "$src" = file10 &&
445                 git config git-p4.detectCopies $(($level + 2)) &&
446                 git p4 submit &&
447                 p4 filelog //depot/file12 &&
448                 p4 filelog //depot/file12 | test_must_fail grep -q "branch from" &&
449
450                 cp file2 file13 &&
451                 echo "different text" >>file13 &&
452                 git add file13 &&
453                 git commit -a -m "Copy file2 to file13 with changes" &&
454                 git diff-tree -r -C --find-copies-harder HEAD &&
455                 level=$(git diff-tree -r -C --find-copies-harder HEAD | sed 1d | cut -f1 | cut -d" " -f5 | sed "s/C0*//") &&
456                 test -n "$level" && test "$level" -gt 2 && test "$level" -lt 100 &&
457                 src=$(git diff-tree -r -C --find-copies-harder HEAD | sed 1d | cut -f2) &&
458                 test "$src" = file10 &&
459                 git config git-p4.detectCopies $(($level - 2)) &&
460                 git p4 submit &&
461                 p4 filelog //depot/file13 &&
462                 p4 filelog //depot/file13 | grep -q "branch from //depot/file"
463         )
464 '
465
466 test_expect_success 'kill p4d' '
467         kill_p4d
468 '
469
470 test_done