git.oblomov.eu Git - git/blob - 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