#!/bin/sh

global test_description := ''basic symbolic-ref tests''
source ./test-lib.sh

# If the tests munging HEAD fail, they can break detection of
# the git repo, meaning that further tests will operate on
# the surrounding git repo instead of the trash directory.
proc reset_to_sane {
	echo ref: refs/heads/foo >.git/HEAD
}

test_expect_success 'symbolic-ref writes HEAD' '
	git symbolic-ref HEAD refs/heads/foo &&
	echo ref: refs/heads/foo >expect &&
	test_cmp expect .git/HEAD
'

test_expect_success 'symbolic-ref reads HEAD' '
	echo refs/heads/foo >expect &&
	git symbolic-ref HEAD >actual &&
	test_cmp expect actual
'

test_expect_success 'symbolic-ref refuses non-ref for HEAD' '
	test_must_fail git symbolic-ref HEAD foo
'
reset_to_sane

test_expect_success 'symbolic-ref refuses bare sha1' '
	echo content >file && git add file && git commit -m one &&
	test_must_fail git symbolic-ref HEAD $(git rev-parse HEAD)
'
reset_to_sane

test_expect_success 'HEAD cannot be removed' '
	test_must_fail git symbolic-ref -d HEAD
'

reset_to_sane

test_expect_success 'symbolic-ref can be deleted' '
	git symbolic-ref NOTHEAD refs/heads/foo &&
	git symbolic-ref -d NOTHEAD &&
	test_path_is_file .git/refs/heads/foo &&
	test_path_is_missing .git/NOTHEAD
'
reset_to_sane

test_expect_success 'symbolic-ref can delete dangling symref' '
	git symbolic-ref NOTHEAD refs/heads/missing &&
	git symbolic-ref -d NOTHEAD &&
	test_path_is_missing .git/refs/heads/missing &&
	test_path_is_missing .git/NOTHEAD
'
reset_to_sane

test_expect_success 'symbolic-ref fails to delete missing FOO' '
	echo "fatal: Cannot delete FOO, not a symbolic ref" >expect &&
	test_must_fail git symbolic-ref -d FOO >actual 2>&1 &&
	test_cmp expect actual
'
reset_to_sane

test_expect_success 'symbolic-ref fails to delete real ref' '
	echo "fatal: Cannot delete refs/heads/foo, not a symbolic ref" >expect &&
	test_must_fail git symbolic-ref -d refs/heads/foo >actual 2>&1 &&
	test_path_is_file .git/refs/heads/foo &&
	test_cmp expect actual
'
reset_to_sane

test_expect_success 'create large ref name' '
	# make 256+ character ref; some systems may not handle that,
	# so be gentle
	long=0123456789abcdef &&
	long=$long/$long/$long/$long &&
	long=$long/$long/$long/$long &&
	long_ref=refs/heads/$long &&
	tree=$(git write-tree) &&
	commit=$(echo foo | git commit-tree $tree) &&
	if git update-ref $long_ref $commit; then
		test_set_prereq LONG_REF
	else
		echo >&2 "long refs not supported"
	fi
'

test_expect_success LONG_REF 'symbolic-ref can point to large ref name' '
	git symbolic-ref HEAD $long_ref &&
	echo $long_ref >expect &&
	git symbolic-ref HEAD >actual &&
	test_cmp expect actual
'

test_expect_success LONG_REF 'we can parse long symbolic ref' '
	echo $commit >expect &&
	git rev-parse --verify HEAD >actual &&
	test_cmp expect actual
'

test_expect_success 'symbolic-ref reports failure in exit code' '
	test_when_finished "rm -f .git/HEAD.lock" &&
	>.git/HEAD.lock &&
	test_must_fail git symbolic-ref HEAD refs/heads/whatever
'

