#!/bin/sh

global test_description := ''git merge

Testing pull.* configuration parsing.''

source ./test-lib.sh

test_expect_success 'setup' '
	echo c0 >c0.c &&
	git add c0.c &&
	git commit -m c0 &&
	git tag c0 &&
	echo c1 >c1.c &&
	git add c1.c &&
	git commit -m c1 &&
	git tag c1 &&
	git reset --hard c0 &&
	echo c2 >c2.c &&
	git add c2.c &&
	git commit -m c2 &&
	git tag c2 &&
	git reset --hard c0 &&
	echo c3 >c3.c &&
	git add c3.c &&
	git commit -m c3 &&
	git tag c3
'

test_expect_success 'merge c1 with c2' '
	git reset --hard c1 &&
	test -f c0.c &&
	test -f c1.c &&
	test ! -f c2.c &&
	test ! -f c3.c &&
	git merge c2 &&
	test -f c1.c &&
	test -f c2.c
'

test_expect_success 'fast-forward pull succeeds with "true" in pull.ff' '
	git reset --hard c0 &&
	test_config pull.ff true &&
	git pull . c1 &&
	test "$(git rev-parse HEAD)" = "$(git rev-parse c1)"
'

test_expect_success 'pull.ff=true overrides merge.ff=false' '
	git reset --hard c0 &&
	test_config merge.ff false &&
	test_config pull.ff true &&
	git pull . c1 &&
	test "$(git rev-parse HEAD)" = "$(git rev-parse c1)"
'

test_expect_success 'fast-forward pull creates merge with "false" in pull.ff' '
	git reset --hard c0 &&
	test_config pull.ff false &&
	git pull . c1 &&
	test "$(git rev-parse HEAD^1)" = "$(git rev-parse c0)" &&
	test "$(git rev-parse HEAD^2)" = "$(git rev-parse c1)"
'

test_expect_success 'pull prevents non-fast-forward with "only" in pull.ff' '
	git reset --hard c1 &&
	test_config pull.ff only &&
	test_must_fail git pull . c3
'

test_expect_success 'merge c1 with c2 (ours in pull.twohead)' '
	git reset --hard c1 &&
	git config pull.twohead ours &&
	git merge c2 &&
	test -f c1.c &&
	! test -f c2.c
'

test_expect_success 'merge c1 with c2 and c3 (recursive in pull.octopus)' '
	git reset --hard c1 &&
	git config pull.octopus "recursive" &&
	test_must_fail git merge c2 c3 &&
	test "$(git rev-parse c1)" = "$(git rev-parse HEAD)"
'

test_expect_success 'merge c1 with c2 and c3 (recursive and octopus in pull.octopus)' '
	git reset --hard c1 &&
	git config pull.octopus "recursive octopus" &&
	git merge c2 c3 &&
	test "$(git rev-parse c1)" != "$(git rev-parse HEAD)" &&
	test "$(git rev-parse c1)" = "$(git rev-parse HEAD^1)" &&
	test "$(git rev-parse c2)" = "$(git rev-parse HEAD^2)" &&
	test "$(git rev-parse c3)" = "$(git rev-parse HEAD^3)" &&
	git diff --exit-code &&
	test -f c0.c &&
	test -f c1.c &&
	test -f c2.c &&
	test -f c3.c
'

proc conflict_count
{
	do {
		git diff-files --name-only
		git ls-files --unmerged
	} | wc -l
}

# c4 - c5
#    \ c6
#
# There are two conflicts here:
#
# 1) Because foo.c is renamed to bar.c, recursive will handle this,
# resolve won't.
#
# 2) One in conflict.c and that will always fail.

test_expect_success 'setup conflicted merge' '
	git reset --hard c0 &&
	echo A >conflict.c &&
	git add conflict.c &&
	echo contents >foo.c &&
	git add foo.c &&
	git commit -m c4 &&
	git tag c4 &&
	echo B >conflict.c &&
	git add conflict.c &&
	git mv foo.c bar.c &&
	git commit -m c5 &&
	git tag c5 &&
	git reset --hard c4 &&
	echo C >conflict.c &&
	git add conflict.c &&
	echo secondline >> foo.c &&
	git add foo.c &&
	git commit -m c6 &&
	git tag c6
'

# First do the merge with resolve and recursive then verify that
# recursive is chosen.

