#!/bin/sh
#
# Blackbox tests for the "net registry" and "net rpc registry" commands.
#
# Copyright (C) 2010-2011 Michael Adam <obnox@samba.org>
# Copyright (C) 2010 Gregor Beck <gbeck@sernet.de>
#
# rpc tests are chose by specifying "rpc" as commandline parameter.

if [ $# -lt 3 ]; then
	cat <<EOF
Usage: test_net_registry.sh SCRIPTDIR SERVERCONFFILE NET CONFIGURATION RPC
EOF
	exit 1
fi

SCRIPTDIR="$1"
SERVERCONFFILE="$2"
NET="$3"
CONFIGURATION="$4"
RPC="$5"

NET="$VALGRIND ${NET:-$BINDIR/net} $CONFIGURATION"

if test "x${RPC}" = "xrpc"; then
	NETREG="${NET} -U${USERNAME}%${PASSWORD} -I ${SERVER_IP} rpc registry"
else
	NETREG="${NET} registry"
fi

incdir=$(dirname $0)/../../../testprogs/blackbox
. $incdir/subunit.sh

failed=0

test_enumerate()
{
	KEY="$1"

	${NETREG} enumerate ${KEY}
}

test_getsd()
{
	KEY="$1"

	${NETREG} getsd ${KEY}
}

test_enumerate_nonexisting()
{
	KEY="$1"
	${NETREG} enumerate ${KEY}

	if test "x$?" = "x0"; then
		echo "ERROR: enumerate succeeded with key '${KEY}'"
		false
	else
		true
	fi
}

test_enumerate_no_key()
{
	${NETREG} enumerate
	if test "x$?" = "x0"; then
		echo "ERROR: enumerate succeeded without any key specified"
		false
	else
		true
	fi
}

test_create_existing()
{
	KEY="HKLM"
	EXPECTED="createkey opened existing ${KEY}"

	OUTPUT=$(${NETREG} createkey ${KEY})
	if test "x$?" = "x0"; then
		if test "$OUTPUT" = "$EXPECTED"; then
			true
		else
			echo "got '$OUTPUT', expected '$EXPECTED'"
			false
		fi
	else
		printf "%s\n" "$OUTPUT"
		false
	fi
}

test_createkey()
{
	KEY="$1"
	BASEKEY=$(dirname $KEY)
	SUBKEY=$(basename $KEY)

	OUTPUT=$(${NETREG} createkey ${KEY})
	if test "x$?" != "x0"; then
		echo "ERROR: createkey ${KEY} failed"
		echo "output:"
		printf "%s\n" "$OUTPUT"
		false
		return
	fi

	# check enumerate of basekey lists new key:
	OUTPUT=$(${NETREG} enumerate ${BASEKEY})
	if test "x$?" != "x0"; then
		echo "ERROR: failed to enumerate key '${BASEKEY}'"
		echo "output:"
		printf "%s\n" "$OUTPUT"
		false
		return
	fi

	EXPECTED="Keyname = ${SUBKEY}"
	printf "%s\n" "$OUTPUT" | grep '^Keyname' | grep ${SUBKEY}
	if test "x$?" != "x0"; then
		echo "ERROR: did not find expected '$EXPECTED' in output"
		echo "output:"
		printf "%s\n" "$OUTPUT"
		false
	fi

	# check enumerate of new key works:
	${NETREG} enumerate ${KEY}
}

test_deletekey()
{
	KEY="$1"
	BASEKEY=$(dirname ${KEY})
	SUBKEY=$(basename ${KEY})

	OUTPUT=$(test_createkey "${KEY}")
	if test "x$?" != "x0"; then
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	OUTPUT=$(${NETREG} deletekey ${KEY})
	if test "x$?" != "x0"; then
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	# check enumerate of basekey does not show key anymore:
	OUTPUT=$(${NETREG} enumerate ${BASEKEY})
	if test "x$?" != "x0"; then
		printf "%s\n" "$OUTPUT"
		false
		return
	fi

	UNEXPECTED="Keyname = ${SUBKEY}"
	printf "%s\n" "$OUTPUT" | grep '^Keyname' | grep ${SUBKEY}
	if test "x$?" = "x0"; then
		echo "ERROR: found '$UNEXPECTED' after delete in output"
		echo "output:"
		printf "%s\n" "$OUTPUT"
		false
	fi

	# check enumerate of key itself does not work anymore:
	${NETREG} enumerate ${KEY}
	if test "x$?" = "x0"; then
		echo "ERROR: 'enumerate ${KEY}' works after 'deletekey ${KEY}'"
		false
	else
		true
	fi
}

test_deletekey_nonexisting()
{
	KEY="$1"

	OUTPUT=$(test_deletekey "${KEY}")
	if test "x$?" != "x0"; then
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	${NETREG} deletekey "${KEY}"
	if test "x$?" = "x0"; then
		echo "ERROR: delete after delete succeeded for key '${KEY}'"
		false
	fi
}

test_createkey_with_subkey()
{
	KEY="$1"
	KEY2=$(dirname ${KEY})
	SUBKEYNAME2=$(basename ${KEY})
	BASENAME=$(dirname ${KEY2})
	SUBKEYNAME1=$(basename ${KEY2})

	OUTPUT=$(${NETREG} createkey ${KEY})
	if test "x$?" != "x0"; then
		echo "ERROR: createkey ${KEY} failed"
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	# check we can enumerate to level key
	OUTPUT=$(${NETREG} enumerate ${KEY})
	if test "x$?" != "x0"; then
		echo "ERROR: failed to enumerate '${KEY}' after creation"
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	# clear:
	${NETREG} deletekey ${KEY} && ${NETREG} deletekey ${KEY2}
}

test_deletekey_with_subkey()
{
	KEY="$1"
	KEY2=$(dirname ${KEY})

	OUTPUT=$(${NETREG} createkey ${KEY})
	if test "x$?" != "x0"; then
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	OUTPUT=$(${NETREG} deletekey ${KEY2})

	if test "x$?" = "x0"; then
		echo "ERROR: delete of key with subkey succeeded"
		echo "output:"
		printf "%s\n" "$OUTPUT"
		false
		return
	fi

	${NETREG} deletekey ${KEY} && ${NETREG} deletekey ${KEY2}
}

test_setvalue()
{
	KEY="$1"
	VALNAME="${2#_}"
	VALTYPE="$3"
	VALVALUE="$4"

	OUTPUT=$(test_createkey ${KEY})
	if test "x$?" != "x0"; then
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	OUTPUT=$(${NETREG} setvalue ${KEY} "${VALNAME}" ${VALTYPE} ${VALVALUE})
	if test "x$?" != "x0"; then
		echo "ERROR: failed to set value testval in key ${KEY}"
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	OUTPUT=$(${NETREG} getvalueraw ${KEY} "${VALNAME}")
	if test "x$?" != "x0"; then
		echo "ERROR: failure calling getvalueraw for key ${KEY}"
		echo output:
		printf "%s\n" "${OUTPUT}"
		false
		return
	fi

	if test "x${OUTPUT}" != "x${VALVALUE}"; then
		echo "ERROR: failure retrieving value ${VALNAME} for key ${KEY}"
		printf "expected: %s\ngot: %s\n" "${VALVALUE}" "${OUTPUT}"
		false
		return
	fi

}

test_deletevalue()
{
	KEY="$1"
	VALNAME="${2#_}"

	${NETREG} deletevalue ${KEY} "${VALNAME}"
}

test_deletevalue_nonexisting()
{
	KEY="$1"
	VALNAME="${2#_}"

	${NETREG} deletevalue ${KEY} "${VALNAME}"
	if test "x$?" = "x0"; then
		echo "ERROR: succeeded deleting value ${VALNAME}"
		false
	else
		true
	fi
}

test_setvalue_twice()
{
	KEY="$1"
	VALNAME="${2#_}"
	VALTYPE1="$3"
	VALVALUE1="$4"
	VALTYPE2="$5"
	VALVALUE2="$6"

	OUTPUT=$(test_setvalue ${KEY} _"${VALNAME}" ${VALTYPE1} ${VALVALUE1})
	if test "x$?" != "x0"; then
		echo "ERROR: first setvalue call failed"
		printf "%s\n" "$OUTPUT"
		false
		return
	fi

	${NETREG} setvalue ${KEY} "${VALNAME}" ${VALTYPE2} ${VALVALUE2}
}

testit "enumerate HKLM" \
	test_enumerate HKLM ||
	failed=$(expr $failed + 1)

testit "enumerate nonexisting hive" \
	test_enumerate_nonexisting XYZ ||
	failed=$(expr $failed + 1)

testit "enumerate without key" \
	test_enumerate_no_key ||
	failed=$(expr $failed + 1)

# skip getsd test for registry currently: it fails
if test "x${RPC}" != "xrpc"; then
	testit "getsd HKLM" \
		test_getsd HKLM ||
		failed=$(expr $failed + 1)
fi

testit "create existing HKLM" \
	test_create_existing ||
	failed=$(expr $failed + 1)

testit "create key" \
	test_createkey HKLM/testkey ||
	failed=$(expr $failed + 1)

testit "delete key" \
	test_deletekey HKLM/testkey ||
	failed=$(expr $failed + 1)

testit "delete^2 key" \
	test_deletekey_nonexisting HKLM/testkey ||
	failed=$(expr $failed + 1)

testit "enumerate nonexisting key" \
	test_enumerate_nonexisting HKLM/testkey ||
	failed=$(expr $failed + 1)

testit "create key with subkey" \
	test_createkey_with_subkey HKLM/testkey/subkey ||
	failed=$(expr $failed + 1)

testit "delete key with subkey" \
	test_deletekey_with_subkey HKLM/testkey/subkey ||
	failed=$(expr $failed + 1)

testit "set value" \
	test_setvalue HKLM/testkey _testval sz moin ||
	failed=$(expr $failed + 1)

testit "delete value" \
	test_deletevalue HKLM/testkey _testval ||
	failed=$(expr $failed + 1)

testit "delete nonexisting value" \
	test_deletevalue_nonexisting HKLM/testkey _testval ||
	failed=$(expr $failed + 1)

testit "set value to different type" \
	test_setvalue_twice HKLM/testkey testval sz moin dword 42 ||
	failed=$(expr $failed + 1)

testit "set default value" \
	test_setvalue HKLM/testkey _"" sz 42 ||
	failed=$(expr $failed + 1)

testit "delete default value" \
	test_deletevalue HKLM/testkey _"" ||
	failed=$(expr $failed + 1)

testit "delete nonexisting default value" \
	test_deletevalue_nonexisting HKLM/testkey _"" ||
	failed=$(expr $failed + 1)

testit "delete key with value" \
	test_deletekey HKLM/testkey ||
	failed=$(expr $failed + 1)

testok $0 $failed