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