test_expect_success 'symbolic-ref writes reflog entry' '
	git checkout -b log1 &&
	test_commit one &&
	git checkout -b log2  &&
	test_commit two &&
	git checkout --orphan orphan &&
	git symbolic-ref -m create HEAD refs/heads/log1 &&
	git symbolic-ref -m update HEAD refs/heads/log2 &&
	cat >expect <<-\EOF &&
	update
	create
	EOF
	git log --format=%gs -g -2 >actual &&
	test_cmp expect actual
'

test_expect_success 'symbolic-ref does not create ref d/f conflicts' '
	git checkout -b df &&
	test_commit df &&
	test_must_fail git symbolic-ref refs/heads/df/conflict refs/heads/df &&
	git pack-refs --all --prune &&
	test_must_fail git symbolic-ref refs/heads/df/conflict refs/heads/df
'

test_expect_success 'symbolic-ref handles existing pointer to invalid name' '
	head=$(git rev-parse HEAD) &&
	git symbolic-ref HEAD refs/heads/outer &&
	git update-ref refs/heads/outer/inner $head &&
	git symbolic-ref HEAD refs/heads/unrelated
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"basic symbolic-ref tests">)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (C {(.)} {(./test-lib.sh)})
    (FuncDef
      name: reset_to_sane
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(echo)} {(ref) (Lit_Other ":")} {(refs/heads/foo)}]
              redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(.git/HEAD)} spids:[37])]
            )
          ]
          spids: [27]
        )
      spids: [23 26]
    )
    (C {(test_expect_success)} {(SQ <"symbolic-ref writes HEAD">)} 
      {
        (SQ <"\n"> <"\tgit symbolic-ref HEAD refs/heads/foo &&\n"> 
          <"\techo ref: refs/heads/foo >expect &&\n"> <"\ttest_cmp expect .git/HEAD\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"symbolic-ref reads HEAD">)} 
      {
        (SQ <"\n"> <"\techo refs/heads/foo >expect &&\n"> <"\tgit symbolic-ref HEAD >actual &&\n"> 
          <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"symbolic-ref refuses non-ref for HEAD">)} 
      {(SQ <"\n"> <"\ttest_must_fail git symbolic-ref HEAD foo\n">)}
    )
    (C {(reset_to_sane)})
    (C {(test_expect_success)} {(SQ <"symbolic-ref refuses bare sha1">)} 
      {
        (SQ <"\n"> <"\techo content >file && git add file && git commit -m one &&\n"> 
          <"\ttest_must_fail git symbolic-ref HEAD $(git rev-parse HEAD)\n">
        )
      }
    )
    (C {(reset_to_sane)})
    (C {(test_expect_success)} {(SQ <"HEAD cannot be removed">)} 
      {(SQ <"\n"> <"\ttest_must_fail git symbolic-ref -d HEAD\n">)}
    )
    (C {(reset_to_sane)})
    (C {(test_expect_success)} {(SQ <"symbolic-ref can be deleted">)} 
      {
        (SQ <"\n"> <"\tgit symbolic-ref NOTHEAD refs/heads/foo &&\n"> 
          <"\tgit symbolic-ref -d NOTHEAD &&\n"> <"\ttest_path_is_file .git/refs/heads/foo &&\n"> <"\ttest_path_is_missing .git/NOTHEAD\n">
        )
      }
    )
    (C {(reset_to_sane)})
    (C {(test_expect_success)} {(SQ <"symbolic-ref can delete dangling symref">)} 
      {
        (SQ <"\n"> <"\tgit symbolic-ref NOTHEAD refs/heads/missing &&\n"> 
          <"\tgit symbolic-ref -d NOTHEAD &&\n"> <"\ttest_path_is_missing .git/refs/heads/missing &&\n"> <"\ttest_path_is_missing .git/NOTHEAD\n">
        )
      }
    )
    (C {(reset_to_sane)})
    (C {(test_expect_success)} {(SQ <"symbolic-ref fails to delete missing FOO">)} 
      {
        (SQ <"\n"> <"\techo \"fatal: Cannot delete FOO, not a symbolic ref\" >expect &&\n"> 
          <"\ttest_must_fail git symbolic-ref -d FOO >actual 2>&1 &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(reset_to_sane)})
    (C {(test_expect_success)} {(SQ <"symbolic-ref fails to delete real ref">)} 
      {
        (SQ <"\n"> <"\techo \"fatal: Cannot delete refs/heads/foo, not a symbolic ref\" >expect &&\n"> 
          <"\ttest_must_fail git symbolic-ref -d refs/heads/foo >actual 2>&1 &&\n"> <"\ttest_path_is_file .git/refs/heads/foo &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(reset_to_sane)})
    (C {(test_expect_success)} {(SQ <"create large ref name">)} 
      {
        (SQ <"\n"> <"\t# make 256+ character ref; some systems may not handle that,\n"> 
          <"\t# so be gentle\n"> <"\tlong=0123456789abcdef &&\n"> <"\tlong=$long/$long/$long/$long &&\n"> 
          <"\tlong=$long/$long/$long/$long &&\n"> <"\tlong_ref=refs/heads/$long &&\n"> <"\ttree=$(git write-tree) &&\n"> 
          <"\tcommit=$(echo foo | git commit-tree $tree) &&\n"> <"\tif git update-ref $long_ref $commit; then\n"> <"\t\ttest_set_prereq LONG_REF\n"> <"\telse\n"> 
          <"\t\techo >&2 \"long refs not supported\"\n"> <"\tfi\n">
        )
      }
    )
    (C {(test_expect_success)} {(LONG_REF)} {(SQ <"symbolic-ref can point to large ref name">)} 
      {
        (SQ <"\n"> <"\tgit symbolic-ref HEAD $long_ref &&\n"> <"\techo $long_ref >expect &&\n"> 
          <"\tgit symbolic-ref HEAD >actual &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(LONG_REF)} {(SQ <"we can parse long symbolic ref">)} 
      {
        (SQ <"\n"> <"\techo $commit >expect &&\n"> <"\tgit rev-parse --verify HEAD >actual &&\n"> 
          <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"symbolic-ref reports failure in exit code">)} 
      {
        (SQ <"\n"> <"\ttest_when_finished \"rm -f .git/HEAD.lock\" &&\n"> <"\t>.git/HEAD.lock &&\n"> 
          <"\ttest_must_fail git symbolic-ref HEAD refs/heads/whatever\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"symbolic-ref writes reflog entry">)} 
      {
        (SQ <"\n"> <"\tgit checkout -b log1 &&\n"> <"\ttest_commit one &&\n"> 
          <"\tgit checkout -b log2  &&\n"> <"\ttest_commit two &&\n"> <"\tgit checkout --orphan orphan &&\n"> 
          <"\tgit symbolic-ref -m create HEAD refs/heads/log1 &&\n"> <"\tgit symbolic-ref -m update HEAD refs/heads/log2 &&\n"> <"\tcat >expect <<-\\EOF &&\n"> 
          <"\tupdate\n"> <"\tcreate\n"> <"\tEOF\n"> <"\tgit log --format=%gs -g -2 >actual &&\n"> <"\ttest_cmp expect actual\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"symbolic-ref does not create ref d/f conflicts">)} 
      {
        (SQ <"\n"> <"\tgit checkout -b df &&\n"> <"\ttest_commit df &&\n"> 
          <"\ttest_must_fail git symbolic-ref refs/heads/df/conflict refs/heads/df &&\n"> <"\tgit pack-refs --all --prune &&\n"> 
          <"\ttest_must_fail git symbolic-ref refs/heads/df/conflict refs/heads/df\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"symbolic-ref handles existing pointer to invalid name">)} 
      {
        (SQ <"\n"> <"\thead=$(git rev-parse HEAD) &&\n"> 
          <"\tgit symbolic-ref HEAD refs/heads/outer &&\n"> <"\tgit update-ref refs/heads/outer/inner $head &&\n"> 
          <"\tgit symbolic-ref HEAD refs/heads/unrelated\n">
        )
      }
    )
    (C {(test_done)})
  ]
)