./test: Refactoring of test script for modularization

This refactoring offers following benefits:

  - Unified way how go test commands are being called (in terms of flags intepretation)
  - Uses standard go mechanisms (like go lists) to find files/packages that are subject for test. The mechanism are module aware.
  - Added instruction how to install tools needed for the tests/checkers.
  - Added colors to the output to make it easier to spot any failure.

Confirmed to work using:
- COVERDIR="./coverage" CPU="4" RACE=false COVER=false PASSES="build build_cov cov" ./test
- CPU="4" RACE=false COVER=false PASSES="e2e functional integration" ./test
- COVERDIR="./coverage" COVER="false" CPU="4" RACE="false" PASSES="fmt build unit build_cov integration e2e integration_e2e grpcproxy cov" ./test
- PASSES=unit PKG=./wal TIMEOUT=1m ./test
- PASSES=integration PKG=./clientv3 TIMEOUT=1m ./test
- PASSES=unit PKG=./wal TESTCASE=TestNew TIMEOUT=1m ./test
- PASSES=unit PKG=./wal TESTCASE="\bTestNew\b" TIMEOUT=1m ./test
- PASSES=integration PKG=./client/integration TESTCASE="\bTestV2NoRetryEOF\b" TIMEOUT=1m ./test
- COVERDIR=coverage PASSES="build_cov cov" ./test

.gitignore

@@ -17,5 +17,6 @@ hack/tls-setup/certs
 /contrib/raftexample/raftexample
 /contrib/raftexample/raftexample-*
 /vendor
+/tests/e2e/default.proxy
 
 *.bak

.travis.yml

@@ -78,19 +78,22 @@ script:
           /bin/bash -c "GOARCH=amd64 PASSES='fmt bom dep' ./test"
         ;;
       linux-amd64-integration-1-cpu)
+        # TODO: Reenable 'race' when https://github.com/etcd-io/etcd/issues/12336 fixed.
         docker run --rm \
           --volume=`pwd`:/go/src/go.etcd.io/etcd gcr.io/etcd-development/etcd-test:go${TRAVIS_GO_VERSION} \
-          /bin/bash -c "GOARCH=amd64 CPU=1 PASSES='integration' ./test"
+          /bin/bash -c "GOARCH=amd64 CPU=1 PASSES='integration' RACE='false' ./test"
         ;;
       linux-amd64-integration-2-cpu)
+        # TODO: Reenable 'race' when https://github.com/etcd-io/etcd/issues/12336 fixed.
         docker run --rm \
           --volume=`pwd`:/go/src/go.etcd.io/etcd gcr.io/etcd-development/etcd-test:go${TRAVIS_GO_VERSION} \
-          /bin/bash -c "GOARCH=amd64 CPU=2 PASSES='integration' ./test"
+          /bin/bash -c "GOARCH=amd64 CPU=2 PASSES='integration' RACE='false' ./test"
         ;;
       linux-amd64-integration-4-cpu)
+        # TODO: Reenable 'race' when https://github.com/etcd-io/etcd/issues/12336 fixed.
         docker run --rm \
           --volume=`pwd`:/go/src/go.etcd.io/etcd gcr.io/etcd-development/etcd-test:go${TRAVIS_GO_VERSION} \
-          /bin/bash -c "GOARCH=amd64 CPU=4 PASSES='integration' ./test"
+          /bin/bash -c "GOARCH=amd64 CPU=4 PASSES='integration' RACE='false' ./test"
         ;;
       linux-amd64-functional)
         docker run --rm \
@@ -100,7 +103,7 @@ script:
       linux-amd64-unit)
         docker run --rm \
           --volume=`pwd`:/go/src/go.etcd.io/etcd gcr.io/etcd-development/etcd-test:go${TRAVIS_GO_VERSION} \
-          /bin/bash -c "GOARCH=amd64 PASSES='unit' ./test"
+          /bin/bash -c "GOARCH=amd64 PASSES='unit' ./test -p=2"
         ;;
       all-build)
         docker run --rm \
@@ -115,17 +118,18 @@ script:
             && GO_BUILD_FLAGS='-v -mod=readonly' GOARCH=s390x ./build"
         ;;
       linux-amd64-grpcproxy)
