Andrew's git / gitweb.git / t/t9810-git-p4-rcs.sh
?
t / t9810-git-p4-rcs.shon commit Merge branch 'jk/peel-ref' (315ea32)
   1#!/bin/sh
   2
   3test_description='git p4 rcs keywords'
   4
   5. ./lib-git-p4.sh
   6
   7test_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#
  16test_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#
  45write_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
  56test_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#
  64scrub_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}
  72scrub_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#
  85test_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#
 101test_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#
 118test_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#
 135test_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
 151test_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#
 166test_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
 191test_expect_success 'cleanup after failure 2' '
 192        (
 193                cd "$cli" &&
 194                p4 revert ...
 195        )
 196'
 197
 198create_kw_file () {
 199        cat <<\EOF >"$1"
 200/* A file
 201        Id: $Id$
 202        Revision: $Revision$
 203        File: $File$
 204 */
 205int main(int argc, const char **argv) {
 206        return 0;
 207}
 208EOF
 209}
 210
 211test_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
 223p4_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.
 234test_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
 267test_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.
 296test_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#
 320test_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
 340test_expect_success 'kill p4d' '
 341        kill_p4d
 342'
 343
 344test_done