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 # When re-using $VENVDIR, upgrade any packages (except arvados) that are
 372 # already installed
 373 pip install --quiet --upgrade `pip freeze | grep -v arvados | cut -f1 -d=`
 374
 375 # Note: this must be the last time we change PATH, otherwise rvm will
 376 # whine a lot.
 377 setup_ruby_environment
 378
 379 echo "PATH is $PATH"
 380
 381 if ! which bundler >/dev/null
 382 then
 383     gem install --user-install bundler || fatal 'Could not install bundler'
 384 fi
 385
 386 # Needed for run_test_server.py which is used by certain (non-Python) tests.
 387 echo "pip install -q PyYAML"
 388 pip install --quiet PyYAML || 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     test_database=$(python -c "import yaml; print yaml.load(file('config/database.yml'))['test']['database']")
 614     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
 615
 616     cd "$WORKSPACE/services/api" \
 617         && RAILS_ENV=test bundle exec rake db:drop \
 618         && RAILS_ENV=test bundle exec rake db:setup \
 619         && RAILS_ENV=test bundle exec rake db:fixtures:load
 620 }
 621 do_install services/api apiserver
 622
 623 declare -a gostuff
 624 gostuff=(
 625     services/arv-git-httpd
 626     services/crunchstat
 627     services/keepstore
 628     services/keepproxy
 629     sdk/go/arvadosclient
 630     sdk/go/keepclient
 631     sdk/go/streamer
 632     )
 633 for g in "${gostuff[@]}"
 634 do
 635     do_install "$g" go
 636 done
 637
 638 install_workbench() {
 639     cd "$WORKSPACE/apps/workbench" \
 640         && mkdir -p tmp/cache \
 641         && RAILS_ENV=test bundle_install_trylocal
 642 }
 643 do_install apps/workbench workbench
 644
 645 test_doclinkchecker() {
 646     (
 647         set -e
 648         cd "$WORKSPACE/doc"
 649         ARVADOS_API_HOST=qr1hi.arvadosapi.com
 650         # Make sure python-epydoc is installed or the next line won't
 651         # do much good!
 652         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
 653     )
 654 }
 655 do_test doc doclinkchecker
 656
 657 stop_services
 658
 659 test_apiserver() {
 660     cd "$WORKSPACE/services/api" \
 661         && RAILS_ENV=test bundle exec rake test TESTOPTS=-v ${testargs[services/api]}
 662 }
 663 do_test services/api apiserver
 664
 665 # Shortcut for when we're only running apiserver tests. This saves a bit of time,
 666 # because we don't need to start up the api server for subsequent tests.
 667 if [ ! -z "$only" ] && [ "$only" == "services/api" ]; then
 668   rotate_logfile "$WORKSPACE/services/api/log/" "test.log"
 669   exit_cleanly
 670 fi
 671
 672 start_api
 673
 674 test_ruby_sdk() {
 675     cd "$WORKSPACE/sdk/ruby" \
 676         && bundle exec rake test TESTOPTS=-v ${testargs[sdk/ruby]}
 677 }
 678 do_test sdk/ruby ruby_sdk
 679
 680 test_cli() {
 681     cd "$WORKSPACE/sdk/cli" \
 682         && mkdir -p /tmp/keep \
 683         && KEEP_LOCAL_STORE=/tmp/keep bundle exec rake test TESTOPTS=-v ${testargs[sdk/cli]}
 684 }
 685 do_test sdk/cli cli
 686
 687 for p in "${pythonstuff[@]}"
 688 do
 689     do_test "$p" pip
 690 done
 691 do_test services/dockercleaner pip "$VENV3DIR/bin/"
 692
 693 for g in "${gostuff[@]}"
 694 do
 695     do_test "$g" go
 696 done
 697
 698 test_workbench() {
 699     start_nginx_proxy_services \
 700         && cd "$WORKSPACE/apps/workbench" \
 701         && RAILS_ENV=test bundle exec rake test TESTOPTS=-v ${testargs[apps/workbench]}
 702 }
 703 do_test apps/workbench workbench
 704
 705 test_workbench_benchmark() {
 706     start_nginx_proxy_services \
 707         && cd "$WORKSPACE/apps/workbench" \
 708         && RAILS_ENV=test bundle exec rake test:benchmark ${testargs[apps/workbench_benchmark]}
 709 }
 710 do_test apps/workbench_benchmark workbench_benchmark
 711
 712 test_workbench_profile() {
 713     start_nginx_proxy_services \
 714         && cd "$WORKSPACE/apps/workbench" \
 715         && RAILS_ENV=test bundle exec rake test:profile ${testargs[apps/workbench_profile]}
 716 }
 717 do_test apps/workbench_profile workbench_profile
 718
 719 exit_cleanly