git.oblomov.eu Git - git/blob - t/t5526-fetch-submodules.sh

   1 #!/bin/sh
   2 # Copyright (c) 2010, Jens Lehmann
   3
   4 test_description='Recursive "git fetch" for submodules'
   5
   6 . ./test-lib.sh
   7
   8 pwd=$(pwd)
   9
  10 add_upstream_commit() {
  11         (
  12                 cd submodule &&
  13                 head1=$(git rev-parse --short HEAD) &&
  14                 echo new >> subfile &&
  15                 test_tick &&
  16                 git add subfile &&
  17                 git commit -m new subfile &&
  18                 head2=$(git rev-parse --short HEAD) &&
  19                 echo "Fetching submodule submodule" > ../expect.err &&
  20                 echo "From $pwd/submodule" >> ../expect.err &&
  21                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
  22         ) &&
  23         (
  24                 cd deepsubmodule &&
  25                 head1=$(git rev-parse --short HEAD) &&
  26                 echo new >> deepsubfile &&
  27                 test_tick &&
  28                 git add deepsubfile &&
  29                 git commit -m new deepsubfile &&
  30                 head2=$(git rev-parse --short HEAD) &&
  31                 echo "Fetching submodule submodule/subdir/deepsubmodule" >> ../expect.err
  32                 echo "From $pwd/deepsubmodule" >> ../expect.err &&
  33                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
  34         )
  35 }
  36
  37 test_expect_success setup '
  38         mkdir deepsubmodule &&
  39         (
  40                 cd deepsubmodule &&
  41                 git init &&
  42                 echo deepsubcontent > deepsubfile &&
  43                 git add deepsubfile &&
  44                 git commit -m new deepsubfile
  45         ) &&
  46         mkdir submodule &&
  47         (
  48                 cd submodule &&
  49                 git init &&
  50                 echo subcontent > subfile &&
  51                 git add subfile &&
  52                 git submodule add "$pwd/deepsubmodule" subdir/deepsubmodule &&
  53                 git commit -a -m new
  54         ) &&
  55         git submodule add "$pwd/submodule" submodule &&
  56         git commit -am initial &&
  57         git clone . downstream &&
  58         (
  59                 cd downstream &&
  60                 git submodule update --init --recursive
  61         )
  62 '
  63
  64 test_expect_success "fetch --recurse-submodules recurses into submodules" '
  65         add_upstream_commit &&
  66         (
  67                 cd downstream &&
  68                 git fetch --recurse-submodules >../actual.out 2>../actual.err
  69         ) &&
  70         test_must_be_empty actual.out &&
  71         test_i18ncmp expect.err actual.err
  72 '
  73
  74 test_expect_success "fetch --recurse-submodules -j2 has the same output behaviour" '
  75         add_upstream_commit &&
  76         (
  77                 cd downstream &&
  78                 GIT_TRACE=$(pwd)/../trace.out git fetch --recurse-submodules -j2 2>../actual.err
  79         ) &&
  80         test_must_be_empty actual.out &&
  81         test_i18ncmp expect.err actual.err &&
  82         grep "2 tasks" trace.out
  83 '
  84
  85 test_expect_success "fetch alone only fetches superproject" '
  86         add_upstream_commit &&
  87         (
  88                 cd downstream &&
  89                 git fetch >../actual.out 2>../actual.err
  90         ) &&
  91         ! test -s actual.out &&
  92         ! test -s actual.err
  93 '
  94
  95 test_expect_success "fetch --no-recurse-submodules only fetches superproject" '
  96         (
  97                 cd downstream &&
  98                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
  99         ) &&
 100         ! test -s actual.out &&
 101         ! test -s actual.err
 102 '
 103
 104 test_expect_success "using fetchRecurseSubmodules=true in .gitmodules recurses into submodules" '
 105         (
 106                 cd downstream &&
 107                 git config -f .gitmodules submodule.submodule.fetchRecurseSubmodules true &&
 108                 git fetch >../actual.out 2>../actual.err
 109         ) &&
 110         test_must_be_empty actual.out &&
 111         test_i18ncmp expect.err actual.err
 112 '
 113
 114 test_expect_success "--no-recurse-submodules overrides .gitmodules config" '
 115         add_upstream_commit &&
 116         (
 117                 cd downstream &&
 118                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
 119         ) &&
 120         ! test -s actual.out &&
 121         ! test -s actual.err
 122 '
 123
 124 test_expect_success "using fetchRecurseSubmodules=false in .git/config overrides setting in .gitmodules" '
 125         (
 126                 cd downstream &&
 127                 git config submodule.submodule.fetchRecurseSubmodules false &&
 128                 git fetch >../actual.out 2>../actual.err
 129         ) &&
 130         ! test -s actual.out &&
 131         ! test -s actual.err
 132 '
 133
 134 test_expect_success "--recurse-submodules overrides fetchRecurseSubmodules setting from .git/config" '
 135         (
 136                 cd downstream &&
 137                 git fetch --recurse-submodules >../actual.out 2>../actual.err &&
 138                 git config --unset -f .gitmodules submodule.submodule.fetchRecurseSubmodules &&
 139                 git config --unset submodule.submodule.fetchRecurseSubmodules
 140         ) &&
 141         test_must_be_empty actual.out &&
 142         test_i18ncmp expect.err actual.err
 143 '
 144
 145 test_expect_success "--quiet propagates to submodules" '
 146         (
 147                 cd downstream &&
 148                 git fetch --recurse-submodules --quiet >../actual.out 2>../actual.err
 149         ) &&
 150         ! test -s actual.out &&
 151         ! test -s actual.err
 152 '
 153
 154 test_expect_success "--quiet propagates to parallel submodules" '
 155         (
 156                 cd downstream &&
 157                 git fetch --recurse-submodules -j 2 --quiet  >../actual.out 2>../actual.err
 158         ) &&
 159         ! test -s actual.out &&
 160         ! test -s actual.err
 161 '
 162
 163 test_expect_success "--dry-run propagates to submodules" '
 164         add_upstream_commit &&
 165         (
 166                 cd downstream &&
 167                 git fetch --recurse-submodules --dry-run >../actual.out 2>../actual.err
 168         ) &&
 169         test_must_be_empty actual.out &&
 170         test_i18ncmp expect.err actual.err
 171 '
 172
 173 test_expect_success "Without --dry-run propagates to submodules" '
 174         (
 175                 cd downstream &&
 176                 git fetch --recurse-submodules >../actual.out 2>../actual.err
 177         ) &&
 178         test_must_be_empty actual.out &&
 179         test_i18ncmp expect.err actual.err
 180 '
 181
 182 test_expect_success "recurseSubmodules=true propagates into submodules" '
 183         add_upstream_commit &&
 184         (
 185                 cd downstream &&
 186                 git config fetch.recurseSubmodules true
 187                 git fetch >../actual.out 2>../actual.err
 188         ) &&
 189         test_must_be_empty actual.out &&
 190         test_i18ncmp expect.err actual.err
 191 '
 192
 193 test_expect_success "--recurse-submodules overrides config in submodule" '
 194         add_upstream_commit &&
 195         (
 196                 cd downstream &&
 197                 (
 198                         cd submodule &&
 199                         git config fetch.recurseSubmodules false
 200                 ) &&
 201                 git fetch --recurse-submodules >../actual.out 2>../actual.err
 202         ) &&
 203         test_must_be_empty actual.out &&
 204         test_i18ncmp expect.err actual.err
 205 '
 206
 207 test_expect_success "--no-recurse-submodules overrides config setting" '
 208         add_upstream_commit &&
 209         (
 210                 cd downstream &&
 211                 git config fetch.recurseSubmodules true
 212                 git fetch --no-recurse-submodules >../actual.out 2>../actual.err
 213         ) &&
 214         ! test -s actual.out &&
 215         ! test -s actual.err
 216 '
 217
 218 test_expect_success "Recursion doesn't happen when no new commits are fetched in the superproject" '
 219         (
 220                 cd downstream &&
 221                 (
 222                         cd submodule &&
 223                         git config --unset fetch.recurseSubmodules
 224                 ) &&
 225                 git config --unset fetch.recurseSubmodules
 226                 git fetch >../actual.out 2>../actual.err
 227         ) &&
 228         ! test -s actual.out &&
 229         ! test -s actual.err
 230 '
 231
 232 test_expect_success "Recursion stops when no new submodule commits are fetched" '
 233         head1=$(git rev-parse --short HEAD) &&
 234         git add submodule &&
 235         git commit -m "new submodule" &&
 236         head2=$(git rev-parse --short HEAD) &&
 237         echo "From $pwd/." > expect.err.sub &&
 238         echo "   $head1..$head2  master     -> origin/master" >>expect.err.sub &&
 239         head -3 expect.err >> expect.err.sub &&
 240         (
 241                 cd downstream &&
 242                 git fetch >../actual.out 2>../actual.err
 243         ) &&
 244         test_i18ncmp expect.err.sub actual.err &&
 245         test_must_be_empty actual.out
 246 '
 247
 248 test_expect_success "Recursion doesn't happen when new superproject commits don't change any submodules" '
 249         add_upstream_commit &&
 250         head1=$(git rev-parse --short HEAD) &&
 251         echo a > file &&
 252         git add file &&
 253         git commit -m "new file" &&
 254         head2=$(git rev-parse --short HEAD) &&
 255         echo "From $pwd/." > expect.err.file &&
 256         echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
 257         (
 258                 cd downstream &&
 259                 git fetch >../actual.out 2>../actual.err
 260         ) &&
 261         ! test -s actual.out &&
 262         test_i18ncmp expect.err.file actual.err
 263 '
 264
 265 test_expect_success "Recursion picks up config in submodule" '
 266         (
 267                 cd downstream &&
 268                 git fetch --recurse-submodules &&
 269                 (
 270                         cd submodule &&
 271                         git config fetch.recurseSubmodules true
 272                 )
 273         ) &&
 274         add_upstream_commit &&
 275         head1=$(git rev-parse --short HEAD) &&
 276         git add submodule &&
 277         git commit -m "new submodule" &&
 278         head2=$(git rev-parse --short HEAD) &&
 279         echo "From $pwd/." > expect.err.sub &&
 280         echo "   $head1..$head2  master     -> origin/master" >> expect.err.sub &&
 281         cat expect.err >> expect.err.sub &&
 282         (
 283                 cd downstream &&
 284                 git fetch >../actual.out 2>../actual.err &&
 285                 (
 286                         cd submodule &&
 287                         git config --unset fetch.recurseSubmodules
 288                 )
 289         ) &&
 290         test_i18ncmp expect.err.sub actual.err &&
 291         test_must_be_empty actual.out
 292 '
 293
 294 test_expect_success "Recursion picks up all submodules when necessary" '
 295         add_upstream_commit &&
 296         (
 297                 cd submodule &&
 298                 (
 299                         cd subdir/deepsubmodule &&
 300                         git fetch &&
 301                         git checkout -q FETCH_HEAD
 302                 ) &&
 303                 head1=$(git rev-parse --short HEAD^) &&
 304                 git add subdir/deepsubmodule &&
 305                 git commit -m "new deepsubmodule"
 306                 head2=$(git rev-parse --short HEAD) &&
 307                 echo "Fetching submodule submodule" > ../expect.err.sub &&
 308                 echo "From $pwd/submodule" >> ../expect.err.sub &&
 309                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
 310         ) &&
 311         head1=$(git rev-parse --short HEAD) &&
 312         git add submodule &&
 313         git commit -m "new submodule" &&
 314         head2=$(git rev-parse --short HEAD) &&
 315         echo "From $pwd/." > expect.err.2 &&
 316         echo "   $head1..$head2  master     -> origin/master" >> expect.err.2 &&
 317         cat expect.err.sub >> expect.err.2 &&
 318         tail -3 expect.err >> expect.err.2 &&
 319         (
 320                 cd downstream &&
 321                 git fetch >../actual.out 2>../actual.err
 322         ) &&
 323         test_i18ncmp expect.err.2 actual.err &&
 324         test_must_be_empty actual.out
 325 '
 326
 327 test_expect_success "'--recurse-submodules=on-demand' doesn't recurse when no new commits are fetched in the superproject (and ignores config)" '
 328         add_upstream_commit &&
 329         (
 330                 cd submodule &&
 331                 (
 332                         cd subdir/deepsubmodule &&
 333                         git fetch &&
 334                         git checkout -q FETCH_HEAD
 335                 ) &&
 336                 head1=$(git rev-parse --short HEAD^) &&
 337                 git add subdir/deepsubmodule &&
 338                 git commit -m "new deepsubmodule" &&
 339                 head2=$(git rev-parse --short HEAD) &&
 340                 echo Fetching submodule submodule > ../expect.err.sub &&
 341                 echo "From $pwd/submodule" >> ../expect.err.sub &&
 342                 echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
 343         ) &&
 344         (
 345                 cd downstream &&
 346                 git config fetch.recurseSubmodules true &&
 347                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
 348                 git config --unset fetch.recurseSubmodules
 349         ) &&
 350         ! test -s actual.out &&
 351         ! test -s actual.err
 352 '
 353
 354 test_expect_success "'--recurse-submodules=on-demand' recurses as deep as necessary (and ignores config)" '
 355         head1=$(git rev-parse --short HEAD) &&
 356         git add submodule &&
 357         git commit -m "new submodule" &&
 358         head2=$(git rev-parse --short HEAD) &&
 359         tail -3 expect.err > expect.err.deepsub &&
 360         echo "From $pwd/." > expect.err &&
 361         echo "   $head1..$head2  master     -> origin/master" >>expect.err &&
 362         cat expect.err.sub >> expect.err &&
 363         cat expect.err.deepsub >> expect.err &&
 364         (
 365                 cd downstream &&
 366                 git config fetch.recurseSubmodules false &&
 367                 (
 368                         cd submodule &&
 369                         git config -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive false
 370                 ) &&
 371                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
 372                 git config --unset fetch.recurseSubmodules
 373                 (
 374                         cd submodule &&
 375                         git config --unset -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive
 376                 )
 377         ) &&
 378         test_must_be_empty actual.out &&
 379         test_i18ncmp expect.err actual.err
 380 '
 381
 382 test_expect_success "'--recurse-submodules=on-demand' stops when no new submodule commits are found in the superproject (and ignores config)" '
 383         add_upstream_commit &&
 384         head1=$(git rev-parse --short HEAD) &&
 385         echo a >> file &&
 386         git add file &&
 387         git commit -m "new file" &&
 388         head2=$(git rev-parse --short HEAD) &&
 389         echo "From $pwd/." > expect.err.file &&
 390         echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
 391         (
 392                 cd downstream &&
 393                 git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err
 394         ) &&
 395         ! test -s actual.out &&
 396         test_i18ncmp expect.err.file actual.err
 397 '
 398
 399 test_expect_success "'fetch.recurseSubmodules=on-demand' overrides global config" '
 400         (
 401                 cd downstream &&
 402                 git fetch --recurse-submodules
 403         ) &&
 404         add_upstream_commit &&
 405         git config --global fetch.recurseSubmodules false &&
 406         head1=$(git rev-parse --short HEAD) &&
 407         git add submodule &&
 408         git commit -m "new submodule" &&
 409         head2=$(git rev-parse --short HEAD) &&
 410         echo "From $pwd/." > expect.err.2 &&
 411         echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
 412         head -3 expect.err >> expect.err.2 &&
 413         (
 414                 cd downstream &&
 415                 git config fetch.recurseSubmodules on-demand &&
 416                 git fetch >../actual.out 2>../actual.err
 417         ) &&
 418         git config --global --unset fetch.recurseSubmodules &&
 419         (
 420                 cd downstream &&
 421                 git config --unset fetch.recurseSubmodules
 422         ) &&
 423         test_must_be_empty actual.out &&
 424         test_i18ncmp expect.err.2 actual.err
 425 '
 426
 427 test_expect_success "'submodule.<sub>.fetchRecurseSubmodules=on-demand' overrides fetch.recurseSubmodules" '
 428         (
 429                 cd downstream &&
 430                 git fetch --recurse-submodules
 431         ) &&
 432         add_upstream_commit &&
 433         git config fetch.recurseSubmodules false &&
 434         head1=$(git rev-parse --short HEAD) &&
 435         git add submodule &&
 436         git commit -m "new submodule" &&
 437         head2=$(git rev-parse --short HEAD) &&
 438         echo "From $pwd/." > expect.err.2 &&
 439         echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
 440         head -3 expect.err >> expect.err.2 &&
 441         (
 442                 cd downstream &&
 443                 git config submodule.submodule.fetchRecurseSubmodules on-demand &&
 444                 git fetch >../actual.out 2>../actual.err
 445         ) &&
 446         git config --unset fetch.recurseSubmodules &&
 447         (
 448                 cd downstream &&
 449                 git config --unset submodule.submodule.fetchRecurseSubmodules
 450         ) &&
 451         test_must_be_empty actual.out &&
 452         test_i18ncmp expect.err.2 actual.err
 453 '
 454
 455 test_expect_success "don't fetch submodule when newly recorded commits are already present" '
 456         (
 457                 cd submodule &&
 458                 git checkout -q HEAD^^
 459         ) &&
 460         head1=$(git rev-parse --short HEAD) &&
 461         git add submodule &&
 462         git commit -m "submodule rewound" &&
 463         head2=$(git rev-parse --short HEAD) &&
 464         echo "From $pwd/." > expect.err &&
 465         echo "   $head1..$head2  master     -> origin/master" >> expect.err &&
 466         (
 467                 cd downstream &&
 468                 git fetch >../actual.out 2>../actual.err
 469         ) &&
 470         ! test -s actual.out &&
 471         test_i18ncmp expect.err actual.err
 472 '
 473
 474 test_expect_success 'fetching submodules respects parallel settings' '
 475         git config fetch.recurseSubmodules true &&
 476         (
 477                 cd downstream &&
 478                 GIT_TRACE=$(pwd)/trace.out git fetch --jobs 7 &&
 479                 grep "7 tasks" trace.out &&
 480                 git config submodule.fetchJobs 8 &&
 481                 GIT_TRACE=$(pwd)/trace.out git fetch &&
 482                 grep "8 tasks" trace.out &&
 483                 GIT_TRACE=$(pwd)/trace.out git fetch --jobs 9 &&
 484                 grep "9 tasks" trace.out
 485         )
 486 '
 487
 488 test_expect_success 'fetching submodule into a broken repository' '
 489         # Prepare src and src/sub nested in it
 490         git init src &&
 491         (
 492                 cd src &&
 493                 git init sub &&
 494                 git -C sub commit --allow-empty -m "initial in sub" &&
 495                 git submodule add -- ./sub sub &&
 496                 git commit -m "initial in top"
 497         ) &&
 498
 499         # Clone the old-fashoned way
 500         git clone src dst &&
 501         git -C dst clone ../src/sub sub &&
 502
 503         # Make sure that old-fashoned layout is still supported
 504         git -C dst status &&
 505
 506         # "diff" would find no change
 507         git -C dst diff --exit-code &&
 508
 509         # Recursive-fetch works fine
 510         git -C dst fetch --recurse-submodules &&
 511
 512         # Break the receiving submodule
 513         rm -f dst/sub/.git/HEAD &&
 514
 515         # NOTE: without the fix the following tests will recurse forever!
 516         # They should terminate with an error.
 517
 518         test_must_fail git -C dst status &&
 519         test_must_fail git -C dst diff &&
 520         test_must_fail git -C dst fetch --recurse-submodules
 521 '
 522
 523 test_done