-        sudo HOST_TMP_DIR=/tmp TEST_OPTS="PASSES='build grpcproxy'" make docker-test
+        # TODO: Reenable race when https://github.com/etcd-io/etcd/issues/12336 fixed.
+        sudo HOST_TMP_DIR=/tmp TEST_OPTS="PASSES='build grpcproxy' VERBOSE='1' CPU='4' COVER='false' RACE='false'" make docker-test
         ;;
       linux-amd64-coverage)
-        sudo HOST_TMP_DIR=/tmp make docker-test-coverage
+        sudo HOST_TMP_DIR=/tmp TEST_OPTS="VERBOSE='1'" make docker-test-coverage
         ;;
       linux-amd64-fmt-unit-go-tip)
-        GOARCH=amd64 PASSES='fmt unit' ./test
+        GOARCH=amd64 PASSES='fmt unit' ./test -p=2
         ;;
       linux-386-unit)
         docker run --rm \
           --volume=`pwd`:/go/src/go.etcd.io/etcd gcr.io/etcd-development/etcd-test:go${TRAVIS_GO_VERSION} \
-          /bin/bash -c "GOARCH=386 PASSES='unit' ./test"
+          /bin/bash -c "GOARCH=386 PASSES='unit' ./test -p=2"
         ;;
     esac

clientv3/snapshot/v3_snapshot_test.go

@@ -33,8 +33,6 @@ import (
 	"go.uber.org/zap"
 )
 
