Public Git Hosting - Samba.git/blob - ctdb/tests/run

1 #!/usr/bin/env bash

3 usage() {

4 cat <<EOF

5 Usage: $0 [OPTIONS] [TESTS]

7 Options:

8 -A Use "cat -A" to print test output (only some tests)

9 -c Run integration tests on a cluster

10 -C Clean up when done by removing test state directory (see -V)

11 -D Show diff between failed/expected test output (some tests only)

12 -e Exit on the first test failure

13 -H No headers - for running single test with other wrapper

14 -I <count> Iterate tests <count> times, exiting on failure (implies -e, -N)

15 -N Don't print summary of tests results after running all tests

16 -q Quiet - don't show tests being run (still displays summary)

17 -S <lib> Use socket wrapper library <lib> for local integration tests

18 -v Verbose - print test output for non-failures (only some tests)

19 -V <dir> Use <dir> as test state directory

20 -x Trace this script with the -x option

21 -X Trace certain scripts run by tests using -x (only some tests)

22 EOF

23 exit 1

24 }

26 # Print a message and exit.

27 die ()

28 {

    echo "$1" >&2 ; exit "${2:-1}"

30 }

32 ######################################################################

34 with_summary=true

35 quiet=false

36 exit_on_fail=false

37 max_iterations=1

38 no_header=false

39 test_state_dir=""

41 export TEST_VERBOSE=false

42 export TEST_COMMAND_TRACE=false

43 export TEST_CAT_RESULTS_OPTS=""

44 export TEST_DIFF_RESULTS=false

45 export TEST_LOCAL_DAEMONS

[ -n "$TEST_LOCAL_DAEMONS" ] || TEST_LOCAL_DAEMONS=3

47 export TEST_CLEANUP=false

48 export TEST_TIMEOUT=3600

49 export TEST_SOCKET_WRAPPER_SO_PATH=""

while getopts "AcCDehHI:NqS:T:vV:xX?" opt ; do

        case "$opt" in

53 A) TEST_CAT_RESULTS_OPTS="-A" ;;

54 c) TEST_LOCAL_DAEMONS="" ;;

55 C) TEST_CLEANUP=true ;;

56 D) TEST_DIFF_RESULTS=true ;;

57 e) exit_on_fail=true ;;

58 H) no_header=true ;;

        I) max_iterations="$OPTARG" ; exit_on_fail=true ; with_summary=false ;;

60 N) with_summary=false ;;

61 q) quiet=true ;;

        S) TEST_SOCKET_WRAPPER_SO_PATH="$OPTARG" ;;

        T) TEST_TIMEOUT="$OPTARG" ;;

64 v) TEST_VERBOSE=true ;;

        V) test_state_dir="$OPTARG" ;;

66 x) set -x ;;

67 X) TEST_COMMAND_TRACE=true ;;

68 \?|h) usage ;;

69 esac

70 done

shift $((OPTIND - 1))

case $(basename "$0") in

74 *run_cluster_tests*)

75 # Running on a cluster... same as -c

76 TEST_LOCAL_DAEMONS=""

77 ;;

78 esac

80 if $quiet ; then

    show_progress() { cat >/dev/null ; }

82 else

83 show_progress() { cat ; }

84 fi

86 ######################################################################

88 ctdb_test_begin ()

89 {

    local name="$1"

    teststarttime=$(date '+%s')

93 testduration=0

95 echo "--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--"

96 echo "Running test $name ($(date '+%T'))"

97 echo "--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--==--"

98 }

100 ctdb_test_end ()

