jenkins/run-tests.sh

   1 #!/bin/bash
   2
   3 read -rd "\000" helpmessage <<EOF
   4 $(basename $0): Install and test Arvados components.
   5
   6 Exit non-zero if any tests fail.
   7
   8 Syntax:
   9         $(basename $0) WORKSPACE=/path/to/arvados [options]
  10
  11 Options:
  12
  13 --skip FOO     Do not test the FOO component.
  14 --only FOO     Do not test anything except the FOO component.
  15 --leave-temp   Do not remove GOPATH, virtualenv, and other temp dirs at exit.
  16                Instead, show which directories were used this time so they
  17                can be reused in subsequent invocations.
  18 --skip-install Do not run any install steps. Just run tests.
  19                You should provide GOPATH, GEMHOME, and VENVDIR options
  20                from a previous invocation if you use this option.
  21 --only-install Run specific install step
  22 WORKSPACE=path Arvados source tree to test.
  23 CONFIGSRC=path Dir with api server config files to copy into source tree.
  24                (If none given, leave config files alone in source tree.)
  25 services/api_test="TEST=test/functional/arvados/v1/collections_controller_test.rb"
  26                Restrict apiserver tests to the given file
  27 sdk/python_test="--test-suite test.test_keep_locator"
  28                Restrict Python SDK tests to the given class
  29 apps/workbench_test="TEST=test/integration/pipeline_instances_test.rb"
  30                Restrict Workbench tests to the given file
  31 services/arv-git-httpd_test="-check.vv"
  32                Show all log messages, even when tests pass (also works
  33                with services/keepstore_test etc.)
  34 ARVADOS_DEBUG=1
  35                Print more debug messages
  36 envvar=value   Set \$envvar to value. Primarily useful for WORKSPACE,
  37                *_test, and other examples shown above.
  38
  39 Assuming --skip-install is not given, all components are installed
  40 into \$GOPATH, \$VENDIR, and \$GEMHOME before running any tests. Many
  41 test suites depend on other components being installed, and installing
  42 everything tends to be quicker than debugging dependencies.
  43
  44 As a special concession to the current CI server config, CONFIGSRC
  45 defaults to $HOME/arvados-api-server if that directory exists.
  46
  47 More information and background:
  48
  49 https://arvados.org/projects/arvados/wiki/Running_tests
  50
  51 Available tests:
  52
  53 apps/workbench
  54 apps/workbench_benchmark
  55 apps/workbench_profile
  56 doc
  57 services/api
  58 services/crunchstat
  59 services/dockercleaner
  60 services/fuse
  61 services/keepproxy
  62 services/keepstore
  63 services/nodemanager
  64 services/arv-git-httpd
  65 sdk/cli
  66 sdk/python
  67 sdk/ruby
  68 sdk/go/arvadosclient
  69 sdk/go/keepclient
  70 sdk/go/streamer
  71
  72 EOF
  73
  74 # First make sure to remove any ARVADOS_ variables from the calling
  75 # environment that could interfere with the tests.
  76 unset $(env | cut -d= -f1 | grep \^ARVADOS_)
  77
  78 # Reset other variables that could affect our [tests'] behavior by
  79 # accident.
  80 GITDIR=
  81 GOPATH=
  82 VENVDIR=
  83 VENV3DIR=
  84 PYTHONPATH=
  85 GEMHOME=
  86
  87 COLUMNS=80
  88
  89 leave_temp=
  90 skip_install=
  91
  92 declare -A leave_temp
  93 clear_temp() {
  94     leaving=""
  95     for var in VENVDIR VENV3DIR GOPATH GITDIR GEMHOME
  96     do
  97         if [[ -z "${leave_temp[$var]}" ]]
  98         then
  99             if [[ -n "${!var}" ]]
 100             then
 101                 rm -rf "${!var}"
 102             fi
 103         else
 104             leaving+=" $var=\"${!var}\""
 105         fi
 106     done
 107     if [[ -n "$leaving" ]]; then
 108         echo "Leaving behind temp dirs: $leaving"
 109     fi
 110 }
 111
 112 fatal() {
 113     clear_temp
 114     echo >&2 "Fatal: $* (encountered in ${FUNCNAME[1]} at ${BASH_SOURCE[1]} line ${BASH_LINENO[0]})"
 115     exit 1
 116 }
 117
 118 report_outcomes() {
 119     for x in "${successes[@]}"
 120     do
 121         echo "Pass: $x"
 122     done
 123
 124     if [[ ${#failures[@]} == 0 ]]
 125     then
 126         echo "All test suites passed."
 127     else
 128         echo "Failures (${#failures[@]}):"
 129         for x in "${failures[@]}"
 130         do
 131             echo "Fail: $x"
 132         done
 133     fi
 134 }
 135
 136 exit_cleanly() {
 137     trap - INT
 138     create-plot-data-from-log.sh $BUILD_NUMBER "$WORKSPACE/apps/workbench/log/test.log" "$WORKSPACE/apps/workbench/log/"
 139     rotate_logfile "$WORKSPACE/apps/workbench/log/" "test.log"
 140     stop_services
 141     rotate_logfile "$WORKSPACE/services/api/log/" "test.log"
 142     report_outcomes
 143     clear_temp
 144     exit ${#failures}
 145 }
 146
 147 sanity_checks() {
 148     ( [[ -n "$WORKSPACE" ]] && [[ -d "$WORKSPACE/services" ]] ) \
 149         || fatal "WORKSPACE environment variable not set to a source directory (see: $0 --help)"
 150     echo Checking dependencies:
 151     echo -n 'virtualenv: '
 152     virtualenv --version \
 153         || fatal "No virtualenv. Try: apt-get install virtualenv"
 154     echo -n 'go: '
 155     go version \
 156         || fatal "No go binary. See http://golang.org/doc/install"
 157     echo -n 'gcc: '
 158     gcc --version | egrep ^gcc \
 159         || fatal "No gcc. Try: apt-get install build-essential"
 160     echo -n 'fuse.h: '
 161     find /usr/include -wholename '*fuse/fuse.h' \
 162         || fatal "No fuse/fuse.h. Try: apt-get install libfuse-dev"
 163     echo -n 'pyconfig.h: '
 164     find /usr/include -name pyconfig.h | egrep --max-count=1 . \
 165         || fatal "No pyconfig.h. Try: apt-get install python-dev"
 166     echo -n 'nginx: '
 167     PATH="$PATH:/sbin:/usr/sbin:/usr/local/sbin" nginx -v \
 168         || fatal "No nginx. Try: apt-get install nginx"
 169 }
 170
 171 rotate_logfile() {
 172   # i.e.  rotate_logfile "$WORKSPACE/apps/workbench/log/" "test.log"
 173   # $BUILD_NUMBER is set by Jenkins if this script is being called as part of a Jenkins run
 174   if [[ -f "$1/$2" ]]; then
 175     THEDATE=`date +%Y%m%d%H%M%S`
 176     mv "$1/$2" "$1/$THEDATE-$BUILD_NUMBER-$2"
 177     gzip "$1/$THEDATE-$BUILD_NUMBER-$2"
 178   fi
 179 }
 180
 181 declare -a failures
 182 declare -A skip
 183 declare -A testargs
 184 skip[apps/workbench_profile]=1
 185
 186 while [[ -n "$1" ]]
 187 do
 188     arg="$1"; shift
 189     case "$arg" in
 190         --help)
 191             echo >&2 "$helpmessage"
 192             echo >&2
 193             exit 1
 194             ;;
 195         --skip)
 196             skipwhat="$1"; shift
 197             skip[$skipwhat]=1
 198             ;;
 199         --only)
 200             only="$1"; skip[$1]=""; shift
 201             ;;
 202         --skip-install)
 203             skip_install=1
 204             ;;
 205         --only-install)
 206             skip_install=1
 207             only_install="$1"; shift
 208             ;;
 209         --leave-temp)
 210             leave_temp[VENVDIR]=1
 211             leave_temp[VENV3DIR]=1
 212             leave_temp[GOPATH]=1
 213             leave_temp[GEMHOME]=1
 214             ;;
 215         --retry)
 216             retry=1
 217             ;;
 218         *_test=*)
 219             suite="${arg%%_test=*}"
 220             args="${arg#*=}"
 221             testargs["$suite"]="$args"
 222             ;;
 223         *=*)
 224             eval export $(echo $arg | cut -d= -f1)=\"$(echo $arg | cut -d= -f2-)\"
 225             ;;
 226         *)
 227             echo >&2 "$0: Unrecognized option: '$arg'. Try: $0 --help"
 228             exit 1
 229             ;;
 230     esac
 231 done
 232
 233 start_api() {
 234     echo 'Starting API server...'
 235     cd "$WORKSPACE" \
 236         && eval $(python sdk/python/tests/run_test_server.py start --auth admin) \
 237         && export ARVADOS_TEST_API_HOST="$ARVADOS_API_HOST" \
 238         && export ARVADOS_TEST_API_INSTALLED="$$" \
 239         && (env | egrep ^ARVADOS)
 240 }
 241
 242 start_nginx_proxy_services() {
 243     echo 'Starting keepproxy, arv-git-httpd, and nginx ssl proxy...'
 244     cd "$WORKSPACE" \
 245         && python sdk/python/tests/run_test_server.py start_keep_proxy \
 246         && python sdk/python/tests/run_test_server.py start_arv-git-httpd \
 247         && python sdk/python/tests/run_test_server.py start_nginx \
 248         && export ARVADOS_TEST_PROXY_SERVICES=1
 249 }
 250
 251 stop_services() {
 252     if [[ -n "$ARVADOS_TEST_PROXY_SERVICES" ]]; then
 253         unset ARVADOS_TEST_PROXY_SERVICES
 254         cd "$WORKSPACE" \
 255             && python sdk/python/tests/run_test_server.py stop_nginx \
 256             && python sdk/python/tests/run_test_server.py stop_arv-git-httpd \
 257             && python sdk/python/tests/run_test_server.py stop_keep_proxy
 258     fi
 259     if [[ -n "$ARVADOS_TEST_API_HOST" ]]; then
 260         unset ARVADOS_TEST_API_HOST
 261         cd "$WORKSPACE" \
 262             && python sdk/python/tests/run_test_server.py stop
 263     fi
 264 }
 265
 266 interrupt() {
 267     failures+=("($(basename $0) interrupted)")
 268     exit_cleanly
 269 }
 270 trap interrupt INT
 271
 272 sanity_checks
 273
 274 echo "WORKSPACE=$WORKSPACE"
 275
 276 if [[ -z "$CONFIGSRC" ]] && [[ -d "$HOME/arvados-api-server" ]]; then
 277     # Jenkins expects us to use this by default.
 278     CONFIGSRC="$HOME/arvados-api-server"
 279 fi
 280
 281 # Clean up .pyc files that may exist in the workspace
 282 cd "$WORKSPACE"
 283 find -name '*.pyc' -delete
 284
 285 # Set up temporary install dirs (unless existing dirs were supplied)
 286 for tmpdir in VENVDIR VENV3DIR GOPATH GEMHOME
 287 do
 288     if [[ -n "${!tmpdir}" ]]; then
 289         leave_temp[$tmpdir]=1
 290         mkdir -p "${!tmpdir}"
 291     else
 292         eval "$tmpdir"='$(mktemp -d)'
 293     fi
 294 done
 295
 296 setup_ruby_environment() {
 297     if [[ -s "$HOME/.rvm/scripts/rvm" ]] ; then
 298       source "$HOME/.rvm/scripts/rvm"
 299       using_rvm=true
 300     elif [[ -s "/usr/local/rvm/scripts/rvm" ]] ; then
 301       source "/usr/local/rvm/scripts/rvm"
 302       using_rvm=true
 303     else
 304       using_rvm=false
 305     fi
 306
 307     if [[ "$using_rvm" == true ]]; then
 308         # If rvm is in use, we can't just put separate "dependencies"
 309         # and "gems-under-test" paths to GEM_PATH: passenger resets
 310         # the environment to the "current gemset", which would lose
 311         # our GEM_PATH and prevent our test suites from running ruby
 312         # programs (for example, the Workbench test suite could not
 313         # boot an API server or run arv). Instead, we have to make an
 314         # rvm gemset and use it for everything.
 315
 316         [[ `type rvm | head -n1` == "rvm is a function" ]] \
 317             || fatal 'rvm check'
 318
 319         # Put rvm's favorite path back in first place (overriding
 320         # virtualenv, which just put itself there). Ignore rvm's
 321         # complaint about not being in first place already.
 322         rvm use @default 2>/dev/null
 323
 324         # Create (if needed) and switch to an @arvados-tests
 325         # gemset. (Leave the choice of ruby to the caller.)
 326         rvm use @arvados-tests --create \
 327             || fatal 'rvm gemset setup'
 328
 329         rvm env
 330     else
 331         # When our "bundle install"s need to install new gems to
 332         # satisfy dependencies, we want them to go where "gem install
 333         # --user-install" would put them. (However, if the caller has
 334         # already set GEM_HOME, we assume that's where dependencies
 335         # should be installed, and we should leave it alone.)
 336
 337         if [ -z "$GEM_HOME" ]; then
 338             user_gempath="$(gem env gempath)"
 339             export GEM_HOME="${user_gempath%%:*}"
 340         fi
 341         PATH="$(gem env gemdir)/bin:$PATH"
 342
 343         # When we build and install our own gems, we install them in our
 344         # $GEMHOME tmpdir, and we want them to be at the front of GEM_PATH and
 345         # PATH so integration tests prefer them over other versions that
 346         # happen to be installed in $user_gempath, system dirs, etc.
 347
 348         tmpdir_gem_home="$(env - PATH="$PATH" HOME="$GEMHOME" gem env gempath | cut -f1 -d:)"
 349         PATH="$tmpdir_gem_home/bin:$PATH"
 350         export GEM_PATH="$tmpdir_gem_home:$(gem env gempath)"
 351
 352         echo "Will install dependencies to $(gem env gemdir)"
 353         echo "Will install arvados gems to $tmpdir_gem_home"
 354         echo "Gem search path is GEM_PATH=$GEM_PATH"
 355     fi
 356 }
 357
 358 with_test_gemset() {
 359     if [[ "$using_rvm" == true ]]; then
 360         "$@"
 361     else
 362         GEM_HOME="$tmpdir_gem_home" "$@"
 363     fi
 364 }
 365
 366 export GOPATH
 367 mkdir -p "$GOPATH/src/git.curoverse.com"
 368 ln -sfn "$WORKSPACE" "$GOPATH/src/git.curoverse.com/arvados.git" \
 369     || fatal "symlink failed"
 370
 371 virtualenv --setuptools "$VENVDIR" || fatal "virtualenv $VENVDIR failed"
 372 . "$VENVDIR/bin/activate"
 373
 374 # Note: this must be the last time we change PATH, otherwise rvm will
 375 # whine a lot.
 376 setup_ruby_environment
 377
 378 echo "PATH is $PATH"
 379
 380 if ! which bundler >/dev/null
 381 then
 382     gem install --user-install bundler || fatal 'Could not install bundler'
 383 fi
 384
 385 # Needed for run_test_server.py which is used by certain (non-Python) tests.
 386 pip freeze 2>/dev/null | egrep ^PyYAML= \
 387     || pip install PyYAML >/dev/null \
 388     || fatal "pip install PyYAML failed"
 389
 390 # If Python 3 is available, set up its virtualenv in $VENV3DIR.
 391 # Otherwise, skip dependent tests.
 392 PYTHON3=$(which python3)
 393 if [ "0" = "$?" ]; then
 394     virtualenv --python "$PYTHON3" --setuptools "$VENV3DIR" \
 395         || fatal "python3 virtualenv $VENV3DIR failed"
 396 else
 397     PYTHON3=
 398     skip[services/dockercleaner]=1
 399     cat >&2 <<EOF
 400
 401 Warning: python3 could not be found
 402 services/dockercleaner install and tests will be skipped
 403
 404 EOF
 405 fi
 406
 407 checkexit() {
 408     if [[ "$1" != "0" ]]; then
 409         title "!!!!!! $2 FAILED !!!!!!"
 410         failures+=("$2 (`timer`)")
 411     else
 412         successes+=("$2 (`timer`)")
 413     fi
 414 }
 415
 416 timer_reset() {
 417     t0=$SECONDS
 418 }
 419
 420 timer() {
 421     echo -n "$(($SECONDS - $t0))s"
 422 }
 423
 424 do_test() {
 425     while ! do_test_once ${@} && [[ "$retry" == 1 ]]
 426     do
 427         read -p 'Try again? [Y/n] ' x
 428         if [[ "$x" != "y" ]] && [[ "$x" != "" ]]
 429         then
 430             break
 431         fi
 432     done
 433 }
 434
 435 do_test_once() {
 436     if [[ -z "${skip[$1]}" ]] && ( [[ -z "$only" ]] || [[ "$only" == "$1" ]] )
 437     then
 438         title "Running $1 tests"
 439         timer_reset
 440         if [[ "$2" == "go" ]]
 441         then
 442             if [[ -n "${testargs[$1]}" ]]
 443             then
 444                 # "go test -check.vv giturl" doesn't work, but this
 445                 # does:
 446                 cd "$WORKSPACE/$1" && go test ${testargs[$1]}
 447             else
 448                 # The above form gets verbose even when testargs is
 449                 # empty, so use this form in such cases:
 450                 go test "git.curoverse.com/arvados.git/$1"
 451             fi
 452         elif [[ "$2" == "pip" ]]
 453         then
 454             # $3 can name a path directory for us to use, including trailing
 455             # slash; e.g., the bin/ subdirectory of a virtualenv.
 456             cd "$WORKSPACE/$1" \
 457                 && "${3}python" setup.py test ${testargs[$1]}
 458         elif [[ "$2" != "" ]]
 459         then
 460             "test_$2"
 461         else
 462             "test_$1"
 463         fi
 464         result="$?"
 465         checkexit $result "$1 tests"
 466         title "End of $1 tests (`timer`)"
 467         return $result
 468     else
 469         title "Skipping $1 tests"
 470     fi
 471 }
 472
 473 do_install() {
 474     if [[ -z "$skip_install" || (-n "$only_install" && "$only_install" == "$1") ]]
 475     then
 476         title "Running $1 install"
 477         timer_reset
 478         if [[ "$2" == "go" ]]
 479         then
 480             go get -t "git.curoverse.com/arvados.git/$1"
 481         elif [[ "$2" == "pip" ]]
 482         then
 483             # $3 can name a path directory for us to use, including trailing
 484             # slash; e.g., the bin/ subdirectory of a virtualenv.
 485
 486             # Need to change to a different directory after creating
 487             # the source dist package to avoid a pip bug.
 488             # see https://arvados.org/issues/5766 for details.
 489
 490             # Also need to install twice, because if it belives the package is
 491             # already installed, pip it won't install it.  So the first "pip
 492             # install" ensures that the dependencies are met, the second "pip
 493             # install" ensures that we've actually install the local package
 494             # we just built.
 495             cd "$WORKSPACE/$1" \
 496                 && "${3}python" setup.py sdist rotate --keep=1 --match .tar.gz \
 497                 && cd "$WORKSPACE" \
 498                 && "${3}pip" install --quiet "$WORKSPACE/$1/dist"/*.tar.gz \
 499                 && "${3}pip" install --quiet --no-deps --ignore-installed "$WORKSPACE/$1/dist"/*.tar.gz
 500         elif [[ "$2" != "" ]]
 501         then
 502             "install_$2"
 503         else
 504             "install_$1"
 505         fi
 506         checkexit $? "$1 install"
 507         title "End of $1 install (`timer`)"
 508     else
 509         title "Skipping $1 install"
 510     fi
 511 }
 512
 513 title () {
 514     txt="********** $1 **********"
 515     printf "\n%*s%s\n\n" $((($COLUMNS-${#txt})/2)) "" "$txt"
 516 }
 517
 518 bundle_install_trylocal() {
 519     (
 520         set -e
 521         echo "(Running bundle install --local. 'could not find package' messages are OK.)"
 522         if ! bundle install --local --no-deployment; then
 523             echo "(Running bundle install again, without --local.)"
 524             bundle install --no-deployment
 525         fi
 526         bundle package --all
 527     )
 528 }
 529
 530 install_doc() {
 531     cd "$WORKSPACE/doc" \
 532         && bundle_install_trylocal \
 533         && rm -rf .site
 534 }
 535 do_install doc
 536
 537 install_ruby_sdk() {
 538     with_test_gemset gem uninstall --force --all --executables arvados \
 539         && cd "$WORKSPACE/sdk/ruby" \
 540         && bundle_install_trylocal \
 541         && gem build arvados.gemspec \
 542         && with_test_gemset gem install --no-ri --no-rdoc `ls -t arvados-*.gem|head -n1`
 543 }
 544 do_install sdk/ruby ruby_sdk
 545
 546 install_cli() {
 547     with_test_gemset gem uninstall --force --all --executables arvados-cli \
 548         && cd "$WORKSPACE/sdk/cli" \
 549         && bundle_install_trylocal \
 550         && gem build arvados-cli.gemspec \
 551         && with_test_gemset gem install --no-ri --no-rdoc `ls -t arvados-cli-*.gem|head -n1`
 552 }
 553 do_install sdk/cli cli
 554
 555 # Install the Python SDK early. Various other test suites (like
 556 # keepproxy) bring up run_test_server.py, which imports the arvados
 557 # module. We can't actually *test* the Python SDK yet though, because
 558 # its own test suite brings up some of those other programs (like
 559 # keepproxy).
 560 declare -a pythonstuff
 561 pythonstuff=(
 562     sdk/python
 563     services/fuse
 564     services/nodemanager
 565     )
 566 for p in "${pythonstuff[@]}"
 567 do
 568     do_install "$p" pip
 569 done
 570 if [ -n "$PYTHON3" ]; then
 571     do_install services/dockercleaner pip "$VENV3DIR/bin/"
 572 fi
 573
 574 install_apiserver() {
 575     cd "$WORKSPACE/services/api" \
 576         && RAILS_ENV=test bundle_install_trylocal
 577
 578     rm -f config/environments/test.rb
 579     cp config/environments/test.rb.example config/environments/test.rb
 580
 581     if [ -n "$CONFIGSRC" ]
 582     then
 583         for f in database.yml application.yml
 584         do
 585             cp "$CONFIGSRC/$f" config/ || fatal "$f"
 586         done
 587     fi
 588
 589     # Fill in a random secret_token and blob_signing_key for testing
 590     SECRET_TOKEN=`echo 'puts rand(2**512).to_s(36)' |ruby`
 591     BLOB_SIGNING_KEY=`echo 'puts rand(2**512).to_s(36)' |ruby`
 592
 593     sed -i'' -e "s:SECRET_TOKEN:$SECRET_TOKEN:" config/application.yml
 594     sed -i'' -e "s:BLOB_SIGNING_KEY:$BLOB_SIGNING_KEY:" config/application.yml
 595
 596     # Set up empty git repo (for git tests)
 597     GITDIR=$(mktemp -d)
 598     sed -i'' -e "s:/var/cache/git:$GITDIR:" config/application.default.yml
 599
 600     rm -rf $GITDIR
 601     mkdir -p $GITDIR/test
 602     cd $GITDIR/test \
 603         && git init \
 604         && git config user.email "jenkins@ci.curoverse.com" \
 605         && git config user.name "Jenkins, CI" \
 606         && touch tmp \
 607         && git add tmp \
 608         && git commit -m 'initial commit'
 609
 610     # Clear out any lingering postgresql connections to the test
 611     # database, so that we can drop it. This assumes the current user
 612     # is a postgresql superuser.
 613     cd "$WORKSPACE/services/api" \
 614         && test_database=$(python -c "import yaml; print yaml.load(file('config/database.yml'))['test']['database']") \
 615         && psql "$test_database" -c "SELECT pg_terminate_backend (pg_stat_activity.procpid::int) FROM pg_stat_activity WHERE pg_stat_activity.datname = '$test_database';" 2>/dev/null
 616
 617     cd "$WORKSPACE/services/api" \
 618         && RAILS_ENV=test bundle exec rake db:drop \
 619         && RAILS_ENV=test bundle exec rake db:setup \
 620         && RAILS_ENV=test bundle exec rake db:fixtures:load
 621 }
 622 do_install services/api apiserver
 623
 624 declare -a gostuff
 625 gostuff=(
 626     services/arv-git-httpd
 627     services/crunchstat
 628     services/keepstore
 629     services/keepproxy
 630     sdk/go/arvadosclient
 631     sdk/go/keepclient
 632     sdk/go/streamer
 633     )
 634 for g in "${gostuff[@]}"
 635 do
 636     do_install "$g" go
 637 done
 638
 639 install_workbench() {
 640     cd "$WORKSPACE/apps/workbench" \
 641         && mkdir -p tmp/cache \
 642         && RAILS_ENV=test bundle_install_trylocal
 643 }
 644 do_install apps/workbench workbench
 645
 646 test_doclinkchecker() {
 647     (
 648         set -e
 649         cd "$WORKSPACE/doc"
 650         ARVADOS_API_HOST=qr1hi.arvadosapi.com
 651         # Make sure python-epydoc is installed or the next line won't
 652         # do much good!
 653         PYTHONPATH=$WORKSPACE/sdk/python/ bundle exec rake linkchecker baseurl=file://$WORKSPACE/doc/.site/ arvados_workbench_host=https://workbench.$ARVADOS_API_HOST arvados_api_host=$ARVADOS_API_HOST
 654     )
 655 }
 656 do_test doc doclinkchecker
 657
 658 stop_services
 659
 660 test_apiserver() {
 661     cd "$WORKSPACE/services/api" \
 662         && RAILS_ENV=test bundle exec rake test TESTOPTS=-v ${testargs[services/api]}
 663 }
 664 do_test services/api apiserver
 665
 666 # Shortcut for when we're only running apiserver tests. This saves a bit of time,
 667 # because we don't need to start up the api server for subsequent tests.
 668 if [ ! -z "$only" ] && [ "$only" == "services/api" ]; then
 669   rotate_logfile "$WORKSPACE/services/api/log/" "test.log"
 670   exit_cleanly
 671 fi
 672
 673 start_api
 674
 675 test_ruby_sdk() {
 676     cd "$WORKSPACE/sdk/ruby" \
 677         && bundle exec rake test TESTOPTS=-v ${testargs[sdk/ruby]}
 678 }
 679 do_test sdk/ruby ruby_sdk
 680
 681 test_cli() {
 682     cd "$WORKSPACE/sdk/cli" \
 683         && mkdir -p /tmp/keep \
 684         && KEEP_LOCAL_STORE=/tmp/keep bundle exec rake test TESTOPTS=-v ${testargs[sdk/cli]}
 685 }
 686 do_test sdk/cli cli
 687
 688 for p in "${pythonstuff[@]}"
 689 do
 690     do_test "$p" pip
 691 done
 692 do_test services/dockercleaner pip "$VENV3DIR/bin/"
 693
 694 for g in "${gostuff[@]}"
 695 do
 696     do_test "$g" go
 697 done
 698
 699 test_workbench() {
 700     start_nginx_proxy_services \
 701         && cd "$WORKSPACE/apps/workbench" \
 702         && RAILS_ENV=test bundle exec rake test TESTOPTS=-v ${testargs[apps/workbench]}
 703 }
 704 do_test apps/workbench workbench
 705
 706 test_workbench_benchmark() {
 707     start_nginx_proxy_services \
 708         && cd "$WORKSPACE/apps/workbench" \
 709         && RAILS_ENV=test bundle exec rake test:benchmark ${testargs[apps/workbench_benchmark]}
 710 }
 711 do_test apps/workbench_benchmark workbench_benchmark
 712
 713 test_workbench_profile() {
 714     start_nginx_proxy_services \
 715         && cd "$WORKSPACE/apps/workbench" \
 716         && RAILS_ENV=test bundle exec rake test:profile ${testargs[apps/workbench_profile]}
 717 }
 718 do_test apps/workbench_profile workbench_profile
 719
 720 exit_cleanly