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