101 {

    local name="$1" ; shift

    local status="$1" ; shift

104 # "$@" is command-line

105

106 local interp="SKIPPED"

107 local statstr=" (reason $*)"

    if [ -n "$status" ] ; then

        if [ "$status" -eq 0 ] ; then

110 interp="PASSED"

111 statstr=""

112 echo "ALL OK: $*"

        elif [ "$status" -eq 124 ] ; then

114 interp="TIMEOUT"

115 statstr=" (status $status)"

116 else

117 interp="FAILED"

118 statstr=" (status $status)"

119 fi

120 fi

121

    testduration=$(($(date +%s) - teststarttime))

123

124 echo "=========================================================================="

125 echo "TEST ${interp}: ${name}${statstr} (duration: ${testduration}s)"

126 echo "=========================================================================="

130 ctdb_test_run ()

    local name="$1" ; shift

133

    [ -n "$1" ] || set -- "$name"

135

136 $no_header || ctdb_test_begin "$name"

137

138 local status=0

    if [ -x "$1" ] ; then

            timeout "$TEST_TIMEOUT" "$@" || status=$?

141 else

142 echo "TEST IS NOT EXECUTABLE"

143 status=1

144 fi

145

    $no_header || ctdb_test_end "$name" "$status" "$*"

147

148 return $status

149 }

150

151 ######################################################################

152

153 tests_total=0

154 tests_passed=0

155 tests_failed=0

156

if ! type mktemp >/dev/null 2>&1 ; then

158 # Not perfect, but it will do...

159 mktemp ()

160 {

161 local dir=false

        if [ "$1" = "-d" ] ; then

163 dir=true

164 fi

        local t="${TMPDIR:-/tmp}/tmp.$$.$RANDOM"

166 (

167 umask 077

168 if $dir ; then

169 mkdir "$t"

170 else

171 : >"$t"

172 fi

173 )

174 echo "$t"

175 }

176 fi

177

178 set -o pipefail

179

180 run_one_test ()

181 {

    local f="$1"

183

    CTDB_TEST_SUITE_DIR=$(dirname "$f")

185 export CTDB_TEST_SUITE_DIR

186 # This expands the most probable problem cases like "." and "..".

    if [ "$(dirname "$CTDB_TEST_SUITE_DIR")" = "." ] ; then

            CTDB_TEST_SUITE_DIR=$(cd "$CTDB_TEST_SUITE_DIR" && pwd)

189 fi

190

191 # Set CTDB_TEST_TMP_DIR

192 #

193 # Determine the relative test suite subdirectory. The top-level

194 # test directory needs to be a prefix of the test suite directory,

195 # so make absolute versions of both.

196 local test_dir test_suite_dir reldir

    test_dir=$(cd "$CTDB_TEST_DIR" && pwd)

    test_suite_dir=$(cd "$CTDB_TEST_SUITE_DIR" && pwd)

199 reldir="${test_suite_dir#${test_dir}/}"

200

    export CTDB_TEST_TMP_DIR="${test_state_dir}/${reldir}"

    rm -rf "$CTDB_TEST_TMP_DIR"

203 mkdir -p "$CTDB_TEST_TMP_DIR"

204

    tests_total=$((tests_total + 1))

206

207 ctdb_test_run "$f" | show_progress

208 status=$?

    if [ $status -eq 0 ] ; then

        tests_passed=$((tests_passed + 1))

211 else

        tests_failed=$((tests_failed + 1))

213 fi

214 if $with_summary ; then

215 local t

        if [ $status -eq 0 ] ; then

217 t=" PASSED "

218 else

219 t="*FAILED*"

220 fi

        echo "$t $f" >>"$summary_file"

222 fi

223 }

224

225 find_and_run_one_test ()

226 {

    local t="$1"

    local dir="$2"

229

    local f="${dir}${dir:+/}${t}"

231

    if [ -d "$f" ] ; then

233 local i

        for i in "${f%/}/"*".sh" ; do

235 # Only happens if test removed (unlikely) or empty directory

            if [ ! -f "$i" ] ; then

237 break

238 fi

239 run_one_test "$i"

            if $exit_on_fail && [ $status -ne 0 ] ; then

241 break

242 fi

243 done

244 # No tests found? Not a tests directory! Not found...

        [ -n "$status" ] || status=127

    elif [ -f "$f" ] ; then

247 run_one_test "$f"

248 else

249 status=127

250 fi

251 }

252

253 run_tests ()

