@@ -57,7 +57,7 @@ Run the unit tests with:

     $ hack/test-go.sh

-or an individual package unit test with:

+or an individual package using its relative path with:

     $ hack/test-go.sh pkg/build

@@ -69,37 +69,53 @@ To run only a certain regex of tests in a package, use:

     $ hack/test-go.sh pkg/build -test.run=SynchronizeBuildRunning

-To get verbose output add `-v` to the end:

+To get verbose output for the above example:

     $ hack/test-go.sh pkg/build -test.run=SynchronizeBuildRunning -v

 To run all tests with verbose output:

-    $ hack/test-go.sh "" -v

+    $ hack/test-go.sh -v

+

+To change the timeout for individual unit tests, which defaults to one minute, use:

+

+    $ TIMEOUT=<timeout> hack/test-go.sh

 To enable running the kubernetes unit tests:

-    $ TEST_KUBE=1 hack/test-go.sh

+    $ TEST_KUBE=true hack/test-go.sh

 To run unit test for an individual kubernetes package:

-    $ TEST_KUBE=1 hack/test-go.sh Godeps/_workspace/src/k8s.io/kubernetes/examples

+    $ hack/test-go.sh Godeps/_workspace/src/k8s.io/kubernetes/examples

+

+To change the coverage mode, which is `-cover -covermode=atomic` by default, use:

-To turn off or change the coverage mode, which is `-cover -covermode=atomic` by default, use:

+    $ COVERAGE_SPEC="<some coverage specification>" hack/test-go.sh

-    $ KUBE_COVER="" hack/test-go.sh

+To turn off coverage calculation, which is on by default, use:

+

+    $ COVERAGE_SPEC= hack/test-go.sh

 To run tests without the go race detector, which is on by default, use:

-    $ KUBE_RACE="" hack/test-go.sh

+    $ DETECT_RACES= hack/test-go.sh

 To create a line coverage report, set `OUTPUT_COVERAGE` to a path where the

 report should be stored. For example:

-    $ OUTPUT_COVERAGE=/path/to/dir hack/test-go.sh pkg/build

+    $ COVERAGE_OUTPUT_DIR='/path/to/dir' hack/test-go.sh

 After that you can open `/path/to/dir/coverage.html` in the browser.

+To generate a jUnit XML report from the output of the tests, and see a summary of the test output 

+instead of the full test output, use:

+    

+    $ JUNIT_REPORT=true hack/test-go.sh

+

+`hack/test-go.sh` cannot generate jUnit XML and a coverage report for all packages at once. If you

+require both, you must call `hack/test-go.sh` twice.

+

 ### Integration tests

 Integration tests cover multiple components acting together (generally, 2 or 3). These tests should

@@ -70,7 +70,7 @@ verify: build

 #   make test-unit

 #   make test-unit WHAT=pkg/build GOFLAGS=-v

 test-unit:

-	TEST_KUBE=1 hack/test-go.sh $(WHAT) $(TESTS) $(TESTFLAGS)

+	TEST_KUBE=true GOTEST_FLAGS="$(TESTFLAGS)" hack/test-go.sh $(WHAT) $(TESTS) 

 .PHONY: test-unit

 # Run integration tests. Compiles its own tests, cannot be run

@@ -1,129 +1,250 @@

 #!/bin/bash

-

-# See HACKING.md for usage

+#

+# This script runs Go language unit tests for the Origin repository. Arguments to this script

+# are parsed as a list of packages to test until the first argument starting with '-' or '--' is

+# found. That argument and all following arguments are interpreted as flags to be passed directly

+# to `go test`. If no arguments are given, then "all" packages are tested.

+# 

+# Coverage reports and jUnit XML reports can be generated by this script as well, but both cannot

+# be generated at once.

+#

+# This script consumes the following parameters as environment variables:

+#  - DRY_RUN:             prints all packages that would be tested with the args that would be used and exits

+#  - TEST_KUBE:           toggles testing of non-essential Kubernetes unit tests

+#  - TIMEOUT:             the timeout for any one unit test (default '60s')

+#  - DETECT_RACES:        toggles the 'go test' race detector (defaults '-race')

