git.oblomov.eu Git - git/blob - t/t3404-rebase-interactive.sh

   1 #!/bin/sh
   2 #
   3 # Copyright (c) 2007 Johannes E. Schindelin
   4 #
   5
   6 test_description='git rebase interactive
   7
   8 This test runs git rebase "interactively", by faking an edit, and verifies
   9 that the result still makes sense.
  10
  11 Initial setup:
  12
  13      one - two - three - four (conflict-branch)
  14    /
  15  A - B - C - D - E            (master)
  16  | \
  17  |   F - G - H                (branch1)
  18  |     \
  19  |\      I                    (branch2)
  20  | \
  21  |   J - K - L - M            (no-conflict-branch)
  22   \
  23     N - O - P                 (no-ff-branch)
  24
  25  where A, B, D and G all touch file1, and one, two, three, four all
  26  touch file "conflict".
  27 '
  28 . ./test-lib.sh
  29
  30 . "$TEST_DIRECTORY"/lib-rebase.sh
  31
  32 # WARNING: Modifications to the initial repository can change the SHA ID used
  33 # in the expect2 file for the 'stop on conflicting pick' test.
  34
  35 test_expect_success 'setup' '
  36         test_commit A file1 &&
  37         test_commit B file1 &&
  38         test_commit C file2 &&
  39         test_commit D file1 &&
  40         test_commit E file3 &&
  41         git checkout -b branch1 A &&
  42         test_commit F file4 &&
  43         test_commit G file1 &&
  44         test_commit H file5 &&
  45         git checkout -b branch2 F &&
  46         test_commit I file6 &&
  47         git checkout -b conflict-branch A &&
  48         test_commit one conflict &&
  49         test_commit two conflict &&
  50         test_commit three conflict &&
  51         test_commit four conflict &&
  52         git checkout -b no-conflict-branch A &&
  53         test_commit J fileJ &&
  54         test_commit K fileK &&
  55         test_commit L fileL &&
  56         test_commit M fileM &&
  57         git checkout -b no-ff-branch A &&
  58         test_commit N fileN &&
  59         test_commit O fileO &&
  60         test_commit P fileP
  61 '
  62
  63 # "exec" commands are ran with the user shell by default, but this may
  64 # be non-POSIX. For example, if SHELL=zsh then ">file" doesn't work
  65 # to create a file. Unseting SHELL avoids such non-portable behavior
  66 # in tests. It must be exported for it to take effect where needed.
  67 SHELL=
  68 export SHELL
  69
  70 test_expect_success 'rebase -i with the exec command' '
  71         git checkout master &&
  72         (
  73         set_fake_editor &&
  74         FAKE_LINES="1 exec_>touch-one
  75                 2 exec_>touch-two exec_false exec_>touch-three
  76                 3 4 exec_>\"touch-file__name_with_spaces\";_>touch-after-semicolon 5" &&
  77         export FAKE_LINES &&
  78         test_must_fail git rebase -i A
  79         ) &&
  80         test_path_is_file touch-one &&
  81         test_path_is_file touch-two &&
  82         test_path_is_missing touch-three " (should have stopped before)" &&
  83         test_cmp_rev C HEAD &&
  84         git rebase --continue &&
  85         test_path_is_file touch-three &&
  86         test_path_is_file "touch-file  name with spaces" &&
  87         test_path_is_file touch-after-semicolon &&
  88         test_cmp_rev master HEAD &&
  89         rm -f touch-*
  90 '
  91
  92 test_expect_success 'rebase -i with the exec command runs from tree root' '
  93         git checkout master &&
  94         mkdir subdir && (cd subdir &&
  95         set_fake_editor &&
  96         FAKE_LINES="1 exec_>touch-subdir" \
  97                 git rebase -i HEAD^
  98         ) &&
  99         test_path_is_file touch-subdir &&
 100         rm -fr subdir
 101 '
 102
 103 test_expect_success 'rebase -i with the exec command checks tree cleanness' '
 104         git checkout master &&
 105         (
 106         set_fake_editor &&
 107         FAKE_LINES="exec_echo_foo_>file1 1" &&
 108         export FAKE_LINES &&
 109         test_must_fail git rebase -i HEAD^
 110         ) &&
 111         test_cmp_rev master^ HEAD &&
 112         git reset --hard &&
 113         git rebase --continue
 114 '
 115
 116 test_expect_success 'rebase -i with exec of inexistent command' '
 117         git checkout master &&
 118         test_when_finished "git rebase --abort" &&
 119         (
 120         set_fake_editor &&
 121         FAKE_LINES="exec_this-command-does-not-exist 1" &&
 122         export FAKE_LINES &&
 123         test_must_fail git rebase -i HEAD^ >actual 2>&1
 124         ) &&
 125         ! grep "Maybe git-rebase is broken" actual
 126 '
 127
 128 test_expect_success 'no changes are a nop' '
 129         git checkout branch2 &&
 130         set_fake_editor &&
 131         git rebase -i F &&
 132         test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch2" &&
 133         test $(git rev-parse I) = $(git rev-parse HEAD)
 134 '
 135
 136 test_expect_success 'test the [branch] option' '
 137         git checkout -b dead-end &&
 138         git rm file6 &&
 139         git commit -m "stop here" &&
 140         set_fake_editor &&
 141         git rebase -i F branch2 &&
 142         test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch2" &&
 143         test $(git rev-parse I) = $(git rev-parse branch2) &&
 144         test $(git rev-parse I) = $(git rev-parse HEAD)
 145 '
 146
 147 test_expect_success 'test --onto <branch>' '
 148         git checkout -b test-onto branch2 &&
 149         set_fake_editor &&
 150         git rebase -i --onto branch1 F &&
 151         test "$(git symbolic-ref -q HEAD)" = "refs/heads/test-onto" &&
 152         test $(git rev-parse HEAD^) = $(git rev-parse branch1) &&
 153         test $(git rev-parse I) = $(git rev-parse branch2)
 154 '
 155
 156 test_expect_success 'rebase on top of a non-conflicting commit' '
 157         git checkout branch1 &&
 158         git tag original-branch1 &&
 159         set_fake_editor &&
 160         git rebase -i branch2 &&
 161         test file6 = $(git diff --name-only original-branch1) &&
 162         test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch1" &&
 163         test $(git rev-parse I) = $(git rev-parse branch2) &&
 164         test $(git rev-parse I) = $(git rev-parse HEAD~2)
 165 '
 166
 167 test_expect_success 'reflog for the branch shows state before rebase' '
 168         test $(git rev-parse branch1@{1}) = $(git rev-parse original-branch1)
 169 '
 170
 171 test_expect_success 'exchange two commits' '
 172         set_fake_editor &&
 173         FAKE_LINES="2 1" git rebase -i HEAD~2 &&
 174         test H = $(git cat-file commit HEAD^ | sed -ne \$p) &&
 175         test G = $(git cat-file commit HEAD | sed -ne \$p)
 176 '
 177
 178 cat > expect << EOF
 179 diff --git a/file1 b/file1
 180 index f70f10e..fd79235 100644
 181 --- a/file1
 182 +++ b/file1
 183 @@ -1 +1 @@
 184 -A
 185 +G
 186 EOF
 187
 188 cat > expect2 << EOF
 189 <<<<<<< HEAD
 190 D
 191 =======
 192 G
 193 >>>>>>> 5d18e54... G
 194 EOF
 195
 196 test_expect_success 'stop on conflicting pick' '
 197         git tag new-branch1 &&
 198         set_fake_editor &&
 199         test_must_fail git rebase -i master &&
 200         test "$(git rev-parse HEAD~3)" = "$(git rev-parse master)" &&
 201         test_cmp expect .git/rebase-merge/patch &&
 202         test_cmp expect2 file1 &&
 203         test "$(git diff --name-status |
 204                 sed -n -e "/^U/s/^U[^a-z]*//p")" = file1 &&
 205         test 4 = $(grep -v "^#" < .git/rebase-merge/done | wc -l) &&
 206         test 0 = $(grep -c "^[^#]" < .git/rebase-merge/git-rebase-todo)
 207 '
 208
 209 test_expect_success 'abort' '
 210         git rebase --abort &&
 211         test $(git rev-parse new-branch1) = $(git rev-parse HEAD) &&
 212         test "$(git symbolic-ref -q HEAD)" = "refs/heads/branch1" &&
 213         test_path_is_missing .git/rebase-merge
 214 '
 215
 216 test_expect_success 'abort with error when new base cannot be checked out' '
 217         git rm --cached file1 &&
 218         git commit -m "remove file in base" &&
 219         set_fake_editor &&
 220         test_must_fail git rebase -i master > output 2>&1 &&
 221         grep "The following untracked working tree files would be overwritten by checkout:" \
 222                 output &&
 223         grep "file1" output &&
 224         test_path_is_missing .git/rebase-merge &&
 225         git reset --hard HEAD^
 226 '
 227
 228 test_expect_success 'retain authorship' '
 229         echo A > file7 &&
 230         git add file7 &&
 231         test_tick &&
 232         GIT_AUTHOR_NAME="Twerp Snog" git commit -m "different author" &&
 233         git tag twerp &&
 234         set_fake_editor &&
 235         git rebase -i --onto master HEAD^ &&
 236         git show HEAD | grep "^Author: Twerp Snog"
 237 '
 238
 239 test_expect_success 'squash' '
 240         git reset --hard twerp &&
 241         echo B > file7 &&
 242         test_tick &&
 243         GIT_AUTHOR_NAME="Nitfol" git commit -m "nitfol" file7 &&
 244         echo "******************************" &&
 245         set_fake_editor &&
 246         FAKE_LINES="1 squash 2" EXPECT_HEADER_COUNT=2 \
 247                 git rebase -i --onto master HEAD~2 &&
 248         test B = $(cat file7) &&
 249         test $(git rev-parse HEAD^) = $(git rev-parse master)
 250 '
 251
 252 test_expect_success 'retain authorship when squashing' '
 253         git show HEAD | grep "^Author: Twerp Snog"
 254 '
 255
 256 test_expect_success '-p handles "no changes" gracefully' '
 257         HEAD=$(git rev-parse HEAD) &&
 258         set_fake_editor &&
 259         git rebase -i -p HEAD^ &&
 260         git update-index --refresh &&
 261         git diff-files --quiet &&
 262         git diff-index --quiet --cached HEAD -- &&
 263         test $HEAD = $(git rev-parse HEAD)
 264 '
 265
 266 test_expect_failure 'exchange two commits with -p' '
 267         git checkout H &&
 268         set_fake_editor &&
 269         FAKE_LINES="2 1" git rebase -i -p HEAD~2 &&
 270         test H = $(git cat-file commit HEAD^ | sed -ne \$p) &&
 271         test G = $(git cat-file commit HEAD | sed -ne \$p)
 272 '
 273
 274 test_expect_success 'preserve merges with -p' '
 275         git checkout -b to-be-preserved master^ &&
 276         : > unrelated-file &&
 277         git add unrelated-file &&
 278         test_tick &&
 279         git commit -m "unrelated" &&
 280         git checkout -b another-branch master &&
 281         echo B > file1 &&
 282         test_tick &&
 283         git commit -m J file1 &&
 284         test_tick &&
 285         git merge to-be-preserved &&
 286         echo C > file1 &&
 287         test_tick &&
 288         git commit -m K file1 &&
 289         echo D > file1 &&
 290         test_tick &&
 291         git commit -m L1 file1 &&
 292         git checkout HEAD^ &&
 293         echo 1 > unrelated-file &&
 294         test_tick &&
 295         git commit -m L2 unrelated-file &&
 296         test_tick &&
 297         git merge another-branch &&
 298         echo E > file1 &&
 299         test_tick &&
 300         git commit -m M file1 &&
 301         git checkout -b to-be-rebased &&
 302         test_tick &&
 303         set_fake_editor &&
 304         git rebase -i -p --onto branch1 master &&
 305         git update-index --refresh &&
 306         git diff-files --quiet &&
 307         git diff-index --quiet --cached HEAD -- &&
 308         test $(git rev-parse HEAD~6) = $(git rev-parse branch1) &&
 309         test $(git rev-parse HEAD~4^2) = $(git rev-parse to-be-preserved) &&
 310         test $(git rev-parse HEAD^^2^) = $(git rev-parse HEAD^^^) &&
 311         test $(git show HEAD~5:file1) = B &&
 312         test $(git show HEAD~3:file1) = C &&
 313         test $(git show HEAD:file1) = E &&
 314         test $(git show HEAD:unrelated-file) = 1
 315 '
 316
 317 test_expect_success 'edit ancestor with -p' '
 318         set_fake_editor &&
 319         FAKE_LINES="1 2 edit 3 4" git rebase -i -p HEAD~3 &&
 320         echo 2 > unrelated-file &&
 321         test_tick &&
 322         git commit -m L2-modified --amend unrelated-file &&
 323         git rebase --continue &&
 324         git update-index --refresh &&
 325         git diff-files --quiet &&
 326         git diff-index --quiet --cached HEAD -- &&
 327         test $(git show HEAD:unrelated-file) = 2
 328 '
 329
 330 test_expect_success '--continue tries to commit' '
 331         test_tick &&
 332         set_fake_editor &&
 333         test_must_fail git rebase -i --onto new-branch1 HEAD^ &&
 334         echo resolved > file1 &&
 335         git add file1 &&
 336         FAKE_COMMIT_MESSAGE="chouette!" git rebase --continue &&
 337         test $(git rev-parse HEAD^) = $(git rev-parse new-branch1) &&
 338         git show HEAD | grep chouette
 339 '
 340
 341 test_expect_success 'verbose flag is heeded, even after --continue' '
 342         git reset --hard master@{1} &&
 343         test_tick &&
 344         set_fake_editor &&
 345         test_must_fail git rebase -v -i --onto new-branch1 HEAD^ &&
 346         echo resolved > file1 &&
 347         git add file1 &&
 348         git rebase --continue > output &&
 349         grep "^ file1 | 2 +-$" output
 350 '
 351
 352 test_expect_success 'multi-squash only fires up editor once' '
 353         base=$(git rev-parse HEAD~4) &&
 354         set_fake_editor &&
 355         FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="1 squash 2 squash 3 squash 4" \
 356                 EXPECT_HEADER_COUNT=4 \
 357                 git rebase -i $base &&
 358         test $base = $(git rev-parse HEAD^) &&
 359         test 1 = $(git show | grep ONCE | wc -l)
 360 '
 361
 362 test_expect_success 'multi-fixup does not fire up editor' '
 363         git checkout -b multi-fixup E &&
 364         base=$(git rev-parse HEAD~4) &&
 365         set_fake_editor &&
 366         FAKE_COMMIT_AMEND="NEVER" FAKE_LINES="1 fixup 2 fixup 3 fixup 4" \
 367                 git rebase -i $base &&
 368         test $base = $(git rev-parse HEAD^) &&
 369         test 0 = $(git show | grep NEVER | wc -l) &&
 370         git checkout to-be-rebased &&
 371         git branch -D multi-fixup
 372 '
 373
 374 test_expect_success 'commit message used after conflict' '
 375         git checkout -b conflict-fixup conflict-branch &&
 376         base=$(git rev-parse HEAD~4) &&
 377         set_fake_editor &&
 378         (
 379                 FAKE_LINES="1 fixup 3 fixup 4" &&
 380                 export FAKE_LINES &&
 381                 test_must_fail git rebase -i $base
 382         ) &&
 383         echo three > conflict &&
 384         git add conflict &&
 385         FAKE_COMMIT_AMEND="ONCE" EXPECT_HEADER_COUNT=2 \
 386                 git rebase --continue &&
 387         test $base = $(git rev-parse HEAD^) &&
 388         test 1 = $(git show | grep ONCE | wc -l) &&
 389         git checkout to-be-rebased &&
 390         git branch -D conflict-fixup
 391 '
 392
 393 test_expect_success 'commit message retained after conflict' '
 394         git checkout -b conflict-squash conflict-branch &&
 395         base=$(git rev-parse HEAD~4) &&
 396         set_fake_editor &&
 397         (
 398                 FAKE_LINES="1 fixup 3 squash 4" &&
 399                 export FAKE_LINES &&
 400                 test_must_fail git rebase -i $base
 401         ) &&
 402         echo three > conflict &&
 403         git add conflict &&
 404         FAKE_COMMIT_AMEND="TWICE" EXPECT_HEADER_COUNT=2 \
 405                 git rebase --continue &&
 406         test $base = $(git rev-parse HEAD^) &&
 407         test 2 = $(git show | grep TWICE | wc -l) &&
 408         git checkout to-be-rebased &&
 409         git branch -D conflict-squash
 410 '
 411
 412 cat > expect-squash-fixup << EOF
 413 B
 414
 415 D
 416
 417 ONCE
 418 EOF
 419
 420 test_expect_success 'squash and fixup generate correct log messages' '
 421         git checkout -b squash-fixup E &&
 422         base=$(git rev-parse HEAD~4) &&
 423         set_fake_editor &&
 424         FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="1 fixup 2 squash 3 fixup 4" \
 425                 EXPECT_HEADER_COUNT=4 \
 426                 git rebase -i $base &&
 427         git cat-file commit HEAD | sed -e 1,/^\$/d > actual-squash-fixup &&
 428         test_cmp expect-squash-fixup actual-squash-fixup &&
 429         git checkout to-be-rebased &&
 430         git branch -D squash-fixup
 431 '
 432
 433 test_expect_success 'squash ignores comments' '
 434         git checkout -b skip-comments E &&
 435         base=$(git rev-parse HEAD~4) &&
 436         set_fake_editor &&
 437         FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="# 1 # squash 2 # squash 3 # squash 4 #" \
 438                 EXPECT_HEADER_COUNT=4 \
 439                 git rebase -i $base &&
 440         test $base = $(git rev-parse HEAD^) &&
 441         test 1 = $(git show | grep ONCE | wc -l) &&
 442         git checkout to-be-rebased &&
 443         git branch -D skip-comments
 444 '
 445
 446 test_expect_success 'squash ignores blank lines' '
 447         git checkout -b skip-blank-lines E &&
 448         base=$(git rev-parse HEAD~4) &&
 449         set_fake_editor &&
 450         FAKE_COMMIT_AMEND="ONCE" FAKE_LINES="> 1 > squash 2 > squash 3 > squash 4 >" \
 451                 EXPECT_HEADER_COUNT=4 \
 452                 git rebase -i $base &&
 453         test $base = $(git rev-parse HEAD^) &&
 454         test 1 = $(git show | grep ONCE | wc -l) &&
 455         git checkout to-be-rebased &&
 456         git branch -D skip-blank-lines
 457 '
 458
 459 test_expect_success 'squash works as expected' '
 460         git checkout -b squash-works no-conflict-branch &&
 461         one=$(git rev-parse HEAD~3) &&
 462         set_fake_editor &&
 463         FAKE_LINES="1 squash 3 2" EXPECT_HEADER_COUNT=2 \
 464                 git rebase -i HEAD~3 &&
 465         test $one = $(git rev-parse HEAD~2)
 466 '
 467
 468 test_expect_success 'interrupted squash works as expected' '
 469         git checkout -b interrupted-squash conflict-branch &&
 470         one=$(git rev-parse HEAD~3) &&
 471         set_fake_editor &&
 472         (
 473                 FAKE_LINES="1 squash 3 2" &&
 474                 export FAKE_LINES &&
 475                 test_must_fail git rebase -i HEAD~3
 476         ) &&
 477         (echo one; echo two; echo four) > conflict &&
 478         git add conflict &&
 479         test_must_fail git rebase --continue &&
 480         echo resolved > conflict &&
 481         git add conflict &&
 482         git rebase --continue &&
 483         test $one = $(git rev-parse HEAD~2)
 484 '
 485
 486 test_expect_success 'interrupted squash works as expected (case 2)' '
 487         git checkout -b interrupted-squash2 conflict-branch &&
 488         one=$(git rev-parse HEAD~3) &&
 489         set_fake_editor &&
 490         (
 491                 FAKE_LINES="3 squash 1 2" &&
 492                 export FAKE_LINES &&
 493                 test_must_fail git rebase -i HEAD~3
 494         ) &&
 495         (echo one; echo four) > conflict &&
 496         git add conflict &&
 497         test_must_fail git rebase --continue &&
 498         (echo one; echo two; echo four) > conflict &&
 499         git add conflict &&
 500         test_must_fail git rebase --continue &&
 501         echo resolved > conflict &&
 502         git add conflict &&
 503         git rebase --continue &&
 504         test $one = $(git rev-parse HEAD~2)
 505 '
 506
 507 test_expect_success '--continue tries to commit, even for "edit"' '
 508         echo unrelated > file7 &&
 509         git add file7 &&
 510         test_tick &&
 511         git commit -m "unrelated change" &&
 512         parent=$(git rev-parse HEAD^) &&
 513         test_tick &&
 514         set_fake_editor &&
 515         FAKE_LINES="edit 1" git rebase -i HEAD^ &&
 516         echo edited > file7 &&
 517         git add file7 &&
 518         FAKE_COMMIT_MESSAGE="chouette!" git rebase --continue &&
 519         test edited = $(git show HEAD:file7) &&
 520         git show HEAD | grep chouette &&
 521         test $parent = $(git rev-parse HEAD^)
 522 '
 523
 524 test_expect_success 'aborted --continue does not squash commits after "edit"' '
 525         old=$(git rev-parse HEAD) &&
 526         test_tick &&
 527         set_fake_editor &&
 528         FAKE_LINES="edit 1" git rebase -i HEAD^ &&
 529         echo "edited again" > file7 &&
 530         git add file7 &&
 531         (
 532                 FAKE_COMMIT_MESSAGE=" " &&
 533                 export FAKE_COMMIT_MESSAGE &&
 534                 test_must_fail git rebase --continue
 535         ) &&
 536         test $old = $(git rev-parse HEAD) &&
 537         git rebase --abort
 538 '
 539
 540 test_expect_success 'auto-amend only edited commits after "edit"' '
 541         test_tick &&
 542         set_fake_editor &&
 543         FAKE_LINES="edit 1" git rebase -i HEAD^ &&
 544         echo "edited again" > file7 &&
 545         git add file7 &&
 546         FAKE_COMMIT_MESSAGE="edited file7 again" git commit &&
 547         echo "and again" > file7 &&
 548         git add file7 &&
 549         test_tick &&
 550         (
 551                 FAKE_COMMIT_MESSAGE="and again" &&
 552                 export FAKE_COMMIT_MESSAGE &&
 553                 test_must_fail git rebase --continue
 554         ) &&
 555         git rebase --abort
 556 '
 557
 558 test_expect_success 'clean error after failed "exec"' '
 559         test_tick &&
 560         test_when_finished "git rebase --abort || :" &&
 561         set_fake_editor &&
 562         (
 563                 FAKE_LINES="1 exec_false" &&
 564                 export FAKE_LINES &&
 565                 test_must_fail git rebase -i HEAD^
 566         ) &&
 567         echo "edited again" > file7 &&
 568         git add file7 &&
 569         test_must_fail git rebase --continue 2>error &&
 570         grep "You have staged changes in your working tree." error
 571 '
 572
 573 test_expect_success 'rebase a detached HEAD' '
 574         grandparent=$(git rev-parse HEAD~2) &&
 575         git checkout $(git rev-parse HEAD) &&
 576         test_tick &&
 577         set_fake_editor &&
 578         FAKE_LINES="2 1" git rebase -i HEAD~2 &&
 579         test $grandparent = $(git rev-parse HEAD~2)
 580 '
 581
 582 test_expect_success 'rebase a commit violating pre-commit' '
 583
 584         mkdir -p .git/hooks &&
 585         PRE_COMMIT=.git/hooks/pre-commit &&
 586         echo "#!/bin/sh" > $PRE_COMMIT &&
 587         echo "test -z \"\$(git diff --cached --check)\"" >> $PRE_COMMIT &&
 588         chmod a+x $PRE_COMMIT &&
 589         echo "monde! " >> file1 &&
 590         test_tick &&
 591         test_must_fail git commit -m doesnt-verify file1 &&
 592         git commit -m doesnt-verify --no-verify file1 &&
 593         test_tick &&
 594         set_fake_editor &&
 595         FAKE_LINES=2 git rebase -i HEAD~2
 596
 597 '
 598
 599 test_expect_success 'rebase with a file named HEAD in worktree' '
 600
 601         rm -fr .git/hooks &&
 602         git reset --hard &&
 603         git checkout -b branch3 A &&
 604
 605         (
 606                 GIT_AUTHOR_NAME="Squashed Away" &&
 607                 export GIT_AUTHOR_NAME &&
 608                 >HEAD &&
 609                 git add HEAD &&
 610                 git commit -m "Add head" &&
 611                 >BODY &&
 612                 git add BODY &&
 613                 git commit -m "Add body"
 614         ) &&
 615
 616         set_fake_editor &&
 617         FAKE_LINES="1 squash 2" git rebase -i to-be-rebased &&
 618         test "$(git show -s --pretty=format:%an)" = "Squashed Away"
 619
 620 '
 621
 622 test_expect_success 'do "noop" when there is nothing to cherry-pick' '
 623
 624         git checkout -b branch4 HEAD &&
 625         GIT_EDITOR=: git commit --amend \
 626                 --author="Somebody else <somebody@else.com>" &&
 627         test $(git rev-parse branch3) != $(git rev-parse branch4) &&
 628         set_fake_editor &&
 629         git rebase -i branch3 &&
 630         test $(git rev-parse branch3) = $(git rev-parse branch4)
 631
 632 '
 633
 634 test_expect_success 'submodule rebase setup' '
 635         git checkout A &&
 636         mkdir sub &&
 637         (
 638                 cd sub && git init && >elif &&
 639                 git add elif && git commit -m "submodule initial"
 640         ) &&
 641         echo 1 >file1 &&
 642         git add file1 sub &&
 643         test_tick &&
 644         git commit -m "One" &&
 645         echo 2 >file1 &&
 646         test_tick &&
 647         git commit -a -m "Two" &&
 648         (
 649                 cd sub && echo 3 >elif &&
 650                 git commit -a -m "submodule second"
 651         ) &&
 652         test_tick &&
 653         set_fake_editor &&
 654         git commit -a -m "Three changes submodule"
 655 '
 656
 657 test_expect_success 'submodule rebase -i' '
 658         set_fake_editor &&
 659         FAKE_LINES="1 squash 2 3" git rebase -i A
 660 '
 661
 662 test_expect_success 'submodule conflict setup' '
 663         git tag submodule-base &&
 664         git checkout HEAD^ &&
 665         (
 666                 cd sub && git checkout HEAD^ && echo 4 >elif &&
 667                 git add elif && git commit -m "submodule conflict"
 668         ) &&
 669         git add sub &&
 670         test_tick &&
 671         git commit -m "Conflict in submodule" &&
 672         git tag submodule-topic
 673 '
 674
 675 test_expect_success 'rebase -i continue with only submodule staged' '
 676         set_fake_editor &&
 677         test_must_fail git rebase -i submodule-base &&
 678         git add sub &&
 679         git rebase --continue &&
 680         test $(git rev-parse submodule-base) != $(git rev-parse HEAD)
 681 '
 682
 683 test_expect_success 'rebase -i continue with unstaged submodule' '
 684         git checkout submodule-topic &&
 685         git reset --hard &&
 686         set_fake_editor &&
 687         test_must_fail git rebase -i submodule-base &&
 688         git reset &&
 689         git rebase --continue &&
 690         test $(git rev-parse submodule-base) = $(git rev-parse HEAD)
 691 '
 692
 693 test_expect_success 'avoid unnecessary reset' '
 694         git checkout master &&
 695         git reset --hard &&
 696         test-chmtime =123456789 file3 &&
 697         git update-index --refresh &&
 698         HEAD=$(git rev-parse HEAD) &&
 699         set_fake_editor &&
 700         git rebase -i HEAD~4 &&
 701         test $HEAD = $(git rev-parse HEAD) &&
 702         MTIME=$(test-chmtime -v +0 file3 | sed 's/[^0-9].*$//') &&
 703         test 123456789 = $MTIME
 704 '
 705
 706 test_expect_success 'reword' '
 707         git checkout -b reword-branch master &&
 708         set_fake_editor &&
 709         FAKE_LINES="1 2 3 reword 4" FAKE_COMMIT_MESSAGE="E changed" git rebase -i A &&
 710         git show HEAD | grep "E changed" &&
 711         test $(git rev-parse master) != $(git rev-parse HEAD) &&
 712         test $(git rev-parse master^) = $(git rev-parse HEAD^) &&
 713         FAKE_LINES="1 2 reword 3 4" FAKE_COMMIT_MESSAGE="D changed" git rebase -i A &&
 714         git show HEAD^ | grep "D changed" &&
 715         FAKE_LINES="reword 1 2 3 4" FAKE_COMMIT_MESSAGE="B changed" git rebase -i A &&
 716         git show HEAD~3 | grep "B changed" &&
 717         FAKE_LINES="1 reword 2 3 4" FAKE_COMMIT_MESSAGE="C changed" git rebase -i A &&
 718         git show HEAD~2 | grep "C changed"
 719 '
 720
 721 test_expect_success 'rebase -i can copy notes' '
 722         git config notes.rewrite.rebase true &&
 723         git config notes.rewriteRef "refs/notes/*" &&
 724         test_commit n1 &&
 725         test_commit n2 &&
 726         test_commit n3 &&
 727         git notes add -m"a note" n3 &&
 728         set_fake_editor &&
 729         git rebase -i --onto n1 n2 &&
 730         test "a note" = "$(git notes show HEAD)"
 731 '
 732
 733 cat >expect <<EOF
 734 an earlier note
 735
 736 a note
 737 EOF
 738
 739 test_expect_success 'rebase -i can copy notes over a fixup' '
 740         git reset --hard n3 &&
 741         git notes add -m"an earlier note" n2 &&
 742         set_fake_editor &&
 743         GIT_NOTES_REWRITE_MODE=concatenate FAKE_LINES="1 fixup 2" git rebase -i n1 &&
 744         git notes show > output &&
 745         test_cmp expect output
 746 '
 747
 748 test_expect_success 'rebase while detaching HEAD' '
 749         git symbolic-ref HEAD &&
 750         grandparent=$(git rev-parse HEAD~2) &&
 751         test_tick &&
 752         set_fake_editor &&
 753         FAKE_LINES="2 1" git rebase -i HEAD~2 HEAD^0 &&
 754         test $grandparent = $(git rev-parse HEAD~2) &&
 755         test_must_fail git symbolic-ref HEAD
 756 '
 757
 758 test_tick # Ensure that the rebased commits get a different timestamp.
 759 test_expect_success 'always cherry-pick with --no-ff' '
 760         git checkout no-ff-branch &&
 761         git tag original-no-ff-branch &&
 762         set_fake_editor &&
 763         git rebase -i --no-ff A &&
 764         touch empty &&
 765         for p in 0 1 2
 766         do
 767                 test ! $(git rev-parse HEAD~$p) = $(git rev-parse original-no-ff-branch~$p) &&
 768                 git diff HEAD~$p original-no-ff-branch~$p > out &&
 769                 test_cmp empty out
 770         done &&
 771         test $(git rev-parse HEAD~3) = $(git rev-parse original-no-ff-branch~3) &&
 772         git diff HEAD~3 original-no-ff-branch~3 > out &&
 773         test_cmp empty out
 774 '
 775
 776 test_expect_success 'set up commits with funny messages' '
 777         git checkout -b funny A &&
 778         echo >>file1 &&
 779         test_tick &&
 780         git commit -a -m "end with slash\\" &&
 781         echo >>file1 &&
 782         test_tick &&
 783         git commit -a -m "something (\000) that looks like octal" &&
 784         echo >>file1 &&
 785         test_tick &&
 786         git commit -a -m "something (\n) that looks like a newline" &&
 787         echo >>file1 &&
 788         test_tick &&
 789         git commit -a -m "another commit"
 790 '
 791
 792 test_expect_success 'rebase-i history with funny messages' '
 793         git rev-list A..funny >expect &&
 794         test_tick &&
 795         set_fake_editor &&
 796         FAKE_LINES="1 2 3 4" git rebase -i A &&
 797         git rev-list A.. >actual &&
 798         test_cmp expect actual
 799 '
 800
 801
 802 test_expect_success 'prepare for rebase -i --exec' '
 803         git checkout master &&
 804         git checkout -b execute &&
 805         test_commit one_exec main.txt one_exec &&
 806         test_commit two_exec main.txt two_exec &&
 807         test_commit three_exec main.txt three_exec
 808 '
 809
 810
 811 test_expect_success 'running "git rebase -i --exec git show HEAD"' '
 812         set_fake_editor &&
 813         git rebase -i --exec "git show HEAD" HEAD~2 >actual &&
 814         (
 815                 FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
 816                 export FAKE_LINES &&
 817                 git rebase -i HEAD~2 >expect
 818         ) &&
 819         sed -e "1,9d" expect >expected &&
 820         test_cmp expected actual
 821 '
 822
 823
 824 test_expect_success 'running "git rebase --exec git show HEAD -i"' '
 825         git reset --hard execute &&
 826         set_fake_editor &&
 827         git rebase --exec "git show HEAD" -i HEAD~2 >actual &&
 828         (
 829                 FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
 830                 export FAKE_LINES &&
 831                 git rebase -i HEAD~2 >expect
 832         ) &&
 833         sed -e "1,9d" expect >expected &&
 834         test_cmp expected actual
 835 '
 836
 837
 838 test_expect_success 'running "git rebase -ix git show HEAD"' '
 839         git reset --hard execute &&
 840         set_fake_editor &&
 841         git rebase -ix "git show HEAD" HEAD~2 >actual &&
 842         (
 843                 FAKE_LINES="1 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
 844                 export FAKE_LINES &&
 845                 git rebase -i HEAD~2 >expect
 846         ) &&
 847         sed -e "1,9d" expect >expected &&
 848         test_cmp expected actual
 849 '
 850
 851
 852 test_expect_success 'rebase -ix with several <CMD>' '
 853         git reset --hard execute &&
 854         set_fake_editor &&
 855         git rebase -ix "git show HEAD; pwd" HEAD~2 >actual &&
 856         (
 857                 FAKE_LINES="1 exec_git_show_HEAD;_pwd 2 exec_git_show_HEAD;_pwd" &&
 858                 export FAKE_LINES &&
 859                 git rebase -i HEAD~2 >expect
 860         ) &&
 861         sed -e "1,9d" expect >expected &&
 862         test_cmp expected actual
 863 '
 864
 865
 866 test_expect_success 'rebase -ix with several instances of --exec' '
 867         git reset --hard execute &&
 868         set_fake_editor &&
 869         git rebase -i --exec "git show HEAD" --exec "pwd" HEAD~2 >actual &&
 870         (
 871                 FAKE_LINES="1 exec_git_show_HEAD exec_pwd 2
 872                                 exec_git_show_HEAD exec_pwd" &&
 873                 export FAKE_LINES &&
 874                 git rebase -i HEAD~2 >expect
 875         ) &&
 876         sed -e "1,11d" expect >expected &&
 877         test_cmp expected actual
 878 '
 879
 880
 881 test_expect_success 'rebase -ix with --autosquash' '
 882         git reset --hard execute &&
 883         git checkout -b autosquash &&
 884         echo second >second.txt &&
 885         git add second.txt &&
 886         git commit -m "fixup! two_exec" &&
 887         echo bis >bis.txt &&
 888         git add bis.txt &&
 889         git commit -m "fixup! two_exec" &&
 890         set_fake_editor &&
 891         (
 892                 git checkout -b autosquash_actual &&
 893                 git rebase -i --exec "git show HEAD" --autosquash HEAD~4 >actual
 894         ) &&
 895         git checkout autosquash &&
 896         (
 897                 git checkout -b autosquash_expected &&
 898                 FAKE_LINES="1 fixup 3 fixup 4 exec_git_show_HEAD 2 exec_git_show_HEAD" &&
 899                 export FAKE_LINES &&
 900                 git rebase -i HEAD~4 >expect
 901         ) &&
 902         sed -e "1,13d" expect >expected &&
 903         test_cmp expected actual
 904 '
 905
 906
 907 test_expect_success 'rebase --exec without -i shows error message' '
 908         git reset --hard execute &&
 909         set_fake_editor &&
 910         test_must_fail git rebase --exec "git show HEAD" HEAD~2 2>actual &&
 911         echo "The --exec option must be used with the --interactive option" >expected &&
 912         test_i18ncmp expected actual
 913 '
 914
 915
 916 test_expect_success 'rebase -i --exec without <CMD>' '
 917         git reset --hard execute &&
 918         set_fake_editor &&
 919         test_must_fail git rebase -i --exec 2>tmp &&
 920         sed -e "1d" tmp >actual &&
 921         test_must_fail git rebase -h >expected &&
 922         test_cmp expected actual &&
 923         git checkout master
 924 '
 925
 926 test_expect_success 'rebase -i --root re-order and drop commits' '
 927         git checkout E &&
 928         set_fake_editor &&
 929         FAKE_LINES="3 1 2 5" git rebase -i --root &&
 930         test E = $(git cat-file commit HEAD | sed -ne \$p) &&
 931         test B = $(git cat-file commit HEAD^ | sed -ne \$p) &&
 932         test A = $(git cat-file commit HEAD^^ | sed -ne \$p) &&
 933         test C = $(git cat-file commit HEAD^^^ | sed -ne \$p) &&
 934         test 0 = $(git cat-file commit HEAD^^^ | grep -c ^parent\ )
 935 '
 936
 937 test_expect_success 'rebase -i --root retain root commit author and message' '
 938         git checkout A &&
 939         echo B >file7 &&
 940         git add file7 &&
 941         GIT_AUTHOR_NAME="Twerp Snog" git commit -m "different author" &&
 942         set_fake_editor &&
 943         FAKE_LINES="2" git rebase -i --root &&
 944         git cat-file commit HEAD | grep -q "^author Twerp Snog" &&
 945         git cat-file commit HEAD | grep -q "^different author$"
 946 '
 947
 948 test_expect_success 'rebase -i --root temporary sentinel commit' '
 949         git checkout B &&
 950         (
 951                 set_fake_editor &&
 952                 FAKE_LINES="2" &&
 953                 export FAKE_LINES &&
 954                 test_must_fail git rebase -i --root
 955         ) &&
 956         git cat-file commit HEAD | grep "^tree 4b825dc642cb" &&
 957         git rebase --abort
 958 '
 959
 960 test_expect_success 'rebase -i --root fixup root commit' '
 961         git checkout B &&
 962         set_fake_editor &&
 963         FAKE_LINES="1 fixup 2" git rebase -i --root &&
 964         test A = $(git cat-file commit HEAD | sed -ne \$p) &&
 965         test B = $(git show HEAD:file1) &&
 966         test 0 = $(git cat-file commit HEAD | grep -c ^parent\ )
 967 '
 968
 969 test_expect_success 'rebase --edit-todo does not works on non-interactive rebase' '
 970         git reset --hard &&
 971         git checkout conflict-branch &&
 972         set_fake_editor &&
 973         test_must_fail git rebase --onto HEAD~2 HEAD~ &&
 974         test_must_fail git rebase --edit-todo &&
 975         git rebase --abort
 976 '
 977
 978 test_expect_success 'rebase --edit-todo can be used to modify todo' '
 979         git reset --hard &&
 980         git checkout no-conflict-branch^0 &&
 981         set_fake_editor &&
 982         FAKE_LINES="edit 1 2 3" git rebase -i HEAD~3 &&
 983         FAKE_LINES="2 1" git rebase --edit-todo &&
 984         git rebase --continue
 985         test M = $(git cat-file commit HEAD^ | sed -ne \$p) &&
 986         test L = $(git cat-file commit HEAD | sed -ne \$p)
 987 '
 988
 989 test_expect_success 'rebase -i produces readable reflog' '
 990         git reset --hard &&
 991         git branch -f branch-reflog-test H &&
 992         set_fake_editor &&
 993         git rebase -i --onto I F branch-reflog-test &&
 994         cat >expect <<-\EOF &&
 995         rebase -i (start): checkout I
 996         rebase -i (pick): G
 997         rebase -i (pick): H
 998         rebase -i (finish): returning to refs/heads/branch-reflog-test
 999         EOF
