Merge branch 'jk/receive-pack-unpack-error-to-pusher'
[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 # This might happen only if the git repo is behind the p4 repo at
164 # submit time, and there is a conflict.
165 #
166 test_expect_success 'do not scrub plain text' '
167         test_when_finished cleanup_git &&
168         git p4 clone --dest="$git" //depot &&
169         (
170                 cd "$git" &&
171                 git config git-p4.skipSubmitEdit true &&
172                 git config git-p4.attemptRCSCleanup true &&
173                 sed -i "s/^line4/line4 edit/" file_text &&
174                 git commit -m "file_text line4 edit" file_text &&
175                 (
176                         cd "$cli" &&
177                         p4 open file_text &&
178                         sed -i "s/^line5/line5 p4 edit/" file_text &&
179                         p4 submit -d "file5 p4 edit"
180                 ) &&
181                 echo s | test_expect_code 1 git p4 submit &&
182                 (
183                         # make sure the file is not left open
184                         cd "$cli" &&
185                         ! p4 fstat -T action file_text
186                 )
187         )
188 '
189
190 # hack; git p4 submit should do it on its own
191 test_expect_success 'cleanup after failure 2' '
192         (
193                 cd "$cli" &&
194                 p4 revert ...
195         )
196 '
197
198 create_kw_file () {
199         cat <<\EOF >"$1"
200 /* A file
201         Id: $Id$
202         Revision: $Revision$
203         File: $File$
204  */
205 int main(int argc, const char **argv) {
206         return 0;
207 }
208 EOF
209 }
210
211 test_expect_success 'add kwfile' '
212         (
213                 cd "$cli" &&
214                 echo file1 >file1 &&
215                 p4 add file1 &&
216                 p4 submit -d "file 1" &&
217                 create_kw_file kwfile1.c &&
218                 p4 add kwfile1.c &&
219                 p4 submit -d "Add rcw kw file" kwfile1.c
220         )
221 '
222
223 p4_append_to_file () {
224         f="$1" &&
225         p4 edit -t ktext "$f" &&
226         echo "/* $(date) */" >>"$f" &&
227         p4 submit -d "appending a line in p4"
228 }
229
230 # Create some files with RCS keywords. If they get modified
231 # elsewhere then the version number gets bumped which then
232 # results in a merge conflict if we touch the RCS kw lines,
233 # even though the change itself would otherwise apply cleanly.
234 test_expect_success 'cope with rcs keyword expansion damage' '
235         test_when_finished cleanup_git &&
236         git p4 clone --dest="$git" //depot &&
237         (
238                 cd "$git" &&
239                 git config git-p4.skipSubmitEdit true &&
240                 git config git-p4.attemptRCSCleanup true &&
241                 (cd "$cli" && p4_append_to_file kwfile1.c) &&
242                 old_lines=$(wc -l <kwfile1.c) &&
243                 "$PERL_PATH" -n -i -e "print unless m/Revision:/" kwfile1.c &&
244                 new_lines=$(wc -l <kwfile1.c) &&
245                 test $new_lines = $(($old_lines - 1)) &&
246
247                 git add kwfile1.c &&
248                 git commit -m "Zap an RCS kw line" &&
249                 git p4 submit &&
250                 git p4 rebase &&
251                 git diff p4/master &&
252                 git p4 commit &&
253                 echo "try modifying in both" &&
254                 cd "$cli" &&
255                 p4 edit kwfile1.c &&
256                 echo "line from p4" >>kwfile1.c &&
257                 p4 submit -d "add a line in p4" kwfile1.c &&
258                 cd "$git" &&
259                 echo "line from git at the top" | cat - kwfile1.c >kwfile1.c.new &&
260                 mv kwfile1.c.new kwfile1.c &&
261                 git commit -m "Add line in git at the top" kwfile1.c &&
262                 git p4 rebase &&
263                 git p4 submit
264         )
265 '
266
267 test_expect_success 'cope with rcs keyword file deletion' '
268         test_when_finished cleanup_git &&
269         (
270                 cd "$cli" &&
271                 echo "\$Revision\$" >kwdelfile.c &&
272                 p4 add -t ktext kwdelfile.c &&
273                 p4 submit -d "Add file to be deleted" &&
274                 cat kwdelfile.c &&
275                 grep 1 kwdelfile.c
276         ) &&
277         git p4 clone --dest="$git" //depot &&
278         (
279                 cd "$git" &&
280                 grep Revision kwdelfile.c &&
281                 git rm -f kwdelfile.c &&
282                 git commit -m "Delete a file containing RCS keywords" &&
283                 git config git-p4.skipSubmitEdit true &&
284                 git config git-p4.attemptRCSCleanup true &&
285                 git p4 submit
286         ) &&
287         (
288                 cd "$cli" &&
289                 p4 sync &&
290                 ! test -f kwdelfile.c
291         )
292 '
293
294 # If you add keywords in git of the form $Header$ then everything should
295 # work fine without any special handling.
296 test_expect_success 'Add keywords in git which match the default p4 values' '
297         test_when_finished cleanup_git &&
298         git p4 clone --dest="$git" //depot &&
299         (
300                 cd "$git" &&
301                 echo "NewKW: \$Revision\$" >>kwfile1.c &&
302                 git add kwfile1.c &&
303                 git commit -m "Adding RCS keywords in git" &&
304                 git config git-p4.skipSubmitEdit true &&
305                 git config git-p4.attemptRCSCleanup true &&
306                 git p4 submit
307         ) &&
308         (
309                 cd "$cli" &&
310                 p4 sync &&
311                 test -f kwfile1.c &&
312                 grep "NewKW.*Revision.*[0-9]" kwfile1.c
313
314         )
315 '
316
317 # If you add keywords in git of the form $Header:#1$ then things will fail
318 # unless git-p4 takes steps to scrub the *git* commit.
319 #
320 test_expect_failure 'Add keywords in git which do not match the default p4 values' '
321         test_when_finished cleanup_git &&
322         git p4 clone --dest="$git" //depot &&
323         (
324                 cd "$git" &&
325                 echo "NewKW2: \$Revision:1\$" >>kwfile1.c &&
326                 git add kwfile1.c &&
327                 git commit -m "Adding RCS keywords in git" &&
328                 git config git-p4.skipSubmitEdit true &&
329                 git config git-p4.attemptRCSCleanup true &&
330                 git p4 submit
331         ) &&
332         (
333                 cd "$cli" &&
334                 p4 sync &&
335                 grep "NewKW2.*Revision.*[0-9]" kwfile1.c
336
337         )
338 '
339
340 test_expect_success 'kill p4d' '
341         kill_p4d
342 '
343
344 test_done