t/t0021-conversion.sh

   1 #!/bin/sh
   2
   3 test_description='blob conversion via gitattributes'
   4
   5 GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
   6 export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
   7
   8 . ./test-lib.sh
   9
  10 TEST_ROOT="$PWD"
  11 PATH=$TEST_ROOT:$PATH
  12
  13 write_script <<\EOF "$TEST_ROOT/rot13.sh"
  14 tr \
  15   'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' \
  16   'nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM'
  17 EOF
  18
  19 write_script rot13-filter.pl "$PERL_PATH" \
  20         <"$TEST_DIRECTORY"/t0021/rot13-filter.pl
  21
  22 generate_random_characters () {
  23         LEN=$1
  24         NAME=$2
  25         test-tool genrandom some-seed $LEN |
  26                 perl -pe "s/./chr((ord($&) % 26) + ord('a'))/sge" >"$TEST_ROOT/$NAME"
  27 }
  28
  29 filter_git () {
  30         rm -f *.log &&
  31         git "$@"
  32 }
  33
  34 # Compare two files and ensure that `clean` and `smudge` respectively are
  35 # called at least once if specified in the `expect` file. The actual
  36 # invocation count is not relevant because their number can vary.
  37 # c.f. https://lore.kernel.org/git/xmqqshv18i8i.fsf@gitster.mtv.corp.google.com/
  38 test_cmp_count () {
  39         expect=$1
  40         actual=$2
  41         for FILE in "$expect" "$actual"
  42         do
  43                 sort "$FILE" | uniq -c |
  44                 sed -e "s/^ *[0-9][0-9]*[       ]*IN: /x IN: /" >"$FILE.tmp"
  45         done &&
  46         test_cmp "$expect.tmp" "$actual.tmp" &&
  47         rm "$expect.tmp" "$actual.tmp"
  48 }
  49
  50 # Compare two files but exclude all `clean` invocations because Git can
  51 # call `clean` zero or more times.
  52 # c.f. https://lore.kernel.org/git/xmqqshv18i8i.fsf@gitster.mtv.corp.google.com/
  53 test_cmp_exclude_clean () {
  54         expect=$1
  55         actual=$2
  56         for FILE in "$expect" "$actual"
  57         do
  58                 grep -v "IN: clean" "$FILE" >"$FILE.tmp"
  59         done &&
  60         test_cmp "$expect.tmp" "$actual.tmp" &&
  61         rm "$expect.tmp" "$actual.tmp"
  62 }
  63
  64 # Check that the contents of two files are equal and that their rot13 version
  65 # is equal to the committed content.
  66 test_cmp_committed_rot13 () {
  67         test_cmp "$1" "$2" &&
  68         rot13.sh <"$1" >expected &&
  69         git cat-file blob :"$2" >actual &&
  70         test_cmp expected actual
  71 }
  72
  73 test_expect_success setup '
  74         git config filter.rot13.smudge ./rot13.sh &&
  75         git config filter.rot13.clean ./rot13.sh &&
  76
  77         {
  78             echo "*.t filter=rot13"
  79             echo "*.i ident"
  80         } >.gitattributes &&
  81
  82         {
  83             echo a b c d e f g h i j k l m
  84             echo n o p q r s t u v w x y z
  85             echo '\''$Id$'\''
  86         } >test &&
  87         cat test >test.t &&
  88         cat test >test.o &&
  89         cat test >test.i &&
  90         git add test test.t test.i &&
  91         rm -f test test.t test.i &&
  92         git checkout -- test test.t test.i &&
  93
  94         echo "content-test2" >test2.o &&
  95         echo "content-test3 - filename with special characters" >"test3 '\''sq'\'',\$x=.o"
  96 '
  97
  98 script='s/^\$Id: \([0-9a-f]*\) \$/\1/p'
  99
 100 test_expect_success check '
 101
 102         test_cmp test.o test &&
 103         test_cmp test.o test.t &&
 104
 105         # ident should be stripped in the repository
 106         git diff --raw --exit-code :test :test.i &&
 107         id=$(git rev-parse --verify :test) &&
 108         embedded=$(sed -ne "$script" test.i) &&
 109         test "z$id" = "z$embedded" &&
 110
 111         git cat-file blob :test.t >test.r &&
 112
 113         ./rot13.sh <test.o >test.t &&
 114         test_cmp test.r test.t
 115 '
 116
 117 # If an expanded ident ever gets into the repository, we want to make sure that
 118 # it is collapsed before being expanded again on checkout
 119 test_expect_success expanded_in_repo '
 120         {
 121                 echo "File with expanded keywords"
 122                 echo "\$Id\$"
 123                 echo "\$Id:\$"
 124                 echo "\$Id: 0000000000000000000000000000000000000000 \$"
 125                 echo "\$Id: NoSpaceAtEnd\$"
 126                 echo "\$Id:NoSpaceAtFront \$"
 127                 echo "\$Id:NoSpaceAtEitherEnd\$"
 128                 echo "\$Id: NoTerminatingSymbol"
 129                 echo "\$Id: Foreign Commit With Spaces \$"
 130         } >expanded-keywords.0 &&
 131
 132         {
 133                 cat expanded-keywords.0 &&
 134                 printf "\$Id: NoTerminatingSymbolAtEOF"
 135         } >expanded-keywords &&
 136         cat expanded-keywords >expanded-keywords-crlf &&
 137         git add expanded-keywords expanded-keywords-crlf &&
 138         git commit -m "File with keywords expanded" &&
 139         id=$(git rev-parse --verify :expanded-keywords) &&
 140
 141         {
 142                 echo "File with expanded keywords"
 143                 echo "\$Id: $id \$"
 144                 echo "\$Id: $id \$"
 145                 echo "\$Id: $id \$"
 146                 echo "\$Id: $id \$"
 147                 echo "\$Id: $id \$"
 148                 echo "\$Id: $id \$"
 149                 echo "\$Id: NoTerminatingSymbol"
 150                 echo "\$Id: Foreign Commit With Spaces \$"
 151         } >expected-output.0 &&
 152         {
 153                 cat expected-output.0 &&
 154                 printf "\$Id: NoTerminatingSymbolAtEOF"
 155         } >expected-output &&
 156         {
 157                 append_cr <expected-output.0 &&
 158                 printf "\$Id: NoTerminatingSymbolAtEOF"
 159         } >expected-output-crlf &&
 160         {
 161                 echo "expanded-keywords ident"
 162                 echo "expanded-keywords-crlf ident text eol=crlf"
 163         } >>.gitattributes &&
 164
 165         rm -f expanded-keywords expanded-keywords-crlf &&
 166
 167         git checkout -- expanded-keywords &&
 168         test_cmp expected-output expanded-keywords &&
 169
 170         git checkout -- expanded-keywords-crlf &&
 171         test_cmp expected-output-crlf expanded-keywords-crlf
 172 '
 173
 174 # The use of %f in a filter definition is expanded to the path to
 175 # the filename being smudged or cleaned.  It must be shell escaped.
 176 # First, set up some interesting file names and pet them in
 177 # .gitattributes.
 178 test_expect_success 'filter shell-escaped filenames' '
 179         cat >argc.sh <<-EOF &&
 180         #!$SHELL_PATH
 181         cat >/dev/null
 182         echo argc: \$# "\$@"
 183         EOF
 184         normal=name-no-magic &&
 185         special="name  with '\''sq'\'' and \$x" &&
 186         echo some test text >"$normal" &&
 187         echo some test text >"$special" &&
 188         git add "$normal" "$special" &&
 189         git commit -q -m "add files" &&
 190         echo "name* filter=argc" >.gitattributes &&
 191
 192         # delete the files and check them out again, using a smudge filter
 193         # that will count the args and echo the command-line back to us
 194         test_config filter.argc.smudge "sh ./argc.sh %f" &&
 195         rm "$normal" "$special" &&
 196         git checkout -- "$normal" "$special" &&
 197
 198         # make sure argc.sh counted the right number of args
 199         echo "argc: 1 $normal" >expect &&
 200         test_cmp expect "$normal" &&
 201         echo "argc: 1 $special" >expect &&
 202         test_cmp expect "$special" &&
 203
 204         # do the same thing, but with more args in the filter expression
 205         test_config filter.argc.smudge "sh ./argc.sh %f --my-extra-arg" &&
 206         rm "$normal" "$special" &&
 207         git checkout -- "$normal" "$special" &&
 208
 209         # make sure argc.sh counted the right number of args
 210         echo "argc: 2 $normal --my-extra-arg" >expect &&
 211         test_cmp expect "$normal" &&
 212         echo "argc: 2 $special --my-extra-arg" >expect &&
 213         test_cmp expect "$special" &&
 214         :
 215 '
 216
 217 test_expect_success 'required filter should filter data' '
 218         test_config filter.required.smudge ./rot13.sh &&
 219         test_config filter.required.clean ./rot13.sh &&
 220         test_config filter.required.required true &&
 221
 222         echo "*.r filter=required" >.gitattributes &&
 223
 224         cat test.o >test.r &&
 225         git add test.r &&
 226
 227         rm -f test.r &&
 228         git checkout -- test.r &&
 229         test_cmp test.o test.r &&
 230
 231         ./rot13.sh <test.o >expected &&
 232         git cat-file blob :test.r >actual &&
 233         test_cmp expected actual
 234 '
 235
 236 test_expect_success 'required filter smudge failure' '
 237         test_config filter.failsmudge.smudge false &&
 238         test_config filter.failsmudge.clean cat &&
 239         test_config filter.failsmudge.required true &&
 240
 241         echo "*.fs filter=failsmudge" >.gitattributes &&
 242
 243         echo test >test.fs &&
 244         git add test.fs &&
 245         rm -f test.fs &&
 246         test_must_fail git checkout -- test.fs
 247 '
 248
 249 test_expect_success 'required filter clean failure' '
 250         test_config filter.failclean.smudge cat &&
 251         test_config filter.failclean.clean false &&
 252         test_config filter.failclean.required true &&
 253
 254         echo "*.fc filter=failclean" >.gitattributes &&
 255
 256         echo test >test.fc &&
 257         test_must_fail git add test.fc
 258 '
 259
 260 test_expect_success 'filtering large input to small output should use little memory' '
 261         test_config filter.devnull.clean "cat >/dev/null" &&
 262         test_config filter.devnull.required true &&
 263         for i in $(test_seq 1 30); do printf "%1048576d" 1; done >30MB &&
 264         echo "30MB filter=devnull" >.gitattributes &&
 265         GIT_MMAP_LIMIT=1m GIT_ALLOC_LIMIT=1m git add 30MB
 266 '
 267
 268 test_expect_success 'filter that does not read is fine' '
 269         test-tool genrandom foo $((128 * 1024 + 1)) >big &&
 270         echo "big filter=epipe" >.gitattributes &&
 271         test_config filter.epipe.clean "echo xyzzy" &&
 272         git add big &&
 273         git cat-file blob :big >actual &&
 274         echo xyzzy >expect &&
 275         test_cmp expect actual
 276 '
 277
 278 test_expect_success EXPENSIVE 'filter large file' '
 279         test_config filter.largefile.smudge cat &&
 280         test_config filter.largefile.clean cat &&
 281         for i in $(test_seq 1 2048); do printf "%1048576d" 1; done >2GB &&
 282         echo "2GB filter=largefile" >.gitattributes &&
 283         git add 2GB 2>err &&
 284         test_must_be_empty err &&
 285         rm -f 2GB &&
 286         git checkout -- 2GB 2>err &&
 287         test_must_be_empty err
 288 '
 289
 290 test_expect_success "filter: clean empty file" '
 291         test_config filter.in-repo-header.clean  "echo cleaned && cat" &&
 292         test_config filter.in-repo-header.smudge "sed 1d" &&
 293
 294         echo "empty-in-worktree    filter=in-repo-header" >>.gitattributes &&
 295         >empty-in-worktree &&
 296
 297         echo cleaned >expected &&
 298         git add empty-in-worktree &&
 299         git show :empty-in-worktree >actual &&
 300         test_cmp expected actual
 301 '
 302
 303 test_expect_success "filter: smudge empty file" '
 304         test_config filter.empty-in-repo.clean "cat >/dev/null" &&
 305         test_config filter.empty-in-repo.smudge "echo smudged && cat" &&
 306
 307         echo "empty-in-repo filter=empty-in-repo" >>.gitattributes &&
 308         echo dead data walking >empty-in-repo &&
 309         git add empty-in-repo &&
 310
 311         echo smudged >expected &&
 312         git checkout-index --prefix=filtered- empty-in-repo &&
 313         test_cmp expected filtered-empty-in-repo
 314 '
 315
 316 test_expect_success 'disable filter with empty override' '
 317         test_config_global filter.disable.smudge false &&
 318         test_config_global filter.disable.clean false &&
 319         test_config filter.disable.smudge false &&
 320         test_config filter.disable.clean false &&
 321
 322         echo "*.disable filter=disable" >.gitattributes &&
 323
 324         echo test >test.disable &&
 325         git -c filter.disable.clean= add test.disable 2>err &&
 326         test_must_be_empty err &&
 327         rm -f test.disable &&
 328         git -c filter.disable.smudge= checkout -- test.disable 2>err &&
 329         test_must_be_empty err
 330 '
 331
 332 test_expect_success 'diff does not reuse worktree files that need cleaning' '
 333         test_config filter.counter.clean "echo . >>count; sed s/^/clean:/" &&
 334         echo "file filter=counter" >.gitattributes &&
 335         test_commit one file &&
 336         test_commit two file &&
 337
 338         >count &&
 339         git diff-tree -p HEAD &&
 340         test_line_count = 0 count
 341 '
 342
 343 test_expect_success PERL 'required process filter should filter data' '
 344         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
 345         test_config_global filter.protocol.required true &&
 346         rm -rf repo &&
 347         mkdir repo &&
 348         (
 349                 cd repo &&
 350                 git init &&
 351
 352                 echo "*.r filter=protocol" >.gitattributes &&
 353                 git add . &&
 354                 git commit -m "test commit 1" &&
 355                 git branch empty-branch &&
 356
 357                 cp "$TEST_ROOT/test.o" test.r &&
 358                 cp "$TEST_ROOT/test2.o" test2.r &&
 359                 mkdir testsubdir &&
 360                 cp "$TEST_ROOT/test3 '\''sq'\'',\$x=.o" "testsubdir/test3 '\''sq'\'',\$x=.r" &&
 361                 >test4-empty.r &&
 362
 363                 S=$(test_file_size test.r) &&
 364                 S2=$(test_file_size test2.r) &&
 365                 S3=$(test_file_size "testsubdir/test3 '\''sq'\'',\$x=.r") &&
 366                 M=$(git hash-object test.r) &&
 367                 M2=$(git hash-object test2.r) &&
 368                 M3=$(git hash-object "testsubdir/test3 '\''sq'\'',\$x=.r") &&
 369                 EMPTY=$(git hash-object /dev/null) &&
 370
 371                 filter_git add . &&
 372                 cat >expected.log <<-EOF &&
 373                         START
 374                         init handshake complete
 375                         IN: clean test.r $S [OK] -- OUT: $S . [OK]
 376                         IN: clean test2.r $S2 [OK] -- OUT: $S2 . [OK]
 377                         IN: clean test4-empty.r 0 [OK] -- OUT: 0  [OK]
 378                         IN: clean testsubdir/test3 '\''sq'\'',\$x=.r $S3 [OK] -- OUT: $S3 . [OK]
 379                         STOP
 380                 EOF
 381                 test_cmp_count expected.log debug.log &&
 382
 383                 git commit -m "test commit 2" &&
 384                 MAIN=$(git rev-parse --verify main) &&
 385                 META="ref=refs/heads/main treeish=$MAIN" &&
 386                 rm -f test2.r "testsubdir/test3 '\''sq'\'',\$x=.r" &&
 387
 388                 filter_git checkout --quiet --no-progress . &&
 389                 cat >expected.log <<-EOF &&
 390                         START
 391                         init handshake complete
 392                         IN: smudge test2.r blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 393                         IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r blob=$M3 $S3 [OK] -- OUT: $S3 . [OK]
 394                         STOP
 395                 EOF
 396                 test_cmp_exclude_clean expected.log debug.log &&
 397
 398                 # Make sure that the file appears dirty, so checkout below has to
 399                 # run the configured filter.
 400                 touch test.r &&
 401                 filter_git checkout --quiet --no-progress empty-branch &&
 402                 cat >expected.log <<-EOF &&
 403                         START
 404                         init handshake complete
 405                         IN: clean test.r $S [OK] -- OUT: $S . [OK]
 406                         STOP
 407                 EOF
 408                 test_cmp_exclude_clean expected.log debug.log &&
 409
 410                 filter_git checkout --quiet --no-progress main &&
 411                 cat >expected.log <<-EOF &&
 412                         START
 413                         init handshake complete
 414                         IN: smudge test.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 415                         IN: smudge test2.r $META blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 416                         IN: smudge test4-empty.r $META blob=$EMPTY 0 [OK] -- OUT: 0  [OK]
 417                         IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $META blob=$M3 $S3 [OK] -- OUT: $S3 . [OK]
 418                         STOP
 419                 EOF
 420                 test_cmp_exclude_clean expected.log debug.log &&
 421
 422                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.r &&
 423                 test_cmp_committed_rot13 "$TEST_ROOT/test2.o" test2.r &&
 424                 test_cmp_committed_rot13 "$TEST_ROOT/test3 '\''sq'\'',\$x=.o" "testsubdir/test3 '\''sq'\'',\$x=.r"
 425         )
 426 '
 427
 428 test_expect_success PERL 'required process filter should filter data for various subcommands' '
 429         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
 430         test_config_global filter.protocol.required true &&
 431         (
 432                 cd repo &&
 433
 434                 S=$(test_file_size test.r) &&
 435                 S2=$(test_file_size test2.r) &&
 436                 S3=$(test_file_size "testsubdir/test3 '\''sq'\'',\$x=.r") &&
 437                 M=$(git hash-object test.r) &&
 438                 M2=$(git hash-object test2.r) &&
 439                 M3=$(git hash-object "testsubdir/test3 '\''sq'\'',\$x=.r") &&
 440                 EMPTY=$(git hash-object /dev/null) &&
 441
 442                 MAIN=$(git rev-parse --verify main) &&
 443
 444                 cp "$TEST_ROOT/test.o" test5.r &&
 445                 git add test5.r &&
 446                 git commit -m "test commit 3" &&
 447                 git checkout empty-branch &&
 448                 filter_git rebase --onto empty-branch main^^ main &&
 449                 MAIN2=$(git rev-parse --verify main) &&
 450                 META="ref=refs/heads/main treeish=$MAIN2" &&
 451                 cat >expected.log <<-EOF &&
 452                         START
 453                         init handshake complete
 454                         IN: smudge test.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 455                         IN: smudge test2.r $META blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 456                         IN: smudge test4-empty.r $META blob=$EMPTY 0 [OK] -- OUT: 0  [OK]
 457                         IN: smudge test5.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 458                         IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $META blob=$M3 $S3 [OK] -- OUT: $S3 . [OK]
 459                         STOP
 460                 EOF
 461                 test_cmp_exclude_clean expected.log debug.log &&
 462
 463                 git reset --hard empty-branch &&
 464                 filter_git reset --hard $MAIN &&
 465                 META="treeish=$MAIN" &&
 466                 cat >expected.log <<-EOF &&
 467                         START
 468                         init handshake complete
 469                         IN: smudge test.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 470                         IN: smudge test2.r $META blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 471                         IN: smudge test4-empty.r $META blob=$EMPTY 0 [OK] -- OUT: 0  [OK]
 472                         IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $META blob=$M3 $S3 [OK] -- OUT: $S3 . [OK]
 473                         STOP
 474                 EOF
 475                 test_cmp_exclude_clean expected.log debug.log &&
 476
 477                 git branch old-main $MAIN &&
 478                 git reset --hard empty-branch &&
 479                 filter_git reset --hard old-main &&
 480                 META="ref=refs/heads/old-main treeish=$MAIN" &&
 481                 cat >expected.log <<-EOF &&
 482                         START
 483                         init handshake complete
 484                         IN: smudge test.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 485                         IN: smudge test2.r $META blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 486                         IN: smudge test4-empty.r $META blob=$EMPTY 0 [OK] -- OUT: 0  [OK]
 487                         IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $META blob=$M3 $S3 [OK] -- OUT: $S3 . [OK]
 488                         STOP
 489                 EOF
 490                 test_cmp_exclude_clean expected.log debug.log &&
 491
 492                 git checkout -b merge empty-branch &&
 493                 git branch -f main $MAIN2 &&
 494                 filter_git merge main &&
 495                 META="treeish=$MAIN2" &&
 496                 cat >expected.log <<-EOF &&
 497                         START
 498                         init handshake complete
 499                         IN: smudge test.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 500                         IN: smudge test2.r $META blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 501                         IN: smudge test4-empty.r $META blob=$EMPTY 0 [OK] -- OUT: 0  [OK]
 502                         IN: smudge test5.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 503                         IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $META blob=$M3 $S3 [OK] -- OUT: $S3 . [OK]
 504                         STOP
 505                 EOF
 506                 test_cmp_exclude_clean expected.log debug.log &&
 507
 508                 filter_git archive main >/dev/null &&
 509                 META="ref=refs/heads/main treeish=$MAIN2" &&
 510                 cat >expected.log <<-EOF &&
 511                         START
 512                         init handshake complete
 513                         IN: smudge test.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 514                         IN: smudge test2.r $META blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 515                         IN: smudge test4-empty.r $META blob=$EMPTY 0 [OK] -- OUT: 0  [OK]
 516                         IN: smudge test5.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 517                         IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $META blob=$M3 $S3 [OK] -- OUT: $S3 . [OK]
 518                         STOP
 519                 EOF
 520                 test_cmp_exclude_clean expected.log debug.log &&
 521
 522                 TREE="$(git rev-parse $MAIN2^{tree})" &&
 523                 filter_git archive $TREE >/dev/null &&
 524                 META="treeish=$TREE" &&
 525                 cat >expected.log <<-EOF &&
 526                         START
 527                         init handshake complete
 528                         IN: smudge test.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 529                         IN: smudge test2.r $META blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 530                         IN: smudge test4-empty.r $META blob=$EMPTY 0 [OK] -- OUT: 0  [OK]
 531                         IN: smudge test5.r $META blob=$M $S [OK] -- OUT: $S . [OK]
 532                         IN: smudge testsubdir/test3 '\''sq'\'',\$x=.r $META blob=$M3 $S3 [OK] -- OUT: $S3 . [OK]
 533                         STOP
 534                 EOF
 535                 test_cmp_exclude_clean expected.log debug.log
 536         )
 537 '
 538
 539 test_expect_success PERL 'required process filter takes precedence' '
 540         test_config_global filter.protocol.clean false &&
 541         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean" &&
 542         test_config_global filter.protocol.required true &&
 543         rm -rf repo &&
 544         mkdir repo &&
 545         (
 546                 cd repo &&
 547                 git init &&
 548
 549                 echo "*.r filter=protocol" >.gitattributes &&
 550                 cp "$TEST_ROOT/test.o" test.r &&
 551                 S=$(test_file_size test.r) &&
 552
 553                 # Check that the process filter is invoked here
 554                 filter_git add . &&
 555                 cat >expected.log <<-EOF &&
 556                         START
 557                         init handshake complete
 558                         IN: clean test.r $S [OK] -- OUT: $S . [OK]
 559                         STOP
 560                 EOF
 561                 test_cmp_count expected.log debug.log
 562         )
 563 '
 564
 565 test_expect_success PERL 'required process filter should be used only for "clean" operation only' '
 566         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean" &&
 567         rm -rf repo &&
 568         mkdir repo &&
 569         (
 570                 cd repo &&
 571                 git init &&
 572
 573                 echo "*.r filter=protocol" >.gitattributes &&
 574                 cp "$TEST_ROOT/test.o" test.r &&
 575                 S=$(test_file_size test.r) &&
 576
 577                 filter_git add . &&
 578                 cat >expected.log <<-EOF &&
 579                         START
 580                         init handshake complete
 581                         IN: clean test.r $S [OK] -- OUT: $S . [OK]
 582                         STOP
 583                 EOF
 584                 test_cmp_count expected.log debug.log &&
 585
 586                 rm test.r &&
 587
 588                 filter_git checkout --quiet --no-progress . &&
 589                 # If the filter would be used for "smudge", too, we would see
 590                 # "IN: smudge test.r 57 [OK] -- OUT: 57 . [OK]" here
 591                 cat >expected.log <<-EOF &&
 592                         START
 593                         init handshake complete
 594                         STOP
 595                 EOF
 596                 test_cmp_exclude_clean expected.log debug.log
 597         )
 598 '
 599
 600 test_expect_success PERL 'required process filter should process multiple packets' '
 601         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
 602         test_config_global filter.protocol.required true &&
 603
 604         rm -rf repo &&
 605         mkdir repo &&
 606         (
 607                 cd repo &&
 608                 git init &&
 609
 610                 # Generate data requiring 1, 2, 3 packets
 611                 S=65516 && # PKTLINE_DATA_MAXLEN -> Maximal size of a packet
 612                 generate_random_characters $(($S    )) 1pkt_1__.file &&
 613                 generate_random_characters $(($S  +1)) 2pkt_1+1.file &&
 614                 generate_random_characters $(($S*2-1)) 2pkt_2-1.file &&
 615                 generate_random_characters $(($S*2  )) 2pkt_2__.file &&
 616                 generate_random_characters $(($S*2+1)) 3pkt_2+1.file &&
 617
 618                 for FILE in "$TEST_ROOT"/*.file
 619                 do
 620                         cp "$FILE" . &&
 621                         rot13.sh <"$FILE" >"$FILE.rot13"
 622                 done &&
 623
 624                 echo "*.file filter=protocol" >.gitattributes &&
 625                 filter_git add *.file .gitattributes &&
 626                 cat >expected.log <<-EOF &&
 627                         START
 628                         init handshake complete
 629                         IN: clean 1pkt_1__.file $(($S    )) [OK] -- OUT: $(($S    )) . [OK]
 630                         IN: clean 2pkt_1+1.file $(($S  +1)) [OK] -- OUT: $(($S  +1)) .. [OK]
 631                         IN: clean 2pkt_2-1.file $(($S*2-1)) [OK] -- OUT: $(($S*2-1)) .. [OK]
 632                         IN: clean 2pkt_2__.file $(($S*2  )) [OK] -- OUT: $(($S*2  )) .. [OK]
 633                         IN: clean 3pkt_2+1.file $(($S*2+1)) [OK] -- OUT: $(($S*2+1)) ... [OK]
 634                         STOP
 635                 EOF
 636                 test_cmp_count expected.log debug.log &&
 637
 638                 M1="blob=$(git hash-object 1pkt_1__.file)" &&
 639                 M2="blob=$(git hash-object 2pkt_1+1.file)" &&
 640                 M3="blob=$(git hash-object 2pkt_2-1.file)" &&
 641                 M4="blob=$(git hash-object 2pkt_2__.file)" &&
 642                 M5="blob=$(git hash-object 3pkt_2+1.file)" &&
 643                 rm -f *.file debug.log &&
 644
 645                 filter_git checkout --quiet --no-progress -- *.file &&
 646                 cat >expected.log <<-EOF &&
 647                         START
 648                         init handshake complete
 649                         IN: smudge 1pkt_1__.file $M1 $(($S    )) [OK] -- OUT: $(($S    )) . [OK]
 650                         IN: smudge 2pkt_1+1.file $M2 $(($S  +1)) [OK] -- OUT: $(($S  +1)) .. [OK]
 651                         IN: smudge 2pkt_2-1.file $M3 $(($S*2-1)) [OK] -- OUT: $(($S*2-1)) .. [OK]
 652                         IN: smudge 2pkt_2__.file $M4 $(($S*2  )) [OK] -- OUT: $(($S*2  )) .. [OK]
 653                         IN: smudge 3pkt_2+1.file $M5 $(($S*2+1)) [OK] -- OUT: $(($S*2+1)) ... [OK]
 654                         STOP
 655                 EOF
 656                 test_cmp_exclude_clean expected.log debug.log &&
 657
 658                 for FILE in *.file
 659                 do
 660                         test_cmp_committed_rot13 "$TEST_ROOT/$FILE" $FILE
 661                 done
 662         )
 663 '
 664
 665 test_expect_success PERL 'required process filter with clean error should fail' '
 666         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
 667         test_config_global filter.protocol.required true &&
 668         rm -rf repo &&
 669         mkdir repo &&
 670         (
 671                 cd repo &&
 672                 git init &&
 673
 674                 echo "*.r filter=protocol" >.gitattributes &&
 675
 676                 cp "$TEST_ROOT/test.o" test.r &&
 677                 echo "this is going to fail" >clean-write-fail.r &&
 678                 echo "content-test3-subdir" >test3.r &&
 679
 680                 test_must_fail git add .
 681         )
 682 '
 683
 684 test_expect_success PERL 'process filter should restart after unexpected write failure' '
 685         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
 686         rm -rf repo &&
 687         mkdir repo &&
 688         (
 689                 cd repo &&
 690                 git init &&
 691
 692                 echo "*.r filter=protocol" >.gitattributes &&
 693
 694                 cp "$TEST_ROOT/test.o" test.r &&
 695                 cp "$TEST_ROOT/test2.o" test2.r &&
 696                 echo "this is going to fail" >smudge-write-fail.o &&
 697                 cp smudge-write-fail.o smudge-write-fail.r &&
 698
 699                 S=$(test_file_size test.r) &&
 700                 S2=$(test_file_size test2.r) &&
 701                 SF=$(test_file_size smudge-write-fail.r) &&
 702                 M=$(git hash-object test.r) &&
 703                 M2=$(git hash-object test2.r) &&
 704                 MF=$(git hash-object smudge-write-fail.r) &&
 705                 rm -f debug.log &&
 706
 707                 git add . &&
 708                 rm -f *.r &&
 709
 710                 rm -f debug.log &&
 711                 git checkout --quiet --no-progress . 2>git-stderr.log &&
 712
 713                 grep "smudge write error at" git-stderr.log &&
 714                 test_i18ngrep "error: external filter" git-stderr.log &&
 715
 716                 cat >expected.log <<-EOF &&
 717                         START
 718                         init handshake complete
 719                         IN: smudge smudge-write-fail.r blob=$MF $SF [OK] -- [WRITE FAIL]
 720                         START
 721                         init handshake complete
 722                         IN: smudge test.r blob=$M $S [OK] -- OUT: $S . [OK]
 723                         IN: smudge test2.r blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 724                         STOP
 725                 EOF
 726                 test_cmp_exclude_clean expected.log debug.log &&
 727
 728                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.r &&
 729                 test_cmp_committed_rot13 "$TEST_ROOT/test2.o" test2.r &&
 730
 731                 # Smudge failed
 732                 ! test_cmp smudge-write-fail.o smudge-write-fail.r &&
 733                 rot13.sh <smudge-write-fail.o >expected &&
 734                 git cat-file blob :smudge-write-fail.r >actual &&
 735                 test_cmp expected actual
 736         )
 737 '
 738
 739 test_expect_success PERL 'process filter should not be restarted if it signals an error' '
 740         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
 741         rm -rf repo &&
 742         mkdir repo &&
 743         (
 744                 cd repo &&
 745                 git init &&
 746
 747                 echo "*.r filter=protocol" >.gitattributes &&
 748
 749                 cp "$TEST_ROOT/test.o" test.r &&
 750                 cp "$TEST_ROOT/test2.o" test2.r &&
 751                 echo "this will cause an error" >error.o &&
 752                 cp error.o error.r &&
 753
 754                 S=$(test_file_size test.r) &&
 755                 S2=$(test_file_size test2.r) &&
 756                 SE=$(test_file_size error.r) &&
 757                 M=$(git hash-object test.r) &&
 758                 M2=$(git hash-object test2.r) &&
 759                 ME=$(git hash-object error.r) &&
 760                 rm -f debug.log &&
 761
 762                 git add . &&
 763                 rm -f *.r &&
 764
 765                 filter_git checkout --quiet --no-progress . &&
 766                 cat >expected.log <<-EOF &&
 767                         START
 768                         init handshake complete
 769                         IN: smudge error.r blob=$ME $SE [OK] -- [ERROR]
 770                         IN: smudge test.r blob=$M $S [OK] -- OUT: $S . [OK]
 771                         IN: smudge test2.r blob=$M2 $S2 [OK] -- OUT: $S2 . [OK]
 772                         STOP
 773                 EOF
 774                 test_cmp_exclude_clean expected.log debug.log &&
 775
 776                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.r &&
 777                 test_cmp_committed_rot13 "$TEST_ROOT/test2.o" test2.r &&
 778                 test_cmp error.o error.r
 779         )
 780 '
 781
 782 test_expect_success PERL 'process filter abort stops processing of all further files' '
 783         test_config_global filter.protocol.process "rot13-filter.pl debug.log clean smudge" &&
 784         rm -rf repo &&
 785         mkdir repo &&
 786         (
 787                 cd repo &&
 788                 git init &&
 789
 790                 echo "*.r filter=protocol" >.gitattributes &&
 791
 792                 cp "$TEST_ROOT/test.o" test.r &&
 793                 cp "$TEST_ROOT/test2.o" test2.r &&
 794                 echo "error this blob and all future blobs" >abort.o &&
 795                 cp abort.o abort.r &&
 796
 797                 M="blob=$(git hash-object abort.r)" &&
 798                 rm -f debug.log &&
 799                 SA=$(test_file_size abort.r) &&
 800
 801                 git add . &&
 802                 rm -f *.r &&
 803
 804
 805                 # Note: This test assumes that Git filters files in alphabetical
 806                 # order ("abort.r" before "test.r").
 807                 filter_git checkout --quiet --no-progress . &&
 808                 cat >expected.log <<-EOF &&
 809                         START
 810                         init handshake complete
 811                         IN: smudge abort.r $M $SA [OK] -- [ABORT]
 812                         STOP
 813                 EOF
 814                 test_cmp_exclude_clean expected.log debug.log &&
 815
 816                 test_cmp "$TEST_ROOT/test.o" test.r &&
 817                 test_cmp "$TEST_ROOT/test2.o" test2.r &&
 818                 test_cmp abort.o abort.r
 819         )
 820 '
 821
 822 test_expect_success PERL 'invalid process filter must fail (and not hang!)' '
 823         test_config_global filter.protocol.process cat &&
 824         test_config_global filter.protocol.required true &&
 825         rm -rf repo &&
 826         mkdir repo &&
 827         (
 828                 cd repo &&
 829                 git init &&
 830
 831                 echo "*.r filter=protocol" >.gitattributes &&
 832
 833                 cp "$TEST_ROOT/test.o" test.r &&
 834                 test_must_fail git add . 2>git-stderr.log &&
 835                 grep "expected git-filter-server" git-stderr.log
 836         )
 837 '
 838
 839 test_expect_success PERL 'delayed checkout in process filter' '
 840         test_config_global filter.a.process "rot13-filter.pl a.log clean smudge delay" &&
 841         test_config_global filter.a.required true &&
 842         test_config_global filter.b.process "rot13-filter.pl b.log clean smudge delay" &&
 843         test_config_global filter.b.required true &&
 844
 845         rm -rf repo &&
 846         mkdir repo &&
 847         (
 848                 cd repo &&
 849                 git init &&
 850                 echo "*.a filter=a" >.gitattributes &&
 851                 echo "*.b filter=b" >>.gitattributes &&
 852                 cp "$TEST_ROOT/test.o" test.a &&
 853                 cp "$TEST_ROOT/test.o" test-delay10.a &&
 854                 cp "$TEST_ROOT/test.o" test-delay11.a &&
 855                 cp "$TEST_ROOT/test.o" test-delay20.a &&
 856                 cp "$TEST_ROOT/test.o" test-delay10.b &&
 857                 git add . &&
 858                 git commit -m "test commit"
 859         ) &&
 860
 861         S=$(test_file_size "$TEST_ROOT/test.o") &&
 862         PM="ref=refs/heads/main treeish=$(git -C repo rev-parse --verify main) " &&
 863         M="${PM}blob=$(git -C repo rev-parse --verify main:test.a)" &&
 864         cat >a.exp <<-EOF &&
 865                 START
 866                 init handshake complete
 867                 IN: smudge test.a $M $S [OK] -- OUT: $S . [OK]
 868                 IN: smudge test-delay10.a $M $S [OK] -- [DELAYED]
 869                 IN: smudge test-delay11.a $M $S [OK] -- [DELAYED]
 870                 IN: smudge test-delay20.a $M $S [OK] -- [DELAYED]
 871                 IN: list_available_blobs test-delay10.a test-delay11.a [OK]
 872                 IN: smudge test-delay10.a $M 0 [OK] -- OUT: $S . [OK]
 873                 IN: smudge test-delay11.a $M 0 [OK] -- OUT: $S . [OK]
 874                 IN: list_available_blobs test-delay20.a [OK]
 875                 IN: smudge test-delay20.a $M 0 [OK] -- OUT: $S . [OK]
 876                 IN: list_available_blobs [OK]
 877                 STOP
 878         EOF
 879         cat >b.exp <<-EOF &&
 880                 START
 881                 init handshake complete
 882                 IN: smudge test-delay10.b $M $S [OK] -- [DELAYED]
 883                 IN: list_available_blobs test-delay10.b [OK]
 884                 IN: smudge test-delay10.b $M 0 [OK] -- OUT: $S . [OK]
 885                 IN: list_available_blobs [OK]
 886                 STOP
 887         EOF
 888
 889         rm -rf repo-cloned &&
 890         filter_git clone repo repo-cloned &&
 891         test_cmp_count a.exp repo-cloned/a.log &&
 892         test_cmp_count b.exp repo-cloned/b.log &&
 893
 894         (
 895                 cd repo-cloned &&
 896                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.a &&
 897                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay10.a &&
 898                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay11.a &&
 899                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay20.a &&
 900                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay10.b &&
 901
 902                 rm *.a *.b &&
 903                 filter_git checkout . &&
 904                 # We are not checking out a ref here, so filter out ref metadata.
 905                 sed -e "s!$PM!!" ../a.exp >a.exp.filtered &&
 906                 sed -e "s!$PM!!" ../b.exp >b.exp.filtered &&
 907                 test_cmp_count a.exp.filtered a.log &&
 908                 test_cmp_count b.exp.filtered b.log &&
 909
 910                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test.a &&
 911                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay10.a &&
 912                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay11.a &&
 913                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay20.a &&
 914                 test_cmp_committed_rot13 "$TEST_ROOT/test.o" test-delay10.b
 915         )
 916 '
 917
 918 test_expect_success PERL 'missing file in delayed checkout' '
 919         test_config_global filter.bug.process "rot13-filter.pl bug.log clean smudge delay" &&
 920         test_config_global filter.bug.required true &&
 921
 922         rm -rf repo &&
 923         mkdir repo &&
 924         (
 925                 cd repo &&
 926                 git init &&
 927                 echo "*.a filter=bug" >.gitattributes &&
 928                 cp "$TEST_ROOT/test.o" missing-delay.a &&
 929                 git add . &&
 930                 git commit -m "test commit"
 931         ) &&
 932
 933         rm -rf repo-cloned &&
 934         test_must_fail git clone repo repo-cloned 2>git-stderr.log &&
 935         grep "error: .missing-delay\.a. was not filtered properly" git-stderr.log
 936 '
 937
 938 test_expect_success PERL 'invalid file in delayed checkout' '
 939         test_config_global filter.bug.process "rot13-filter.pl bug.log clean smudge delay" &&
 940         test_config_global filter.bug.required true &&
 941
 942         rm -rf repo &&
 943         mkdir repo &&
 944         (
 945                 cd repo &&
 946                 git init &&
 947                 echo "*.a filter=bug" >.gitattributes &&
 948                 cp "$TEST_ROOT/test.o" invalid-delay.a &&
 949                 cp "$TEST_ROOT/test.o" unfiltered &&
 950                 git add . &&
 951                 git commit -m "test commit"
 952         ) &&
 953
 954         rm -rf repo-cloned &&
 955         test_must_fail git clone repo repo-cloned 2>git-stderr.log &&
 956         grep "error: external filter .* signaled that .unfiltered. is now available although it has not been delayed earlier" git-stderr.log
 957 '
 958
 959 test_done