+#  - COVERAGE_OUTPUT_DIR: locates the directory in which coverage output files will be placed

+#  - COVERAGE_SPEC:       a set of flags for 'go test' that specify the coverage behavior (default '-cover -covermode=atomic')

+#  - GOTEST_FLAGS:        any other flags to be sent to 'go test'

+#  - JUNIT_REPORT:        toggles the creation of jUnit XML from the test output and changes this script's output behavior

+#                         to use the 'junitreport' tool for summarizing the tests.

 set -o errexit

 set -o nounset

 set -o pipefail

-STARTTIME=$(date +%s)

-OS_ROOT=$(dirname "${BASH_SOURCE}")/..

-source "${OS_ROOT}/hack/common.sh"

+function exit_trap() {

+    local return_code=$?

-# Go to the top of the tree.

-cd "${OS_ROOT}"

+    end_time=$(date +%s)

+    

+    if [[ "${return_code}" -eq "0" ]]; then

+        verb="succeeded"

+    else

+        verb="failed"

+    fi

+

+    echo "$0 ${verb} after $((${end_time} - ${start_time})) seconds"

+    exit "${return_code}"

+}

-PRINT_PACKAGES=${PRINT_PACKAGES:-""}

-TEST_KUBE=${TEST_KUBE:-""}

-KUBE_GODEP_PATH="./Godeps/_workspace/src/k8s.io/kubernetes/pkg"

+trap exit_trap EXIT

+start_time=$(date +%s)

+OS_ROOT=$(dirname "${BASH_SOURCE}")/..

+source "${OS_ROOT}/hack/common.sh"

+source "${OS_ROOT}/hack/util.sh"

+source "${OS_ROOT}/hack/lib/util/environment.sh"

+cd "${OS_ROOT}"

+os::log::install_errexit

 os::build::setup_env

+os::util::environment::setup_tmpdir_vars "test-go"

-find_test_dirs() {

-  cd "${OS_ROOT}"

-  find $1 -not \( \

-      \( \

-        -wholename './Godeps' \

-        -o -wholename './_output' \

-        -o -wholename './_tools' \

-        -o -wholename './.git' \

-        -o -wholename './openshift.local.*' \

-        -o -wholename '*/Godeps/*' \

-        -o -wholename './assets/node_modules' \

-        -o -wholename './test/extended' \

-      \) -prune \

-    \) -name '*_test.go' -print0 | xargs -0n1 dirname | sort -u | xargs -n1 printf "${OS_GO_PACKAGE}/%s\n"

-}

+# TODO(skuznets): remove these once we've migrated all tools to the new vars

+if [[ -n "${KUBE_TIMEOUT+x}" ]]; then

+    TIMEOUT="${KUBE_TIMEOUT}"

+    echo "[WARNING] The flag \$KUBE_TIMEOUT for $0 is deprecated, use \$TIMEOUT instead."

+fi

-special_upstream_test_dirs() {

-  echo "${OS_GO_PACKAGE}/${KUBE_GODEP_PATH}/api"

-  echo "${OS_GO_PACKAGE}/${KUBE_GODEP_PATH}/api/v1"

-}

+if [[ -n "${KUBE_COVER+x}" ]]; then

+    COVERAGE_SPEC="${KUBE_COVER}"

+    echo "[WARNING] The flag \$KUBE_COVER for $0 is deprecated, use \$COVERAGE_SPEC instead."

+fi

-# find the upstream test directories, excluding special-case directories and the upstream runtime package.

-# The tests for the upstream runtime package are not solvent currently due to a patch for:

-# https://github.com/kubernetes/kubernetes/pull/9971

-#

-# k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testoutput/testgroup/unversioned  - ignored because it is

-#   for testing types.generated.go which we are not currently using and will fail.

-find_upstream_test_dirs() {

-  cd "${OS_ROOT}"

-  find ./Godeps/_workspace/src/k8s.io/kubernetes -not \( \

-      \( \

-        -wholename "${KUBE_GODEP_PATH}/api" \

-        -o -wholename "${KUBE_GODEP_PATH}/api/v1" \

-        -o -wholename './Godeps/_workspace/src/k8s.io/kubernetes/pkg/runtime' \

-        -o -wholename './Godeps/_workspace/src/k8s.io/kubernetes/test/e2e' \

-        -o -wholename './Godeps/_workspace/src/k8s.io/kubernetes/cmd/libs/go2idl/client-gen/testoutput/testgroup/unversioned' \

-      \) -prune \

-    \) -name '*_test.go' -print0 | xargs -0n1 dirname | sort -u | xargs -n1 printf "${OS_GO_PACKAGE}/%s\n"

-}