test_expect_success 'merge picks up the best result' '
	git config --unset-all pull.twohead &&
	git reset --hard c5 &&
	test_must_fail git merge -s resolve c6 &&
	resolve_count=$(conflict_count) &&
	git reset --hard c5 &&
	test_must_fail git merge -s recursive c6 &&
	recursive_count=$(conflict_count) &&
	git reset --hard c5 &&
	test_must_fail git merge -s recursive -s resolve c6 &&
	auto_count=$(conflict_count) &&
	test $auto_count = $recursive_count &&
	test $auto_count != $resolve_count
'

test_expect_success 'merge picks up the best result (from config)' '
	git config pull.twohead "recursive resolve" &&
	git reset --hard c5 &&
	test_must_fail git merge -s resolve c6 &&
	resolve_count=$(conflict_count) &&
	git reset --hard c5 &&
	test_must_fail git merge -s recursive c6 &&
	recursive_count=$(conflict_count) &&
	git reset --hard c5 &&
	test_must_fail git merge c6 &&
	auto_count=$(conflict_count) &&
	test $auto_count = $recursive_count &&
	test $auto_count != $resolve_count
'

test_expect_success 'merge errors out on invalid strategy' '
	git config pull.twohead "foobar" &&
	git reset --hard c5 &&
	test_must_fail git merge c6
'

