Merge branch 'jk/maint-commit-document-editmsg'
[git] / t / t9810-git-p4-rcs.sh
1 #!/bin/sh
2
3 test_description='git p4 rcs keywords'
4
5 . ./lib-git-p4.sh
6
7 test_expect_success 'start p4d' '
8         start_p4d
9 '
10
11 #
12 # Make one file with keyword lines at the top, and
13 # enough plain text to be able to test modifications
14 # far away from the keywords.
15 #
16 test_expect_success 'init depot' '
17         (
18                 cd "$cli" &&
19                 cat <<-\EOF >filek &&
20                 $Id$
21                 /* $Revision$ */
22                 # $Change$
23                 line4
24                 line5
25                 line6
26                 line7
27                 line8
28                 EOF
29                 cp filek fileko &&
30                 sed -i "s/Revision/Revision: do not scrub me/" fileko
31                 cp fileko file_text &&
32                 sed -i "s/Id/Id: do not scrub me/" file_text
33                 p4 add -t text+k filek &&
34                 p4 submit -d "filek" &&
35                 p4 add -t text+ko fileko &&
36                 p4 submit -d "fileko" &&
37                 p4 add -t text file_text &&
38                 p4 submit -d "file_text"
39         )
40 '
41
42 #
43 # Generate these in a function to make it easy to use single quote marks.
44 #
45 write_scrub_scripts () {
46         cat >"$TRASH_DIRECTORY/scrub_k.py" <<-\EOF &&
47         import re, sys
48         sys.stdout.write(re.sub(r'(?i)\$(Id|Header|Author|Date|DateTime|Change|File|Revision):[^$]*\$', r'$\1$', sys.stdin.read()))
49         EOF
50         cat >"$TRASH_DIRECTORY/scrub_ko.py" <<-\EOF
51         import re, sys
52         sys.stdout.write(re.sub(r'(?i)\$(Id|Header):[^$]*\$', r'$\1$', sys.stdin.read()))
53         EOF
54 }
55
56 test_expect_success 'scrub scripts' '
57         write_scrub_scripts
58 '
59
60 #
61 # Compare $cli/file to its scrubbed version, should be different.
62 # Compare scrubbed $cli/file to $git/file, should be same.
63 #
64 scrub_k_check () {
65         file="$1" &&
66         scrub="$TRASH_DIRECTORY/$file" &&
67         "$PYTHON_PATH" "$TRASH_DIRECTORY/scrub_k.py" <"$git/$file" >"$scrub" &&
68         ! test_cmp "$cli/$file" "$scrub" &&
69         test_cmp "$git/$file" "$scrub" &&
70         rm "$scrub"
71 }
72 scrub_ko_check () {
73         file="$1" &&
74         scrub="$TRASH_DIRECTORY/$file" &&
75         "$PYTHON_PATH" "$TRASH_DIRECTORY/scrub_ko.py" <"$git/$file" >"$scrub" &&
76         ! test_cmp "$cli/$file" "$scrub" &&
77         test_cmp "$git/$file" "$scrub" &&
78         rm "$scrub"
79 }
80
81 #
82 # Modify far away from keywords.  If no RCS lines show up
83 # in the diff, there is no conflict.
84 #
85 test_expect_success 'edit far away from RCS lines' '
86         test_when_finished cleanup_git &&
87         git p4 clone --dest="$git" //depot &&
88         (
89                 cd "$git" &&
90                 git config git-p4.skipSubmitEdit true &&
91                 sed -i "s/^line7/line7 edit/" filek &&
92                 git commit -m "filek line7 edit" filek &&
93                 git p4 submit &&
94                 scrub_k_check filek
95         )
96 '
97
98 #
99 # Modify near the keywords.  This will require RCS scrubbing.
100 #
101 test_expect_success 'edit near RCS lines' '
102         test_when_finished cleanup_git &&
103         git p4 clone --dest="$git" //depot &&
104         (
105                 cd "$git" &&
106                 git config git-p4.skipSubmitEdit true &&
107                 git config git-p4.attemptRCSCleanup true &&
108                 sed -i "s/^line4/line4 edit/" filek &&
109                 git commit -m "filek line4 edit" filek &&
110                 git p4 submit &&
111                 scrub_k_check filek
112         )
113 '
114
115 #
116 # Modify the keywords themselves.  This also will require RCS scrubbing.
117 #
118 test_expect_success 'edit keyword lines' '
119         test_when_finished cleanup_git &&
120         git p4 clone --dest="$git" //depot &&
121         (
122                 cd "$git" &&
123                 git config git-p4.skipSubmitEdit true &&
124                 git config git-p4.attemptRCSCleanup true &&
125                 sed -i "/Revision/d" filek &&
126                 git commit -m "filek remove Revision line" filek &&
127                 git p4 submit &&
128                 scrub_k_check filek
129         )
130 '
131
132 #
133 # Scrubbing text+ko files should not alter all keywords, just Id, Header.
134 #
135 test_expect_success 'scrub ko files differently' '
136         test_when_finished cleanup_git &&
137         git p4 clone --dest="$git" //depot &&
138         (
139                 cd "$git" &&
140                 git config git-p4.skipSubmitEdit true &&
141                 git config git-p4.attemptRCSCleanup true &&
142                 sed -i "s/^line4/line4 edit/" fileko &&
143                 git commit -m "fileko line4 edit" fileko &&
144                 git p4 submit &&
145                 scrub_ko_check fileko &&
146                 ! scrub_k_check fileko
147         )
148 '
149
150 # hack; git p4 submit should do it on its own
151 test_expect_success 'cleanup after failure' '
152         (
153                 cd "$cli" &&
154                 p4 revert ...
155         )
156 '
157
158 #
159 # Do not scrub anything but +k or +ko files.  Sneak a change into
160 # the cli file so that submit will get a conflict.  Make sure that
161 # scrubbing doesn't make a mess of things.
162 #
163 # Assumes that git-p4 exits leaving the p4 file open, with the
164 # conflict-generating patch unapplied.
165 #
166 # This might happen only if the git repo is behind the p4 repo at
167 # submit time, and there is a conflict.
168 #
169 test_expect_success 'do not scrub plain text' '
170         test_when_finished cleanup_git &&
171         git p4 clone --dest="$git" //depot &&
172         (
173                 cd "$git" &&
174                 git config git-p4.skipSubmitEdit true &&
175                 git config git-p4.attemptRCSCleanup true &&
176                 sed -i "s/^line4/line4 edit/" file_text &&
177                 git commit -m "file_text line4 edit" file_text &&
178                 (
179                         cd "$cli" &&
180                         p4 open file_text &&
181                         sed -i "s/^line5/line5 p4 edit/" file_text &&
182                         p4 submit -d "file5 p4 edit"
183                 ) &&
184                 ! git p4 submit &&
185                 (
186                         # exepct something like:
187                         #    file_text - file(s) not opened on this client
188                         # but not copious diff output
189                         cd "$cli" &&
190                         p4 diff file_text >wc &&
191                         test_line_count = 1 wc
192                 )
193         )
194 '
195
196 # hack; git p4 submit should do it on its own
197 test_expect_success 'cleanup after failure 2' '
198         (
199                 cd "$cli" &&
200                 p4 revert ...
201         )
202 '
203
204 create_kw_file () {
205         cat <<\EOF >"$1"
206 /* A file
207         Id: $Id$
208         Revision: $Revision$
209         File: $File$
210  */
211 int main(int argc, const char **argv) {
212         return 0;
213 }
214 EOF
215 }
216
217 test_expect_success 'add kwfile' '
218         (
219                 cd "$cli" &&
220                 echo file1 >file1 &&
221                 p4 add file1 &&
222                 p4 submit -d "file 1" &&
223                 create_kw_file kwfile1.c &&
224                 p4 add kwfile1.c &&
225                 p4 submit -d "Add rcw kw file" kwfile1.c
226         )
227 '
228
229 p4_append_to_file () {
230         f="$1" &&
231         p4 edit -t ktext "$f" &&
232         echo "/* $(date) */" >>"$f" &&
233         p4 submit -d "appending a line in p4"
234 }
235
236 # Create some files with RCS keywords. If they get modified
237 # elsewhere then the version number gets bumped which then
238 # results in a merge conflict if we touch the RCS kw lines,
239 # even though the change itself would otherwise apply cleanly.
240 test_expect_success 'cope with rcs keyword expansion damage' '
241         test_when_finished cleanup_git &&
242         git p4 clone --dest="$git" //depot &&
243         (
244                 cd "$git" &&
245                 git config git-p4.skipSubmitEdit true &&
246                 git config git-p4.attemptRCSCleanup true &&
247                 (cd "$cli" && p4_append_to_file kwfile1.c) &&
248                 old_lines=$(wc -l <kwfile1.c) &&
249                 "$PERL_PATH" -n -i -e "print unless m/Revision:/" kwfile1.c &&
250                 new_lines=$(wc -l <kwfile1.c) &&
251                 test $new_lines = $(($old_lines - 1)) &&
252
253                 git add kwfile1.c &&
254                 git commit -m "Zap an RCS kw line" &&
255                 git p4 submit &&
256                 git p4 rebase &&
257                 git diff p4/master &&
258                 git p4 commit &&
259                 echo "try modifying in both" &&
260                 cd "$cli" &&
261                 p4 edit kwfile1.c &&
262                 echo "line from p4" >>kwfile1.c &&
263                 p4 submit -d "add a line in p4" kwfile1.c &&
264                 cd "$git" &&
265                 echo "line from git at the top" | cat - kwfile1.c >kwfile1.c.new &&
266                 mv kwfile1.c.new kwfile1.c &&
267                 git commit -m "Add line in git at the top" kwfile1.c &&
268                 git p4 rebase &&
269                 git p4 submit
270         )
271 '
272
273 test_expect_success 'cope with rcs keyword file deletion' '
274         test_when_finished cleanup_git &&
275         (
276                 cd "$cli" &&
277                 echo "\$Revision\$" >kwdelfile.c &&
278                 p4 add -t ktext kwdelfile.c &&
279                 p4 submit -d "Add file to be deleted" &&
280                 cat kwdelfile.c &&
281                 grep 1 kwdelfile.c
282         ) &&
283         git p4 clone --dest="$git" //depot &&
284         (
285                 cd "$git" &&
286                 grep Revision kwdelfile.c &&
287                 git rm -f kwdelfile.c &&
288                 git commit -m "Delete a file containing RCS keywords" &&
289                 git config git-p4.skipSubmitEdit true &&
290                 git config git-p4.attemptRCSCleanup true &&
291                 git p4 submit
292         ) &&
293         (
294                 cd "$cli" &&
295                 p4 sync &&
296                 ! test -f kwdelfile.c
297         )
298 '
299
300 # If you add keywords in git of the form $Header$ then everything should
301 # work fine without any special handling.
302 test_expect_success 'Add keywords in git which match the default p4 values' '
303         test_when_finished cleanup_git &&
304         git p4 clone --dest="$git" //depot &&
305         (
306                 cd "$git" &&
307                 echo "NewKW: \$Revision\$" >>kwfile1.c &&
308                 git add kwfile1.c &&
309                 git commit -m "Adding RCS keywords in git" &&
310                 git config git-p4.skipSubmitEdit true &&
311                 git config git-p4.attemptRCSCleanup true &&
312                 git p4 submit
313         ) &&
314         (
315                 cd "$cli" &&
316                 p4 sync &&
317                 test -f kwfile1.c &&
318                 grep "NewKW.*Revision.*[0-9]" kwfile1.c
319
320         )
321 '
322
323 # If you add keywords in git of the form $Header:#1$ then things will fail
324 # unless git-p4 takes steps to scrub the *git* commit.
325 #
326 test_expect_failure 'Add keywords in git which do not match the default p4 values' '
327         test_when_finished cleanup_git &&
328         git p4 clone --dest="$git" //depot &&
329         (
330                 cd "$git" &&
331                 echo "NewKW2: \$Revision:1\$" >>kwfile1.c &&
332                 git add kwfile1.c &&
333                 git commit -m "Adding RCS keywords in git" &&
334                 git config git-p4.skipSubmitEdit true &&
335                 git config git-p4.attemptRCSCleanup true &&
336                 git p4 submit
337         ) &&
338         (
339                 cd "$cli" &&
340                 p4 sync &&
341                 grep "NewKW2.*Revision.*[0-9]" kwfile1.c
342
343         )
344 '
345
346 # Check that the existing merge conflict handling still works.
347 # Modify kwfile1.c in git, and delete in p4. We should be able
348 # to skip the git commit.
349 #
350 test_expect_success 'merge conflict handling still works' '
351         test_when_finished cleanup_git &&
352         (
353                 cd "$cli" &&
354                 echo "Hello:\$Id\$" >merge2.c &&
355                 echo "World" >>merge2.c &&
356                 p4 add -t ktext merge2.c &&
357                 p4 submit -d "add merge test file"
358         ) &&
359         git p4 clone --dest="$git" //depot &&
360         (
361                 cd "$git" &&
362                 sed -e "/Hello/d" merge2.c >merge2.c.tmp &&
363                 mv merge2.c.tmp merge2.c &&
364                 git add merge2.c &&
365                 git commit -m "Modifying merge2.c"
366         ) &&
367         (
368                 cd "$cli" &&
369                 p4 delete merge2.c &&
370                 p4 submit -d "remove merge test file"
371         ) &&
372         (
373                 cd "$git" &&
374                 test -f merge2.c &&
375                 git config git-p4.skipSubmitEdit true &&
376                 git config git-p4.attemptRCSCleanup true &&
377                 !(echo "s" | git p4 submit) &&
378                 git rebase --skip &&
379                 ! test -f merge2.c
380         )
381 '
382
383
384 test_expect_success 'kill p4d' '
385         kill_p4d
386 '
387
388 test_done