-// TODO(ptabor): This is integration test. Skip it in --short and move to integration tests directory.
-
 // TestSnapshotV3RestoreSingle tests single node cluster restoring
 // from a snapshot file.
 func TestSnapshotV3RestoreSingle(t *testing.T) {
@@ -194,6 +192,8 @@ type kv struct {
 
 // creates a snapshot file and returns the file path.
 func createSnapshotFile(t *testing.T, kvs []kv) string {
+	testutil.SkipTestIfShortMode(t,
+		"Snapshot creation tests are depending on embedded etcServer so are integration-level tests.")
 	clusterN := 1
 	urls := newEmbedURLs(clusterN * 2)
 	cURLs, pURLs := urls[:clusterN], urls[clusterN:]

integration/embed/embed_proxy_test.go

@@ -0,0 +1,19 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// +build cluster_proxy
+
+// The purpose of this (empty) package is too keep following test working:
+// #  go test -tags=cluster_proxy ./integration/embed
+package embed_test

scripts/test_lib.sh

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+
+ETCD_ROOT_DIR="$(pwd)"
+
+####   Convenient IO methods #####
+
+COLOR_RED='\033[0;31m'
+COLOR_ORANGE='\033[0;33m'
+COLOR_GREEN='\033[0;32m'
+COLOR_LIGHTCYAN='\033[0;36m'
+
+COLOR_NONE='\033[0m' # No Color
+
+function log_error {
+  >&2 echo -n -e "${COLOR_RED}"
+  >&2 echo "$@"
+  >&2 echo -n -e "${COLOR_NONE}"
+}
+
+function log_warning {
+  >&2 echo -n -e "${COLOR_ORANGE}"
+  >&2 echo "$@"
+  >&2 echo -n -e "${COLOR_NONE}"
+}
+
+function log_callout {
+  >&2 echo -n -e "${COLOR_LIGHTCYAN}"
+  >&2 echo "$@"
+  >&2 echo -n -e "${COLOR_NONE}"
+}
+
+function log_success {
+  >&2 echo -n -e "${COLOR_GREEN}"
+  >&2 echo "$@"
+  >&2 echo -n -e "${COLOR_NONE}"
+}
+
+
+####   Discovery of files/packages within a go module #####
+
+# go_srcs_in_module [package]
+# returns list of all not-generated go sources in the current (dir) module.
+function go_srcs_in_module {
+  go fmt -n "$1"  | grep -Eo "([^ ]*)$" | grep -vE "(\\_test.go|\\.pb\\.go|\\.pb\\.gw.go)"
+}
+
+# pkgs_in_module [optional:package_pattern]
+# returns list of all packages in the current (dir) module.
+# if the package_pattern is given, its being resolved.
+function pkgs_in_module {
+  go list -mod=mod "${1:-./...}";
+}
+
+function filter_out_integration_style_tests {
+  grep -Ev '/(tests/e2e|integration|functional)(/|$)'
+}
+
+####    Running actions against multiple modules ####
+
+# run [command...] - runs given command, printing it first and
+# again if it failed (in RED). Use to wrap important test commands
+# that user might want to re-execute to shorten the feedback loop when fixing
+# the test.
+function run {
+  local rpath
+  rpath=$(realpath "--relative-to=${ETCD_ROOT_DIR}" "${PWD}")
+  local repro="$*"
+  if [ "${rpath}" != "." ]; then
+    repro="(cd ${rpath} && ${repro})"
+  fi
+
+  log_callout "% ${repro}"
+  "${@}"
+  local error_code=$?
+  if [ ${error_code} != 0 ]; then
+    log_error -e "FAIL: (code:${error_code}):\n  % ${repro}"
+    return ${error_code}
+  fi
+}
+
+# run_for_module [module] [cmd]
+# executes given command in the given module for given pkgs.
+#   module_name - "." (in future: tests, client, server)
+#   cmd         - cmd to be executed - that takes package as last argument
+function run_for_module {
+  local module=${1:-"."}
+  shift 1
+  (
+    cd "${module}" && "$@"
+  )
+}
+
+#  run_for_modules [cmd]
+#  run given command across all modules and packages
+#  (unless the set is limited using ${PKG} or / ${USERMOD})
+function run_for_modules {
+  local pkg="${PKG:-./...}"
+  if [ -z "${USERMOD}" ]; then
+    run_for_module "." "$@" "${pkg}" || return "$?"
+  else
+    run_for_module "${USERMOD}" "$@" "${pkg}" || return "$?"
+  fi
+}
+
+
+####    Running go test  ########
+
+# go_test [packages] [mode] [flags_for_package_func] [$@]
+# [mode] supports 3 states:
+#   - "parallel": fastest as concurrently processes multiple packages, but silent
+#                 till the last package. See: https://github.com/golang/go/issues/2731
+#   - "keep_going" : executes tests package by package, but postpones reporting error to the last
+#   - "fail_fast"  : executes tests packages 1 by 1, exits on the first failure.
+#
+# [flags_for_package_func] is a name of function that takes list of packages as parameter
+#   and computes additional flags to the go_test commands.
+#   Use 'true' or ':' if you dont need additional arguments.
+#
+#  depends on the VERBOSE top-level variable.
+#
+#  Example:
+#    go_test "./..." "keep_going" ":" --short
+#
+#  The function returns != 0 code in case of test failure.
+function go_test {
+  local packages="${1}"
+  local mode="${2}"
+  local flags_for_package_func="${3}"
+
+  shift 3
+
+  local goTestFlags=""
+  local goTestEnv=""
+  if [ "${VERBOSE}" == "1" ]; then
+    goTestFlags="-v"
+  fi
+  if [ "${VERBOSE}" == "2" ]; then
+    goTestFlags="-v"
+    goTestEnv="CLIENT_DEBUG=1"
+  fi
+
+  # Expanding patterns (like ./...) into list of packages
+
+  local unpacked_packages=("${packages}")
+  if [ "${mode}" != "parallel" ]; then
+    # shellcheck disable=SC2207
+    # shellcheck disable=SC2086
+    if ! unpacked_packages=($(go list ${packages})); then
+      log_error "Cannot resolve packages: ${packages}"
+      return 255
+    fi
+  fi
+
+  local failures=""
+
+  # execution of tests against packages:
+  for pkg in "${unpacked_packages[@]}"; do
+    local additional_flags
+    # shellcheck disable=SC2086
+    additional_flags=$(${flags_for_package_func} ${pkg})
+
+    # shellcheck disable=SC2206
+    local cmd=( go test ${goTestFlags} ${additional_flags} "$@" ${pkg} )
+
+    if ! run env ${goTestEnv} "${cmd[@]}" ; then
+      if [ "${mode}" != "keep_going" ]; then
+        return 2
+      else
+        failures=("${failures[@]}" "${pkg}")
+      fi
+    fi
+    echo
+  done
+
+  if [ -n "${failures[*]}" ] ; then
+    log_error -e "ERROR: Tests for following packages failed:\n  ${failures[*]}"
+    return 2
+  fi
+}
+
+#### Other ####
+
+# tool_exists [tool] [instruction]
+# Checks whether given [tool] is installed. In case of failure,
+# prints a warning with installation [instruction] and returns !=0 code.
+function tool_exists {
+  local tool="${1}"
+  local instruction="${2}"
+  if ! command -v "${tool}" >/dev/null; then
+    log_warning "Tool: '${tool}' not found on PATH. ${instruction}"
+    return 255
+  fi
+}
+