#!/bin/sh

global test_description := ''test automatic tag following''

source ./test-lib.sh

# End state of the repository:
#
#         T - tag1          S - tag2
#        /                 /
#   L - A ------ O ------ B
#    \   \                 \
#     \   C - origin/cat    \
#      origin/master         master

test_expect_success setup '
	test_tick &&
	echo ichi >file &&
	git add file &&
	git commit -m L &&
	L=$(git rev-parse --verify HEAD) &&

	(
		mkdir cloned &&
		cd cloned &&
		git init-db &&
		git remote add -f origin ..
	) &&

	test_tick &&
	echo A >file &&
	git add file &&
	git commit -m A &&
	A=$(git rev-parse --verify HEAD)
'

global U := 'UPLOAD_LOG'
global UPATH := ""$[pwd]/$U""

test_expect_success 'setup expect' '
cat - <<EOF >expect
want $A
EOF
'

proc get_needs {
	test -s $1 &&
	perl -alne '
		next unless $F[1] eq "upload-pack<";
		last if $F[2] eq "0000";
		print $F[2], " ", $F[3];
	' $1
}

test_expect_success 'fetch A (new commit : 1 connection)' '
	rm -f $U &&
	(
		cd cloned &&
		GIT_TRACE_PACKET=$UPATH git fetch &&
		test $A = $(git rev-parse --verify origin/master)
	) &&
	get_needs $U >actual &&
	test_cmp expect actual
'

test_expect_success "create tag T on A, create C on branch cat" '
	git tag -a -m tag1 tag1 $A &&
	T=$(git rev-parse --verify tag1) &&

	git checkout -b cat &&
	echo C >file &&
	git add file &&
	git commit -m C &&
	C=$(git rev-parse --verify HEAD) &&
	git checkout master
'

test_expect_success 'setup expect' '
cat - <<EOF >expect
want $C
want $T
EOF
'

test_expect_success 'fetch C, T (new branch, tag : 1 connection)' '
	rm -f $U &&
	(
		cd cloned &&
		GIT_TRACE_PACKET=$UPATH git fetch &&
		test $C = $(git rev-parse --verify origin/cat) &&
		test $T = $(git rev-parse --verify tag1) &&
		test $A = $(git rev-parse --verify tag1^0)
	) &&
	get_needs $U >actual &&
	test_cmp expect actual
'

test_expect_success "create commits O, B, tag S on B" '
	test_tick &&
	echo O >file &&
	git add file &&
	git commit -m O &&

	test_tick &&
	echo B >file &&
	git add file &&
	git commit -m B &&
	B=$(git rev-parse --verify HEAD) &&

	git tag -a -m tag2 tag2 $B &&
	S=$(git rev-parse --verify tag2)
'

test_expect_success 'setup expect' '
cat - <<EOF >expect
want $B
want $S
EOF
'

test_expect_success 'fetch B, S (commit and tag : 1 connection)' '
	rm -f $U &&
	(
		cd cloned &&
		GIT_TRACE_PACKET=$UPATH git fetch &&
		test $B = $(git rev-parse --verify origin/master) &&
		test $B = $(git rev-parse --verify tag2^0) &&
		test $S = $(git rev-parse --verify tag2)
	) &&
	get_needs $U >actual &&
	test_cmp expect actual
'

test_expect_success 'setup expect' '
cat - <<EOF >expect
want $B
want $S
EOF
'

