diff --git a/hack/test-extended.sh b/hack/test-extended.sh new file mode 100755 index 000000000000..e2edc302418b --- /dev/null +++ b/hack/test-extended.sh @@ -0,0 +1,125 @@ +#!/bin/bash + +set -o nounset +set -o pipefail + +OS_ROOT=$(dirname "${BASH_SOURCE}")/.. + +source ${OS_ROOT}/hack/util.sh +source ${OS_ROOT}/hack/common.sh + +TIME_SEC=1000 +TIME_MIN=$((60 * $TIME_SEC)) + +# TODO: Randomize these ports +export OS_MASTER_PORT=$(go run ${OS_ROOT}/test/util/random_port/generate.go) +export OS_ASSETS_PORT=$(go run ${OS_ROOT}/test/util/random_port/generate.go) +export OS_DNS_PORT=$(go run ${OS_ROOT}/test/util/random_port/generate.go) +export ETCD_PORT=$(go run ${OS_ROOT}/test/util/random_port/generate.go) + +DEFAULT_SERVER_IP=$(ifconfig | grep -Ev "(127.0.0.1|172.17.42.1)" | grep "inet " | head -n 1 | awk '{print $2}') + +export OS_MASTER_ADDR=${DEFAULT_SERVER_IP}:${OS_MASTER_PORT} +export OS_ASSETS_ADDR=${DEFAULT_SERVER_IP}:${OS_ASSETS_PORT} +export OS_DNS_ADDR=${DEFAULT_SERVER_IP}:${OS_DNS_PORT} +export KUBERNETES_MASTER="https://${OS_MASTER_ADDR}" + +export TMPDIR=${TMPDIR:-/tmp} +export BASETMPDIR="${TMPDIR}/openshift-extended-tests" + +# Remove all test artifacts from the previous run +rm -rf ${BASETMPDIR} && mkdir -p ${BASETMPDIR} + +# Setup directories and certificates for 'curl' +export CERT_DIR="${BASETMPDIR}/cert" +export CURL_CA_BUNDLE="${CERT_DIR}/ca/cert.crt" +export CURL_CERT="${CERT_DIR}/admin/cert.crt" +export CURL_KEY="${CERT_DIR}/admin/key.key" +export KUBECONFIG="${CERT_DIR}/admin/.kubeconfig" +export OPENSHIFT_ON_PANIC=crash + +cleanup() { + set +e + server_pids=$(pgrep -P $(cat ${BASETMPDIR}/server.pid)) + kill $server_pids $(cat ${BASETMPDIR}/server.pid) ${ETCD_PID} + rm -rf ${ETCD_DIR} + echo "[INFO] Cleanup complete" +} + +# TODO: There is a lot of code shared between this test launcher and e2e test +# launcher. +start_server() { + mkdir -p ${BASETMPDIR}/volumes + ALL_IP_ADDRESSES=`ifconfig | grep "inet " | awk '{print $2}'` + SERVER_HOSTNAME_LIST="${DEFAULT_SERVER_IP},localhost" + while read -r IP_ADDRESS; do + SERVER_HOSTNAME_LIST="${SERVER_HOSTNAME_LIST},${IP_ADDRESS}" + done <<< "${ALL_IP_ADDRESSES}" + + echo "[INFO] Create certificates for the OpenShift server" + sudo env "PATH=${PATH}" openshift admin create-all-certs \ + --overwrite=false \ + --cert-dir="${CERT_DIR}" \ + --hostnames="${SERVER_HOSTNAME_LIST}" \ + --nodes="127.0.0.1" \ + --master="https://${OS_MASTER_ADDR}" \ + --public-master="https://${OS_MASTER_ADDR}" + + echo "[INFO] Starting OpenShift server" + sudo env "PATH=${PATH}" openshift start \ + --listen="https://0.0.0.0:${OS_MASTER_PORT}" \ + --public-master="https://${OS_MASTER_ADDR}" \ + --etcd="http://127.0.0.1:${ETCD_PORT}" \ + --hostname="127.0.0.1" \ + --create-certs=false \ + --cert-dir="${CERT_DIR}" \ + --volume-dir="${BASETMPDIR}/volumes" \ + --master="https://${OS_MASTER_ADDR}" \ + --latest-images \ + --loglevel=${VERBOSE:-3} &> ${BASETMPDIR}/server.log & + echo -n $! > ${BASETMPDIR}/server.pid +} + +start_docker_registry() { + mkdir -p ${BASETMPDIR}/.registry + echo "[INFO] Creating default Router" + openshift ex router --create --credentials="${KUBECONFIG}" \ + --images='openshift/origin-${component}:latest' &>/dev/null + + echo "[INFO] Creating Docker Registry" + openshift ex registry --create --credentials="${KUBECONFIG}" \ + --mount-host="${BASETMPDIR}/.registry" \ + --images='openshift/origin-${component}:latest' &>/dev/null +} + +# Go to the top of the tree. +cd "${OS_ROOT}" + +trap cleanup EXIT SIGINT + +# Start the Etcd server +echo "[INFO] Starting etcd server (127.0.0.1:${ETCD_PORT})" +start_etcd +export ETCD_STARTED="1" + +# Start OpenShift sever that will be common for all extended test cases +start_server + +# Wait for the API server to come up +wait_for_url_timed "https://${OS_MASTER_ADDR}/healthz" "" 90*TIME_SEC >/dev/null +wait_for_url_timed "https://${OS_MASTER_ADDR}/osapi" "" 90*TIME_SEC >/dev/null +wait_for_url "https://${OS_MASTER_ADDR}/api/v1beta1/minions/127.0.0.1" "" 0.25 80 >/dev/null + +# Start the Docker registry (172.30.17.101:5000) +start_docker_registry + +wait_for_command '[[ "$(osc get endpoints docker-registry -t "{{ if .endpoints}}{{ len .endpoints }}{{ else }}0{{ end }}" 2>/dev/null || echo "0")" != "0" ]]' $((5*TIME_MIN)) + +REGISTRY_ADDR=$(osc get --output-version=v1beta1 --template="{{ .portalIP }}:{{.port }}" \ + service docker-registry) +echo "[INFO] Verifying the docker-registry is up at ${REGISTRY_ADDR}" +wait_for_url_timed "http://${REGISTRY_ADDR}" "" $((2*TIME_MIN)) + +# Run all extended tests cases +echo "[INFO] Starting extended tests" +OS_TEST_PACKAGE="test/extended" OS_TEST_TAGS="extended" OS_TEST_NAMESPACE="extended" ${OS_ROOT}/hack/test-integration.sh $@ diff --git a/hack/test-integration.sh b/hack/test-integration.sh index 4727c3692854..d350d8cd3d8f 100755 --- a/hack/test-integration.sh +++ b/hack/test-integration.sh @@ -15,16 +15,20 @@ os::build::setup_env function cleanup() { - set +e - kill ${ETCD_PID} 1>&2 2>/dev/null - rm -rf ${ETCD_DIR} 1>&2 2>/dev/null - echo - echo "Complete" + [ ! -z "${ETCD_STARTED-}" ] && return + set +e + kill ${ETCD_PID} 1>&2 2>/dev/null + rm -rf ${ETCD_DIR} 1>&2 2>/dev/null + echo + echo "Complete" } package="${OS_TEST_PACKAGE:-test/integration}" tags="${OS_TEST_TAGS:-integration no-docker}" +TMPDIR=${TMPDIR:-/tmp} +export BASETMPDIR=${BASETMPDIR:-"${TMPDIR}/openshift-integration"} + echo echo "Test ${package} -tags='${tags}' ..." echo @@ -44,15 +48,21 @@ start_etcd trap cleanup EXIT SIGINT function exectest() { - echo "running $1..." + echo "Running $1..." - out=$("${testexec}" -test.run="^$1$" "${@:2}" 2>&1) + result=1 + if [ ! -z "${VERBOSE-}" ]; then + out=$("${testexec}" -test.v=true -v ${VERBOSE-} -test.run="^$1$" "${@:2}" 2>&1) + result=$? + else + out=$("${testexec}" -test.run="^$1$" "${@:2}" 2>&1) + result=$? + fi tput cuu 1 # Move up one line tput el # Clear "running" line - res=$? - if [[ ${res} -eq 0 ]]; then + if [[ ${result} -eq 0 ]]; then tput setaf 2 # green echo "ok $1" tput sgr0 # reset @@ -65,6 +75,7 @@ function exectest() { exit 1 fi } + export -f exectest export testexec export childargs diff --git a/hack/util.sh b/hack/util.sh index 3c8fc5819f5f..8385f532733c 100644 --- a/hack/util.sh +++ b/hack/util.sh @@ -197,6 +197,8 @@ function validate_response { # $1 - Optional host (Default: 127.0.0.1) # $2 - Optional port (Default: 4001) function start_etcd { + [ ! -z "${ETCD_STARTED-}" ] && return + host=${ETCD_HOST:-127.0.0.1} port=${ETCD_PORT:-4001} @@ -228,7 +230,7 @@ function start_etcd { etcd -name test -data-dir ${ETCD_DIR} -bind-addr ${host}:${port} ${initial_cluster} >/dev/null 2>/dev/null & export ETCD_PID=$! - wait_for_url "http://127.0.0.1:4001/version" "etcd: " + wait_for_url "http://${host}:${port}/version" "etcd: " } # stop_openshift_server utility function to terminate an diff --git a/test/extended/build_context_dir_test.go b/test/extended/build_context_dir_test.go new file mode 100644 index 000000000000..e5e6d65d0135 --- /dev/null +++ b/test/extended/build_context_dir_test.go @@ -0,0 +1,85 @@ +// +build extended + +package extended + +// This extended tests excercise the scenario of having the 'contextDir' set to +// directory where the application sources resides inside the repository. +// The STI strategy is used for this build and this test succeed when the Build +// completes and the resulting image is used for a Pod that replies to HTTP +// request. + +import ( + "fmt" + "io/ioutil" + "net/http" + "strings" + "testing" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/labels" + buildapi "github.com/openshift/origin/pkg/build/api" + "github.com/openshift/origin/test/util" +) + +func init() { + util.RequireServer() +} + +func TestSTIContextDirBuild(t *testing.T) { + namespace := util.RandomNamespace("contextdir") + fmt.Printf("Using '%s' namespace\n", namespace) + + build := util.GetBuildFixture("fixtures/contextdir-build.json") + client, _ := util.GetClusterAdminClient(util.KubeConfigPath()) + + repo := util.CreateSampleImageRepository(namespace) + if repo == nil { + t.Fatal("Failed to create ImageRepository") + } + defer util.DeleteSampleImageRepository(repo, namespace) + + // TODO: Tweak the selector to match the build name + watcher, err := client.Builds(namespace).Watch(labels.Everything(), labels.Everything(), "0") + if err != nil { + t.Fatalf("Failed to create watcher: %v", err) + } + defer watcher.Stop() + + newBuild, err := client.Builds(namespace).Create(build) + if err != nil { + t.Fatalf("Unexpected error: %v", err) + } + + for event := range watcher.ResultChan() { + build, ok := event.Object.(*buildapi.Build) + if !ok { + t.Fatalf("cannot convert input to Build") + } + + // Iterate over watcher's results and search for + // the build we just started. Also make sure that + // the build is running, complete, or has failed + if build.Name == newBuild.Name { + switch build.Status { + case buildapi.BuildStatusFailed, buildapi.BuildStatusError: + t.Fatalf("Unexpected build status: ", buildapi.BuildStatusFailed) + case buildapi.BuildStatusComplete: + err := util.VerifyImage(repo, namespace, func(addr string) error { + resp, err := http.Get("http://" + addr) + if err != nil { + return err + } + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + if strings.TrimSpace(string(body)) != "success" { + return fmt.Errorf("Expected 'success' got '%v'", body) + } + return nil + }) + if err != nil { + t.Fatalf("The build image failed validation: %v", err) + } + return + } + } + } +} diff --git a/test/extended/build_docker_test.go b/test/extended/build_docker_test.go new file mode 100644 index 000000000000..198d89bb680f --- /dev/null +++ b/test/extended/build_docker_test.go @@ -0,0 +1,61 @@ +// +build extended + +package extended + +// This extended test exercise the Docker strategy build. This test succeed when +// the Docker image is successfully built. + +import ( + "fmt" + "testing" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/labels" + buildapi "github.com/openshift/origin/pkg/build/api" + "github.com/openshift/origin/test/util" +) + +func init() { + util.RequireServer() +} + +func TestDockerStrategyBuild(t *testing.T) { + namespace := util.RandomNamespace("docker") + fmt.Printf("Using '%s' namespace\n", namespace) + + build := util.GetBuildFixture("fixtures/docker-build.json") + client, _ := util.GetClusterAdminClient(util.KubeConfigPath()) + + if repo == nil { + t.Fatal("Failed to create ImageRepository") + } + + // TODO: Tweak the selector to match the build name + watcher, err := client.Builds(namespace).Watch(labels.Everything(), labels.Everything(), "0") + if err != nil { + t.Fatalf("Failed to create watcher: %v", err) + } + defer watcher.Stop() + + newBuild, err := client.Builds(namespace).Create(build) + if err != nil { + t.Fatalf("Unexpected error: %v", err) + } + + for event := range watcher.ResultChan() { + build, ok := event.Object.(*buildapi.Build) + if !ok { + t.Fatalf("cannot convert input to Build") + } + + if build.Name == newBuild.Name { + switch build.Status { + case buildapi.BuildStatusFailed, buildapi.BuildStatusError: + t.Fatalf("Unexpected build status: ", buildapi.BuildStatusFailed) + case buildapi.BuildStatusComplete: + // If the Docker build strategy finishes with Complete, then this test + // succeeded + return + } + } + } +} diff --git a/test/extended/build_sti_env_test.go b/test/extended/build_sti_env_test.go new file mode 100644 index 000000000000..62f3bb23d349 --- /dev/null +++ b/test/extended/build_sti_env_test.go @@ -0,0 +1,85 @@ +// +build extended + +package extended + +// This extended test exercise the scenario of having the '.sti/environment' +// file in the application sources that should set the defined environment +// variables for the resulting application. HTTP request is made to Pod that +// runs the output image and this HTTP request should reply the value of the +// TEST_VAR. + +import ( + "fmt" + "io/ioutil" + "net/http" + "strings" + "testing" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/labels" + buildapi "github.com/openshift/origin/pkg/build/api" + "github.com/openshift/origin/test/util" +) + +func init() { + util.RequireServer() +} + +func TestSTIEnvironmentBuild(t *testing.T) { + namespace := util.RandomNamespace("stienv") + fmt.Printf("Using '%s' namespace\n", namespace) + + build := util.GetBuildFixture("fixtures/sti-env-build.json") + client, _ := util.GetClusterAdminClient(util.KubeConfigPath()) + + repo := util.CreateSampleImageRepository(namespace) + if repo == nil { + t.Fatal("Failed to create ImageRepository") + } + defer util.DeleteSampleImageRepository(repo, namespace) + + // TODO: Tweak the selector to match the build name + watcher, err := client.Builds(namespace).Watch(labels.Everything(), labels.Everything(), "0") + if err != nil { + t.Fatalf("Failed to create watcher: %v", err) + } + defer watcher.Stop() + + newBuild, err := client.Builds(namespace).Create(build) + if err != nil { + t.Fatalf("Unexpected error: %v", err) + } + + for event := range watcher.ResultChan() { + build, ok := event.Object.(*buildapi.Build) + if !ok { + t.Fatalf("cannot convert input to Build") + } + + // Iterate over watcher's results and search for + // the build we just started. Also make sure that + // the build is running, complete, or has failed + if build.Name == newBuild.Name { + switch build.Status { + case buildapi.BuildStatusFailed, buildapi.BuildStatusError: + t.Fatalf("Unexpected build status: ", buildapi.BuildStatusFailed) + case buildapi.BuildStatusComplete: + err := util.VerifyImage(repo, namespace, func(addr string) error { + resp, err := http.Get("http://" + addr) + if err != nil { + return err + } + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + if strings.TrimSpace(string(body)) != "success" { + return fmt.Errorf("Expected 'success' got '%v'", body) + } + return nil + }) + if err != nil { + t.Fatalf("The build image failed validation: %v", err) + } + return + } + } + } +} diff --git a/test/extended/doc.go b/test/extended/doc.go new file mode 100644 index 000000000000..edebcabf18f6 --- /dev/null +++ b/test/extended/doc.go @@ -0,0 +1,2 @@ +// Package extended contains extended tests for OpenShift Origin +package extended diff --git a/test/extended/fixtures/context-build-app/Gemfile b/test/extended/fixtures/context-build-app/Gemfile new file mode 100644 index 000000000000..e965cf0cc729 --- /dev/null +++ b/test/extended/fixtures/context-build-app/Gemfile @@ -0,0 +1,3 @@ +source "https://rubygems.org" + +gem "rack" diff --git a/test/extended/fixtures/context-build-app/config.ru b/test/extended/fixtures/context-build-app/config.ru new file mode 100644 index 000000000000..006addaf1bdf --- /dev/null +++ b/test/extended/fixtures/context-build-app/config.ru @@ -0,0 +1 @@ +run Proc.new {|env| [200, {"Content-Type" => "text/html"}, ["success"]]} diff --git a/test/extended/fixtures/contextdir-build.json b/test/extended/fixtures/contextdir-build.json new file mode 100644 index 000000000000..6f9bd4dae962 --- /dev/null +++ b/test/extended/fixtures/contextdir-build.json @@ -0,0 +1,30 @@ +{ + "apiVersion": "v1beta1", + "kind": "Build", + "metadata": { + "name": "sample", + "labels": { + "name": "sample" + } + }, + "parameters": { + "output": { + "to": { + "name": "samplerepository" + } + }, + "source": { + "type": "Git", + "git": { + "uri": "https://github.com/openshift/origin" + }, + "contextDir": "test/extended/fixtures/context-build-app" + }, + "strategy": { + "type": "STI", + "stiStrategy": { + "image": "openshift/ruby-20-centos7" + } + } + } +} diff --git a/test/extended/fixtures/docker-build-app/Dockerfile b/test/extended/fixtures/docker-build-app/Dockerfile new file mode 100644 index 000000000000..6877861e1104 --- /dev/null +++ b/test/extended/fixtures/docker-build-app/Dockerfile @@ -0,0 +1,3 @@ +FROM busybox + +ENTRYPOINT echo "success" diff --git a/test/extended/fixtures/docker-build.json b/test/extended/fixtures/docker-build.json new file mode 100644 index 000000000000..15ef73dc9fbe --- /dev/null +++ b/test/extended/fixtures/docker-build.json @@ -0,0 +1,22 @@ +{ + "apiVersion": "v1beta1", + "kind": "Build", + "metadata": { + "name": "sample", + "labels": { + "name": "sample" + } + }, + "parameters": { + "source": { + "type": "Git", + "git": { + "uri": "https://github.com/openshift/origin" + }, + "contextDir": "test/extended/fixtures/docker-build-app" + }, + "strategy": { + "type": "Docker" + } + } +} diff --git a/test/extended/fixtures/sample-image-repository.json b/test/extended/fixtures/sample-image-repository.json new file mode 100644 index 000000000000..69496889e084 --- /dev/null +++ b/test/extended/fixtures/sample-image-repository.json @@ -0,0 +1,7 @@ +{ + "apiVersion": "v1beta1", + "kind": "ImageRepository", + "metadata": { + "name": "samplerepository" + } +} diff --git a/test/extended/fixtures/sti-env-build.json b/test/extended/fixtures/sti-env-build.json new file mode 100644 index 000000000000..b5c8dc0c4444 --- /dev/null +++ b/test/extended/fixtures/sti-env-build.json @@ -0,0 +1,30 @@ +{ + "apiVersion": "v1beta1", + "kind": "Build", + "metadata": { + "name": "sample", + "labels": { + "name": "sample" + } + }, + "parameters": { + "output": { + "to": { + "name": "samplerepository" + } + }, + "source": { + "type": "Git", + "git": { + "uri": "https://github.com/openshift/origin" + }, + "contextDir": "test/extended/fixtures/sti-environment-build-app" + }, + "strategy": { + "type": "STI", + "stiStrategy": { + "image": "openshift/ruby-20-centos7" + } + } + } +} diff --git a/test/extended/fixtures/sti-environment-build-app/.sti/environment b/test/extended/fixtures/sti-environment-build-app/.sti/environment new file mode 100644 index 000000000000..eb4a24af056f --- /dev/null +++ b/test/extended/fixtures/sti-environment-build-app/.sti/environment @@ -0,0 +1 @@ +TEST_ENV=success diff --git a/test/extended/fixtures/sti-environment-build-app/Gemfile b/test/extended/fixtures/sti-environment-build-app/Gemfile new file mode 100644 index 000000000000..e965cf0cc729 --- /dev/null +++ b/test/extended/fixtures/sti-environment-build-app/Gemfile @@ -0,0 +1,3 @@ +source "https://rubygems.org" + +gem "rack" diff --git a/test/extended/fixtures/sti-environment-build-app/config.ru b/test/extended/fixtures/sti-environment-build-app/config.ru new file mode 100644 index 000000000000..a3bed2276520 --- /dev/null +++ b/test/extended/fixtures/sti-environment-build-app/config.ru @@ -0,0 +1 @@ +run Proc.new {|env| [200, {"Content-Type" => "text/html"}, [ENV['TEST_ENV']]]} diff --git a/test/integration/auth_proxy_test.go b/test/integration/auth_proxy_test.go index b70cd6b5c764..356bdcb4c2b9 100644 --- a/test/integration/auth_proxy_test.go +++ b/test/integration/auth_proxy_test.go @@ -26,10 +26,11 @@ import ( "github.com/openshift/origin/pkg/oauth/server/osinserver/registrystorage" "github.com/openshift/origin/pkg/user" useretcd "github.com/openshift/origin/pkg/user/registry/etcd" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } var ( @@ -41,10 +42,10 @@ var ( ) func TestFrontProxyOnAuthorize(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() // setup - etcdClient := newEtcdClient() + etcdClient := util.NewEtcdClient() etcdHelper, _ := master.NewEtcdHelper(etcdClient, klatest.Version) oauthEtcd := oauthetcd.New(etcdHelper) userRegistry := useretcd.New(etcdHelper, user.NewDefaultUserInitStrategy()) diff --git a/test/integration/authorization_test.go b/test/integration/authorization_test.go index a65d74aacba4..4ae00008e5c2 100644 --- a/test/integration/authorization_test.go +++ b/test/integration/authorization_test.go @@ -10,6 +10,7 @@ import ( kapierror "github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/util" + testutil "github.com/openshift/origin/test/util" authorizationapi "github.com/openshift/origin/pkg/authorization/api" "github.com/openshift/origin/pkg/client" @@ -18,21 +19,26 @@ import ( ) func TestRestrictedAccessForProjectAdmins(t *testing.T) { - _, clusterAdminKubeConfig, err := StartTestMaster() + _, clusterAdminKubeConfig, err := testutil.StartTestMaster() if err != nil { t.Fatalf("unexpected error: %v", err) } - clusterAdminClient, _, clusterAdminClientConfig, err := GetClusterAdminClient(clusterAdminKubeConfig) + clusterAdminClient, err := testutil.GetClusterAdminClient(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } - haroldClient, err := CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "hammer-project", "harold") + clusterAdminClientConfig, err := testutil.GetClusterAdminClientConfig(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } - markClient, err := CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "mallet-project", "mark") + + haroldClient, err := testutil.CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "hammer-project", "harold") + if err != nil { + t.Errorf("unexpected error: %v", err) + } + markClient, err := testutil.CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "mallet-project", "mark") if err != nil { t.Errorf("unexpected error: %v", err) } @@ -82,12 +88,12 @@ func TestRestrictedAccessForProjectAdmins(t *testing.T) { } func TestOnlyResolveRolesForBindingsThatMatter(t *testing.T) { - _, clusterAdminKubeConfig, err := StartTestMaster() + _, clusterAdminKubeConfig, err := testutil.StartTestMaster() if err != nil { t.Fatalf("unexpected error: %v", err) } - clusterAdminClient, _, _, err := GetClusterAdminClient(clusterAdminKubeConfig) + clusterAdminClient, err := testutil.GetClusterAdminClient(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -157,21 +163,27 @@ func (test resourceAccessReviewTest) run(t *testing.T) { } func TestResourceAccessReview(t *testing.T) { - _, clusterAdminKubeConfig, err := StartTestMaster() + _, clusterAdminKubeConfig, err := testutil.StartTestMaster() if err != nil { t.Fatalf("unexpected error: %v", err) } - clusterAdminClient, _, clusterAdminClientConfig, err := GetClusterAdminClient(clusterAdminKubeConfig) + clusterAdminClient, err := testutil.GetClusterAdminClient(clusterAdminKubeConfig) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + + clusterAdminClientConfig, err := testutil.GetClusterAdminClientConfig(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } - haroldClient, err := CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "hammer-project", "harold") + haroldClient, err := testutil.CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "hammer-project", "harold") if err != nil { t.Errorf("unexpected error: %v", err) } - markClient, err := CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "mallet-project", "mark") + markClient, err := testutil.CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "mallet-project", "mark") + if err != nil { t.Errorf("unexpected error: %v", err) } @@ -279,21 +291,27 @@ func (test subjectAccessReviewTest) run(t *testing.T) { } func TestSubjectAccessReview(t *testing.T) { - _, clusterAdminKubeConfig, err := StartTestMaster() + _, clusterAdminKubeConfig, err := testutil.StartTestMaster() if err != nil { t.Fatalf("unexpected error: %v", err) } - clusterAdminClient, _, clusterAdminClientConfig, err := GetClusterAdminClient(clusterAdminKubeConfig) + clusterAdminClient, err := testutil.GetClusterAdminClient(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } - haroldClient, err := CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "hammer-project", "harold") + clusterAdminClientConfig, err := testutil.GetClusterAdminClientConfig(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } - markClient, err := CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "mallet-project", "mark") + + haroldClient, err := testutil.CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "hammer-project", "harold") + if err != nil { + t.Errorf("unexpected error: %v", err) + } + markClient, err := testutil.CreateNewProject(clusterAdminClient, *clusterAdminClientConfig, "mallet-project", "mark") + if err != nil { t.Errorf("unexpected error: %v", err) } diff --git a/test/integration/bootstrap_policy_test.go b/test/integration/bootstrap_policy_test.go index 86ece8070460..cdbaa01f1892 100644 --- a/test/integration/bootstrap_policy_test.go +++ b/test/integration/bootstrap_policy_test.go @@ -15,15 +15,16 @@ import ( "github.com/openshift/origin/pkg/cmd/server/admin" "github.com/openshift/origin/pkg/cmd/server/etcd" "github.com/openshift/origin/pkg/cmd/util/tokencmd" + "github.com/openshift/origin/test/util" ) func TestAuthenticatedUsersAgainstOpenshiftNamespace(t *testing.T) { - _, clusterAdminKubeConfig, err := StartTestMaster() + _, clusterAdminKubeConfig, err := util.StartTestMaster() if err != nil { t.Fatalf("unexpected error: %v", err) } - _, _, clusterAdminClientConfig, err := GetClusterAdminClient(clusterAdminKubeConfig) + clusterAdminClientConfig, err := util.GetClusterAdminClientConfig(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } @@ -73,12 +74,12 @@ func TestAuthenticatedUsersAgainstOpenshiftNamespace(t *testing.T) { } func TestOverwritePolicyCommand(t *testing.T) { - masterConfig, clusterAdminKubeConfig, err := StartTestMaster() + masterConfig, clusterAdminKubeConfig, err := util.StartTestMaster() if err != nil { t.Fatalf("unexpected error: %v", err) } - client, _, _, err := GetClusterAdminClient(clusterAdminKubeConfig) + client, err := util.GetClusterAdminClient(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } diff --git a/test/integration/buildcfgclient_test.go b/test/integration/buildcfgclient_test.go index e64d6854af04..7db49bceb647 100644 --- a/test/integration/buildcfgclient_test.go +++ b/test/integration/buildcfgclient_test.go @@ -9,18 +9,19 @@ import ( "github.com/GoogleCloudPlatform/kubernetes/pkg/labels" buildapi "github.com/openshift/origin/pkg/build/api" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } func TestListBuildConfigs(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() - buildConfigs, err := openshift.Client.BuildConfigs(testNamespace).List(labels.Everything(), labels.Everything()) + buildConfigs, err := openshift.Client.BuildConfigs(util.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("Unexpected error %v", err) } @@ -30,12 +31,12 @@ func TestListBuildConfigs(t *testing.T) { } func TestCreateBuildConfig(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() buildConfig := mockBuildConfig() - expected, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig) + expected, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -43,7 +44,7 @@ func TestCreateBuildConfig(t *testing.T) { t.Errorf("Unexpected empty buildConfig ID %v", expected) } - buildConfigs, err := openshift.Client.BuildConfigs(testNamespace).List(labels.Everything(), labels.Everything()) + buildConfigs, err := openshift.Client.BuildConfigs(util.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("Unexpected error %v", err) } @@ -53,52 +54,52 @@ func TestCreateBuildConfig(t *testing.T) { } func TestUpdateBuildConfig(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() buildConfig := mockBuildConfig() - actual, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig) + actual, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig) if err != nil { t.Fatalf("Unexpected error: %v", err) } - actual, err = openshift.Client.BuildConfigs(testNamespace).Get(actual.Name) + actual, err = openshift.Client.BuildConfigs(util.Namespace()).Get(actual.Name) if err != nil { t.Fatalf("Unexpected error: %v", err) } - if _, err := openshift.Client.BuildConfigs(testNamespace).Update(actual); err != nil { + if _, err := openshift.Client.BuildConfigs(util.Namespace()).Update(actual); err != nil { t.Fatalf("Unexpected error: %v", err) } } func TestDeleteBuildConfig(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() buildConfig := mockBuildConfig() - actual, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig) + actual, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig) if err != nil { t.Fatalf("Unexpected error: %v", err) } - if err := openshift.Client.BuildConfigs(testNamespace).Delete(actual.Name); err != nil { + if err := openshift.Client.BuildConfigs(util.Namespace()).Delete(actual.Name); err != nil { t.Fatalf("Unxpected error: %v", err) } } func TestWatchBuildConfigs(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() buildConfig := mockBuildConfig() - watch, err := openshift.Client.BuildConfigs(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.Client.BuildConfigs(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Unexpected error: %v", err) } defer watch.Stop() - expected, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig) + expected, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -147,11 +148,11 @@ func mockBuildConfig() *buildapi.BuildConfig { } func TestBuildConfigClient(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() - buildConfigs, err := openshift.Client.BuildConfigs(testNamespace).List(labels.Everything(), labels.Everything()) + buildConfigs, err := openshift.Client.BuildConfigs(util.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("unexpected error %v", err) } @@ -186,7 +187,7 @@ func TestBuildConfigClient(t *testing.T) { } // get a created buildConfig - got, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig) + got, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -195,7 +196,7 @@ func TestBuildConfigClient(t *testing.T) { } // get a list of buildConfigs - buildConfigs, err = openshift.Client.BuildConfigs(testNamespace).List(labels.Everything(), labels.Everything()) + buildConfigs, err = openshift.Client.BuildConfigs(util.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("unexpected error: %v", err) } @@ -208,11 +209,11 @@ func TestBuildConfigClient(t *testing.T) { } // delete a buildConfig - err = openshift.Client.BuildConfigs(testNamespace).Delete(got.Name) + err = openshift.Client.BuildConfigs(util.Namespace()).Delete(got.Name) if err != nil { t.Fatalf("unexpected error %v", err) } - buildConfigs, err = openshift.Client.BuildConfigs(testNamespace).List(labels.Everything(), labels.Everything()) + buildConfigs, err = openshift.Client.BuildConfigs(util.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("unexpected error %v", err) } diff --git a/test/integration/buildclient_test.go b/test/integration/buildclient_test.go index 41c61d78eb5c..6a2d1bd5ca73 100644 --- a/test/integration/buildclient_test.go +++ b/test/integration/buildclient_test.go @@ -30,19 +30,20 @@ import ( osclient "github.com/openshift/origin/pkg/client" "github.com/openshift/origin/pkg/image/registry/imagerepository" imagerepositoryetcd "github.com/openshift/origin/pkg/image/registry/imagerepository/etcd" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } func TestListBuilds(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() - builds, err := openshift.Client.Builds(testNamespace).List(labels.Everything(), labels.Everything()) + builds, err := openshift.Client.Builds(util.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("Unexpected error %v", err) } @@ -53,12 +54,12 @@ func TestListBuilds(t *testing.T) { func TestCreateBuild(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() build := mockBuild() - expected, err := openshift.Client.Builds(testNamespace).Create(build) + expected, err := openshift.Client.Builds(util.Namespace()).Create(build) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -66,7 +67,7 @@ func TestCreateBuild(t *testing.T) { t.Errorf("Unexpected empty build Name %v", expected) } - builds, err := openshift.Client.Builds(testNamespace).List(labels.Everything(), labels.Everything()) + builds, err := openshift.Client.Builds(util.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("Unexpected error %v", err) } @@ -76,33 +77,33 @@ func TestCreateBuild(t *testing.T) { } func TestDeleteBuild(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() build := mockBuild() - actual, err := openshift.Client.Builds(testNamespace).Create(build) + actual, err := openshift.Client.Builds(util.Namespace()).Create(build) if err != nil { t.Fatalf("Unexpected error: %v", err) } - if err := openshift.Client.Builds(testNamespace).Delete(actual.Name); err != nil { + if err := openshift.Client.Builds(util.Namespace()).Delete(actual.Name); err != nil { t.Fatalf("Unxpected error: %v", err) } } func TestWatchBuilds(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() build := mockBuild() - watch, err := openshift.Client.Builds(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.Client.Builds(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Unexpected error: %v", err) } defer watch.Stop() - expected, err := openshift.Client.Builds(testNamespace).Create(build) + expected, err := openshift.Client.Builds(util.Namespace()).Create(build) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -157,7 +158,7 @@ func NewTestBuildOpenshift(t *testing.T) *testBuildOpenshift { openshift.lock.Lock() defer openshift.lock.Unlock() - etcdClient := newEtcdClient() + etcdClient := util.NewEtcdClient() etcdHelper, _ := master.NewEtcdHelper(etcdClient, klatest.Version) osMux := http.NewServeMux() diff --git a/test/integration/cli_get_token_test.go b/test/integration/cli_get_token_test.go index 3deaf2f8b5d2..d23e07fffe69 100644 --- a/test/integration/cli_get_token_test.go +++ b/test/integration/cli_get_token_test.go @@ -30,17 +30,18 @@ import ( "github.com/openshift/origin/pkg/cmd/util/clientcmd" "github.com/openshift/origin/pkg/cmd/util/tokencmd" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } func TestGetToken(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() // setup - etcdClient := newEtcdClient() + etcdClient := util.NewEtcdClient() etcdHelper, _ := master.NewEtcdHelper(etcdClient, klatest.Version) oauthEtcd := oauthetcd.New(etcdHelper) userRegistry := useretcd.New(etcdHelper, user.NewDefaultUserInitStrategy()) diff --git a/test/integration/deploy_trigger_test.go b/test/integration/deploy_trigger_test.go index 6e349628e717..c24d74a35f78 100644 --- a/test/integration/deploy_trigger_test.go +++ b/test/integration/deploy_trigger_test.go @@ -42,32 +42,33 @@ import ( "github.com/openshift/origin/pkg/image/registry/imagerepository" imagerepositoryetcd "github.com/openshift/origin/pkg/image/registry/imagerepository/etcd" "github.com/openshift/origin/pkg/image/registry/imagerepositorymapping" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } func TestSuccessfulManualDeployment(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestOpenshift(t) defer openshift.Close() config := manualDeploymentConfig() var err error - dc, err := openshift.Client.DeploymentConfigs(testNamespace).Create(config) + dc, err := openshift.Client.DeploymentConfigs(util.Namespace()).Create(config) if err != nil { t.Fatalf("Couldn't create DeploymentConfig: %v %#v", err, config) } - watch, err := openshift.KubeClient.ReplicationControllers(testNamespace).Watch(labels.Everything(), labels.Everything(), dc.ResourceVersion) + watch, err := openshift.KubeClient.ReplicationControllers(util.Namespace()).Watch(labels.Everything(), labels.Everything(), dc.ResourceVersion) if err != nil { t.Fatalf("Couldn't subscribe to Deployments: %v", err) } defer watch.Stop() - config, err = openshift.Client.DeploymentConfigs(testNamespace).Generate(config.Name) + config, err = openshift.Client.DeploymentConfigs(util.Namespace()).Generate(config.Name) if err != nil { t.Fatalf("Error generating config: %v", err) } @@ -76,7 +77,7 @@ func TestSuccessfulManualDeployment(t *testing.T) { } glog.Infof("config(1): %#v", config) - new, err := openshift.Client.DeploymentConfigs(testNamespace).Update(config) + new, err := openshift.Client.DeploymentConfigs(util.Namespace()).Update(config) if err != nil { t.Fatalf("Couldn't create updated DeploymentConfig: %v %#v", err, config) } @@ -97,7 +98,7 @@ func TestSuccessfulManualDeployment(t *testing.T) { } func TestSimpleImageChangeTrigger(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestOpenshift(t) defer openshift.Close() @@ -112,25 +113,25 @@ func TestSimpleImageChangeTrigger(t *testing.T) { config := imageChangeDeploymentConfig() var err error - watch, err := openshift.KubeClient.ReplicationControllers(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.KubeClient.ReplicationControllers(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Couldn't subscribe to Deployments %v", err) } defer watch.Stop() - if imageRepo, err = openshift.Client.ImageRepositories(testNamespace).Create(imageRepo); err != nil { + if imageRepo, err = openshift.Client.ImageRepositories(util.Namespace()).Create(imageRepo); err != nil { t.Fatalf("Couldn't create ImageRepository: %v", err) } - if _, err := openshift.Client.DeploymentConfigs(testNamespace).Create(config); err != nil { + if _, err := openshift.Client.DeploymentConfigs(util.Namespace()).Create(config); err != nil { t.Fatalf("Couldn't create DeploymentConfig: %v", err) } - if config, err = openshift.Client.DeploymentConfigs(testNamespace).Generate(config.Name); err != nil { + if config, err = openshift.Client.DeploymentConfigs(util.Namespace()).Generate(config.Name); err != nil { t.Fatalf("Error generating config: %v", err) } - if _, err := openshift.Client.DeploymentConfigs(testNamespace).Update(config); err != nil { + if _, err := openshift.Client.DeploymentConfigs(util.Namespace()).Update(config); err != nil { t.Fatalf("Couldn't create updated DeploymentConfig: %v", err) } @@ -146,7 +147,7 @@ func TestSimpleImageChangeTrigger(t *testing.T) { imageRepo.Tags["latest"] = "ref-2" - if _, err = openshift.Client.ImageRepositories(testNamespace).Update(imageRepo); err != nil { + if _, err = openshift.Client.ImageRepositories(util.Namespace()).Update(imageRepo); err != nil { t.Fatalf("Error updating imageRepo: %v", err) } @@ -162,7 +163,7 @@ func TestSimpleImageChangeTrigger(t *testing.T) { } func TestSimpleImageChangeTriggerFrom(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestOpenshift(t) defer openshift.Close() @@ -180,25 +181,25 @@ func TestSimpleImageChangeTriggerFrom(t *testing.T) { } var err error - watch, err := openshift.KubeClient.ReplicationControllers(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.KubeClient.ReplicationControllers(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Couldn't subscribe to Deployments %v", err) } defer watch.Stop() - if imageRepo, err = openshift.Client.ImageRepositories(testNamespace).Create(imageRepo); err != nil { + if imageRepo, err = openshift.Client.ImageRepositories(util.Namespace()).Create(imageRepo); err != nil { t.Fatalf("Couldn't create ImageRepository: %v", err) } - if _, err := openshift.Client.DeploymentConfigs(testNamespace).Create(config); err != nil { + if _, err := openshift.Client.DeploymentConfigs(util.Namespace()).Create(config); err != nil { t.Fatalf("Couldn't create DeploymentConfig: %v", err) } - if config, err = openshift.Client.DeploymentConfigs(testNamespace).Generate(config.Name); err != nil { + if config, err = openshift.Client.DeploymentConfigs(util.Namespace()).Generate(config.Name); err != nil { t.Fatalf("Error generating config: %v", err) } - if _, err := openshift.Client.DeploymentConfigs(testNamespace).Update(config); err != nil { + if _, err := openshift.Client.DeploymentConfigs(util.Namespace()).Update(config); err != nil { t.Fatalf("Couldn't create updated DeploymentConfig: %v", err) } @@ -214,7 +215,7 @@ func TestSimpleImageChangeTriggerFrom(t *testing.T) { imageRepo.Tags["latest"] = "ref-2" - if _, err = openshift.Client.ImageRepositories(testNamespace).Update(imageRepo); err != nil { + if _, err = openshift.Client.ImageRepositories(util.Namespace()).Update(imageRepo); err != nil { t.Fatalf("Error updating imageRepo: %v", err) } @@ -227,27 +228,27 @@ func TestSimpleImageChangeTriggerFrom(t *testing.T) { if newDeployment.Name == deployment.Name { t.Fatalf("expected new deployment; old=%s, new=%s", deployment.Name, newDeployment.Name) } - if a, e := newDeployment.Spec.Template.Spec.Containers[0].Image, "registry:3000/integration-test/test-image-repo:ref-2"; e != a { + if a, e := newDeployment.Spec.Template.Spec.Containers[0].Image, "registry:3000/integration/test-image-repo:ref-2"; e != a { t.Fatalf("new deployment isn't pointing to the right image: %s %s", e, a) } } func TestSimpleConfigChangeTrigger(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestOpenshift(t) defer openshift.Close() config := changeDeploymentConfig() var err error - watch, err := openshift.KubeClient.ReplicationControllers(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.KubeClient.ReplicationControllers(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Couldn't subscribe to Deployments %v", err) } defer watch.Stop() // submit the initial deployment config - if _, err := openshift.Client.DeploymentConfigs(testNamespace).Create(config); err != nil { + if _, err := openshift.Client.DeploymentConfigs(util.Namespace()).Create(config); err != nil { t.Fatalf("Couldn't create DeploymentConfig: %v", err) } @@ -266,13 +267,13 @@ func TestSimpleConfigChangeTrigger(t *testing.T) { assertEnvVarEquals("ENV_TEST", "ENV_VALUE1", deployment, t) // submit a new config with an updated environment variable - if config, err = openshift.Client.DeploymentConfigs(testNamespace).Generate(config.Name); err != nil { + if config, err = openshift.Client.DeploymentConfigs(util.Namespace()).Generate(config.Name); err != nil { t.Fatalf("Error generating config: %v", err) } config.Template.ControllerTemplate.Template.Spec.Containers[0].Env[0].Value = "UPDATED" - if _, err := openshift.Client.DeploymentConfigs(testNamespace).Update(config); err != nil { + if _, err := openshift.Client.DeploymentConfigs(util.Namespace()).Update(config); err != nil { t.Fatalf("Couldn't create updated DeploymentConfig: %v", err) } @@ -324,7 +325,7 @@ func NewTestOpenshift(t *testing.T) *testOpenshift { stop: make(chan struct{}), } - etcdClient := newEtcdClient() + etcdClient := util.NewEtcdClient() etcdHelper, _ := master.NewEtcdHelper(etcdClient, klatest.Version) osMux := http.NewServeMux() diff --git a/test/integration/dns_test.go b/test/integration/dns_test.go index a9d47593fb39..aa10a2130724 100644 --- a/test/integration/dns_test.go +++ b/test/integration/dns_test.go @@ -9,10 +9,11 @@ import ( "github.com/GoogleCloudPlatform/kubernetes/pkg/util" "github.com/miekg/dns" + testutil "github.com/openshift/origin/test/util" ) func TestDNS(t *testing.T) { - masterConfig, _, err := StartTestAllInOne() + masterConfig, _, err := testutil.StartTestAllInOne() if err != nil { t.Fatalf("unexpected error: %v", err) } diff --git a/test/integration/imagechange_buildtrigger_test.go b/test/integration/imagechange_buildtrigger_test.go index 535c87dca9a2..a9ffcaef605c 100644 --- a/test/integration/imagechange_buildtrigger_test.go +++ b/test/integration/imagechange_buildtrigger_test.go @@ -11,14 +11,15 @@ import ( buildapi "github.com/openshift/origin/pkg/build/api" imageapi "github.com/openshift/origin/pkg/image/api" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } func TestSimpleImageChangeBuildTrigger(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestOpenshift(t) defer openshift.Close() @@ -32,24 +33,24 @@ func TestSimpleImageChangeBuildTrigger(t *testing.T) { config := imageChangeBuildConfig() - created, err := openshift.Client.BuildConfigs(testNamespace).Create(config) + created, err := openshift.Client.BuildConfigs(util.Namespace()).Create(config) if err != nil { t.Fatalf("Couldn't create BuildConfig: %v", err) } - watch, err := openshift.Client.Builds(testNamespace).Watch(labels.Everything(), labels.Everything(), created.ResourceVersion) + watch, err := openshift.Client.Builds(util.Namespace()).Watch(labels.Everything(), labels.Everything(), created.ResourceVersion) if err != nil { t.Fatalf("Couldn't subscribe to Builds %v", err) } defer watch.Stop() - watch2, err := openshift.Client.BuildConfigs(testNamespace).Watch(labels.Everything(), labels.Everything(), created.ResourceVersion) + watch2, err := openshift.Client.BuildConfigs(util.Namespace()).Watch(labels.Everything(), labels.Everything(), created.ResourceVersion) if err != nil { t.Fatalf("Couldn't subscribe to BuildConfigs %v", err) } defer watch2.Stop() - imageRepo, err = openshift.Client.ImageRepositories(testNamespace).Create(imageRepo) + imageRepo, err = openshift.Client.ImageRepositories(util.Namespace()).Create(imageRepo) if err != nil { t.Fatalf("Couldn't create ImageRepository: %v", err) } @@ -61,8 +62,8 @@ func TestSimpleImageChangeBuildTrigger(t *testing.T) { } newBuild := event.Object.(*buildapi.Build) if newBuild.Parameters.Strategy.DockerStrategy.Image != "registry:8080/openshift/test-image-trigger:latest" { - i, _ := openshift.Client.ImageRepositories(testNamespace).Get(imageRepo.Name) - bc, _ := openshift.Client.BuildConfigs(testNamespace).Get(config.Name) + i, _ := openshift.Client.ImageRepositories(util.Namespace()).Get(imageRepo.Name) + bc, _ := openshift.Client.BuildConfigs(util.Namespace()).Get(config.Name) t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\ntrigger is %s\n", "registry:8080/openshift/test-image-trigger:latest", newBuild.Parameters.Strategy.DockerStrategy.Image, i, bc.Triggers[0].ImageChange) } event = <-watch.ResultChan() @@ -79,7 +80,7 @@ func TestSimpleImageChangeBuildTrigger(t *testing.T) { // wait for build config to be updated <-watch2.ResultChan() - updatedConfig, err := openshift.Client.BuildConfigs(testNamespace).Get(config.Name) + updatedConfig, err := openshift.Client.BuildConfigs(util.Namespace()).Get(config.Name) if err != nil { t.Fatalf("Couldn't get BuildConfig: %v", err) } @@ -89,9 +90,9 @@ func TestSimpleImageChangeBuildTrigger(t *testing.T) { } // trigger a build by posting a new image - if err := openshift.Client.ImageRepositoryMappings(testNamespace).Create(&imageapi.ImageRepositoryMapping{ + if err := openshift.Client.ImageRepositoryMappings(util.Namespace()).Create(&imageapi.ImageRepositoryMapping{ ObjectMeta: kapi.ObjectMeta{ - Namespace: testNamespace, + Namespace: util.Namespace(), Name: imageRepo.Name, }, Tag: "latest", @@ -107,7 +108,7 @@ func TestSimpleImageChangeBuildTrigger(t *testing.T) { /* // update the image tag to ref-2 in the imagerepo so we get another build event using that tag. imageRepo.Tags["latest"] = "ref-2" - if _, err = openshift.Client.ImageRepositories(testNamespace).Update(imageRepo); err != nil { + if _, err = openshift.Client.ImageRepositories(util.Namespace()).Update(imageRepo); err != nil { t.Fatalf("Error updating imageRepo: %v", err) } */ @@ -117,8 +118,8 @@ func TestSimpleImageChangeBuildTrigger(t *testing.T) { } newBuild = event.Object.(*buildapi.Build) if newBuild.Parameters.Strategy.DockerStrategy.Image != "registry:8080/openshift/test-image-trigger:ref-2" { - i, _ := openshift.Client.ImageRepositories(testNamespace).Get(imageRepo.Name) - bc, _ := openshift.Client.BuildConfigs(testNamespace).Get(config.Name) + i, _ := openshift.Client.ImageRepositories(util.Namespace()).Get(imageRepo.Name) + bc, _ := openshift.Client.BuildConfigs(util.Namespace()).Get(config.Name) t.Fatalf("Expected build with base image %s, got %s\n, imagerepo is %v\trigger is %s\n", "registry:8080/openshift/test-image-trigger:ref-2", newBuild.Parameters.Strategy.DockerStrategy.Image, i, bc.Triggers[0].ImageChange) } event = <-watch.ResultChan() @@ -134,7 +135,7 @@ func TestSimpleImageChangeBuildTrigger(t *testing.T) { } event = <-watch2.ResultChan() - updatedConfig, err = openshift.Client.BuildConfigs(testNamespace).Get(config.Name) + updatedConfig, err = openshift.Client.BuildConfigs(util.Namespace()).Get(config.Name) if err != nil { t.Fatalf("Couldn't get BuildConfig: %v", err) } diff --git a/test/integration/imageclient_test.go b/test/integration/imageclient_test.go index c993adf9a7b7..b64900ba8f4e 100644 --- a/test/integration/imageclient_test.go +++ b/test/integration/imageclient_test.go @@ -28,18 +28,19 @@ import ( imagerepositoryetcd "github.com/openshift/origin/pkg/image/registry/imagerepository/etcd" "github.com/openshift/origin/pkg/image/registry/imagerepositorymapping" "github.com/openshift/origin/pkg/image/registry/imagerepositorytag" + testutil "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + testutil.RequireEtcd() } func TestImageRepositoryList(t *testing.T) { - deleteAllEtcdKeys() + testutil.DeleteAllEtcdKeys() openshift := NewTestImageOpenShift(t) defer openshift.Close() - builds, err := openshift.Client.ImageRepositories(testNamespace).List(labels.Everything(), labels.Everything()) + builds, err := openshift.Client.ImageRepositories(testutil.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("Unexpected error %v", err) } @@ -53,16 +54,16 @@ func mockImageRepository() *imageapi.ImageRepository { } func TestImageRepositoryCreate(t *testing.T) { - deleteAllEtcdKeys() + testutil.DeleteAllEtcdKeys() openshift := NewTestImageOpenShift(t) defer openshift.Close() repo := mockImageRepository() - if _, err := openshift.Client.ImageRepositories(testNamespace).Create(&imageapi.ImageRepository{}); err == nil || !errors.IsInvalid(err) { + if _, err := openshift.Client.ImageRepositories(testutil.Namespace()).Create(&imageapi.ImageRepository{}); err == nil || !errors.IsInvalid(err) { t.Fatalf("Unexpected error: %v", err) } - expected, err := openshift.Client.ImageRepositories(testNamespace).Create(repo) + expected, err := openshift.Client.ImageRepositories(testutil.Namespace()).Create(repo) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -70,7 +71,7 @@ func TestImageRepositoryCreate(t *testing.T) { t.Errorf("Unexpected empty image Name %v", expected) } - actual, err := openshift.Client.ImageRepositories(testNamespace).Get(repo.Name) + actual, err := openshift.Client.ImageRepositories(testutil.Namespace()).Get(repo.Name) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -78,7 +79,7 @@ func TestImageRepositoryCreate(t *testing.T) { t.Errorf("unexpected object: %s", util.ObjectDiff(expected, actual)) } - repos, err := openshift.Client.ImageRepositories(testNamespace).List(labels.Everything(), labels.Everything()) + repos, err := openshift.Client.ImageRepositories(testutil.Namespace()).List(labels.Everything(), labels.Everything()) if err != nil { t.Fatalf("Unexpected error %v", err) } @@ -88,12 +89,12 @@ func TestImageRepositoryCreate(t *testing.T) { } func TestImageRepositoryMappingCreate(t *testing.T) { - deleteAllEtcdKeys() + testutil.DeleteAllEtcdKeys() openshift := NewTestImageOpenShift(t) defer openshift.Close() repo := mockImageRepository() - expected, err := openshift.Client.ImageRepositories(testNamespace).Create(repo) + expected, err := openshift.Client.ImageRepositories(testutil.Namespace()).Create(repo) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -112,12 +113,12 @@ func TestImageRepositoryMappingCreate(t *testing.T) { DockerImageReference: "some/other/name", }, } - if err := openshift.Client.ImageRepositoryMappings(testNamespace).Create(mapping); err != nil { + if err := openshift.Client.ImageRepositoryMappings(testutil.Namespace()).Create(mapping); err != nil { t.Fatalf("unexpected error: %v", err) } // verify we can tag a second time with the same data, and nothing changes - if err := openshift.Client.ImageRepositoryMappings(testNamespace).Create(mapping); err != nil { + if err := openshift.Client.ImageRepositoryMappings(testutil.Namespace()).Create(mapping); err != nil { t.Fatalf("unexpected non-error or type: %v", err) } @@ -149,7 +150,7 @@ func TestImageRepositoryMappingCreate(t *testing.T) { Image: *image, } mapping.Image.DockerImageReference = "different" - if err := openshift.Client.ImageRepositoryMappings(testNamespace).Create(mapping); err != nil { + if err := openshift.Client.ImageRepositoryMappings(testutil.Namespace()).Create(mapping); err != nil { t.Fatalf("unexpected error: %v", err) } image, err = openshift.Client.Images().Get(image.Name) @@ -161,7 +162,7 @@ func TestImageRepositoryMappingCreate(t *testing.T) { } // ensure the correct tags are set - updated, err := openshift.Client.ImageRepositories(testNamespace).Get(repo.Name) + updated, err := openshift.Client.ImageRepositories(testutil.Namespace()).Get(repo.Name) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -169,7 +170,7 @@ func TestImageRepositoryMappingCreate(t *testing.T) { t.Errorf("unexpected object: %#v", updated.Tags) } - fromTag, err := openshift.Client.ImageRepositoryTags(testNamespace).Get(repo.Name, "newer") + fromTag, err := openshift.Client.ImageRepositoryTags(testutil.Namespace()).Get(repo.Name, "newer") if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -177,7 +178,7 @@ func TestImageRepositoryMappingCreate(t *testing.T) { t.Errorf("unexpected object: %#v", fromTag) } - fromTag, err = openshift.Client.ImageRepositoryTags(testNamespace).Get(repo.Name, "newest") + fromTag, err = openshift.Client.ImageRepositoryTags(testutil.Namespace()).Get(repo.Name, "newest") if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -192,11 +193,11 @@ func TestImageRepositoryMappingCreate(t *testing.T) { Tag: "anothertag", Image: *image, } - if err := openshift.Client.ImageRepositoryMappings(testNamespace).Create(mapping); err != nil { + if err := openshift.Client.ImageRepositoryMappings(testutil.Namespace()).Create(mapping); err != nil { t.Fatalf("unexpected error: %v", err) } // ensure the correct tags are set - updated, err = openshift.Client.ImageRepositories(testNamespace).Get(repo.Name) + updated, err = openshift.Client.ImageRepositories(testutil.Namespace()).Get(repo.Name) if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -204,7 +205,7 @@ func TestImageRepositoryMappingCreate(t *testing.T) { t.Errorf("unexpected object: %#v", updated.Tags) } - fromTag, err = openshift.Client.ImageRepositoryTags(testNamespace).Get(repo.Name, "newer") + fromTag, err = openshift.Client.ImageRepositoryTags(testutil.Namespace()).Get(repo.Name, "newer") if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -212,14 +213,14 @@ func TestImageRepositoryMappingCreate(t *testing.T) { t.Errorf("unexpected object: %#v", fromTag) } - fromTag, err = openshift.Client.ImageRepositoryTags(testNamespace).Get(repo.Name, "newest") + fromTag, err = openshift.Client.ImageRepositoryTags(testutil.Namespace()).Get(repo.Name, "newest") if err != nil { t.Fatalf("Unexpected error: %v", err) } if fromTag.Name != "image2" || fromTag.UID == "" || fromTag.DockerImageReference != "some/other/name" { t.Errorf("unexpected object: %#v", fromTag) } - fromTag, err = openshift.Client.ImageRepositoryTags(testNamespace).Get(repo.Name, "anothertag") + fromTag, err = openshift.Client.ImageRepositoryTags(testutil.Namespace()).Get(repo.Name, "anothertag") if err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -230,19 +231,19 @@ func TestImageRepositoryMappingCreate(t *testing.T) { } func TestImageRepositoryDelete(t *testing.T) { - deleteAllEtcdKeys() + testutil.DeleteAllEtcdKeys() openshift := NewTestImageOpenShift(t) defer openshift.Close() repo := mockImageRepository() - if err := openshift.Client.ImageRepositories(testNamespace).Delete(repo.Name); err == nil || !errors.IsNotFound(err) { + if err := openshift.Client.ImageRepositories(testutil.Namespace()).Delete(repo.Name); err == nil || !errors.IsNotFound(err) { t.Fatalf("Unxpected non-error or type: %v", err) } - actual, err := openshift.Client.ImageRepositories(testNamespace).Create(repo) + actual, err := openshift.Client.ImageRepositories(testutil.Namespace()).Create(repo) if err != nil { t.Fatalf("Unexpected error: %v", err) } - if err := openshift.Client.ImageRepositories(testNamespace).Delete(actual.Name); err != nil { + if err := openshift.Client.ImageRepositories(testutil.Namespace()).Delete(actual.Name); err != nil { t.Fatalf("Unxpected error: %v", err) } } @@ -262,7 +263,7 @@ func NewTestImageOpenShift(t *testing.T) *testImageOpenshift { stop: make(chan struct{}), } - etcdClient := newEtcdClient() + etcdClient := testutil.NewEtcdClient() etcdHelper, _ := master.NewEtcdHelper(etcdClient, klatest.Version) osMux := http.NewServeMux() diff --git a/test/integration/login_test.go b/test/integration/login_test.go index 583f8642490c..aeec5a0cb656 100644 --- a/test/integration/login_test.go +++ b/test/integration/login_test.go @@ -13,20 +13,26 @@ import ( "github.com/openshift/origin/pkg/cmd/server/bootstrappolicy" "github.com/openshift/origin/pkg/cmd/util/clientcmd" "github.com/openshift/origin/pkg/user/api" + "github.com/openshift/origin/test/util" "github.com/spf13/pflag" ) func init() { - requireEtcd() + util.RequireEtcd() } func TestLogin(t *testing.T) { - _, clusterAdminKubeConfig, err := StartTestMaster() + _, clusterAdminKubeConfig, err := util.StartTestMaster() if err != nil { t.Fatalf("unexpected error: %v", err) } - clusterAdminClient, _, clusterAdminClientConfig, err := GetClusterAdminClient(clusterAdminKubeConfig) + clusterAdminClient, err := util.GetClusterAdminClient(clusterAdminKubeConfig) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + clusterAdminClientConfig, err := util.GetClusterAdminClientConfig(clusterAdminKubeConfig) if err != nil { t.Fatalf("unexpected error: %v", err) } diff --git a/test/integration/oauth_htpasswd_test.go b/test/integration/oauth_htpasswd_test.go index 76ac006f4ea3..7de0a82d71ed 100644 --- a/test/integration/oauth_htpasswd_test.go +++ b/test/integration/oauth_htpasswd_test.go @@ -11,6 +11,7 @@ import ( "github.com/openshift/origin/pkg/client" "github.com/openshift/origin/pkg/cmd/util/tokencmd" + "github.com/openshift/origin/test/util" ) func TestHTPasswd(t *testing.T) { @@ -25,12 +26,12 @@ func TestHTPasswd(t *testing.T) { os.Setenv("OPENSHIFT_OAUTH_PASSWORD_AUTH", "htpasswd") os.Setenv("OPENSHIFT_OAUTH_HTPASSWD_FILE", htpasswdFile.Name()) - _, clusterAdminKubeConfig, err := StartTestMaster() + _, clusterAdminKubeConfig, err := util.StartTestMaster() if err != nil { t.Fatalf("unexpected error: %v", err) } - _, _, clientConfig, err := GetClusterAdminClient(clusterAdminKubeConfig) + clientConfig, err := util.GetClusterAdminClientConfig(clusterAdminKubeConfig) if err != nil { t.Errorf("unexpected error: %v", err) } diff --git a/test/integration/oauth_request_header_test.go b/test/integration/oauth_request_header_test.go index 774ba7802141..a5dc457d1718 100644 --- a/test/integration/oauth_request_header_test.go +++ b/test/integration/oauth_request_header_test.go @@ -12,6 +12,7 @@ import ( kclient "github.com/GoogleCloudPlatform/kubernetes/pkg/client" "github.com/openshift/origin/pkg/client" + "github.com/openshift/origin/test/util" ) var ( @@ -104,12 +105,12 @@ func TestOAuthRequestHeader(t *testing.T) { os.Setenv("OPENSHIFT_OAUTH_REQUEST_HEADER_CA_FILE", caFile.Name()) // Start server - _, clusterAdminKubeConfig, err := StartTestAllInOne() + _, clusterAdminKubeConfig, err := util.StartTestAllInOne() if err != nil { t.Fatalf("unexpected error: %v", err) } - _, _, clientConfig, err := GetClusterAdminClient(clusterAdminKubeConfig) + clientConfig, err := util.GetClusterAdminClientConfig(clusterAdminKubeConfig) if err != nil { t.Fatalf("unexpected error: %v", err) } diff --git a/test/integration/oauthstorage_test.go b/test/integration/oauthstorage_test.go index ebcf1b208142..598583d3bbb1 100644 --- a/test/integration/oauthstorage_test.go +++ b/test/integration/oauthstorage_test.go @@ -19,10 +19,11 @@ import ( "github.com/openshift/origin/pkg/oauth/registry/etcd" "github.com/openshift/origin/pkg/oauth/server/osinserver" registrystorage "github.com/openshift/origin/pkg/oauth/server/osinserver/registrystorage" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } type testUser struct { @@ -52,9 +53,9 @@ func (u *testUser) ConvertFromAccessToken(*api.OAuthAccessToken) (interface{}, e } func TestOAuthStorage(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() interfaces, _ := latest.InterfacesFor(latest.Version) - etcdClient := newEtcdClient() + etcdClient := util.NewEtcdClient() etcdHelper := tools.EtcdHelper{etcdClient, interfaces.Codec, tools.RuntimeVersionAdapter{interfaces.MetadataAccessor}} registry := etcd.New(etcdHelper) diff --git a/test/integration/project_test.go b/test/integration/project_test.go index 89099130303c..9b24cc10ca96 100644 --- a/test/integration/project_test.go +++ b/test/integration/project_test.go @@ -20,16 +20,17 @@ import ( "github.com/openshift/origin/pkg/client" projectapi "github.com/openshift/origin/pkg/project/api" projectregistry "github.com/openshift/origin/pkg/project/registry/project" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } // TestProjectIsNamespace verifies that a project is a namespace, and a namespace is a project func TestProjectIsNamespace(t *testing.T) { - deleteAllEtcdKeys() - etcdClient := newEtcdClient() + util.DeleteAllEtcdKeys() + etcdClient := util.NewEtcdClient() etcdHelper, err := master.NewEtcdHelper(etcdClient, "") if err != nil { t.Fatalf("Unexpected error: %v", err) diff --git a/test/integration/router_test.go b/test/integration/router_test.go index 0c3f1da37c6b..855d3666cca8 100644 --- a/test/integration/router_test.go +++ b/test/integration/router_test.go @@ -20,6 +20,7 @@ import ( dockerClient "github.com/fsouza/go-dockerclient" routeapi "github.com/openshift/origin/pkg/route/api" tr "github.com/openshift/origin/test/integration/router" + "github.com/openshift/origin/test/util" ) const ( @@ -34,7 +35,7 @@ const ( // init ensures docker exists for this test func init() { - requireDocker() + util.RequireDocker() } // TestRouter is the table based test for routers. It will initialize a fake master/client and expect to deploy @@ -54,7 +55,7 @@ func TestRouter(t *testing.T) { } //deploy router docker container - dockerCli, err := newDockerClient() + dockerCli, err := util.NewDockerClient() if err != nil { t.Fatalf("Unable to get docker client: %v", err) @@ -301,7 +302,7 @@ func TestRouterPathSpecificity(t *testing.T) { validateServer(fakeMasterAndPod, t) - dockerCli, err := newDockerClient() + dockerCli, err := util.NewDockerClient() if err != nil { t.Fatalf("Unable to get docker client: %v", err) } diff --git a/test/integration/userclient_test.go b/test/integration/userclient_test.go index 6b964e493e2c..06d92ba85666 100644 --- a/test/integration/userclient_test.go +++ b/test/integration/userclient_test.go @@ -27,15 +27,16 @@ import ( "github.com/openshift/origin/pkg/user/registry/etcd" userregistry "github.com/openshift/origin/pkg/user/registry/user" "github.com/openshift/origin/pkg/user/registry/useridentitymapping" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } func TestUserInitialization(t *testing.T) { - deleteAllEtcdKeys() - etcdClient := newEtcdClient() + util.DeleteAllEtcdKeys() + etcdClient := util.NewEtcdClient() interfaces, _ := latest.InterfacesFor(latest.Version) userRegistry := etcd.New(tools.EtcdHelper{etcdClient, interfaces.Codec, tools.RuntimeVersionAdapter{interfaces.MetadataAccessor}}, user.NewDefaultUserInitStrategy()) storage := map[string]apiserver.RESTStorage{ @@ -150,8 +151,8 @@ func (s *testTokenSource) AuthenticatePassword(username, password string) (strin } func TestUserLookup(t *testing.T) { - deleteAllEtcdKeys() - etcdClient := newEtcdClient() + util.DeleteAllEtcdKeys() + etcdClient := util.NewEtcdClient() interfaces, _ := latest.InterfacesFor(latest.Version) userRegistry := etcd.New(tools.EtcdHelper{etcdClient, interfaces.Codec, tools.RuntimeVersionAdapter{interfaces.MetadataAccessor}}, user.NewDefaultUserInitStrategy()) userInfo := &kuser.DefaultInfo{ diff --git a/test/integration/utils.go b/test/integration/utils.go deleted file mode 100644 index 738411ac1218..000000000000 --- a/test/integration/utils.go +++ /dev/null @@ -1,108 +0,0 @@ -// +build integration - -package integration - -import ( - "flag" - "fmt" - "log" - "math/rand" - "os" - - "github.com/coreos/go-etcd/etcd" - dockerClient "github.com/fsouza/go-dockerclient" - "github.com/golang/glog" - - "github.com/GoogleCloudPlatform/kubernetes/pkg/capabilities" -) - -const ( - testNamespace = "integration-test" - defaultDockerEndpoint = "unix:///var/run/docker.sock" -) - -func newEtcdClient() *etcd.Client { - etcdServers := []string{getEtcdURL()} - - return etcd.NewClient(etcdServers) -} - -func getEtcdURL() string { - etcdFromEnv := os.Getenv("ETCD_SERVER") - if len(etcdFromEnv) > 0 { - return etcdFromEnv - } - - return "http://127.0.0.1:4001" -} - -func init() { - capabilities.SetForTests(capabilities.Capabilities{ - AllowPrivileged: true, - }) - flag.Set("v", "5") -} - -func logEtcd() { - etcd.SetLogger(log.New(os.Stderr, "go-etcd", log.LstdFlags)) -} - -func requireEtcd() { - if _, err := newEtcdClient().Get("/", false, false); err != nil { - glog.Fatalf("unable to connect to etcd for integration testing: %v", err) - } -} - -// requireDocker ensures that a new docker client can be created and that a ListImages command can be run on the client -// or it fails with glog.Fatal -func requireDocker() { - client, err := newDockerClient() - - if err != nil { - glog.Fatalf("unable to create docker client for integration testing: %v", err) - } - - //simple test to make sure you can take action with the client - _, err = client.ListImages(dockerClient.ListImagesOptions{All: false}) - - if err != nil { - glog.Fatalf("unable to create docker client for integration testing: %v", err) - } -} - -// newDockerClient creates a docker client using the env var DOCKER_ENDPOINT or, if not supplied, uses the default -// docker endpoint /var/run/docker.sock -func newDockerClient() (*dockerClient.Client, error) { - endpoint := os.Getenv("DOCKER_ENDPOINT") - - if len(endpoint) == 0 { - endpoint = defaultDockerEndpoint - } - - client, err := dockerClient.NewClient(endpoint) - - if err != nil { - return nil, err - } - - return client, nil -} - -func withEtcdKey(f func(string)) { - prefix := fmt.Sprintf("/test-%d", rand.Int63()) - defer newEtcdClient().Delete(prefix, true) - f(prefix) -} - -func deleteAllEtcdKeys() { - client := newEtcdClient() - keys, err := client.Get("/", false, false) - if err != nil { - glog.Fatalf("Unable to list root etcd keys: %v", err) - } - for _, node := range keys.Node.Nodes { - if _, err := client.Delete(node.Key, true); err != nil { - glog.Fatalf("Unable delete key: %v", err) - } - } -} diff --git a/test/integration/webhookgithub_test.go b/test/integration/webhookgithub_test.go index 288b38a1ea1f..1b2527546036 100644 --- a/test/integration/webhookgithub_test.go +++ b/test/integration/webhookgithub_test.go @@ -14,31 +14,32 @@ import ( buildapi "github.com/openshift/origin/pkg/build/api" imageapi "github.com/openshift/origin/pkg/image/api" + "github.com/openshift/origin/test/util" ) func init() { - requireEtcd() + util.RequireEtcd() } func TestWebhookGithubPush(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() // create buildconfig buildConfig := mockBuildConfigParms("image", "repo", "tag") - if _, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig); err != nil { + if _, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig); err != nil { t.Fatalf("Unexpected error: %v", err) } - watch, err := openshift.Client.Builds(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.Client.Builds(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Couldn't subscribe to builds: %v", err) } defer watch.Stop() // trigger build event sending push notification - postFile("push", "pushevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+testNamespace, http.StatusOK, t) + postFile("push", "pushevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+util.Namespace(), http.StatusOK, t) event := <-watch.ResultChan() actual := event.Object.(*buildapi.Build) @@ -49,7 +50,7 @@ func TestWebhookGithubPush(t *testing.T) { } func TestWebhookGithubPushWithImageTag(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() @@ -58,25 +59,25 @@ func TestWebhookGithubPushWithImageTag(t *testing.T) { ObjectMeta: kapi.ObjectMeta{Name: "imageRepo"}, Tags: map[string]string{"validTag": "success"}, } - if _, err := openshift.Client.ImageRepositories(testNamespace).Create(imageRepo); err != nil { + if _, err := openshift.Client.ImageRepositories(util.Namespace()).Create(imageRepo); err != nil { t.Fatalf("Unexpected error: %v", err) } // create buildconfig buildConfig := mockBuildConfigParms("originalImage", "imageRepo", "validTag") - if _, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig); err != nil { + if _, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig); err != nil { t.Fatalf("Unexpected error: %v", err) } - watch, err := openshift.Client.Builds(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.Client.Builds(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Couldn't subscribe to builds: %v", err) } defer watch.Stop() // trigger build event sending push notification - postFile("push", "pushevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+testNamespace, http.StatusOK, t) + postFile("push", "pushevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+util.Namespace(), http.StatusOK, t) event := <-watch.ResultChan() actual := event.Object.(*buildapi.Build) @@ -85,13 +86,13 @@ func TestWebhookGithubPushWithImageTag(t *testing.T) { t.Errorf("Expected %s, got %s", buildapi.BuildStatusNew, actual.Status) } - if actual.Parameters.Strategy.DockerStrategy.Image != "registry:3000/integration-test/imageRepo:success" { + if actual.Parameters.Strategy.DockerStrategy.Image != "registry:3000/integration/imageRepo:success" { t.Errorf("Expected %s, got %s", "registry:3000/integration-test/imageRepo:success", actual.Parameters.Strategy.DockerStrategy.Image) } } func TestWebhookGithubPushWithImageTagUnmatched(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() @@ -100,24 +101,24 @@ func TestWebhookGithubPushWithImageTagUnmatched(t *testing.T) { ObjectMeta: kapi.ObjectMeta{Name: "imageRepo"}, Tags: map[string]string{"validTag": "success"}, } - if _, err := openshift.Client.ImageRepositories(testNamespace).Create(imageRepo); err != nil { + if _, err := openshift.Client.ImageRepositories(util.Namespace()).Create(imageRepo); err != nil { t.Fatalf("Unexpected error: %v", err) } // create buildconfig buildConfig := mockBuildConfigParms("originalImage", "imageRepo", "invalidTag") - if _, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig); err != nil { + if _, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig); err != nil { t.Fatalf("Unexpected error: %v", err) } - watch, err := openshift.Client.Builds(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.Client.Builds(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Couldn't subscribe to builds: %v", err) } defer watch.Stop() // trigger build event sending push notification - postFile("push", "pushevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+testNamespace, http.StatusOK, t) + postFile("push", "pushevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+util.Namespace(), http.StatusOK, t) event := <-watch.ResultChan() actual := event.Object.(*buildapi.Build) @@ -132,7 +133,7 @@ func TestWebhookGithubPushWithImageTagUnmatched(t *testing.T) { } func TestWebhookGithubPushWithNamespaceUnmatched(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() @@ -148,18 +149,18 @@ func TestWebhookGithubPushWithNamespaceUnmatched(t *testing.T) { // create buildconfig buildConfig := mockBuildConfigParms("originalImage", "imageRepo", "validTag") - if _, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig); err != nil { + if _, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig); err != nil { t.Fatalf("Unexpected error: %v", err) } - watch, err := openshift.Client.Builds(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.Client.Builds(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Couldn't subscribe to builds: %v", err) } defer watch.Stop() // trigger build event sending push notification - postFile("push", "pushevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+testNamespace, http.StatusOK, t) + postFile("push", "pushevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+util.Namespace(), http.StatusOK, t) event := <-watch.ResultChan() actual := event.Object.(*buildapi.Build) @@ -174,24 +175,24 @@ func TestWebhookGithubPushWithNamespaceUnmatched(t *testing.T) { } func TestWebhookGithubPing(t *testing.T) { - deleteAllEtcdKeys() + util.DeleteAllEtcdKeys() openshift := NewTestBuildOpenshift(t) defer openshift.Close() // create buildconfig buildConfig := mockBuildConfigParms("originalImage", "imageRepo", "validTag") - if _, err := openshift.Client.BuildConfigs(testNamespace).Create(buildConfig); err != nil { + if _, err := openshift.Client.BuildConfigs(util.Namespace()).Create(buildConfig); err != nil { t.Fatalf("Unexpected error: %v", err) } - watch, err := openshift.Client.Builds(testNamespace).Watch(labels.Everything(), labels.Everything(), "0") + watch, err := openshift.Client.Builds(util.Namespace()).Watch(labels.Everything(), labels.Everything(), "0") if err != nil { t.Fatalf("Couldn't subscribe to builds: %v", err) } defer watch.Stop() // trigger build event sending push notification - postFile("ping", "pingevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+testNamespace, http.StatusOK, t) + postFile("ping", "pingevent.json", openshift.server.URL+openshift.whPrefix+"pushbuild/secret101/github?namespace="+util.Namespace(), http.StatusOK, t) // TODO: improve negative testing timer := time.NewTimer(time.Second / 2) diff --git a/test/util/client.go b/test/util/client.go new file mode 100644 index 000000000000..5db8da6eb862 --- /dev/null +++ b/test/util/client.go @@ -0,0 +1,47 @@ +package util + +import ( + "path" + "path/filepath" + + kclient "github.com/GoogleCloudPlatform/kubernetes/pkg/client" + "github.com/openshift/origin/pkg/client" + configapi "github.com/openshift/origin/pkg/cmd/server/api" + "github.com/openshift/origin/pkg/cmd/server/start" +) + +func KubeConfigPath() string { + return filepath.Join(GetBaseDir(), "cert", "admin", ".kubeconfig") +} + +func GetClusterAdminKubeClient(adminKubeConfigFile string) (*kclient.Client, error) { + if c, _, err := configapi.GetKubeClient(adminKubeConfigFile); err != nil { + return nil, err + } else { + return c, nil + } +} + +func GetClusterAdminClient(adminKubeConfigFile string) (*client.Client, error) { + clientConfig, err := GetClusterAdminClientConfig(adminKubeConfigFile) + if err != nil { + return nil, err + } + osClient, err := client.New(clientConfig) + if err != nil { + return nil, err + } + return osClient, nil +} + +func GetClusterAdminClientConfig(adminKubeConfigFile string) (*kclient.Config, error) { + _, conf, err := configapi.GetKubeClient(adminKubeConfigFile) + if err != nil { + return nil, err + } + return conf, nil +} + +func getAdminKubeConfigFile(certArgs start.CertArgs) string { + return path.Clean(path.Join(certArgs.CertDir, "admin/.kubeconfig")) +} diff --git a/test/util/docker.go b/test/util/docker.go new file mode 100644 index 000000000000..98f9d7a57570 --- /dev/null +++ b/test/util/docker.go @@ -0,0 +1,39 @@ +package util + +import ( + "os" + + dockerClient "github.com/fsouza/go-dockerclient" + "github.com/golang/glog" +) + +const defaultDockerEndpoint = "unix:///var/run/docker.sock" + +// RequireDocker ensures that a new docker client can be created and that a ListImages command can be run on the client +// or it fails with glog.Fatal +func RequireDocker() { + client, err := NewDockerClient() + + if err != nil { + glog.Fatalf("unable to create docker client for testing: %v", err) + } + + //simple test to make sure you can take action with the client + _, err = client.ListImages(dockerClient.ListImagesOptions{All: false}) + + if err != nil { + glog.Fatalf("unable to create docker client for testing: %v", err) + } +} + +// newDockerClient creates a docker client using the env var DOCKER_ENDPOINT or, if not supplied, uses the default +// docker endpoint /var/run/docker.sock +func NewDockerClient() (*dockerClient.Client, error) { + endpoint := os.Getenv("DOCKER_ENDPOINT") + + if len(endpoint) == 0 { + endpoint = defaultDockerEndpoint + } + + return dockerClient.NewClient(endpoint) +} diff --git a/test/util/etcd.go b/test/util/etcd.go new file mode 100644 index 000000000000..c10908b1f635 --- /dev/null +++ b/test/util/etcd.go @@ -0,0 +1,71 @@ +package util + +import ( + "flag" + "fmt" + "log" + "math/rand" + "os" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/capabilities" + "github.com/coreos/go-etcd/etcd" + "github.com/golang/glog" +) + +func init() { + capabilities.SetForTests(capabilities.Capabilities{ + AllowPrivileged: true, + }) + flag.Set("v", "5") +} + +// RequireEtcd verifies if the etcd is running and accessible for testing +func RequireEtcd() { + if _, err := NewEtcdClient().Get("/", false, false); err != nil { + glog.Fatalf("unable to connect to etcd for testing: %v", err) + } +} + +// DeleteAllEtcdKeys removes all etcd keys +func DeleteAllEtcdKeys() { + client := NewEtcdClient() + keys, err := client.Get("/", false, false) + if err != nil { + glog.Fatalf("Unable to list root etcd keys: %v", err) + } + for _, node := range keys.Node.Nodes { + if _, err := client.Delete(node.Key, true); err != nil { + glog.Fatalf("Unable delete key: %v", err) + } + } +} + +func NewEtcdClient() *etcd.Client { + etcdServers := []string{GetEtcdURL()} + + return etcd.NewClient(etcdServers) +} + +func GetEtcdURL() string { + etcdFromEnv := os.Getenv("ETCD_SERVER") + if len(etcdFromEnv) > 0 { + return etcdFromEnv + } + + etcdPort := "4001" + if len(os.Getenv("ETCD_PORT")) > 0 { + etcdPort = os.Getenv("ETCD_PORT") + } + + return fmt.Sprintf("http://127.0.0.1:%s", etcdPort) +} + +func logEtcd() { + etcd.SetLogger(log.New(os.Stderr, "go-etcd", log.LstdFlags)) +} + +func withEtcdKey(f func(string)) { + prefix := fmt.Sprintf("/test-%d", rand.Int63()) + defer NewEtcdClient().Delete(prefix, true) + f(prefix) +} diff --git a/test/util/helpers.go b/test/util/helpers.go new file mode 100644 index 000000000000..927eeca0cfe6 --- /dev/null +++ b/test/util/helpers.go @@ -0,0 +1,48 @@ +package util + +import ( + "fmt" + "io/ioutil" + + "github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest" + buildapi "github.com/openshift/origin/pkg/build/api" + imageapi "github.com/openshift/origin/pkg/image/api" +) + +// CreateSampleImageRepository creates a ImageRepository in given namespace +func CreateSampleImageRepository(namespace string) *imageapi.ImageRepository { + var repo imageapi.ImageRepository + jsonData, err := ioutil.ReadFile("fixtures/sample-image-repository.json") + if err != nil { + fmt.Printf("ERROR: Unable to read: %v", err) + return nil + } + latest.Codec.DecodeInto(jsonData, &repo) + + client, _ := GetClusterAdminClient(KubeConfigPath()) + result, err := client.ImageRepositories(namespace).Create(&repo) + if err != nil { + fmt.Printf("ERROR: Unable to create sample ImageRepository: %v\n", err) + return nil + } + return result +} + +// DeleteSampleImageRepository removes the ImageRepository created in given +// namespace +func DeleteSampleImageRepository(repo *imageapi.ImageRepository, namespace string) { + client, _ := GetClusterAdminClient(KubeConfigPath()) + client.ImageRepositories(namespace).Delete(repo.Name) +} + +// GetBuildFixture reads the Build JSON and returns and Build object +func GetBuildFixture(filename string) *buildapi.Build { + var build buildapi.Build + jsonData, err := ioutil.ReadFile(filename) + if err != nil { + fmt.Printf("ERROR: Unable to read %s: %v", filename, err) + return nil + } + latest.Codec.DecodeInto(jsonData, &build) + return &build +} diff --git a/test/util/namespace.go b/test/util/namespace.go new file mode 100644 index 000000000000..b9f72b898193 --- /dev/null +++ b/test/util/namespace.go @@ -0,0 +1,21 @@ +package util + +import ( + "fmt" + "time" + + "github.com/openshift/origin/pkg/cmd/util" +) + +// Namespace returns the test namespace. The default namespace is set to +// 'integration-test'. You can override it by setting the 'OS_TEST_NAMESPACE' +// environment variable +func Namespace() string { + return util.Env("OS_TEST_NAMESPACE", "integration") +} + +// RandomNamespace provides random Kubernetes namespace name based on the UNIX +// timestamp. Optionally you can set the prefix. +func RandomNamespace(prefix string) string { + return prefix + string([]byte(fmt.Sprintf("%d", time.Now().UnixNano()))[3:12]) +} diff --git a/test/util/random_port/generate.go b/test/util/random_port/generate.go new file mode 100644 index 000000000000..d78b8a18ad21 --- /dev/null +++ b/test/util/random_port/generate.go @@ -0,0 +1,13 @@ +package main + +import ( + "fmt" + "net/http/httptest" + "strings" +) + +func main() { + address := httptest.NewUnstartedServer(nil).Listener.Addr().String() + parts := strings.Split(address, ":") + fmt.Printf("%s\n", parts[1]) +} diff --git a/test/integration/server_test.go b/test/util/server.go similarity index 86% rename from test/integration/server_test.go rename to test/util/server.go index 80469ca7e9ca..41e3fbd8097f 100644 --- a/test/integration/server_test.go +++ b/test/util/server.go @@ -1,6 +1,4 @@ -// +build integration,!no-etcd - -package integration +package util import ( "fmt" @@ -12,7 +10,6 @@ import ( kclient "github.com/GoogleCloudPlatform/kubernetes/pkg/client" "github.com/GoogleCloudPlatform/kubernetes/pkg/labels" "github.com/GoogleCloudPlatform/kubernetes/pkg/util" - "github.com/openshift/origin/pkg/client" newproject "github.com/openshift/origin/pkg/cmd/experimental/project" configapi "github.com/openshift/origin/pkg/cmd/server/api" @@ -23,13 +20,29 @@ import ( ) func init() { - requireEtcd() + RequireEtcd() +} + +// RequireServer verifies if the etcd, docker and the OpenShift server are +// available and you can successfully connected to them. +func RequireServer() { + RequireEtcd() + RequireDocker() + if _, err := GetClusterAdminClient(KubeConfigPath()); err != nil { + os.Exit(1) + } +} + +// GetBaseDir returns the base directory used for test. +func GetBaseDir() string { + return cmdutil.Env("BASETMPDIR", path.Join(os.TempDir(), "openshift-"+Namespace())) } func setupStartOptions() (*start.MasterArgs, *start.NodeArgs, *start.ListenArg, *start.ImageFormatArgs, *start.KubeConnectionArgs, *start.CertArgs) { masterArgs, nodeArgs, listenArg, imageFormatArgs, kubeConnectionArgs, certArgs := start.GetAllInOneArgs() - basedir := path.Join(os.TempDir(), "openshift-integration-tests") + basedir := GetBaseDir() + nodeArgs.VolumeDir = path.Join(basedir, "volume") masterArgs.EtcdDir = path.Join(basedir, "etcd") masterArgs.PolicyArgs.PolicyFile = path.Join(basedir, "policy", "policy.json") @@ -38,29 +51,36 @@ func setupStartOptions() (*start.MasterArgs, *start.NodeArgs, *start.ListenArg, // don't wait for nodes to come up masterAddr := httptest.NewUnstartedServer(nil).Listener.Addr().String() + if len(os.Getenv("OS_MASTER_ADDR")) > 0 { + masterAddr = os.Getenv("OS_MASTER_ADDR") + } fmt.Printf("masterAddr: %#v\n", masterAddr) + masterArgs.MasterAddr.Set(masterAddr) listenArg.ListenAddr.Set(masterAddr) - masterArgs.EtcdAddr.Set(getEtcdURL()) + masterArgs.EtcdAddr.Set(GetEtcdURL()) assetAddr := httptest.NewUnstartedServer(nil).Listener.Addr().String() + if len(os.Getenv("OS_ASSETS_ADDR")) > 0 { + assetAddr = os.Getenv("OS_ASSETS_ADDR") + } + fmt.Printf("assetAddr: %#v\n", assetAddr) masterArgs.AssetBindAddr.Set(assetAddr) masterArgs.AssetPublicAddr.Set(assetAddr) dnsAddr := httptest.NewUnstartedServer(nil).Listener.Addr().String() + if len(os.Getenv("OS_DNS_ADDR")) > 0 { + dnsAddr = os.Getenv("OS_DNS_ADDR") + } fmt.Printf("dnsAddr: %#v\n", dnsAddr) masterArgs.DNSBindAddr.Set(dnsAddr) return masterArgs, nodeArgs, listenArg, imageFormatArgs, kubeConnectionArgs, certArgs } -func getAdminKubeConfigFile(certArgs start.CertArgs) string { - return path.Clean(path.Join(certArgs.CertDir, "admin/.kubeconfig")) -} - func StartTestAllInOne() (*configapi.MasterConfig, string, error) { - deleteAllEtcdKeys() + DeleteAllEtcdKeys() masterArgs, nodeArgs, _, _, _, _ := setupStartOptions() masterArgs.NodeList = nil @@ -105,7 +125,7 @@ func StartTestAllInOne() (*configapi.MasterConfig, string, error) { } // confirm that we can actually query from the api server - if client, _, _, err := GetClusterAdminClient(adminKubeConfigFile); err == nil { + if client, err := GetClusterAdminClient(adminKubeConfigFile); err == nil { if _, err := client.Policies(bootstrappolicy.DefaultMasterAuthorizationNamespace).List(labels.Everything(), labels.Everything()); err == nil { break } @@ -119,7 +139,7 @@ func StartTestAllInOne() (*configapi.MasterConfig, string, error) { // StartTestMaster starts up a test master and returns back the startOptions so you can get clients and certs func StartTestMaster() (*configapi.MasterConfig, string, error) { - deleteAllEtcdKeys() + DeleteAllEtcdKeys() masterArgs, _, _, _, _, _ := setupStartOptions() @@ -157,7 +177,7 @@ func StartTestMaster() (*configapi.MasterConfig, string, error) { } // confirm that we can actually query from the api server - client, _, _, err := GetClusterAdminClient(adminKubeConfigFile) + client, err := GetClusterAdminClient(adminKubeConfigFile) if err != nil { return } @@ -206,17 +226,3 @@ func CreateNewProject(clusterAdminClient *client.Client, clientConfig kclient.Co return adminClient, nil } - -func GetClusterAdminClient(adminKubeConfigFile string) (*client.Client, *kclient.Client, *kclient.Config, error) { - kclient, clientConfig, err := configapi.GetKubeClient(adminKubeConfigFile) - if err != nil { - return nil, nil, nil, err - } - - osclient, err := client.New(clientConfig) - if err != nil { - return nil, nil, nil, err - } - - return osclient, kclient, clientConfig, nil -} diff --git a/test/util/verify.go b/test/util/verify.go new file mode 100644 index 000000000000..d82bca5b65e7 --- /dev/null +++ b/test/util/verify.go @@ -0,0 +1,162 @@ +package util + +import ( + "fmt" + "net" + "strconv" + "time" + + kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api" + kubeutil "github.com/GoogleCloudPlatform/kubernetes/pkg/util" + imageapi "github.com/openshift/origin/pkg/image/api" +) + +// VerifyImage verifies if the latest image in given ImageRepository is valid +func VerifyImage(repo *imageapi.ImageRepository, ns string, validateFunc func(addr string) error) error { + pod := CreatePodFromImage(repo, ns) + if pod == nil { + return fmt.Errorf("Unable to create Pod for %+v", repo.Status.DockerImageRepository) + } + service := CreateServiceForPod(pod, ns) + if service == nil { + return fmt.Errorf("Unable to create Service for %+v", service) + } + + defer CleanupServiceAndPod(pod, service, ns) + + address, err := WaitForAddress(pod, service, ns) + if err != nil { + return fmt.Errorf("Failed to obtain address: %v", err) + } + + return validateFunc(address) +} + +// WaitForAddress waits for the Pod to be running and then for the Service to +// get the endpoint. +func WaitForAddress(pod *kapi.Pod, service *kapi.Service, ns string) (string, error) { + client, err := GetClusterAdminKubeClient(KubeConfigPath()) + if err != nil { + return "", err + } + // TODO: There is no Pods.Watch() (yet) in OpenShift. The Watch() is already + // implemented in upstream, so uncomment this once that happens. + /* + podWatch, err := client.Pods(ns).Watch(labels.Everything(), labels.Everything(), "0") + if err != nil { + return "", fmt.Errorf("Unable to create watcher for Pod: %v", err) + } + defer podWatch.Stop() + + running := false + for event := range podWatch.ResultChan() { + currentPod, ok := event.Object.(*kapi.Pod) + if !ok { + return "", fmt.Errorf("Unable to convert event object to Pod") + } + if pod.Name == currentPod.Name { + switch pod.Status.Phase { + case kapi.PodFailed: + return "", fmt.Errorf("Pod failed to run") + case kapi.PodRunning: + running = true + } + } + if running == true { + break + } + } + fmt.Printf("The Pod %s is now running.", pod.Name) + */ + + // Now wait for the service to get the endpoint + // TODO: Endpoints() have no Watch in upstream, once they do, replace this + // code to use Watch() + for retries := 240; retries != 0; retries-- { + endpoints, err := client.Endpoints(ns).Get(service.Name) + if err != nil { + fmt.Printf("%v\n", err) + time.Sleep(1 * time.Second) + continue + } + if len(endpoints.Endpoints) == 0 { + fmt.Printf("Waiting for Service %s endpoints...\n", service.Name) + time.Sleep(1 * time.Second) + continue + } + for i := range endpoints.Endpoints { + ep := &endpoints.Endpoints[i] + addr := net.JoinHostPort(ep.IP, strconv.Itoa(ep.Port)) + fmt.Printf("The Service %s has endpoint: %s", pod.Name, addr) + return addr, nil + } + } + + return "", fmt.Errorf("Service does not get any endpoints") +} + +// CreatePodFromImage creates a Pod from the latest image available in the Image +// Repository +func CreatePodFromImage(repo *imageapi.ImageRepository, ns string) *kapi.Pod { + client, err := GetClusterAdminKubeClient(KubeConfigPath()) + if err != nil { + return nil + } + pod := &kapi.Pod{ + ObjectMeta: kapi.ObjectMeta{ + Name: ns + "pod", + Labels: map[string]string{"name": ns + "pod"}, + }, + Spec: kapi.PodSpec{ + Containers: []kapi.Container{ + { + Name: "sample", + Image: repo.Status.DockerImageRepository, + }, + }, + RestartPolicy: kapi.RestartPolicy{ + Never: &kapi.RestartPolicyNever{}, + }, + }, + } + if pod, err := client.Pods(ns).Create(pod); err != nil { + fmt.Printf("%v\n", err) + return nil + } else { + return pod + } +} + +// CreateServiceForPod creates a service to serve the provided Pod +func CreateServiceForPod(pod *kapi.Pod, ns string) *kapi.Service { + client, err := GetClusterAdminKubeClient(KubeConfigPath()) + if err != nil { + return nil + } + service := &kapi.Service{ + ObjectMeta: kapi.ObjectMeta{ + Name: ns, + }, + Spec: kapi.ServiceSpec{ + Selector: map[string]string{"name": pod.Name}, + ContainerPort: kubeutil.IntOrString{Kind: kubeutil.IntstrInt, IntVal: 8080}, + Port: 8080, + }, + } + if service, err := client.Services(ns).Create(service); err != nil { + fmt.Printf("%v\n", err) + return nil + } else { + return service + } +} + +// CleanupServiceAndPod removes the Service and the Pod +func CleanupServiceAndPod(pod *kapi.Pod, service *kapi.Service, ns string) { + client, err := GetClusterAdminKubeClient(KubeConfigPath()) + if err != nil { + return + } + client.Pods(ns).Delete(pod.Name) + client.Services(ns).Delete(service.Name) +}