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: $* 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   # Make sure WORKSPACE is set
 149   if ! [[ -n "$WORKSPACE" ]]; then
 150     echo >&2 "$helpmessage"
 151     echo >&2
 152     echo >&2 "Error: WORKSPACE environment variable not set"
 153     echo >&2
 154     exit 1
 155   fi
 156
 157   # Make sure virtualenv is installed
 158   `virtualenv --help >/dev/null 2>&1`
 159
 160   if [[ "$?" != "0" ]]; then
 161     echo >&2
 162     echo >&2 "Error: virtualenv could not be found"
 163     echo >&2
 164     exit 1
 165   fi
 166
 167   # Make sure go is installed
 168   `go env >/dev/null 2>&1`
 169
 170   if [[ "$?" != "0" ]]; then
 171     echo >&2
 172     echo >&2 "Error: go could not be found"
 173     echo >&2
 174     exit 1
 175   fi
 176
 177   # Make sure gcc is installed
 178   `gcc --help >/dev/null 2>&1`
 179
 180   if [[ "$?" != "0" ]]; then
 181     echo >&2
 182     echo >&2 "Error: gcc could not be found"
 183     echo >&2
 184     exit 1
 185   fi
 186 }
 187
 188 rotate_logfile() {
 189   # i.e.  rotate_logfile "$WORKSPACE/apps/workbench/log/" "test.log"
 190   # $BUILD_NUMBER is set by Jenkins if this script is being called as part of a Jenkins run
 191   if [[ -f "$1/$2" ]]; then
 192     THEDATE=`date +%Y%m%d%H%M%S`
 193     mv "$1/$2" "$1/$THEDATE-$BUILD_NUMBER-$2"
 194     gzip "$1/$THEDATE-$BUILD_NUMBER-$2"
 195   fi
 196 }
 197
 198 declare -a failures
 199 declare -A skip
 200 declare -A testargs
 201 skip[apps/workbench_profile]=1
 202
 203 while [[ -n "$1" ]]
 204 do
 205     arg="$1"; shift
 206     case "$arg" in
 207         --help)
 208             echo >&2 "$helpmessage"
 209             echo >&2
 210             exit 1
 211             ;;
 212         --skip)
 213             skipwhat="$1"; shift
 214             skip[$skipwhat]=1
 215             ;;
 216         --only)
 217             only="$1"; skip[$1]=""; shift
 218             ;;
 219         --skip-install)
 220             skip_install=1
 221             ;;
 222         --only-install)
 223             skip_install=1
 224             only_install="$1"; shift
 225             ;;
 226         --leave-temp)
 227             leave_temp[VENVDIR]=1
 228             leave_temp[VENV3DIR]=1
 229             leave_temp[GOPATH]=1
 230             leave_temp[GEMHOME]=1
 231             ;;
 232         --retry)
 233             retry=1
 234             ;;
 235         *_test=*)
 236             suite="${arg%%_test=*}"
 237             args="${arg#*=}"
 238             testargs["$suite"]="$args"
 239             ;;
 240         *=*)
 241             eval export $(echo $arg | cut -d= -f1)=\"$(echo $arg | cut -d= -f2-)\"
 242             ;;
 243         *)
 244             echo >&2 "$0: Unrecognized option: '$arg'. Try: $0 --help"
 245             exit 1
 246             ;;
 247     esac
 248 done
 249
 250 start_api() {
 251     echo 'Starting API server...'
 252     cd "$WORKSPACE" \
 253         && eval $(python sdk/python/tests/run_test_server.py start --auth admin) \
 254         && export ARVADOS_TEST_API_HOST="$ARVADOS_API_HOST" \
 255         && export ARVADOS_TEST_API_INSTALLED="$$" \
 256         && (env | egrep ^ARVADOS)
 257 }
 258
 259 start_nginx_proxy_services() {
 260     echo 'Starting keepproxy, arv-git-httpd, and nginx ssl proxy...'
 261     cd "$WORKSPACE" \
 262         && python sdk/python/tests/run_test_server.py start_keep_proxy \
 263         && python sdk/python/tests/run_test_server.py start_arv-git-httpd \
 264         && python sdk/python/tests/run_test_server.py start_nginx \
 265         && export ARVADOS_TEST_PROXY_SERVICES=1
 266 }
 267
 268 stop_services() {
 269     if [[ -n "$ARVADOS_TEST_PROXY_SERVICES" ]]; then
 270         unset ARVADOS_TEST_PROXY_SERVICES
 271         cd "$WORKSPACE" \
 272             && python sdk/python/tests/run_test_server.py stop_nginx \
 273             && python sdk/python/tests/run_test_server.py stop_arv-git-httpd \
 274             && python sdk/python/tests/run_test_server.py stop_keep_proxy
 275     fi
 276     if [[ -n "$ARVADOS_TEST_API_HOST" ]]; then
 277         unset ARVADOS_TEST_API_HOST
 278         cd "$WORKSPACE" \
 279             && python sdk/python/tests/run_test_server.py stop
 280     fi
 281 }
 282
 283 interrupt() {
 284     failures+=("($(basename $0) interrupted)")
 285     exit_cleanly
 286 }
 287 trap interrupt INT
 288
 289 sanity_checks
 290
 291 echo "WORKSPACE=$WORKSPACE"
 292
 293 if [[ -z "$CONFIGSRC" ]] && [[ -d "$HOME/arvados-api-server" ]]; then
 294     # Jenkins expects us to use this by default.
 295     CONFIGSRC="$HOME/arvados-api-server"
 296 fi
 297
 298 # Clean up .pyc files that may exist in the workspace
 299 cd "$WORKSPACE"
 300 find -name '*.pyc' -delete
 301
 302 # Set up temporary install dirs (unless existing dirs were supplied)
 303 for tmpdir in VENVDIR VENV3DIR GOPATH GEMHOME
 304 do
 305     if [[ -n "${!tmpdir}" ]]; then
 306         leave_temp[$tmpdir]=1
 307     else
 308         eval $tmpdir=$(mktemp -d)
 309     fi
 310 done
 311
 312 setup_ruby_environment() {
 313     if [[ -s "$HOME/.rvm/scripts/rvm" ]] ; then
 314       source "$HOME/.rvm/scripts/rvm"
 315       using_rvm=true
 316     elif [[ -s "/usr/local/rvm/scripts/rvm" ]] ; then
 317       source "/usr/local/rvm/scripts/rvm"
 318       using_rvm=true
 319     else
 320       using_rvm=false
 321     fi
 322
 323     if [[ "$using_rvm" == true ]]; then
 324         # If rvm is in use, we can't just put separate "dependencies"
 325         # and "gems-under-test" paths to GEM_PATH: passenger resets
 326         # the environment to the "current gemset", which would lose
 327         # our GEM_PATH and prevent our test suites from running ruby
 328         # programs (for example, the Workbench test suite could not
 329         # boot an API server or run arv). Instead, we have to make an
 330         # rvm gemset and use it for everything.
 331
 332         [[ `type rvm | head -n1` == "rvm is a function" ]] \
 333             || fatal 'rvm check'
 334
 335         # Put rvm's favorite path back in first place (overriding
 336         # virtualenv, which just put itself there). Ignore rvm's
 337         # complaint about not being in first place already.
 338         rvm use @default 2>/dev/null
 339
 340         # Create (if needed) and switch to an @arvados-tests
 341         # gemset. (Leave the choice of ruby to the caller.)
 342         rvm use @arvados-tests --create \
 343             || fatal 'rvm gemset setup'
 344
 345         rvm env
 346     else
 347         # When our "bundle install"s need to install new gems to
 348         # satisfy dependencies, we want them to go where "gem install
 349         # --user-install" would put them. (However, if the caller has
 350         # already set GEM_HOME, we assume that's where dependencies
 351         # should be installed, and we should leave it alone.)
 352
 353         if [ -z "$GEM_HOME" ]; then
 354             user_gempath="$(gem env gempath)"
 355             export GEM_HOME="${user_gempath%%:*}"
 356         fi
 357         PATH="$(gem env gemdir)/bin:$PATH"
 358
 359         # When we build and install our own gems, we install them in our
 360         # $GEMHOME tmpdir, and we want them to be at the front of GEM_PATH and
 361         # PATH so integration tests prefer them over other versions that
 362         # happen to be installed in $user_gempath, system dirs, etc.
 363
 364         tmpdir_gem_home="$(env - PATH="$PATH" HOME="$GEMHOME" gem env gempath | cut -f1 -d:)"
 365         PATH="$tmpdir_gem_home/bin:$PATH"
 366         export GEM_PATH="$tmpdir_gem_home:$(gem env gempath)"
 367
 368         echo "Will install dependencies to $(gem env gemdir)"
 369         echo "Will install arvados gems to $tmpdir_gem_home"
 370         echo "Gem search path is GEM_PATH=$GEM_PATH"
 371     fi
 372 }
 373
 374 with_test_gemset() {
 375     if [[ "$using_rvm" == true ]]; then
 376         "$@"
 377     else
 378         GEM_HOME="$tmpdir_gem_home" "$@"
 379     fi
 380 }
 381
 382 export GOPATH
 383 mkdir -p "$GOPATH/src/git.curoverse.com"
 384 ln -sfn "$WORKSPACE" "$GOPATH/src/git.curoverse.com/arvados.git" \
 385     || fatal "symlink failed"
 386
 387 virtualenv --setuptools "$VENVDIR" || fatal "virtualenv $VENVDIR failed"
 388 . "$VENVDIR/bin/activate"
 389
 390 # When re-using $VENVDIR, upgrade any packages (except arvados) that are
 391 # already installed
 392 pip install --quiet --upgrade `pip freeze | grep -v arvados | cut -f1 -d=`
 393
 394 # Note: this must be the last time we change PATH, otherwise rvm will
 395 # whine a lot.
 396 setup_ruby_environment
 397
 398 echo "PATH is $PATH"
 399
 400 if ! which bundler >/dev/null
 401 then
 402     gem install --user-install bundler || fatal 'Could not install bundler'
 403 fi
 404
 405 # Needed for run_test_server.py which is used by certain (non-Python) tests.
 406 echo "pip install -q PyYAML"
 407 pip install --quiet PyYAML || fatal "pip install PyYAML failed"
 408
 409 # If Python 3 is available, set up its virtualenv in $VENV3DIR.
 410 # Otherwise, skip dependent tests.
 411 PYTHON3=$(which python3)
 412 if [ "0" = "$?" ]; then
 413     virtualenv --python "$PYTHON3" --setuptools "$VENV3DIR" \
 414         || fatal "python3 virtualenv $VENV3DIR failed"
 415 else
 416     PYTHON3=
 417     skip[services/dockercleaner]=1
 418     cat >&2 <<EOF
 419
 420 Warning: python3 could not be found
 421 services/dockercleaner install and tests will be skipped
 422
 423 EOF
 424 fi
 425
 426 checkexit() {
 427     if [[ "$1" != "0" ]]; then
 428         title "!!!!!! $2 FAILED !!!!!!"
 429         failures+=("$2 (`timer`)")
 430     else
 431         successes+=("$2 (`timer`)")
 432     fi
 433 }
 434
 435 timer_reset() {
 436     t0=$SECONDS
 437 }
 438
 439 timer() {
 440     echo -n "$(($SECONDS - $t0))s"
 441 }
 442
 443 do_test() {
 444     while ! do_test_once ${@} && [[ "$retry" == 1 ]]
 445     do
 446         read -p 'Try again? [Y/n] ' x
 447         if [[ "$x" != "y" ]] && [[ "$x" != "" ]]
 448         then
 449             break
 450         fi
 451     done
 452 }
 453
 454 do_test_once() {
 455     if [[ -z "${skip[$1]}" ]] && ( [[ -z "$only" ]] || [[ "$only" == "$1" ]] )
 456     then
 457         title "Running $1 tests"
 458         timer_reset
 459         if [[ "$2" == "go" ]]
 460         then
 461             if [[ -n "${testargs[$1]}" ]]
 462             then
 463                 # "go test -check.vv giturl" doesn't work, but this
 464                 # does:
 465                 cd "$WORKSPACE/$1" && go test ${testargs[$1]}
 466             else
 467                 # The above form gets verbose even when testargs is
 468                 # empty, so use this form in such cases:
 469                 go test "git.curoverse.com/arvados.git/$1"
 470             fi
 471         elif [[ "$2" == "pip" ]]
 472         then
 473             # $3 can name a path directory for us to use, including trailing
 474             # slash; e.g., the bin/ subdirectory of a virtualenv.
 475             cd "$WORKSPACE/$1" \
 476                 && "${3}python" setup.py test ${testargs[$1]}
 477         elif [[ "$2" != "" ]]
 478         then
 479             "test_$2"
 480         else
 481             "test_$1"
 482         fi
 483         result="$?"
 484         checkexit $result "$1 tests"
 485         title "End of $1 tests (`timer`)"
 486         return $result
 487     else
 488         title "Skipping $1 tests"
 489     fi
 490 }
 491
 492 do_install() {
 493     if [[ -z "$skip_install" || (-n "$only_install" && "$only_install" == "$1") ]]
 494     then
 495         title "Running $1 install"
 496         timer_reset
 497         if [[ "$2" == "go" ]]
 498         then
 499             go get -t "git.curoverse.com/arvados.git/$1"
 500         elif [[ "$2" == "pip" ]]
 501         then
 502             # $3 can name a path directory for us to use, including trailing
 503             # slash; e.g., the bin/ subdirectory of a virtualenv.
 504
 505             # Need to change to a different directory after creating
 506             # the source dist package to avoid a pip bug.
 507             # see https://arvados.org/issues/5766 for details.
 508
 509             # Also need to install twice, because if it belives the package is
 510             # already installed, pip it won't install it.  So the first "pip
 511             # install" ensures that the dependencies are met, the second "pip
 512             # install" ensures that we've actually install the local package
 513             # we just built.
 514             cd "$WORKSPACE/$1" \
 515                 && "${3}python" setup.py sdist rotate --keep=1 --match .tar.gz \
 516                 && cd "$WORKSPACE" \
 517                 && "${3}pip" install --quiet "$WORKSPACE/$1/dist"/*.tar.gz \
 518                 && "${3}pip" install --quiet --no-deps --ignore-installed "$WORKSPACE/$1/dist"/*.tar.gz
 519         elif [[ "$2" != "" ]]
 520         then
 521             "install_$2"
 522         else
 523             "install_$1"
 524         fi
 525         checkexit $? "$1 install"
 526         title "End of $1 install (`timer`)"
 527     else
 528         title "Skipping $1 install"
 529     fi
 530 }
 531
 532 title () {
 533     txt="********** $1 **********"
 534     printf "\n%*s%s\n\n" $((($COLUMNS-${#txt})/2)) "" "$txt"
 535 }
 536
 537 bundle_install_trylocal() {
 538     (
 539         set -e
 540         echo "(Running bundle install --local. 'could not find package' messages are OK.)"
 541         if ! bundle install --local --no-deployment; then
 542             echo "(Running bundle install again, without --local.)"
 543             bundle install --no-deployment
 544         fi
 545         bundle package --all
 546     )
 547 }
 548
 549 install_doc() {
 550     cd "$WORKSPACE/doc" \
 551         && bundle_install_trylocal \
 552         && rm -rf .site
 553 }
 554 do_install doc
 555
 556 install_ruby_sdk() {
 557     with_test_gemset gem uninstall --force --all --executables arvados \
 558         && cd "$WORKSPACE/sdk/ruby" \
 559         && bundle_install_trylocal \
 560         && gem build arvados.gemspec \
 561         && with_test_gemset gem install --no-ri --no-rdoc `ls -t arvados-*.gem|head -n1`
 562 }
 563 do_install sdk/ruby ruby_sdk
 564
 565 install_cli() {
 566     with_test_gemset gem uninstall --force --all --executables arvados-cli \
 567         && cd "$WORKSPACE/sdk/cli" \
 568         && bundle_install_trylocal \
 569         && gem build arvados-cli.gemspec \
 570         && with_test_gemset gem install --no-ri --no-rdoc `ls -t arvados-cli-*.gem|head -n1`
 571 }
 572 do_install sdk/cli cli
 573
 574 # Install the Python SDK early. Various other test suites (like
 575 # keepproxy) bring up run_test_server.py, which imports the arvados
 576 # module. We can't actually *test* the Python SDK yet though, because
 577 # its own test suite brings up some of those other programs (like
 578 # keepproxy).
 579 declare -a pythonstuff
 580 pythonstuff=(
 581     sdk/python
 582     services/fuse
 583     services/nodemanager
 584     )
 585 for p in "${pythonstuff[@]}"
 586 do
 587     do_install "$p" pip
 588 done
 589 if [ -n "$PYTHON3" ]; then
 590     do_install services/dockercleaner pip "$VENV3DIR/bin/"
 591 fi
 592
 593 install_apiserver() {
 594     cd "$WORKSPACE/services/api" \
 595         && RAILS_ENV=test bundle_install_trylocal
 596
 597     rm -f config/environments/test.rb
 598     cp config/environments/test.rb.example config/environments/test.rb
 599
 600     if [ -n "$CONFIGSRC" ]
 601     then
 602         for f in database.yml application.yml
 603         do
 604             cp "$CONFIGSRC/$f" config/ || fatal "$f"
 605         done
 606     fi
 607
 608     # Fill in a random secret_token and blob_signing_key for testing
 609     SECRET_TOKEN=`echo 'puts rand(2**512).to_s(36)' |ruby`
 610     BLOB_SIGNING_KEY=`echo 'puts rand(2**512).to_s(36)' |ruby`
 611
 612     sed -i'' -e "s:SECRET_TOKEN:$SECRET_TOKEN:" config/application.yml
 613     sed -i'' -e "s:BLOB_SIGNING_KEY:$BLOB_SIGNING_KEY:" config/application.yml
 614
 615     # Set up empty git repo (for git tests)
 616     GITDIR=$(mktemp -d)
 617     sed -i'' -e "s:/var/cache/git:$GITDIR:" config/application.default.yml
 618
 619     rm -rf $GITDIR
 620     mkdir -p $GITDIR/test
 621     cd $GITDIR/test \
 622         && git init \
 623         && git config user.email "jenkins@ci.curoverse.com" \
 624         && git config user.name "Jenkins, CI" \
 625         && touch tmp \
 626         && git add tmp \
 627         && git commit -m 'initial commit'
 628
 629     # Clear out any lingering postgresql connections to the test
 630     # database, so that we can drop it. This assumes the current user
 631     # is a postgresql superuser.
 632     test_database=$(python -c "import yaml; print yaml.load(file('config/database.yml'))['test']['database']")
 633     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
 634
 635     cd "$WORKSPACE/services/api" \
 636         && RAILS_ENV=test bundle exec rake db:drop \
 637         && RAILS_ENV=test bundle exec rake db:setup \
 638         && RAILS_ENV=test bundle exec rake db:fixtures:load
 639 }
 640 do_install services/api apiserver
 641
 642 declare -a gostuff
 643 gostuff=(
 644     services/arv-git-httpd
 645     services/crunchstat
 646     services/keepstore
 647     services/keepproxy
 648     sdk/go/arvadosclient
 649     sdk/go/keepclient
 650     sdk/go/streamer
 651     )
 652 for g in "${gostuff[@]}"
 653 do
 654     do_install "$g" go
 655 done
 656
 657 install_workbench() {
 658     cd "$WORKSPACE/apps/workbench" \
 659         && mkdir -p tmp/cache \
 660         && RAILS_ENV=test bundle_install_trylocal
 661 }
 662 do_install apps/workbench workbench
 663
 664 test_doclinkchecker() {
 665     (
 666         set -e
 667         cd "$WORKSPACE/doc"
 668         ARVADOS_API_HOST=qr1hi.arvadosapi.com
 669         # Make sure python-epydoc is installed or the next line won't
 670         # do much good!
 671         PYTHONPATH=$WORKSPACE/sdk/python/ bundle exec rake linkchecker baseurl=file://$WORKSPACE/doc/.site/ arvados_workbench_host=workbench.$ARVADOS_API_HOST arvados_api_host=$ARVADOS_API_HOST
 672     )
 673 }
 674 do_test doc doclinkchecker
 675
 676 stop_services
 677
 678 test_apiserver() {
 679     cd "$WORKSPACE/services/api" \
 680         && RAILS_ENV=test bundle exec rake test TESTOPTS=-v ${testargs[services/api]}
 681 }
 682 do_test services/api apiserver
 683
 684 # Shortcut for when we're only running apiserver tests. This saves a bit of time,
 685 # because we don't need to start up the api server for subsequent tests.
 686 if [ ! -z "$only" ] && [ "$only" == "services/api" ]; then
 687   rotate_logfile "$WORKSPACE/services/api/log/" "test.log"
 688   exit_cleanly
 689 fi
 690
 691 start_api
 692
 693 test_ruby_sdk() {
 694     cd "$WORKSPACE/sdk/ruby" \
 695         && bundle exec rake test TESTOPTS=-v ${testargs[sdk/ruby]}
 696 }
 697 do_test sdk/ruby ruby_sdk
 698
 699 test_cli() {
 700     cd "$WORKSPACE/sdk/cli" \
 701         && mkdir -p /tmp/keep \
 702         && KEEP_LOCAL_STORE=/tmp/keep bundle exec rake test TESTOPTS=-v ${testargs[sdk/cli]}
 703 }
 704 do_test sdk/cli cli
 705
 706 for p in "${pythonstuff[@]}"
 707 do
 708     do_test "$p" pip
 709 done
 710 do_test services/dockercleaner pip "$VENV3DIR/bin/"
 711
 712 for g in "${gostuff[@]}"
 713 do
 714     do_test "$g" go
 715 done
 716
 717 test_workbench() {
 718     start_nginx_proxy_services \
 719         && cd "$WORKSPACE/apps/workbench" \
 720         && RAILS_ENV=test bundle exec rake test TESTOPTS=-v ${testargs[apps/workbench]}
 721 }
 722 do_test apps/workbench workbench
 723
 724 test_workbench_benchmark() {
 725     start_nginx_proxy_services \
 726         && cd "$WORKSPACE/apps/workbench" \
 727         && RAILS_ENV=test bundle exec rake test:benchmark ${testargs[apps/workbench_benchmark]}
 728 }
 729 do_test apps/workbench_benchmark workbench_benchmark
 730
 731 test_workbench_profile() {
 732     start_nginx_proxy_services \
 733         && cd "$WORKSPACE/apps/workbench" \
 734         && RAILS_ENV=test bundle exec rake test:profile ${testargs[apps/workbench_profile]}
 735 }
 736 do_test apps/workbench_profile workbench_profile
 737
 738 exit_cleanly