test_expect_success 'new clone fetch master and tags' '
	test_might_fail git branch -D cat &&
	rm -f $U &&
	(
		mkdir clone2 &&
		cd clone2 &&
		git init &&
		git remote add origin .. &&
		GIT_TRACE_PACKET=$UPATH git fetch &&
		test $B = $(git rev-parse --verify origin/master) &&
		test $S = $(git rev-parse --verify tag2) &&
		test $B = $(git rev-parse --verify tag2^0) &&
		test $T = $(git rev-parse --verify tag1) &&
		test $A = $(git rev-parse --verify tag1^0)
	) &&
	get_needs $U >actual &&
	test_cmp expect actual
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"test automatic tag following">)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (C {(.)} {(./test-lib.sh)})
    (C {(test_expect_success)} {(setup)} 
      {
        (SQ <"\n"> <"\ttest_tick &&\n"> <"\techo ichi >file &&\n"> <"\tgit add file &&\n"> 
          <"\tgit commit -m L &&\n"> <"\tL=$(git rev-parse --verify HEAD) &&\n"> <"\n"> <"\t(\n"> <"\t\tmkdir cloned &&\n"> 
          <"\t\tcd cloned &&\n"> <"\t\tgit init-db &&\n"> <"\t\tgit remote add -f origin ..\n"> <"\t) &&\n"> <"\n"> <"\ttest_tick &&\n"> 
          <"\techo A >file &&\n"> <"\tgit add file &&\n"> <"\tgit commit -m A &&\n"> <"\tA=$(git rev-parse --verify HEAD)\n">
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:U) op:Equal rhs:{(UPLOAD_LOG)} spids:[67])]
      spids: [67]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:UPATH)
          op: Equal
          rhs: 
            {
              (DQ 
                (CommandSubPart
                  command_list: (CommandList children:[(C {(pwd)})])
                  left_token: <Left_CommandSub "$(">
                  spids: [72 74]
                ) (/) ($ VSub_Name "$U")
              )
            }
          spids: [70]
        )
      ]
      spids: [70]
    )
    (C {(test_expect_success)} {(SQ <"setup expect">)} 
      {(SQ <"\n"> <"cat - <<EOF >expect\n"> <"want $A\n"> <"EOF\n">)}
    )
    (FuncDef
      name: get_needs
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Number "$1"))})
                (C {(perl)} {(-alne)} 
                  {
                    (SQ <"\n"> <"\t\tnext unless $F[1] eq \"upload-pack<\";\n"> 
                      <"\t\tlast if $F[2] eq \"0000\";\n"> <"\t\tprint $F[2], \" \", $F[3];\n"> <"\t">
                    )
                  } {(DQ ($ VSub_Number "$1"))}
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [99]
        )
      spids: [94 98]
    )
    (C {(test_expect_success)} {(SQ <"fetch A (new commit : 1 connection)">)} 
      {
        (SQ <"\n"> <"\trm -f $U &&\n"> <"\t(\n"> <"\t\tcd cloned &&\n"> 
          <"\t\tGIT_TRACE_PACKET=$UPATH git fetch &&\n"> <"\t\ttest $A = $(git rev-parse --verify origin/master)\n"> <"\t) &&\n"> 
          <"\tget_needs $U >actual &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(DQ ("create tag T on A, create C on branch cat"))} 
      {
        (SQ <"\n"> <"\tgit tag -a -m tag1 tag1 $A &&\n"> <"\tT=$(git rev-parse --verify tag1) &&\n"> 
          <"\n"> <"\tgit checkout -b cat &&\n"> <"\techo C >file &&\n"> <"\tgit add file &&\n"> 
          <"\tgit commit -m C &&\n"> <"\tC=$(git rev-parse --verify HEAD) &&\n"> <"\tgit checkout master\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"setup expect">)} 
      {(SQ <"\n"> <"cat - <<EOF >expect\n"> <"want $C\n"> <"want $T\n"> <"EOF\n">)}
    )
    (C {(test_expect_success)} {(SQ <"fetch C, T (new branch, tag : 1 connection)">)} 
      {
        (SQ <"\n"> <"\trm -f $U &&\n"> <"\t(\n"> <"\t\tcd cloned &&\n"> 
          <"\t\tGIT_TRACE_PACKET=$UPATH git fetch &&\n"> <"\t\ttest $C = $(git rev-parse --verify origin/cat) &&\n"> 
          <"\t\ttest $T = $(git rev-parse --verify tag1) &&\n"> <"\t\ttest $A = $(git rev-parse --verify tag1^0)\n"> <"\t) &&\n"> <"\tget_needs $U >actual &&\n"> 
          <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(DQ ("create commits O, B, tag S on B"))} 
      {
        (SQ <"\n"> <"\ttest_tick &&\n"> <"\techo O >file &&\n"> <"\tgit add file &&\n"> 
          <"\tgit commit -m O &&\n"> <"\n"> <"\ttest_tick &&\n"> <"\techo B >file &&\n"> <"\tgit add file &&\n"> <"\tgit commit -m B &&\n"> 
          <"\tB=$(git rev-parse --verify HEAD) &&\n"> <"\n"> <"\tgit tag -a -m tag2 tag2 $B &&\n"> <"\tS=$(git rev-parse --verify tag2)\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"setup expect">)} 
      {(SQ <"\n"> <"cat - <<EOF >expect\n"> <"want $B\n"> <"want $S\n"> <"EOF\n">)}
    )
    (C {(test_expect_success)} {(SQ <"fetch B, S (commit and tag : 1 connection)">)} 
      {
        (SQ <"\n"> <"\trm -f $U &&\n"> <"\t(\n"> <"\t\tcd cloned &&\n"> 
          <"\t\tGIT_TRACE_PACKET=$UPATH git fetch &&\n"> <"\t\ttest $B = $(git rev-parse --verify origin/master) &&\n"> 
          <"\t\ttest $B = $(git rev-parse --verify tag2^0) &&\n"> <"\t\ttest $S = $(git rev-parse --verify tag2)\n"> <"\t) &&\n"> <"\tget_needs $U >actual &&\n"> 
          <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"setup expect">)} 
      {(SQ <"\n"> <"cat - <<EOF >expect\n"> <"want $B\n"> <"want $S\n"> <"EOF\n">)}
    )
    (C {(test_expect_success)} {(SQ <"new clone fetch master and tags">)} 
      {
        (SQ <"\n"> <"\ttest_might_fail git branch -D cat &&\n"> <"\trm -f $U &&\n"> <"\t(\n"> 
          <"\t\tmkdir clone2 &&\n"> <"\t\tcd clone2 &&\n"> <"\t\tgit init &&\n"> <"\t\tgit remote add origin .. &&\n"> 
          <"\t\tGIT_TRACE_PACKET=$UPATH git fetch &&\n"> <"\t\ttest $B = $(git rev-parse --verify origin/master) &&\n"> 
          <"\t\ttest $S = $(git rev-parse --verify tag2) &&\n"> <"\t\ttest $B = $(git rev-parse --verify tag2^0) &&\n"> 
          <"\t\ttest $T = $(git rev-parse --verify tag1) &&\n"> <"\t\ttest $A = $(git rev-parse --verify tag1^0)\n"> <"\t) &&\n"> <"\tget_needs $U >actual &&\n"> 
          <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_done)})
  ]
)