+if [[ -n "${OUTPUT_COVERAGE+x}" ]]; then

+    COVERAGE_OUTPUT_DIR="${OUTPUT_COVERAGE}"

+    echo "[WARNING] The flag \$OUTPUT_COVERAGE for $0 is deprecated, use \$COVERAGE_OUTPUT_DIR instead."

+fi

-# -covermode=atomic becomes default with -race in Go >=1.3

-if [ -z ${KUBE_COVER+x} ]; then

-  KUBE_COVER=""

+if [[ -n "${KUBE_RACE+x}" ]]; then

+    DETECT_RACES="${KUBE_RACE}"

+    echo "[WARNING] The flag \$KUBE_RACE for $0 is deprecated, use \$DETECT_RACES instead."

 fi

-OUTPUT_COVERAGE=${OUTPUT_COVERAGE:-""}

+if [[ -n "${PRINT_PACKAGES+x}" ]]; then

+    DRY_RUN="${PRINT_PACKAGES}"

+    echo "[WARNING] The flag \$PRINT_PACKAGES for $0 is deprecated, use \$DRY_RUN instead."

+fi

-if [ -n "${OUTPUT_COVERAGE}" ]; then

-  if [ -z ${KUBE_RACE+x} ]; then

-    KUBE_RACE="-race"

-  fi

-  if [ -z "${KUBE_COVER}" ]; then

-    KUBE_COVER="-cover -covermode=atomic"

-  fi

+# Internalize environment variables we consume and default if they're not set

+dry_run="${DRY_RUN:-}"

+test_kube="${TEST_KUBE:-}"

+test_timeout="${TIMEOUT:-60s}"

+detect_races="${DETECT_RACES:-true}"

+coverage_output_dir="${COVERAGE_OUTPUT_DIR:-}"

+coverage_spec="${COVERAGE_SPEC:--cover -covermode atomic}"

+gotest_flags="${GOTEST_FLAGS:-}"

+junit_report="${JUNIT_REPORT:-}"

+

+if [[ -n "${junit_report}" && -n "${coverage_output_dir}" ]]; then

+    echo "$0 cannot create jUnit XML reports and coverage reports at the same time."

+    exit 1

 fi

-if [ -z ${KUBE_RACE+x} ]; then

-  KUBE_RACE=""

+# determine if user wanted verbosity

+verbose=

+if [[ "${gotest_flags}" =~ -v( |$) ]]; then

+    verbose=true

 fi

-KUBE_TIMEOUT=${KUBE_TIMEOUT:-'60s'}

-

-if [ "${1-}" != "" ]; then

-  suffix=/...

-  if [[ "${1}" == *"${suffix}" ]]; then

-    # if the package name ends with /... they are intending a recursive test

-    test_packages=$(find_test_dirs "${1%$suffix}")

-  else

-    test_packages="$OS_GO_PACKAGE/$1"

-  fi

-elif [ -n "$TEST_KUBE" ]; then

-  test_packages=`find_test_dirs "."; special_upstream_test_dirs; find_upstream_test_dirs`

-else

-  test_packages=`find_test_dirs "."; special_upstream_test_dirs`

+# Build arguments for 'go test'

+if [[ -z "${verbose}" && -n "${junit_report}" ]]; then

+    # verbosity can be set explicitly by the user or set implicitly by asking for the jUnit 

+    # XML report, so we only want to add the flag if it hasn't been added by a user already 

+    # and is being implicitly set by jUnit report generation

+    gotest_flags+=" -v"

 fi

-if [ -n "$PRINT_PACKAGES" ]; then

-  for package in $test_packages

-  do

-    echo $package

-  done

+if [[ -n "${detect_races}" ]]; then

+    gotest_flags+=" -race"

+fi

