#!/bin/sh

global test_description := ''fetch/clone from a shallow clone over http''

source ./test-lib.sh
source "$TEST_DIRECTORY"/lib-httpd.sh
start_httpd

proc commit {
	echo $1 >tracked &&
	git add tracked &&
	git commit -m $1
}

test_expect_success 'setup shallow clone' '
	commit 1 &&
	commit 2 &&
	commit 3 &&
	commit 4 &&
	commit 5 &&
	commit 6 &&
	commit 7 &&
	git clone --no-local --depth=5 .git shallow &&
	git config --global transfer.fsckObjects true
'

test_expect_success 'clone http repository' '
	git clone --bare --no-local shallow "$HTTPD_DOCUMENT_ROOT_PATH/repo.git" &&
	git clone $HTTPD_URL/smart/repo.git clone &&
	(
	cd clone &&
	git fsck &&
	git log --format=%s origin/master >actual &&
	cat <<EOF >expect &&
7
6
5
4
3
EOF
	test_cmp expect actual
	)
'

# This test is tricky. We need large enough "have"s that fetch-pack
# will put pkt-flush in between. Then we need a "have" the server
# does not have, it'll send "ACK %s ready"
test_expect_success 'no shallow lines after receiving ACK ready' '
	(
		cd shallow &&
		test_tick &&
		for i in $(test_seq 15)
		do
			git checkout --orphan unrelated$i &&
			test_commit unrelated$i &&
			git push -q "$HTTPD_DOCUMENT_ROOT_PATH/repo.git" \
				refs/heads/unrelated$i:refs/heads/unrelated$i &&
			git push -q ../clone/.git \
				refs/heads/unrelated$i:refs/heads/unrelated$i ||
			exit 1
		done &&
		git checkout master &&
		test_commit new &&
		git push  "$HTTPD_DOCUMENT_ROOT_PATH/repo.git" master
	) &&
	(
		cd clone &&
		git checkout --orphan newnew &&
		test_commit new-too &&
		GIT_TRACE_PACKET="$TRASH_DIRECTORY/trace" git fetch --depth=2 &&
		grep "fetch-pack< ACK .* ready" ../trace &&
		! grep "fetch-pack> done" ../trace
	)
'

test_expect_success 'clone shallow since ...' '
	test_create_repo shallow-since &&
	(
	cd shallow-since &&
	GIT_COMMITTER_DATE="100000000 +0700" git commit --allow-empty -m one &&
	GIT_COMMITTER_DATE="200000000 +0700" git commit --allow-empty -m two &&
	GIT_COMMITTER_DATE="300000000 +0700" git commit --allow-empty -m three &&
	mv .git "$HTTPD_DOCUMENT_ROOT_PATH/shallow-since.git" &&
	git clone --shallow-since "300000000 +0700" $HTTPD_URL/smart/shallow-since.git ../shallow11 &&
	git -C ../shallow11 log --pretty=tformat:%s HEAD >actual &&
	echo three >expected &&
	test_cmp expected actual
	)
'

test_expect_success 'fetch shallow since ...' '
	git -C shallow11 fetch --shallow-since "200000000 +0700" origin &&
	git -C shallow11 log --pretty=tformat:%s origin/master >actual &&
	cat >expected <<-\EOF &&
	three
	two
	EOF
	test_cmp expected actual
'

test_expect_success 'shallow clone exclude tag two' '
	test_create_repo shallow-exclude &&
	(
	cd shallow-exclude &&
	test_commit one &&
	test_commit two &&
	test_commit three &&
	mv .git "$HTTPD_DOCUMENT_ROOT_PATH/shallow-exclude.git" &&
	git clone --shallow-exclude two $HTTPD_URL/smart/shallow-exclude.git ../shallow12 &&
	git -C ../shallow12 log --pretty=tformat:%s HEAD >actual &&
	echo three >expected &&
	test_cmp expected actual
	)
'

test_expect_success 'fetch exclude tag one' '
	git -C shallow12 fetch --shallow-exclude one origin &&
	git -C shallow12 log --pretty=tformat:%s origin/master >actual &&
	test_write_lines three two >expected &&
	test_cmp expected actual
'

