jenkins/run-tests.sh

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