#

exec 2>&1
set -x
set -o pipefail

. tests/lib-core
. tests/lib-restricts

t-set-intree

: ${DGIT_TEST_DEBUG=-D}
export DGIT_TEST_DEBUG

root=`pwd`
troot=$root/tests
testname="${DGIT_TEST_TESTNAME-${0##*/}}"

tmp=$ADTTMP
if [ x"$tmp" = x ]; then
	mkdir -p tests/tmp
	tmp=tests/tmp/$testname
	rm -rf $tmp
	mkdir $tmp
fi
cd $tmp

tmp=`pwd`

t-set-using-tmp

ln -f $troot/ssh ssh

mkdir -p $tmp/gnupg
cp $troot/gnupg/* $tmp/gnupg
chmod go-rw $tmp/gnupg/*

export DEBCHANGE_VENDOR=dpkg

mkdir -p $tmp/incoming
cat <<END >$tmp/dput.cf
[test-dummy]
method			= local
incoming		= $tmp/incoming
run_dinstall		= 0
END

t-expect-fail () {
	local mpat="$1"; shift

	set +o pipefail
	LC_MESSAGES=C "$@" 2>&1 | tee $tmp/t.output
	local ps="${PIPESTATUS[*]}"
	set -o pipefail

	case $ps in
	"0 0")	fail "command unexpectedly succeeded (instead of: $mpat)" ;;
	*" 0")	;;
	*)	fail "tee failed"  ;;
	esac

	t-grep-mpat "$mpat" $tmp/t.output
}

t-grep-mpat () {
	local mpat="$1"
	local file="$2"

	local grepper=fgrep
	case "$mpat" in
	[A-Z]:*)
		case "$mpat" in
		E:*)	grepper=egrep	;;
		F:*)	grepper=fgrep	;;
		*)	fail "bad mpat prefix in $mpat";;
		esac
		mpat=${mpat#[A-Z]:}
		;;
	esac

	$grepper -e "$mpat" "$file" ||
		fail "message not found"
}

t-expect-push-fail () {
	local mpat="$1"; shift

	local triedpush=`git rev-parse HEAD`

	t-reporefs pre-push
	t-expect-fail "$mpat"  "$@"
	t-reporefs post-push
	diff $tmp/show-refs.{pre,post}-push

	t-git-objects-not-present '' $triedpush

	eval "$t_expect_push_fail_hook"
}

t-git-objects-not-present () {
	# t-git-objects-not-present GITDIR|'' OBJID [...]
	# specifying '' means the repo for package $p
	local gitdir="${1-$dgitrepo}"
	local obj
	if ! [ -e "$gitdir" ]; then return; fi
	for obj in "$@"; do
		GIT_DIR=$gitdir \
		t-expect-fail 'unable to find' \
		git cat-file -t $obj
	done
}

t-reporefs () {
	local whichoutput=$1; shift
	local whichrepo=${1-$dgitrepo}
	local outputfile="$tmp/show-refs.$whichoutput"
	(set -e
	 exec >"$outputfile"
	 if test -d $whichrepo; then
		cd $whichrepo
		git show-ref |sort
	fi)
}

t-untar () {
	local tarfile=$1.tar
	local edittree=$1.edit
	if test -d "$edittree"; then
		cp -al "$edittree"/* .
	else
		tar xf "$tarfile"
	fi
}

t-worktree () {
	rm -rf $p
	t-untar $troot/worktrees/${p}_$1
}

t-select-package () {
	p=$1
	dgitrepo=$tmp/git/$p.git
}

t-git () {
	t-select-package $1
	v=$2
	mkdir -p $tmp/git
	local gs=$troot/git-srcs/${p}_$v.git
	(set -e; cd $tmp/git; t-untar $gs)
}

t-git-none () {
	mkdir -p $tmp/git
	(set -e; cd $tmp/git; tar xf $troot/git-template.tar)
}

t-git-merge-base () {
	git merge-base $1 $2 || test $? = 1
}

t-has-ancestor () {
	local now=`git rev-parse HEAD`
	local ancestor=`git rev-parse $1^{}`
	local mbase=`t-git-merge-base $ancestor $now`
	if [ x$mbase != x$ancestor ]; then
		fail "not ff $ancestor..$now, $mbase != $ancestor"
	fi
}

t-prep-newpackage () {
	t-select-package $1
	v=$2
	t-archive-none $p
	t-git-none
	t-worktree $v
	cd $p
	if ! git show-ref --verify --quiet refs/heads/master; then
		git branch -m dgit/sid master
		git remote rm dgit
	fi
	cd ..
}

t-archive-none () {
	t-select-package $1
	mkdir -p $tmp/aq $tmp/mirror/pool/main

	local suite=sid

	>$tmp/aq/package.$suite.$p
	t-archive-updated $suite $p

	>$tmp/aq/package.new.$p
	t-archive-updated new $p

	ln -s sid $tmp/aq/dsc_in_suite/unstable
	cat <<'END' >$tmp/aq/suites
[
   {
      "archive" : "ftp-master",
      "codename" : "sid",
      "components" : [
         "main",
         "contrib",
         "non-free"
      ],
      "name" : "unstable",
      "dakname" : "unstable"
   }
]
END
}

t-archive-updated () {
	local suite=$1
	local p=$2
	local suitedir=$tmp/aq/dsc_in_suite/$suite
	mkdir -p $suitedir
	perl <$tmp/aq/package.$suite.$p >$suitedir/$p -wne '
		use JSON;
		use strict;
		our @v;
		m{^(\S+) (\w+) ([^ \t/]+)/(\S+)} or die;
		push @v, {
			"version" => "$1",
			"sha256sum" => "$2",
			"component" => "$3",
			"filename" => "$4",
		};
		END {
			print to_json \@v or die $!;
		}
	'
}

t-archive-process-incoming () {
	local suite=$1
	mv $tmp/incoming/${p}_${v}[._]* $tmp/mirror/pool/main/
	t-archive-query "$suite"
}

t-archive-query () {
	local suite=${1-sid}
	local dscf=main/${p}_${v}.dsc
	local sha=`sha256sum <$tmp/mirror/pool/$dscf`
	echo "${v} ${sha%  -} $dscf" >>$tmp/aq/package.$suite.${p}
	t-archive-updated $suite $p
}

t-archive () {
	t-archive-none $1
	v=$2
	local dscf=${p}_$2.dsc
	rm -f $tmp/mirror/pool/main/${p}_*
	ln $troot/pkg-srcs/${p}_${2%-*}* $tmp/mirror/pool/main/
	t-archive-query
	rm -rf $tmp/extract
	mkdir $tmp/extract
	(set -e; cd $tmp/extract; dpkg-source -x ../mirror/pool/main/$dscf)
}

t-git-dir-time-passes () {
	touch -d 'last year' $dgitrepo
}

t-git-dir-check () {
	local gitdir=$dgitrepo
	case "$1" in
	enoent)
		if test -e "$gitdir"; then fail "$gitdir exists"; fi
		return
		;;
	public) wantstat='7[75]5' ;;
	secret)	wantstat='7[70]0' ;;
	*)	fail "$1 t-git-dir-check ?" ;;
	esac
	gotstat=`stat -c%a $gitdir`
	case "$gotstat" in
	*$wantstat) return ;;
	*)	fail "$gitdir has mode $gotstat, expected $wantstat" ;;
	esac
}

t-rm-dput-dropping () {
	rm -f $tmp/${p}_${v}_*.upload
}

t-dgit () {
	local dgit=${DGIT_TEST-dgit}
	pwd
	: '
{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{'
	$dgit --dgit=$dgit --dget:-u --dput:--config=$tmp/dput.cf \
		-dtest-dummy $DGIT_TEST_OPTS $DGIT_TEST_DEBUG \
		-k39B13D8A "$@"
	: '}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
'
}

t-diff-nogit () {
	diff --exclude=.git --exclude=.pc -ruN $*
}

t-files-notexist () {
	local f
	for f in "$@"; do
		if [ -e $f ]; then
			fail "$f exists!"
		fi
	done
}

t-cloned-fetched-good () {
	t-diff-nogit ../extract/$p-${v%-*} .
	t-clean-on-branch dgit/sid
	t-refs-same-start
	t-refs-same \
		refs/heads/dgit/sid \
		refs/remotes/dgit/dgit/sid
	t-refs-notexist refs/dgit/unstable refs/remotes/dgit/dgit/unstable
}

t-output () {
	printf "%s\n" "$1" >$tmp/t.want
	shift
	"$@" >$tmp/t.got
	diff $tmp/t.want $tmp/t.got
}

t-clean-on-branch () {
	t-output "## $1" git status -b --porcelain
}

t-git-get-ref-exact () {
	local ref=$1
	# does not dereference, unlike t-git-get-ref
	case "$ref" in
	refs/*) ;;
	*) fail "t-git-get-ref-exact bad $ref" ;;
	esac
	git for-each-ref --format='%(objectname)' "[r]efs/${ref#refs/}"
}

t-git-get-ref () {
	local ref=$1
	case "$ref" in
	refs/*)	;;
	*) fail "t-git-get-ref bad $ref" ;;
	esac
	(git show-ref -d $1 || test $? = 1) | perl -ne '
		$x = $1 if m#^(\w+) \Q'$1'\E(?:\^\{\})?$#;
		END { print "$x\n" if length $x; }
	'
}

t-ref-same-exact () {
	local name="$1"
	local val=`t-git-get-ref-exact $name`
	t-ref-same-val "$name" $val
}

t-ref-same () {
	local name="$1"
	local val=`t-git-get-ref $name`
	t-ref-same-val "$name" $val
}

t-ref-head () {
	local val=`git rev-parse HEAD`
	t-ref-same-val HEAD $val
}

t-ref-same-val () {
	local name="$1"
	local val=$2
	case "$t_ref_val" in
	'')		;;
	"$val")		;;
	*)		fail "ref varies: $name: $val != $t_ref_val" ;;
	esac
	t_ref_val="$val"
}

t-refs-same-start () {
	t_ref_val=''
}

t-refs-same () {
	local g
	for g in $*; do
		t-ref-same $g
	done
}

t-refs-notexist () {
	local val
	for g in $*; do
		val=`t-git-get-ref $g`
		if [ "x$val" != x ]; then
			fail "ref $g unexpectedly exists ($val)"
		fi
	done
}

t-v-tag () {
	echo refs/tags/test-dummy/${v//\~/_}
}

t-check-pushed-master () {
	local master=`t-git-get-ref refs/heads/master`
	if [ x$master = x$t_ref_val ]; then return; fi
	if [ x$master = x ]; then fail "failed to push master"; fi
	# didn't update master, it must be not FF
	local mbase=`t-git-merge-base $master $t_ref_val`
	if [ x$mbase = x$master ]; then fail "failed to ff master"; fi
}

t-pushed-good () {
	local branch=$1
	t-ref-dsc-dgit
	t-refs-same \
		refs/heads/$branch \
		`t-v-tag` \
		refs/remotes/dgit/dgit/sid
	t-refs-notexist \
		refs/heads/dgit/unstable \
		refs/remotes/dgit/dgit/unstable
	(set -e; cd $dgitrepo
	 t-refs-same \
		refs/dgit/sid \
		`t-v-tag`
	 ${t_check_pushed_master:- : NOT-DRS-NO-CHECK-PUSHED-MASTER}
	 t-refs-notexist \
		refs/dgit/unstable
	)
	git verify-tag `t-v-tag`
}

t-commit-build-push-expect-log () {
	local msg=$1
	local mpat=$2
	t-commit "$msg"
	t-dgit build
	LC_MESSAGES=C \
	t-dgit push --new 2>&1 |tee $tmp/push.log
	t-grep-mpat "$mpat" $tmp/push.log
}

t-822-field () {
	local file=$1
	local field=$2
	perl -e '
		use Dpkg::Control::Hash;
		my $h = new Dpkg::Control::Hash allow_pgp=>1;
		$h->parse(\*STDIN,"'"$file"'");
		my $val = $h->{"'$field'"},"\n";
		die "'"$file $field"'" unless defined $val;
		print $val,"\n";
	' <$file
}

t-stunt-envvar () {
	local var=$1
	local tstunt=$2
	eval '
		case "'$var'" in
		"$tstunt:"*)	;;
		*":$tstunt:"*)	;;
		*)		'$var'="$tstunt:$'$var'" ;;
		esac
	'
}

t-tstunt () {
	local tstunt=$tmp/tstunt
	t-stunt-envvar PATH $tstunt
	t-stunt-envvar PERLLIB $tstunt
	local f
	for f in "$@"; do
		f="./$f"
		local d="$tstunt/${f%/*}"
		mkdir -p $d
		ln -sf "$troot/tstunt/$f" "$d"/.
	done
}

t-tstunt-parsechangelog () {
	t-tstunt dpkg-parsechangelog Dpkg/Changelog/Parse.pm
}

t-ref-dsc-dgit () {
	local dsc=${p}_${v}.dsc
	local val=`t-822-field $tmp/incoming/$dsc Dgit`
	perl -e '$_=shift @ARGV; die "$dsc Dgit $_ ?" unless m/^\w+\b/;' "$val"
	t-ref-same-val $dsc "$val"
}

t-apply-diff () {
	local v1=$1
	local v2=$2
	(cd $troot/pkg-srcs;
	 debdiff ${p}_${v1}.dsc ${p}_${v2}.dsc || test $? = 1) \
	 | patch -p1 -u
}

t-commit () {
	local msg=$1
	v=${2-1.$revision}
	dch -v$v --distribution unstable "$1"
	git add debian/changelog
	debcommit
	revision=$(( ${revision-0} + 1 ))
}

t-git-config () {
	git config --global "$@"
}

t-drs () {
	export DGIT_TEST_TROOT=$troot
 t-git-config dgit-distro.test-dummy.git-url "ext::$troot/drs-git-ext %S "
 t-git-config dgit-distro.test-dummy.git-check true
 t-git-config dgit-distro.test-dummy.git-create true
	cp $troot/gnupg/{dd.gpg,dm.gpg,dm.txt} $tmp/.
	cp $troot/suites $tmp/.
	cp $troot/suites $tmp/suites-master

	export t_check_pushed_master=t-check-pushed-master

	drs_dispatch=$tmp/distro=test-dummy
	mkdir $drs_dispatch

	if [ "x$DGIT_TEST_INTREE" != x ]; then
		ln -sf "$DGIT_TEST_INTREE" $drs_dispatch/dgit-live
	fi

	ln -sf $tmp/git $drs_dispatch/repos
	ln -sf $tmp/suites $tmp/suites-master $tmp/dm.txt $drs_dispatch/
	mkdir -p $drs_dispatch/keyrings
	ln -sf $tmp/dd.gpg $drs_dispatch/keyrings/debian-keyring.gpg
	ln -sf $tmp/dm.gpg $drs_dispatch/keyrings/debian-maintainers.gpg
	ln -sf /bin/true $drs_dispatch/policy-hook
}

t-dsd () {
	t-drs
 t-git-config dgit-distro.test-dummy.ssh "$troot/dsd-ssh"
 t-git-config dgit-distro.test-dummy.git-check ssh-cmd
 t-git-config dgit-distro.test-dummy.git-create true
 t-git-config dgit-distro.test-dummy.git-url \
		"ext::$troot/dsd-ssh X %S /dgit/test-dummy/repos"

 t-git-config dgit-distro.test-dummy.diverts.drs /drs
 t-git-config dgit-distro.test-dummy/drs.ssh "$troot/ssh"
 t-git-config dgit-distro.test-dummy/drs.git-url $tmp/git
 t-git-config dgit-distro.test-dummy/drs.git-check ssh-cmd
 t-git-config dgit-distro.test-dummy/drs.git-create ssh-cmd

	echo 'no-such-package* drs' >$drs_dispatch/diverts
}

t-policy-admin () {
	${DGIT_INFRA_PFX}dgit-repos-admin-debian --repos $tmp/git "$@"
}

t-policy-nonexist () {
	ln -sf no-such-file-or-directory $drs_dispatch/policy-hook
}

t-make-hook-link () {
	local hook=$1 # in infra/
	local linkpath=$2
	hook=${DGIT_INFRA_PFX}$hook
	case $hook in
	*/*) 	;;
	*)	hook=`type -P $hook` ;;
	esac
	ln -sf "$hook" $linkpath
}

t-policy () {
	local policyhook=$1
	t-make-hook-link $policyhook $drs_dispatch/policy-hook
}

t-debpolicy () {
	t-dsd
	t-policy dgit-repos-policy-debian

	mkdir $tmp/git
	t-policy-admin create-db
}

t-policy-periodic () {
	${DGIT_REPOS_SERVER_TEST-dgit-repos-server} \
		test-dummy $drs_dispatch '' --cron
}

t-restrict () {
	local restriction=$1
	(cd $root; t-restriction-$restriction >&2)
}

t-dependencies () {
	: "Hopefully installed: $*"
}

t-chain-test () {
	local ct=$1
	local d=${0%/*}
	cd $root
	export DGIT_TEST_TESTNAME="$testname"
	export ADTTMP=$tmp
	exec "$d/$ct"
}	

t-alt-test () {
	local t=${0##*/}
	t-${t%%-*}
	t-chain-test "${t#*-}"
}
