Andrew's git - gitweb.git/blob - t/t5526-fetch-submodules.sh

   1#!/bin/sh
   2# Copyright (c) 2010, Jens Lehmann
   3
   4test_description='Recursive "git fetch" for submodules'
   5
   6. ./test-lib.sh
   7
   8pwd=$(pwd)
   9
  10add_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
  37test_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
  64test_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
  74test_expect_success "fetch alone only fetches superproject" '
  75        add_upstream_commit &&
  76        (
  77                cd downstream &&
  78                git fetch >../actual.out 2>../actual.err
  79        ) &&
  80        ! test -s actual.out &&
  81        ! test -s actual.err
  82'
  83
  84test_expect_success "fetch --no-recurse-submodules only fetches superproject" '
  85        (
  86                cd downstream &&
  87                git fetch --no-recurse-submodules >../actual.out 2>../actual.err
  88        ) &&
  89        ! test -s actual.out &&
  90        ! test -s actual.err
  91'
  92
  93test_expect_success "using fetchRecurseSubmodules=true in .gitmodules recurses into submodules" '
  94        (
  95                cd downstream &&
  96                git config -f .gitmodules submodule.submodule.fetchRecurseSubmodules true &&
  97                git fetch >../actual.out 2>../actual.err
  98        ) &&
  99        test_must_be_empty actual.out &&
 100        test_i18ncmp expect.err actual.err
 101'
 102
 103test_expect_success "--no-recurse-submodules overrides .gitmodules config" '
 104        add_upstream_commit &&
 105        (
 106                cd downstream &&
 107                git fetch --no-recurse-submodules >../actual.out 2>../actual.err
 108        ) &&
 109        ! test -s actual.out &&
 110        ! test -s actual.err
 111'
 112
 113test_expect_success "using fetchRecurseSubmodules=false in .git/config overrides setting in .gitmodules" '
 114        (
 115                cd downstream &&
 116                git config submodule.submodule.fetchRecurseSubmodules false &&
 117                git fetch >../actual.out 2>../actual.err
 118        ) &&
 119        ! test -s actual.out &&
 120        ! test -s actual.err
 121'
 122
 123test_expect_success "--recurse-submodules overrides fetchRecurseSubmodules setting from .git/config" '
 124        (
 125                cd downstream &&
 126                git fetch --recurse-submodules >../actual.out 2>../actual.err &&
 127                git config --unset -f .gitmodules submodule.submodule.fetchRecurseSubmodules &&
 128                git config --unset submodule.submodule.fetchRecurseSubmodules
 129        ) &&
 130        test_must_be_empty actual.out &&
 131        test_i18ncmp expect.err actual.err
 132'
 133
 134test_expect_success "--quiet propagates to submodules" '
 135        (
 136                cd downstream &&
 137                git fetch --recurse-submodules --quiet >../actual.out 2>../actual.err
 138        ) &&
 139        ! test -s actual.out &&
 140        ! test -s actual.err
 141'
 142
 143test_expect_success "--dry-run propagates to submodules" '
 144        add_upstream_commit &&
 145        (
 146                cd downstream &&
 147                git fetch --recurse-submodules --dry-run >../actual.out 2>../actual.err
 148        ) &&
 149        test_must_be_empty actual.out &&
 150        test_i18ncmp expect.err actual.err
 151'
 152
 153test_expect_success "Without --dry-run propagates to submodules" '
 154        (
 155                cd downstream &&
 156                git fetch --recurse-submodules >../actual.out 2>../actual.err
 157        ) &&
 158        test_must_be_empty actual.out &&
 159        test_i18ncmp expect.err actual.err
 160'
 161
 162test_expect_success "recurseSubmodules=true propagates into submodules" '
 163        add_upstream_commit &&
 164        (
 165                cd downstream &&
 166                git config fetch.recurseSubmodules true
 167                git fetch >../actual.out 2>../actual.err
 168        ) &&
 169        test_must_be_empty actual.out &&
 170        test_i18ncmp expect.err actual.err
 171'
 172
 173test_expect_success "--recurse-submodules overrides config in submodule" '
 174        add_upstream_commit &&
 175        (
 176                cd downstream &&
 177                (
 178                        cd submodule &&
 179                        git config fetch.recurseSubmodules false
 180                ) &&
 181                git fetch --recurse-submodules >../actual.out 2>../actual.err
 182        ) &&
 183        test_must_be_empty actual.out &&
 184        test_i18ncmp expect.err actual.err
 185'
 186
 187test_expect_success "--no-recurse-submodules overrides config setting" '
 188        add_upstream_commit &&
 189        (
 190                cd downstream &&
 191                git config fetch.recurseSubmodules true
 192                git fetch --no-recurse-submodules >../actual.out 2>../actual.err
 193        ) &&
 194        ! test -s actual.out &&
 195        ! test -s actual.err
 196'
 197
 198test_expect_success "Recursion doesn't happen when no new commits are fetched in the superproject" '
 199        (
 200                cd downstream &&
 201                (
 202                        cd submodule &&
 203                        git config --unset fetch.recurseSubmodules
 204                ) &&
 205                git config --unset fetch.recurseSubmodules
 206                git fetch >../actual.out 2>../actual.err
 207        ) &&
 208        ! test -s actual.out &&
 209        ! test -s actual.err
 210'
 211
 212test_expect_success "Recursion stops when no new submodule commits are fetched" '
 213        head1=$(git rev-parse --short HEAD) &&
 214        git add submodule &&
 215        git commit -m "new submodule" &&
 216        head2=$(git rev-parse --short HEAD) &&
 217        echo "From $pwd/." > expect.err.sub &&
 218        echo "   $head1..$head2  master     -> origin/master" >>expect.err.sub &&
 219        head -3 expect.err >> expect.err.sub &&
 220        (
 221                cd downstream &&
 222                git fetch >../actual.out 2>../actual.err
 223        ) &&
 224        test_i18ncmp expect.err.sub actual.err &&
 225        test_must_be_empty actual.out
 226'
 227
 228test_expect_success "Recursion doesn't happen when new superproject commits don't change any submodules" '
 229        add_upstream_commit &&
 230        head1=$(git rev-parse --short HEAD) &&
 231        echo a > file &&
 232        git add file &&
 233        git commit -m "new file" &&
 234        head2=$(git rev-parse --short HEAD) &&
 235        echo "From $pwd/." > expect.err.file &&
 236        echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
 237        (
 238                cd downstream &&
 239                git fetch >../actual.out 2>../actual.err
 240        ) &&
 241        ! test -s actual.out &&
 242        test_i18ncmp expect.err.file actual.err
 243'
 244
 245test_expect_success "Recursion picks up config in submodule" '
 246        (
 247                cd downstream &&
 248                git fetch --recurse-submodules &&
 249                (
 250                        cd submodule &&
 251                        git config fetch.recurseSubmodules true
 252                )
 253        ) &&
 254        add_upstream_commit &&
 255        head1=$(git rev-parse --short HEAD) &&
 256        git add submodule &&
 257        git commit -m "new submodule" &&
 258        head2=$(git rev-parse --short HEAD) &&
 259        echo "From $pwd/." > expect.err.sub &&
 260        echo "   $head1..$head2  master     -> origin/master" >> expect.err.sub &&
 261        cat expect.err >> expect.err.sub &&
 262        (
 263                cd downstream &&
 264                git fetch >../actual.out 2>../actual.err &&
 265                (
 266                        cd submodule &&
 267                        git config --unset fetch.recurseSubmodules
 268                )
 269        ) &&
 270        test_i18ncmp expect.err.sub actual.err &&
 271        test_must_be_empty actual.out
 272'
 273
 274test_expect_success "Recursion picks up all submodules when necessary" '
 275        add_upstream_commit &&
 276        (
 277                cd submodule &&
 278                (
 279                        cd subdir/deepsubmodule &&
 280                        git fetch &&
 281                        git checkout -q FETCH_HEAD
 282                ) &&
 283                head1=$(git rev-parse --short HEAD^) &&
 284                git add subdir/deepsubmodule &&
 285                git commit -m "new deepsubmodule"
 286                head2=$(git rev-parse --short HEAD) &&
 287                echo "Fetching submodule submodule" > ../expect.err.sub &&
 288                echo "From $pwd/submodule" >> ../expect.err.sub &&
 289                echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
 290        ) &&
 291        head1=$(git rev-parse --short HEAD) &&
 292        git add submodule &&
 293        git commit -m "new submodule" &&
 294        head2=$(git rev-parse --short HEAD) &&
 295        echo "From $pwd/." > expect.err.2 &&
 296        echo "   $head1..$head2  master     -> origin/master" >> expect.err.2 &&
 297        cat expect.err.sub >> expect.err.2 &&
 298        tail -3 expect.err >> expect.err.2 &&
 299        (
 300                cd downstream &&
 301                git fetch >../actual.out 2>../actual.err
 302        ) &&
 303        test_i18ncmp expect.err.2 actual.err &&
 304        test_must_be_empty actual.out
 305'
 306
 307test_expect_success "'--recurse-submodules=on-demand' doesn't recurse when no new commits are fetched in the superproject (and ignores config)" '
 308        add_upstream_commit &&
 309        (
 310                cd submodule &&
 311                (
 312                        cd subdir/deepsubmodule &&
 313                        git fetch &&
 314                        git checkout -q FETCH_HEAD
 315                ) &&
 316                head1=$(git rev-parse --short HEAD^) &&
 317                git add subdir/deepsubmodule &&
 318                git commit -m "new deepsubmodule" &&
 319                head2=$(git rev-parse --short HEAD) &&
 320                echo Fetching submodule submodule > ../expect.err.sub &&
 321                echo "From $pwd/submodule" >> ../expect.err.sub &&
 322                echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
 323        ) &&
 324        (
 325                cd downstream &&
 326                git config fetch.recurseSubmodules true &&
 327                git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
 328                git config --unset fetch.recurseSubmodules
 329        ) &&
 330        ! test -s actual.out &&
 331        ! test -s actual.err
 332'
 333
 334test_expect_success "'--recurse-submodules=on-demand' recurses as deep as necessary (and ignores config)" '
 335        head1=$(git rev-parse --short HEAD) &&
 336        git add submodule &&
 337        git commit -m "new submodule" &&
 338        head2=$(git rev-parse --short HEAD) &&
 339        tail -3 expect.err > expect.err.deepsub &&
 340        echo "From $pwd/." > expect.err &&
 341        echo "   $head1..$head2  master     -> origin/master" >>expect.err &&
 342        cat expect.err.sub >> expect.err &&
 343        cat expect.err.deepsub >> expect.err &&
 344        (
 345                cd downstream &&
 346                git config fetch.recurseSubmodules false &&
 347                (
 348                        cd submodule &&
 349                        git config -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive false
 350                ) &&
 351                git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err &&
 352                git config --unset fetch.recurseSubmodules
 353                (
 354                        cd submodule &&
 355                        git config --unset -f .gitmodules submodule.subdir/deepsubmodule.fetchRecursive
 356                )
 357        ) &&
 358        test_must_be_empty actual.out &&
 359        test_i18ncmp expect.err actual.err
 360'
 361
 362test_expect_success "'--recurse-submodules=on-demand' stops when no new submodule commits are found in the superproject (and ignores config)" '
 363        add_upstream_commit &&
 364        head1=$(git rev-parse --short HEAD) &&
 365        echo a >> file &&
 366        git add file &&
 367        git commit -m "new file" &&
 368        head2=$(git rev-parse --short HEAD) &&
 369        echo "From $pwd/." > expect.err.file &&
 370        echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
 371        (
 372                cd downstream &&
 373                git fetch --recurse-submodules=on-demand >../actual.out 2>../actual.err
 374        ) &&
 375        ! test -s actual.out &&
 376        test_i18ncmp expect.err.file actual.err
 377'
 378
 379test_expect_success "'fetch.recurseSubmodules=on-demand' overrides global config" '
 380        (
 381                cd downstream &&
 382                git fetch --recurse-submodules
 383        ) &&
 384        add_upstream_commit &&
 385        git config --global fetch.recurseSubmodules false &&
 386        head1=$(git rev-parse --short HEAD) &&
 387        git add submodule &&
 388        git commit -m "new submodule" &&
 389        head2=$(git rev-parse --short HEAD) &&
 390        echo "From $pwd/." > expect.err.2 &&
 391        echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
 392        head -3 expect.err >> expect.err.2 &&
 393        (
 394                cd downstream &&
 395                git config fetch.recurseSubmodules on-demand &&
 396                git fetch >../actual.out 2>../actual.err
 397        ) &&
 398        git config --global --unset fetch.recurseSubmodules &&
 399        (
 400                cd downstream &&
 401                git config --unset fetch.recurseSubmodules
 402        ) &&
 403        test_must_be_empty actual.out &&
 404        test_i18ncmp expect.err.2 actual.err
 405'
 406
 407test_expect_success "'submodule.<sub>.fetchRecurseSubmodules=on-demand' overrides fetch.recurseSubmodules" '
 408        (
 409                cd downstream &&
 410                git fetch --recurse-submodules
 411        ) &&
 412        add_upstream_commit &&
 413        git config fetch.recurseSubmodules false &&
 414        head1=$(git rev-parse --short HEAD) &&
 415        git add submodule &&
 416        git commit -m "new submodule" &&
 417        head2=$(git rev-parse --short HEAD) &&
 418        echo "From $pwd/." > expect.err.2 &&
 419        echo "   $head1..$head2  master     -> origin/master" >>expect.err.2 &&
 420        head -3 expect.err >> expect.err.2 &&
 421        (
 422                cd downstream &&
 423                git config submodule.submodule.fetchRecurseSubmodules on-demand &&
 424                git fetch >../actual.out 2>../actual.err
 425        ) &&
 426        git config --unset fetch.recurseSubmodules &&
 427        (
 428                cd downstream &&
 429                git config --unset submodule.submodule.fetchRecurseSubmodules
 430        ) &&
 431        test_must_be_empty actual.out &&
 432        test_i18ncmp expect.err.2 actual.err
 433'
 434
 435test_expect_success "don't fetch submodule when newly recorded commits are already present" '
 436        (
 437                cd submodule &&
 438                git checkout -q HEAD^^
 439        ) &&
 440        head1=$(git rev-parse --short HEAD) &&
 441        git add submodule &&
 442        git commit -m "submodule rewound" &&
 443        head2=$(git rev-parse --short HEAD) &&
 444        echo "From $pwd/." > expect.err &&
 445        echo "   $head1..$head2  master     -> origin/master" >> expect.err &&
 446        (
 447                cd downstream &&
 448                git fetch >../actual.out 2>../actual.err
 449        ) &&
 450        ! test -s actual.out &&
 451        test_i18ncmp expect.err actual.err
 452'
 453
 454test_done