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 "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
  35 test_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
  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_cmp expect.out actual.out &&
  71         test_cmp expect.err actual.err
  72 '
  73
  74 test_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
  84 test_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
  93 test_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
 103 test_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
 113 test_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
 123 test_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
 134 test_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
 143 test_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
 159 test_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
 170 test_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
 184 test_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
 195 test_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
 209 test_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
 226 test_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
 243 test_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
 272 test_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
 304 test_done