1000         tail -n 4 .git/logs/HEAD |
1001         sed -e "s/.*    //" >actual &&
1002         test_cmp expect actual
1003 '
1004
1005 test_expect_success 'rebase -i respects core.commentchar' '
1006         git reset --hard &&
1007         git checkout E^0 &&
1008         test_config core.commentchar "\\" &&
1009         write_script remove-all-but-first.sh <<-\EOF &&
1010         sed -e "2,\$s/^/\\\\/" "$1" >"$1.tmp" &&
1011         mv "$1.tmp" "$1"
1012         EOF
1013         test_set_editor "$(pwd)/remove-all-but-first.sh" &&
1014         git rebase -i B &&
1015         test B = $(git cat-file commit HEAD^ | sed -ne \$p)
1016 '
1017
1018 test_expect_success 'rebase -i, with <onto> and <upstream> specified as :/quuxery' '
1019         test_when_finished "git branch -D torebase" &&
1020         git checkout -b torebase branch1 &&
1021         upstream=$(git rev-parse ":/J") &&
1022         onto=$(git rev-parse ":/A") &&
1023         git rebase --onto $onto $upstream &&
1024         git reset --hard branch1 &&
1025         git rebase --onto ":/A" ":/J" &&
1026         git checkout branch1
1027 '
1028
1029 test_expect_success 'rebase -i with --strategy and -X' '
1030         git checkout -b conflict-merge-use-theirs conflict-branch &&
1031         git reset --hard HEAD^ &&
1032         echo five >conflict &&
1033         echo Z >file1 &&
1034         git commit -a -m "one file conflict" &&
1035         EDITOR=true git rebase -i --strategy=recursive -Xours conflict-branch &&
1036         test $(git show conflict-branch:conflict) = $(cat conflict) &&
1037         test $(cat file1) = Z
1038 '
1039
1040 test_expect_success 'rebase -i error on commits with \ in message' '
1041         current_head=$(git rev-parse HEAD)
1042         test_when_finished "git rebase --abort; git reset --hard $current_head; rm -f error" &&
1043         test_commit TO-REMOVE will-conflict old-content &&
1044         test_commit "\temp" will-conflict new-content dummy &&
1045         (
1046         EDITOR=true &&
1047         export EDITOR &&
1048         test_must_fail git rebase -i HEAD^ --onto HEAD^^ 2>error
1049         ) &&
1050         test_expect_code 1 grep  "      emp" error
1051 '
1052
1053 test_expect_success 'short SHA-1 setup' '
1054         test_when_finished "git checkout master" &&
1055         git checkout --orphan collide &&
1056         git rm -rf . &&
1057         (
1058         unset test_tick &&
1059         test_commit collide1 collide &&
1060         test_commit --notick collide2 collide &&
1061         test_commit --notick collide3 collide
1062         )
1063 '
1064
1065 test_expect_success 'short SHA-1 collide' '
1066         test_when_finished "reset_rebase && git checkout master" &&
1067         git checkout collide &&
1068         (
1069         unset test_tick &&
1070         test_tick &&
1071         set_fake_editor &&
1072         FAKE_COMMIT_MESSAGE="collide2 ac4f2ee" \
1073         FAKE_LINES="reword 1 2" git rebase -i HEAD~2
1074         )
1075 '
1076
1077 test_done