test_expect_success 'fetching deepen' '
	test_create_repo shallow-deepen &&
	(
	cd shallow-deepen &&
	test_commit one &&
	test_commit two &&
	test_commit three &&
	mv .git "$HTTPD_DOCUMENT_ROOT_PATH/shallow-deepen.git" &&
	git clone --depth 1 $HTTPD_URL/smart/shallow-deepen.git deepen &&
	mv "$HTTPD_DOCUMENT_ROOT_PATH/shallow-deepen.git" .git &&
	test_commit four &&
	git -C deepen log --pretty=tformat:%s master >actual &&
	echo three >expected &&
	test_cmp expected actual &&
	mv .git "$HTTPD_DOCUMENT_ROOT_PATH/shallow-deepen.git" &&
	git -C deepen fetch --deepen=1 &&
	git -C deepen log --pretty=tformat:%s origin/master >actual &&
	cat >expected <<-\EOF &&
	four
	three
	two
	EOF
	test_cmp expected actual
	)
'

stop_httpd
test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"fetch/clone from a shallow clone over http">)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (C {(.)} {(./test-lib.sh)})
    (C {(.)} {(DQ ($ VSub_Name "$TEST_DIRECTORY")) (/lib-httpd.sh)})
    (C {(start_httpd)})
    (FuncDef
      name: commit
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_Number "$1"))}]
                  redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(tracked)} spids:[37])]
                )
                (AndOr
                  children: [
                    (C {(git)} {(add)} {(tracked)})
                    (C {(git)} {(commit)} {(-m)} {(DQ ($ VSub_Number "$1"))})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [28]
        )
      spids: [24 27]
    )
    (C {(test_expect_success)} {(SQ <"setup shallow clone">)} 
      {
        (SQ <"\n"> <"\tcommit 1 &&\n"> <"\tcommit 2 &&\n"> <"\tcommit 3 &&\n"> <"\tcommit 4 &&\n"> 
          <"\tcommit 5 &&\n"> <"\tcommit 6 &&\n"> <"\tcommit 7 &&\n"> <"\tgit clone --no-local --depth=5 .git shallow &&\n"> 
          <"\tgit config --global transfer.fsckObjects true\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"clone http repository">)} 
      {
        (SQ <"\n"> 
          <"\tgit clone --bare --no-local shallow \"$HTTPD_DOCUMENT_ROOT_PATH/repo.git\" &&\n"> <"\tgit clone $HTTPD_URL/smart/repo.git clone &&\n"> <"\t(\n"> <"\tcd clone &&\n"> <"\tgit fsck &&\n"> 
          <"\tgit log --format=%s origin/master >actual &&\n"> <"\tcat <<EOF >expect &&\n"> <"7\n"> <"6\n"> <"5\n"> <"4\n"> <"3\n"> <"EOF\n"> 
          <"\ttest_cmp expect actual\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"no shallow lines after receiving ACK ready">)} 
      {
        (SQ <"\n"> <"\t(\n"> <"\t\tcd shallow &&\n"> <"\t\ttest_tick &&\n"> 
          <"\t\tfor i in $(test_seq 15)\n"> <"\t\tdo\n"> <"\t\t\tgit checkout --orphan unrelated$i &&\n"> <"\t\t\ttest_commit unrelated$i &&\n"> 
          <"\t\t\tgit push -q \"$HTTPD_DOCUMENT_ROOT_PATH/repo.git\" \\\n"> <"\t\t\t\trefs/heads/unrelated$i:refs/heads/unrelated$i &&\n"> 
          <"\t\t\tgit push -q ../clone/.git \\\n"> <"\t\t\t\trefs/heads/unrelated$i:refs/heads/unrelated$i ||\n"> <"\t\t\texit 1\n"> <"\t\tdone &&\n"> 
          <"\t\tgit checkout master &&\n"> <"\t\ttest_commit new &&\n"> <"\t\tgit push  \"$HTTPD_DOCUMENT_ROOT_PATH/repo.git\" master\n"> 
          <"\t) &&\n"> <"\t(\n"> <"\t\tcd clone &&\n"> <"\t\tgit checkout --orphan newnew &&\n"> 
          <"\t\ttest_commit new-too &&\n"> <"\t\tGIT_TRACE_PACKET=\"$TRASH_DIRECTORY/trace\" git fetch --depth=2 &&\n"> 
          <"\t\tgrep \"fetch-pack< ACK .* ready\" ../trace &&\n"> <"\t\t! grep \"fetch-pack> done\" ../trace\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"clone shallow since ...">)} 
      {
        (SQ <"\n"> <"\ttest_create_repo shallow-since &&\n"> <"\t(\n"> <"\tcd shallow-since &&\n"> 
          <"\tGIT_COMMITTER_DATE=\"100000000 +0700\" git commit --allow-empty -m one &&\n"> <"\tGIT_COMMITTER_DATE=\"200000000 +0700\" git commit --allow-empty -m two &&\n"> 
          <"\tGIT_COMMITTER_DATE=\"300000000 +0700\" git commit --allow-empty -m three &&\n"> <"\tmv .git \"$HTTPD_DOCUMENT_ROOT_PATH/shallow-since.git\" &&\n"> 
          <
"\tgit clone --shallow-since \"300000000 +0700\" $HTTPD_URL/smart/shallow-since.git ../shallow11 &&\n"
          > <"\tgit -C ../shallow11 log --pretty=tformat:%s HEAD >actual &&\n"> <"\techo three >expected &&\n"> 
          <"\ttest_cmp expected actual\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fetch shallow since ...">)} 
      {
        (SQ <"\n"> <"\tgit -C shallow11 fetch --shallow-since \"200000000 +0700\" origin &&\n"> 
          <"\tgit -C shallow11 log --pretty=tformat:%s origin/master >actual &&\n"> <"\tcat >expected <<-\\EOF &&\n"> <"\tthree\n"> <"\ttwo\n"> <"\tEOF\n"> <"\ttest_cmp expected actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"shallow clone exclude tag two">)} 
      {
        (SQ <"\n"> <"\ttest_create_repo shallow-exclude &&\n"> <"\t(\n"> <"\tcd shallow-exclude &&\n"> 
          <"\ttest_commit one &&\n"> <"\ttest_commit two &&\n"> <"\ttest_commit three &&\n"> 
          <"\tmv .git \"$HTTPD_DOCUMENT_ROOT_PATH/shallow-exclude.git\" &&\n"> <"\tgit clone --shallow-exclude two $HTTPD_URL/smart/shallow-exclude.git ../shallow12 &&\n"> 
          <"\tgit -C ../shallow12 log --pretty=tformat:%s HEAD >actual &&\n"> <"\techo three >expected &&\n"> <"\ttest_cmp expected actual\n"> <"\t)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fetch exclude tag one">)} 
      {
        (SQ <"\n"> <"\tgit -C shallow12 fetch --shallow-exclude one origin &&\n"> 
          <"\tgit -C shallow12 log --pretty=tformat:%s origin/master >actual &&\n"> <"\ttest_write_lines three two >expected &&\n"> <"\ttest_cmp expected actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fetching deepen">)} 
      {
        (SQ <"\n"> <"\ttest_create_repo shallow-deepen &&\n"> <"\t(\n"> <"\tcd shallow-deepen &&\n"> 
          <"\ttest_commit one &&\n"> <"\ttest_commit two &&\n"> <"\ttest_commit three &&\n"> 
          <"\tmv .git \"$HTTPD_DOCUMENT_ROOT_PATH/shallow-deepen.git\" &&\n"> <"\tgit clone --depth 1 $HTTPD_URL/smart/shallow-deepen.git deepen &&\n"> 
          <"\tmv \"$HTTPD_DOCUMENT_ROOT_PATH/shallow-deepen.git\" .git &&\n"> <"\ttest_commit four &&\n"> <"\tgit -C deepen log --pretty=tformat:%s master >actual &&\n"> 
          <"\techo three >expected &&\n"> <"\ttest_cmp expected actual &&\n"> 
          <"\tmv .git \"$HTTPD_DOCUMENT_ROOT_PATH/shallow-deepen.git\" &&\n"> <"\tgit -C deepen fetch --deepen=1 &&\n"> 
          <"\tgit -C deepen log --pretty=tformat:%s origin/master >actual &&\n"> <"\tcat >expected <<-\\EOF &&\n"> <"\tfour\n"> <"\tthree\n"> <"\ttwo\n"> <"\tEOF\n"> 
          <"\ttest_cmp expected actual\n"> <"\t)\n">
        )
      }
    )
    (C {(stop_httpd)})
    (C {(test_done)})
  ]
)