-  exit 0

+# check to see if user has not disabled coverage mode

+if [[ -n "${coverage_spec}" ]]; then

+    # if we have a coverage spec set, we add it. '-race' implies '-cover -covermode atomic'

+    # but specifying both at the same time does not lead to an error so we can add both specs

+    gotest_flags+=" ${coverage_spec}"

 fi

-export OPENSHIFT_ON_PANIC=crash

+# check to see if user has not disabled test timeouts

+if [[ -n "${test_timeout}" ]]; then

+    gotest_flags+=" -timeout ${test_timeout}"

+fi

-if [[ -n "${KUBE_COVER}" && -n "${OUTPUT_COVERAGE}" ]]; then

-  # Iterate over packages to run coverage

-  test_packages=( $test_packages )

-  for test_package in "${test_packages[@]}"

-  do

-    mkdir -p "$OUTPUT_COVERAGE/$test_package"

-    KUBE_COVER_PROFILE="-coverprofile=$OUTPUT_COVERAGE/$test_package/profile.out"

+# list_test_packages_under lists all packages containing Golang test files that we want to run as unit tests

+# under the given base dir in the OpenShift Origin tree

+function list_test_packages_under() {

+    local basedir=$@

+

+    # we do not quote ${basedir} to allow for multiple arguments to be passed in as well as to allow for

+    # arguments that use expansion, e.g. paths containing brace expansion or wildcards

+    find ${basedir} -not \(                   \

+        \(                                    \

+              -path 'Godeps'                  \

+              -o -path '*_output'             \

+              -o -path '*_tools'              \

+              -o -path '*.git'                \

+              -o -path '*openshift.local.*'   \

+              -o -path '*Godeps/*'            \

+              -o -path '*assets/node_modules' \

+              -o -path '*test/*'              \

+        \) -prune                             \

+    \) -name '*_test.go' -print0 | xargs -0n1 dirname -z | sort -uz | xargs -0n1 printf "${OS_GO_PACKAGE}/%s\n"

+}

-    go test $KUBE_RACE -timeout $KUBE_TIMEOUT $KUBE_COVER "$KUBE_COVER_PROFILE" "$test_package" "${@:2}"

-  done

+# Break up the positional arguments into packages that need to be tested and arguments that need to be passed to `go test`

+package_args=

+for arg in "$@"; do

+    if [[ "${arg}" =~ -.* ]]; then

+        # we found an arg that begins with a dash, so we stop interpreting arguments 

+        # henceforth as packages and instead interpret them as flags to give to `go test`

+        break

+    fi

+    # an arg found before the first flag is a package

+    package_args+=" ${arg}"

+    shift

+done

+gotest_flags+=" $*"

+

+# Determine packages to test

+test_packages=

+if [[ -n "${package_args}" ]]; then

+    for package in ${package_args}; do

+        test_packages="${test_packages} ${OS_GO_PACKAGE}/${package}"

+    done

+else

+    # If no packages are given to test, we need to generate a list of all packages with unit tests

+    openshift_test_packages="$(list_test_packages_under '*')"  

+

+    kubernetes_path="Godeps/_workspace/src/k8s.io/kubernetes"

+    mandatory_kubernetes_packages="${OS_GO_PACKAGE}/${kubernetes_path}/pkg/api ${OS_GO_PACKAGE}/${kubernetes_path}/pkg/api/v1"

+

+    test_packages="${openshift_test_packages} ${mandatory_kubernetes_packages}"

+

+    if [[ -n "${test_kube}" ]]; then

+        # we need to find all of the kubernetes test suites, excluding those we directly whitelisted before, the end-to-end suite, and

+        # the go2idl tests which we currently do not support

+        optional_kubernetes_packages="$(find "${kubernetes_path}" -not \(                             \

+          \(                                                                                          \

+            -path "${kubernetes_path}/pkg/api"                                                        \

+            -o -path "${kubernetes_path}/pkg/api/v1"                                                  \

+            -o -path "${kubernetes_path}/test/e2e"                                                    \

+            -o -path "${kubernetes_path}/cmd/libs/go2idl/client-gen/testoutput/testgroup/unversioned" \

+          \) -prune                                                                                   \