test_expect_success 'merge errors out on invalid strategy' '
	git config --unset-all pull.twohead &&
	git reset --hard c5 &&
	test_must_fail git merge -s "resolve recursive" c6
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"git merge\n"> <"\n"> <"Testing pull.* configuration parsing.">)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (C {(.)} {(./test-lib.sh)})
    (C {(test_expect_success)} {(SQ <setup>)} 
      {
        (SQ <"\n"> <"\techo c0 >c0.c &&\n"> <"\tgit add c0.c &&\n"> <"\tgit commit -m c0 &&\n"> 
          <"\tgit tag c0 &&\n"> <"\techo c1 >c1.c &&\n"> <"\tgit add c1.c &&\n"> <"\tgit commit -m c1 &&\n"> <"\tgit tag c1 &&\n"> 
          <"\tgit reset --hard c0 &&\n"> <"\techo c2 >c2.c &&\n"> <"\tgit add c2.c &&\n"> <"\tgit commit -m c2 &&\n"> <"\tgit tag c2 &&\n"> 
          <"\tgit reset --hard c0 &&\n"> <"\techo c3 >c3.c &&\n"> <"\tgit add c3.c &&\n"> <"\tgit commit -m c3 &&\n"> <"\tgit tag c3\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge c1 with c2">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c1 &&\n"> <"\ttest -f c0.c &&\n"> <"\ttest -f c1.c &&\n"> 
          <"\ttest ! -f c2.c &&\n"> <"\ttest ! -f c3.c &&\n"> <"\tgit merge c2 &&\n"> <"\ttest -f c1.c &&\n"> <"\ttest -f c2.c\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fast-forward pull succeeds with \"true\" in pull.ff">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c0 &&\n"> <"\ttest_config pull.ff true &&\n"> 
          <"\tgit pull . c1 &&\n"> <"\ttest \"$(git rev-parse HEAD)\" = \"$(git rev-parse c1)\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"pull.ff=true overrides merge.ff=false">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c0 &&\n"> <"\ttest_config merge.ff false &&\n"> 
          <"\ttest_config pull.ff true &&\n"> <"\tgit pull . c1 &&\n"> <"\ttest \"$(git rev-parse HEAD)\" = \"$(git rev-parse c1)\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"fast-forward pull creates merge with \"false\" in pull.ff">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c0 &&\n"> <"\ttest_config pull.ff false &&\n"> 
          <"\tgit pull . c1 &&\n"> <"\ttest \"$(git rev-parse HEAD^1)\" = \"$(git rev-parse c0)\" &&\n"> 
          <"\ttest \"$(git rev-parse HEAD^2)\" = \"$(git rev-parse c1)\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"pull prevents non-fast-forward with \"only\" in pull.ff">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c1 &&\n"> <"\ttest_config pull.ff only &&\n"> 
          <"\ttest_must_fail git pull . c3\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge c1 with c2 (ours in pull.twohead)">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c1 &&\n"> <"\tgit config pull.twohead ours &&\n"> 
          <"\tgit merge c2 &&\n"> <"\ttest -f c1.c &&\n"> <"\t! test -f c2.c\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge c1 with c2 and c3 (recursive in pull.octopus)">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c1 &&\n"> <"\tgit config pull.octopus \"recursive\" &&\n"> 
          <"\ttest_must_fail git merge c2 c3 &&\n"> <"\ttest \"$(git rev-parse c1)\" = \"$(git rev-parse HEAD)\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"merge c1 with c2 and c3 (recursive and octopus in pull.octopus)">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c1 &&\n"> 
          <"\tgit config pull.octopus \"recursive octopus\" &&\n"> <"\tgit merge c2 c3 &&\n"> <"\ttest \"$(git rev-parse c1)\" != \"$(git rev-parse HEAD)\" &&\n"> 
          <"\ttest \"$(git rev-parse c1)\" = \"$(git rev-parse HEAD^1)\" &&\n"> <"\ttest \"$(git rev-parse c2)\" = \"$(git rev-parse HEAD^2)\" &&\n"> 
          <"\ttest \"$(git rev-parse c3)\" = \"$(git rev-parse HEAD^3)\" &&\n"> <"\tgit diff --exit-code &&\n"> <"\ttest -f c0.c &&\n"> <"\ttest -f c1.c &&\n"> <"\ttest -f c2.c &&\n"> 
          <"\ttest -f c3.c\n">
        )
      }
    )
    (FuncDef
      name: conflict_count
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (BraceGroup
                  children: [
                    (C {(git)} {(diff-files)} {(--name-only)})
                    (C {(git)} {(ls-files)} {(--unmerged)})
                  ]
                  spids: [187]
                )
                (C {(wc)} {(-l)})
              ]
              negated: False
            )
          ]
          spids: [184]
        )
      spids: [180 183]
    )
    (C {(test_expect_success)} {(SQ <"setup conflicted merge">)} 
      {
        (SQ <"\n"> <"\tgit reset --hard c0 &&\n"> <"\techo A >conflict.c &&\n"> 
          <"\tgit add conflict.c &&\n"> <"\techo contents >foo.c &&\n"> <"\tgit add foo.c &&\n"> <"\tgit commit -m c4 &&\n"> 
          <"\tgit tag c4 &&\n"> <"\techo B >conflict.c &&\n"> <"\tgit add conflict.c &&\n"> <"\tgit mv foo.c bar.c &&\n"> 
          <"\tgit commit -m c5 &&\n"> <"\tgit tag c5 &&\n"> <"\tgit reset --hard c4 &&\n"> <"\techo C >conflict.c &&\n"> 
          <"\tgit add conflict.c &&\n"> <"\techo secondline >> foo.c &&\n"> <"\tgit add foo.c &&\n"> <"\tgit commit -m c6 &&\n"> 
          <"\tgit tag c6\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge picks up the best result">)} 
      {
        (SQ <"\n"> <"\tgit config --unset-all pull.twohead &&\n"> <"\tgit reset --hard c5 &&\n"> 
          <"\ttest_must_fail git merge -s resolve c6 &&\n"> <"\tresolve_count=$(conflict_count) &&\n"> <"\tgit reset --hard c5 &&\n"> 
          <"\ttest_must_fail git merge -s recursive c6 &&\n"> <"\trecursive_count=$(conflict_count) &&\n"> <"\tgit reset --hard c5 &&\n"> 
          <"\ttest_must_fail git merge -s recursive -s resolve c6 &&\n"> <"\tauto_count=$(conflict_count) &&\n"> <"\ttest $auto_count = $recursive_count &&\n"> 
          <"\ttest $auto_count != $resolve_count\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge picks up the best result (from config)">)} 
      {
        (SQ <"\n"> <"\tgit config pull.twohead \"recursive resolve\" &&\n"> 
          <"\tgit reset --hard c5 &&\n"> <"\ttest_must_fail git merge -s resolve c6 &&\n"> <"\tresolve_count=$(conflict_count) &&\n"> 
          <"\tgit reset --hard c5 &&\n"> <"\ttest_must_fail git merge -s recursive c6 &&\n"> <"\trecursive_count=$(conflict_count) &&\n"> 
          <"\tgit reset --hard c5 &&\n"> <"\ttest_must_fail git merge c6 &&\n"> <"\tauto_count=$(conflict_count) &&\n"> 
          <"\ttest $auto_count = $recursive_count &&\n"> <"\ttest $auto_count != $resolve_count\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge errors out on invalid strategy">)} 
      {
        (SQ <"\n"> <"\tgit config pull.twohead \"foobar\" &&\n"> <"\tgit reset --hard c5 &&\n"> 
          <"\ttest_must_fail git merge c6\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"merge errors out on invalid strategy">)} 
      {
        (SQ <"\n"> <"\tgit config --unset-all pull.twohead &&\n"> <"\tgit reset --hard c5 &&\n"> 
          <"\ttest_must_fail git merge -s \"resolve recursive\" c6\n">
        )
      }
    )
    (C {(test_done)})
  ]
)