t/t3421-rebase-topology-linear.sh

   1 #!/bin/sh
   2
   3 test_description='basic rebase topology tests'
   4 . ./test-lib.sh
   5 . "$TEST_DIRECTORY"/lib-rebase.sh
   6
   7 # a---b---c
   8 #      \
   9 #       d---e
  10 test_expect_success 'setup' '
  11         test_commit a &&
  12         test_commit b &&
  13         test_commit c &&
  14         git checkout b &&
  15         test_commit d &&
  16         test_commit e
  17 '
  18
  19 test_run_rebase () {
  20         result=$1
  21         shift
  22         test_expect_$result "simple rebase $*" "
  23                 reset_rebase &&
  24                 git rebase $* c e &&
  25                 test_cmp_rev c HEAD~2 &&
  26                 test_linear_range 'd e' c..
  27         "
  28 }
  29 test_run_rebase success --apply
  30 test_run_rebase success -m
  31 test_run_rebase success -i
  32 test_have_prereq !REBASE_P || test_run_rebase success -p
  33
  34 test_expect_success 'setup branches and remote tracking' '
  35         git tag -l >tags &&
  36         for tag in $(cat tags)
  37         do
  38                 git branch branch-$tag $tag || return 1
  39         done &&
  40         git remote add origin "file://$PWD" &&
  41         git fetch origin
  42 '
  43
  44 test_run_rebase () {
  45         result=$1
  46         shift
  47         test_expect_$result "rebase $* is no-op if upstream is an ancestor" "
  48                 reset_rebase &&
  49                 git rebase $* b e &&
  50                 test_cmp_rev e HEAD
  51         "
  52 }
  53 test_run_rebase success --apply
  54 test_run_rebase success -m
  55 test_run_rebase success -i
  56 test_have_prereq !REBASE_P || test_run_rebase success -p
  57
  58 test_run_rebase () {
  59         result=$1
  60         shift
  61         test_expect_$result "rebase $* -f rewrites even if upstream is an ancestor" "
  62                 reset_rebase &&
  63                 git rebase $* -f b e &&
  64                 test_cmp_rev ! e HEAD &&
  65                 test_cmp_rev b HEAD~2 &&
  66                 test_linear_range 'd e' b..
  67         "
  68 }
  69 test_run_rebase success --apply
  70 test_run_rebase success --fork-point
  71 test_run_rebase success -m
  72 test_run_rebase success -i
  73 test_have_prereq !REBASE_P || test_run_rebase failure -p
  74
  75 test_run_rebase () {
  76         result=$1
  77         shift
  78         test_expect_$result "rebase $* -f rewrites even if remote upstream is an ancestor" "
  79                 reset_rebase &&
  80                 git rebase $* -f branch-b branch-e &&
  81                 test_cmp_rev ! branch-e origin/branch-e &&
  82                 test_cmp_rev branch-b HEAD~2 &&
  83                 test_linear_range 'd e' branch-b..
  84         "
  85 }
  86 test_run_rebase success --apply
  87 test_run_rebase success --fork-point
  88 test_run_rebase success -m
  89 test_run_rebase success -i
  90 test_have_prereq !REBASE_P || test_run_rebase success -p
  91
  92 test_run_rebase () {
  93         result=$1
  94         shift
  95         test_expect_$result "rebase $* fast-forwards from ancestor of upstream" "
  96                 reset_rebase &&
  97                 git rebase $* e b &&
  98                 test_cmp_rev e HEAD
  99         "
 100 }
 101 test_run_rebase success --apply
 102 test_run_rebase success --fork-point
 103 test_run_rebase success -m
 104 test_run_rebase success -i
 105 test_have_prereq !REBASE_P || test_run_rebase success -p
 106
 107 #       f
 108 #      /
 109 # a---b---c---g---h
 110 #      \
 111 #       d---gp--i
 112 #
 113 # gp = cherry-picked g
 114 # h = reverted g
 115 #
 116 # Reverted patches are there for tests to be able to check if a commit
 117 # that introduced the same change as another commit is
 118 # dropped. Without reverted commits, we could get false positives
 119 # because applying the patch succeeds, but simply results in no
 120 # changes.
 121 test_expect_success 'setup of linear history for range selection tests' '
 122         git checkout c &&
 123         test_commit g &&
 124         revert h g &&
 125         git checkout d &&
 126         cherry_pick gp g &&
 127         test_commit i &&
 128         git checkout b &&
 129         test_commit f
 130 '
 131
 132 test_run_rebase () {
 133         result=$1
 134         shift
 135         test_expect_$result "rebase $* drops patches in upstream" "
 136                 reset_rebase &&
 137                 git rebase $* h i &&
 138                 test_cmp_rev h HEAD~2 &&
 139                 test_linear_range 'd i' h..
 140         "
 141 }
 142 test_run_rebase success --apply
 143 test_run_rebase success -m
 144 test_run_rebase success -i
 145 test_have_prereq !REBASE_P || test_run_rebase success -p
 146
 147 test_run_rebase () {
 148         result=$1
 149         shift
 150         test_expect_$result "rebase $* can drop last patch if in upstream" "
 151                 reset_rebase &&
 152                 git rebase $* h gp &&
 153                 test_cmp_rev h HEAD^ &&
 154                 test_linear_range 'd' h..
 155         "
 156 }
 157 test_run_rebase success --apply
 158 test_run_rebase success -m
 159 test_run_rebase success -i
 160 test_have_prereq !REBASE_P || test_run_rebase success -p
 161
 162 test_run_rebase () {
 163         result=$1
 164         shift
 165         test_expect_$result "rebase $* --onto drops patches in upstream" "
 166                 reset_rebase &&
 167                 git rebase $* --onto f h i &&
 168                 test_cmp_rev f HEAD~2 &&
 169                 test_linear_range 'd i' f..
 170         "
 171 }
 172 test_run_rebase success --apply
 173 test_run_rebase success -m
 174 test_run_rebase success -i
 175 test_have_prereq !REBASE_P || test_run_rebase success -p
 176
 177 test_run_rebase () {
 178         result=$1
 179         shift
 180         test_expect_$result "rebase $* --onto does not drop patches in onto" "
 181                 reset_rebase &&
 182                 git rebase $* --onto h f i &&
 183                 test_cmp_rev h HEAD~3 &&
 184                 test_linear_range 'd gp i' h..
 185         "
 186 }
 187 test_run_rebase success --apply
 188 test_run_rebase success -m
 189 test_run_rebase success -i
 190 test_have_prereq !REBASE_P || test_run_rebase success -p
 191
 192 # a---b---c---j!
 193 #      \
 194 #       d---k!--l
 195 #
 196 # ! = empty
 197 test_expect_success 'setup of linear history for empty commit tests' '
 198         git checkout c &&
 199         make_empty j &&
 200         git checkout d &&
 201         make_empty k &&
 202         test_commit l
 203 '
 204
 205 test_run_rebase () {
 206         result=$1
 207         shift
 208         test_expect_$result "rebase $* keeps begin-empty commits" "
 209                 reset_rebase &&
 210                 git rebase $* j l &&
 211                 test_cmp_rev c HEAD~4 &&
 212                 test_linear_range 'j d k l' c..
 213         "
 214 }
 215 test_run_rebase failure --apply
 216 test_run_rebase success -m
 217 test_run_rebase success -i
 218 test_have_prereq !REBASE_P || test_run_rebase failure -p
 219
 220 test_run_rebase () {
 221         result=$1
 222         shift
 223         test_expect_$result "rebase $* --no-keep-empty drops begin-empty commits" "
 224                 reset_rebase &&
 225                 git rebase $* --no-keep-empty c l &&
 226                 test_cmp_rev c HEAD~2 &&
 227                 test_linear_range 'd l' c..
 228         "
 229 }
 230 test_run_rebase success -m
 231 test_run_rebase success -i
 232 test_have_prereq !REBASE_P || test_run_rebase success -p
 233
 234 test_run_rebase () {
 235         result=$1
 236         shift
 237         test_expect_$result "rebase $* --keep-empty keeps empty even if already in upstream" "
 238                 reset_rebase &&
 239                 git rebase $* --keep-empty j l &&
 240                 test_cmp_rev j HEAD~3 &&
 241                 test_linear_range 'd k l' j..
 242         "
 243 }
 244 test_run_rebase success -m
 245 test_run_rebase success -i
 246 test_have_prereq !REBASE_P || test_run_rebase success -p
 247 test_run_rebase success --rebase-merges
 248
 249 #       m
 250 #      /
 251 # a---b---c---g
 252 #
 253 # x---y---bp
 254 #
 255 # bp = cherry-picked b
 256 # m = reverted b
 257 #
 258 # Reverted patches are there for tests to be able to check if a commit
 259 # that introduced the same change as another commit is
 260 # dropped. Without reverted commits, we could get false positives
 261 # because applying the patch succeeds, but simply results in no
 262 # changes.
 263 test_expect_success 'setup of linear history for test involving root' '
 264         git checkout b &&
 265         revert m b &&
 266         git checkout --orphan disjoint &&
 267         git rm -rf . &&
 268         test_commit x &&
 269         test_commit y &&
 270         cherry_pick bp b
 271 '
 272
 273 test_run_rebase () {
 274         result=$1
 275         shift
 276         test_expect_$result "rebase $* --onto --root" "
 277                 reset_rebase &&
 278                 git rebase $* --onto c --root y &&
 279                 test_cmp_rev c HEAD~2 &&
 280                 test_linear_range 'x y' c..
 281         "
 282 }
 283 test_run_rebase success --apply
 284 test_run_rebase success -m
 285 test_run_rebase success -i
 286 test_have_prereq !REBASE_P || test_run_rebase success -p
 287
 288 test_run_rebase () {
 289         result=$1
 290         shift
 291         test_expect_$result "rebase $* without --onto --root with disjoint history" "
 292                 reset_rebase &&
 293                 git rebase $* c y &&
 294                 test_cmp_rev c HEAD~2 &&
 295                 test_linear_range 'x y' c..
 296         "
 297 }
 298 test_run_rebase success --apply
 299 test_run_rebase success -m
 300 test_run_rebase success -i
 301 test_have_prereq !REBASE_P || test_run_rebase failure -p
 302
 303 test_run_rebase () {
 304         result=$1
 305         shift
 306         test_expect_$result "rebase $* --onto --root drops patch in onto" "
 307                 reset_rebase &&
 308                 git rebase $* --onto m --root bp &&
 309                 test_cmp_rev m HEAD~2 &&
 310                 test_linear_range 'x y' m..
 311         "
 312 }
 313 test_run_rebase success --apply
 314 test_run_rebase success -m
 315 test_run_rebase success -i
 316 test_have_prereq !REBASE_P || test_run_rebase success -p
 317
 318 test_run_rebase () {
 319         result=$1
 320         shift
 321         test_expect_$result "rebase $* --onto --root with merge-base does not go to root" "
 322                 reset_rebase &&
 323                 git rebase $* --onto m --root g &&
 324                 test_cmp_rev m HEAD~2 &&
 325                 test_linear_range 'c g' m..
 326         "
 327 }
 328
 329 test_run_rebase success --apply
 330 test_run_rebase success -m
 331 test_run_rebase success -i
 332 test_have_prereq !REBASE_P || test_run_rebase failure -p
 333
 334 test_run_rebase () {
 335         result=$1
 336         shift
 337         test_expect_$result "rebase $* without --onto --root with disjoint history drops patch in onto" "
 338                 reset_rebase &&
 339                 git rebase $* m bp &&
 340                 test_cmp_rev m HEAD~2 &&
 341                 test_linear_range 'x y' m..
 342         "
 343 }
 344 test_run_rebase success --apply
 345 test_run_rebase success -m
 346 test_run_rebase success -i
 347 test_have_prereq !REBASE_P || test_run_rebase failure -p
 348
 349 test_run_rebase () {
 350         result=$1
 351         shift
 352         test_expect_$result "rebase $* --root on linear history is a no-op" "
 353                 reset_rebase &&
 354                 git rebase $* --root c &&
 355                 test_cmp_rev c HEAD
 356         "
 357 }
 358 test_run_rebase success ''
 359 test_run_rebase success -m
 360 test_run_rebase success -i
 361 test_have_prereq !REBASE_P || test_run_rebase failure -p
 362
 363 test_run_rebase () {
 364         result=$1
 365         shift
 366         test_expect_$result "rebase $* -f --root on linear history causes re-write" "
 367                 reset_rebase &&
 368                 git rebase $* -f --root c &&
 369                 test_cmp_rev ! a HEAD~2 &&
 370                 test_linear_range 'a b c' HEAD
 371         "
 372 }
 373 test_run_rebase success ''
 374 test_run_rebase success -m
 375 test_run_rebase success -i
 376 test_have_prereq !REBASE_P || test_run_rebase success -p
 377
 378 test_done