#!/bin/sh
#
# Copyright (c) 2007 Eric Wong
# Based on a script by Joakim Tjernlund <joakim.tjernlund@transmode.se>

test_description='git-svn dcommit handles merges'

. ./lib-git-svn.sh

big_text_block () {
cat << EOF
#
# (C) Copyright 2000 - 2005
# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
#
# See file CREDITS for list of people who contributed to this
# project.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of
# the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
# MA 02111-1307 USA
#
EOF
}

test_expect_success 'setup svn repository' "
	svn co $svnrepo mysvnwork &&
	mkdir -p mysvnwork/trunk &&
	cd mysvnwork &&
		big_text_block >> trunk/README &&
		svn add trunk &&
		svn ci -m 'first commit' trunk &&
		cd ..
	"

test_expect_success 'setup git mirror and merge' "
	git svn init $svnrepo -t tags -T trunk -b branches &&
	git svn fetch &&
	git checkout --track -b svn remotes/trunk &&
	git checkout -b merge &&
	echo new file > new_file &&
	git add new_file &&
	git commit -a -m 'New file' &&
	echo hello >> README &&
	git commit -a -m 'hello' &&
	echo add some stuff >> new_file &&
	git commit -a -m 'add some stuff' &&
	git checkout svn &&
	mv -f README tmp &&
	echo friend > README &&
	cat tmp >> README &&
	git commit -a -m 'friend' &&
	git pull . merge
	"

test_debug 'gitk --all & sleep 1'

test_expect_success 'verify pre-merge ancestry' "
	test x\`git rev-parse --verify refs/heads/svn^2\` = \
	     x\`git rev-parse --verify refs/heads/merge\` &&
	git cat-file commit refs/heads/svn^ | grep '^friend$'
	"

test_expect_success 'git svn dcommit merges' "
	git svn dcommit
	"

test_debug 'gitk --all & sleep 1'

test_expect_success 'verify post-merge ancestry' "
	test x\`git rev-parse --verify refs/heads/svn\` = \
	     x\`git rev-parse --verify refs/remotes/trunk \` &&
	test x\`git rev-parse --verify refs/heads/svn^2\` = \
	     x\`git rev-parse --verify refs/heads/merge\` &&
	git cat-file commit refs/heads/svn^ | grep '^friend$'
	"

test_expect_success 'verify merge commit message' "
	git rev-list --pretty=raw -1 refs/heads/svn | \
	  grep \"    Merge branch 'merge' into svn\"
	"

test_done
