Andrew's git - gitweb.git/blob - t/t5500-fetch-pack.sh

   1#!/bin/sh
   2#
   3# Copyright (c) 2005 Johannes Schindelin
   4#
   5
   6test_description='Testing multi_ack pack fetching
   7
   8'
   9. ./test-lib.sh
  10
  11# Test fetch-pack/upload-pack pair.
  12
  13# Some convenience functions
  14
  15add () {
  16        name=$1
  17        text="$@"
  18        branch=`echo $name | sed -e 's/^\(.\).*$/\1/'`
  19        parents=""
  20
  21        shift
  22        while test $1; do
  23                parents="$parents -p $1"
  24                shift
  25        done
  26
  27        echo "$text" > test.txt
  28        git update-index --add test.txt
  29        tree=$(git write-tree)
  30        # make sure timestamps are in correct order
  31        sec=$(($sec+1))
  32        commit=$(echo "$text" | GIT_AUTHOR_DATE=$sec \
  33                git commit-tree $tree $parents 2>>log2.txt)
  34        eval "$name=$commit; export $name"
  35        echo $commit > .git/refs/heads/$branch
  36        eval ${branch}TIP=$commit
  37}
  38
  39count_objects () {
  40        ls .git/objects/??/* 2>>log2.txt | wc -l | tr -d " "
  41}
  42
  43test_expect_object_count () {
  44        message=$1
  45        count=$2
  46
  47        output="$(count_objects)"
  48        test_expect_success \
  49                "new object count $message" \
  50                "test $count = $output"
  51}
  52
  53pull_to_client () {
  54        number=$1
  55        heads=$2
  56        count=$3
  57        no_strict_count_check=$4
  58
  59        cd client
  60        test_expect_success "$number pull" \
  61                "git fetch-pack -k -v .. $heads"
  62        case "$heads" in *A*) echo $ATIP > .git/refs/heads/A;; esac
  63        case "$heads" in *B*) echo $BTIP > .git/refs/heads/B;; esac
  64        git symbolic-ref HEAD refs/heads/`echo $heads | sed -e 's/^\(.\).*$/\1/'`
  65
  66        test_expect_success "fsck" 'git fsck --full > fsck.txt 2>&1'
  67
  68        test_expect_success 'check downloaded results' \
  69        'mv .git/objects/pack/pack-* . &&
  70         p=`ls -1 pack-*.pack` &&
  71         git unpack-objects <$p &&
  72         git fsck --full'
  73
  74        test_expect_success "new object count after $number pull" \
  75        'idx=`echo pack-*.idx` &&
  76         pack_count=`git show-index <$idx | wc -l` &&
  77         test $pack_count = $count'
  78        test -z "$pack_count" && pack_count=0
  79        if [ -z "$no_strict_count_check" ]; then
  80                test_expect_success "minimal count" "test $count = $pack_count"
  81        else
  82                test $count != $pack_count && \
  83                        echo "WARNING: $pack_count objects transmitted, only $count of which were needed"
  84        fi
  85        rm -f pack-*
  86        cd ..
  87}
  88
  89# Here begins the actual testing
  90
  91# A1 - ... - A20 - A21
  92#    \
  93#      B1  -   B2 - .. - B70
  94
  95# client pulls A20, B1. Then tracks only B. Then pulls A.
  96
  97(
  98        mkdir client &&
  99        cd client &&
 100        git init 2>> log2.txt &&
 101        git config transfer.unpacklimit 0
 102)
 103
 104add A1
 105
 106prev=1; cur=2; while [ $cur -le 10 ]; do
 107        add A$cur $(eval echo \$A$prev)
 108        prev=$cur
 109        cur=$(($cur+1))
 110done
 111
 112add B1 $A1
 113
 114echo $ATIP > .git/refs/heads/A
 115echo $BTIP > .git/refs/heads/B
 116git symbolic-ref HEAD refs/heads/B
 117
 118pull_to_client 1st "B A" $((11*3))
 119
 120add A11 $A10
 121
 122prev=1; cur=2; while [ $cur -le 65 ]; do
 123        add B$cur $(eval echo \$B$prev)
 124        prev=$cur
 125        cur=$(($cur+1))
 126done
 127
 128pull_to_client 2nd "B" $((64*3))
 129
 130pull_to_client 3rd "A" $((1*3)) # old fails
 131
 132test_expect_success "clone shallow" 'git clone --depth 2 "file://$(pwd)/." shallow'
 133
 134(cd shallow; git count-objects -v) > count.shallow
 135
 136test_expect_success "clone shallow object count" \
 137        "test \"in-pack: 18\" = \"$(grep in-pack count.shallow)\""
 138
 139count_output () {
 140        sed -e '/^in-pack:/d' -e '/^packs:/d' -e '/^size-pack:/d' -e '/: 0$/d' "$1"
 141}
 142
 143test_expect_success "clone shallow object count (part 2)" '
 144        test -z "$(count_output count.shallow)"
 145'
 146
 147test_expect_success "fsck in shallow repo" \
 148        "(cd shallow; git fsck --full)"
 149
 150#test_done; exit
 151
 152add B66 $B65
 153add B67 $B66
 154
 155test_expect_success "pull in shallow repo" \
 156        "(cd shallow; git pull .. B)"
 157
 158(cd shallow; git count-objects -v) > count.shallow
 159test_expect_success "clone shallow object count" \
 160        "test \"count: 6\" = \"$(grep count count.shallow)\""
 161
 162add B68 $B67
 163add B69 $B68
 164
 165test_expect_success "deepening pull in shallow repo" \
 166        "(cd shallow; git pull --depth 4 .. B)"
 167
 168(cd shallow; git count-objects -v) > count.shallow
 169test_expect_success "clone shallow object count" \
 170        "test \"count: 12\" = \"$(grep count count.shallow)\""
 171
 172test_expect_success "deepening fetch in shallow repo" \
 173        "(cd shallow; git fetch --depth 4 .. A:A)"
 174
 175(cd shallow; git count-objects -v) > count.shallow
 176test_expect_success "clone shallow object count" \
 177        "test \"count: 18\" = \"$(grep count count.shallow)\""
 178
 179test_expect_success "pull in shallow repo with missing merge base" \
 180        "(cd shallow && test_must_fail git pull --depth 4 .. A)"
 181
 182test_done