254 {

255 local tests=("$@")

256

        for f in "${tests[@]}" ; do

258 find_and_run_one_test "$f"

259

                if [ $status -eq 127 ] ; then

261 # Find the the top-level tests directory

                        d=$(cd "$TEST_SCRIPTS_DIR" && echo "$PWD")

                        if [ -z "$d" ] ; then

                                local t="$TEST_SCRIPTS_DIR"

                                die "Unable to find TEST_SCRIPTS_DIR=\"${t}\""

266 fi

                        tests_dir=$(dirname "$d")

268 # Strip off current directory from beginning,

269 # if there, just to make paths more friendly.

270 tests_dir="${tests_dir#${PWD}/}"

                        find_and_run_one_test "$f" "$tests_dir"

272 fi

273

                if [ $status -eq 127 ] ; then

                        die "test \"$f\" is not recognised"

276 fi

277

                if $exit_on_fail && [ $status -ne 0 ] ; then

279 return $status

280 fi

281 done

282 }

283

284 export CTDB_TEST_MODE="yes"

285

286 # Following 2 lines may be modified by installation script

287 CTDB_TESTS_ARE_INSTALLED=false

CTDB_TEST_DIR=$(dirname "$0")

289 export CTDB_TESTS_ARE_INSTALLED CTDB_TEST_DIR

290

if [ -z "$test_state_dir" ] ; then

292 if $CTDB_TESTS_ARE_INSTALLED ; then

293 test_state_dir=$(mktemp -d)

294 else

295 test_state_dir="${CTDB_TEST_DIR}/var"

296 fi

297 fi

298 mkdir -p "$test_state_dir"

299

300 summary_file="${test_state_dir}/.summary"

301 : >"$summary_file"

302

export TEST_SCRIPTS_DIR="${CTDB_TEST_DIR}/scripts"

304

305 unit_tests="

306 cunit

307 eventd

308 eventscripts

309 onnode

310 shellcheck

311 takeover

312 takeover_helper

313 tool

314 "

315

316 # If no tests specified then run some defaults

if [ -z "$1" ] ; then

        if [ -n "$TEST_LOCAL_DAEMONS" ] ; then

319 set -- UNIT simple

320 else

321 set -- simple complex

322 fi

323 fi

324

325 do_cleanup ()

326 {

327 if $TEST_CLEANUP ; then

328 echo "Removing test state directory: ${test_state_dir}"

        rm -rf "$test_state_dir"

330 else

331 echo "Not cleaning up test state directory: ${test_state_dir}"

332 fi

333 }

334

335 trap "do_cleanup ; exit 130" SIGINT

336 trap "do_cleanup ; exit 143" SIGTERM

337

338 declare -a tests

339 i=0

340 for f ; do

        if [ "$f" = "UNIT" ] ; then

                for t in $unit_tests ; do

                        tests[i++]="$t"

344 done

345 else

                tests[i++]="$f"

347 fi

348 done

349

350 iterations=0

351 # Special case: -I 0 means iterate forever (until failure)

while [ "$max_iterations" -eq 0 ] || [ $iterations -lt "$max_iterations" ] ; do

        iterations=$((iterations + 1))

354

        if [ "$max_iterations" -ne 1 ] ; then

356 echo

357 echo "##################################################"

358 echo "ITERATION ${iterations}"

359 echo "##################################################"

360 echo

361 fi

362

363 run_tests "${tests[@]}"

364 status=$?

365

        if [ $status -ne 0 ] ; then

367 break

368 fi

369 done

370

371 if $with_summary ; then

        if [ $status -eq 0 ] || ! $exit_on_fail ; then

373 echo

374 cat "$summary_file"

375 echo

                echo "${tests_passed}/${tests_total} tests passed"

377 fi

378 fi

rm -f "$summary_file"

380

381 echo

382

383 do_cleanup

384

if $no_header || $exit_on_fail ; then

386 exit $status

elif [ $tests_failed -gt 0 ] ; then

388 exit 1

389 else

390 exit 0

391 fi