+        \) -name '*_test.go' -print0 | xargs -0n1 dirname -z | sort -uz | xargs -0n1 printf "${OS_GO_PACKAGE}/%s\n")"

+

+        test_packages="${test_packages} ${optional_kubernetes_packages}"

+    fi

+fi

-  echo 'mode: atomic' > ${OUTPUT_COVERAGE}/profiles.out

-  find $OUTPUT_COVERAGE -name profile.out | xargs sed '/^mode: atomic$/d' >> ${OUTPUT_COVERAGE}/profiles.out

-  go tool cover "-html=${OUTPUT_COVERAGE}/profiles.out" -o "${OUTPUT_COVERAGE}/coverage.html"

+if [[ -n "${dry_run}" ]]; then

+    echo "The following base flags for \`go test\` will be used by $0:"

+    echo "go test ${gotest_flags}"

+    echo "The following packages will be tested by $0:"

+    for package in ${test_packages}; do

+        echo "${package}"

+    done

+    exit 0

+fi

-  rm -rf $OUTPUT_COVERAGE/$OS_GO_PACKAGE

+# Run 'go test' with the accumulated arguments and packages:

+if [[ -n "${junit_report}" ]]; then

+    # we need to generate jUnit xml

+    hack/build-go.sh tools/junitreport

+    junitreport="$(os::build::find-binary junitreport)"

+

+    if [[ -z "${junitreport}" ]]; then

+        echo "It looks as if you don't have a compiled junitreport binary"

+        echo

+        echo "If you are running from a clone of the git repo, please run"

+        echo "'./hack/build-go.sh tools/junitreport'."

+        exit 1

+    fi

+

+    test_output_file="${LOG_DIR}/test-go.log"

+    junit_report_file="${ARTIFACT_DIR}/report.xml"

+

+    # we don't care if 'go test' fails, we want to summarize the output anyway.

+    return_code=0 # default to 0, overwrite only if the following line fails

+    go test ${gotest_flags} ${test_packages} > ${test_output_file} 2>&1 || return_code=$?

+    echo "[INFO] Output from \`go test\` redirected to ${test_output_file}"

+

+    cat "${test_output_file}" | "${junitreport}" --type gotest --suites nested --roots github.com/openshift/origin > "${junit_report_file}"

+    echo "[INFO] jUnit XML report placed at ${junit_report_file}"

+    cat "${junit_report_file}" | "${junitreport}" summarize

+    exit "${return_code}"

+

+elif [[ -n "${coverage_output_dir}" ]]; then

+    # we need to generate coverage reports

+    for test_package in ${test_packages}; do

+        mkdir -p "${coverage_output_dir}/${test_package}"

+        local_gotest_flags="${gotest_flags} -coverprofile=${coverage_output_dir}/${test_package}/profile.out"

+

+        go test ${local_gotest_flags} ${test_package}

+    done

+

+    # assemble all profiles and generate a coverage report

+    echo 'mode: atomic' > "${coverage_output_dir}/profiles.out"

+    find "${coverage_output_dir}" -name profile.out | xargs sed '/^mode: atomic$/d' >> "${coverage_output_dir}/profiles.out"

+

+    go tool cover "-html=${coverage_output_dir}/profiles.out" -o "${coverage_output_dir}/coverage.html"

+    echo "[INFO] Coverage profile written to ${coverage_output_dir}/coverage.html"

+

+    # clean up all of the individual coverage reports as they have been subsumed into the report at ${coverage_output_dir}/coverage.html

+    # we can clean up all of the coverage reports at once as they all exist in subdirectories of ${coverage_output_dir}/${OS_GO_PACKAGE}

+    # and they are the only files found in those subdirectories

+    rm -rf "${coverage_output_dir}/${OS_GO_PACKAGE}"

 else

-  nice go test $KUBE_RACE -timeout $KUBE_TIMEOUT $KUBE_COVER "${@:2}" $test_packages

+    # we need to generate neither jUnit XML nor coverage reports

+    go test ${gotest_flags} ${test_packages}

 fi

-

-ret=$?; ENDTIME=$(date +%s); echo "$0 took $(($ENDTIME - $STARTTIME)) seconds"; exit "$ret"