Andrew's git / gitweb.git /
6d92f7a5a75dc3728f17966c746638d310ae18b3
   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 "From $pwd/submodule" > ../expect.err &&
  20                echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
  21        ) &&
  22        (
  23                cd deepsubmodule &&
  24                head1=$(git rev-parse --short HEAD) &&
  25                echo new >> deepsubfile &&
  26                test_tick &&
  27                git add deepsubfile &&
  28                git commit -m new deepsubfile &&
  29                head2=$(git rev-parse --short HEAD) &&
  30                echo "From $pwd/deepsubmodule" >> ../expect.err &&
  31                echo "   $head1..$head2  master     -> origin/master" >> ../expect.err
  32        )
  33}
  34
  35test_expect_success setup '
  36        mkdir deepsubmodule &&
  37        (
  38                cd deepsubmodule &&
  39                git init &&
  40                echo deepsubcontent > deepsubfile &&
  41                git add deepsubfile &&
  42                git commit -m new deepsubfile
  43        ) &&
  44        mkdir submodule &&
  45        (
  46                cd submodule &&
  47                git init &&
  48                echo subcontent > subfile &&
  49                git add subfile &&
  50                git submodule add "$pwd/deepsubmodule" deepsubmodule &&
  51                git commit -a -m new
  52        ) &&
  53        git submodule add "$pwd/submodule" submodule &&
  54        git commit -am initial &&
  55        git clone . downstream &&
  56        (
  57                cd downstream &&
  58                git submodule update --init --recursive
  59        ) &&
  60        echo "Fetching submodule submodule" > expect.out &&
  61        echo "Fetching submodule submodule/deepsubmodule" >> expect.out
  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_cmp expect.out actual.out &&
  71        test_cmp 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_cmp expect.out actual.out &&
 100        test_cmp 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_cmp expect.out actual.out &&
 131        test_cmp 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_cmp expect.out actual.out &&
 150        test_cmp expect.err actual.err &&
 151        (
 152                cd downstream &&
 153                git fetch --recurse-submodules >../actual.out 2>../actual.err
 154        ) &&
 155        test_cmp expect.out actual.out &&
 156        test_cmp expect.err actual.err
 157'
 158
 159test_expect_success "recurseSubmodules=true propagates into submodules" '
 160        add_upstream_commit &&
 161        (
 162                cd downstream &&
 163                git config fetch.recurseSubmodules true
 164                git fetch >../actual.out 2>../actual.err
 165        ) &&
 166        test_cmp expect.out actual.out &&
 167        test_cmp expect.err actual.err
 168'
 169
 170test_expect_success "--recurse-submodules overrides config in submodule" '
 171        add_upstream_commit &&
 172        (
 173                cd downstream &&
 174                (
 175                        cd submodule &&
 176                        git config fetch.recurseSubmodules false
 177                ) &&
 178                git fetch --recurse-submodules >../actual.out 2>../actual.err
 179        ) &&
 180        test_cmp expect.out actual.out &&
 181        test_cmp expect.err actual.err
 182'
 183
 184test_expect_success "--no-recurse-submodules overrides config setting" '
 185        add_upstream_commit &&
 186        (
 187                cd downstream &&
 188                git config fetch.recurseSubmodules true
 189                git fetch --no-recurse-submodules >../actual.out 2>../actual.err
 190        ) &&
 191        ! test -s actual.out &&
 192        ! test -s actual.err
 193'
 194
 195test_expect_success "Recursion doesn't happen when no new commits are fetched in the superproject" '
 196        (
 197                cd downstream &&
 198                (
 199                        cd submodule &&
 200                        git config --unset fetch.recurseSubmodules
 201                ) &&
 202                git config --unset fetch.recurseSubmodules
 203                git fetch >../actual.out 2>../actual.err
 204        ) &&
 205        ! test -s actual.out &&
 206        ! test -s actual.err
 207'
 208
 209test_expect_success "Recursion stops when no new submodule commits are fetched" '
 210        head1=$(git rev-parse --short HEAD) &&
 211        git add submodule &&
 212        git commit -m "new submodule" &&
 213        head2=$(git rev-parse --short HEAD) &&
 214        echo "Fetching submodule submodule" > expect.out.sub &&
 215        echo "From $pwd/." > expect.err.sub &&
 216        echo "   $head1..$head2  master     -> origin/master" >> expect.err.sub
 217        head -2 expect.err >> expect.err.sub &&
 218        (
 219                cd downstream &&
 220                git fetch >../actual.out 2>../actual.err
 221        ) &&
 222        test_cmp expect.err.sub actual.err &&
 223        test_cmp expect.out.sub actual.out
 224'
 225
 226test_expect_success "Recursion doesn't happen when new superproject commits don't change any submodules" '
 227        add_upstream_commit &&
 228        head1=$(git rev-parse --short HEAD) &&
 229        echo a > file &&
 230        git add file &&
 231        git commit -m "new file" &&
 232        head2=$(git rev-parse --short HEAD) &&
 233        echo "From $pwd/." > expect.err.file &&
 234        echo "   $head1..$head2  master     -> origin/master" >> expect.err.file &&
 235        (
 236                cd downstream &&
 237                git fetch >../actual.out 2>../actual.err
 238        ) &&
 239        ! test -s actual.out &&
 240        test_cmp expect.err.file actual.err
 241'
 242
 243test_expect_success "Recursion picks up config in submodule" '
 244        (
 245                cd downstream &&
 246                git fetch --recurse-submodules &&
 247                (
 248                        cd submodule &&
 249                        git config fetch.recurseSubmodules true
 250                )
 251        ) &&
 252        add_upstream_commit &&
 253        head1=$(git rev-parse --short HEAD) &&
 254        git add submodule &&
 255        git commit -m "new submodule" &&
 256        head2=$(git rev-parse --short HEAD) &&
 257        echo "From $pwd/." > expect.err.sub &&
 258        echo "   $head1..$head2  master     -> origin/master" >> expect.err.sub &&
 259        cat expect.err >> expect.err.sub &&
 260        (
 261                cd downstream &&
 262                git fetch >../actual.out 2>../actual.err &&
 263                (
 264                        cd submodule &&
 265                        git config --unset fetch.recurseSubmodules
 266                )
 267        ) &&
 268        test_cmp expect.err.sub actual.err &&
 269        test_cmp expect.out actual.out
 270'
 271
 272test_expect_success "Recursion picks up all submodules when necessary" '
 273        add_upstream_commit &&
 274        (
 275                cd submodule &&
 276                (
 277                        cd deepsubmodule &&
 278                        git fetch &&
 279                        git checkout -q FETCH_HEAD
 280                ) &&
 281                head1=$(git rev-parse --short HEAD^) &&
 282                git add deepsubmodule &&
 283                git commit -m "new deepsubmodule"
 284                head2=$(git rev-parse --short HEAD) &&
 285                echo "From $pwd/submodule" > ../expect.err.sub &&
 286                echo "   $head1..$head2  master     -> origin/master" >> ../expect.err.sub
 287        ) &&
 288        head1=$(git rev-parse --short HEAD) &&
 289        git add submodule &&
 290        git commit -m "new submodule" &&
 291        head2=$(git rev-parse --short HEAD) &&
 292        echo "From $pwd/." > expect.err.2 &&
 293        echo "   $head1..$head2  master     -> origin/master" >> expect.err.2 &&
 294        cat expect.err.sub >> expect.err.2 &&
 295        tail -2 expect.err >> expect.err.2 &&
 296        (
 297                cd downstream &&
 298                git fetch >../actual.out 2>../actual.err
 299        ) &&
 300        test_cmp expect.err.2 actual.err &&
 301        test_cmp expect.out actual.out
 302'
 303
 304test_done