github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-02 16:29:21 +00:00
Code Issues Projects Releases Wiki Activity

use log func in test/e2e/apimachinery

Browse Source
This commit is contained in:
hwdef 2019-09-14 16:10:09 +08:00
parent 07e58a361b
commit 937d4df16a
17 changed files with 283 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
test/e2e/apimachinery/BUILD
View File

@ -83,7 +83,6 @@ go_library(
"//test/e2e/apps:go_default_library", "//test/e2e/apps:go_default_library",
"//test/e2e/framework:go_default_library", "//test/e2e/framework:go_default_library",
"//test/e2e/framework/deployment:go_default_library", "//test/e2e/framework/deployment:go_default_library",
"//test/e2e/framework/log:go_default_library",
"//test/e2e/framework/metrics:go_default_library", "//test/e2e/framework/metrics:go_default_library",
"//test/e2e/framework/pod:go_default_library", "//test/e2e/framework/pod:go_default_library",
"//test/e2e/framework/ssh:go_default_library", "//test/e2e/framework/ssh:go_default_library",

29
test/e2e/apimachinery/aggregator.go
View File

@ -41,7 +41,6 @@ import (
rbacv1helpers "k8s.io/kubernetes/pkg/apis/rbac/v1" rbacv1helpers "k8s.io/kubernetes/pkg/apis/rbac/v1"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2edeploy "k8s.io/kubernetes/test/e2e/framework/deployment" e2edeploy "k8s.io/kubernetes/test/e2e/framework/deployment"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
e2epod "k8s.io/kubernetes/test/e2e/framework/pod" e2epod "k8s.io/kubernetes/test/e2e/framework/pod"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
samplev1alpha1 "k8s.io/sample-apiserver/pkg/apis/wardle/v1alpha1" samplev1alpha1 "k8s.io/sample-apiserver/pkg/apis/wardle/v1alpha1"
@ -81,11 +80,11 @@ var _ = SIGDescribe("Aggregator", func() {
if aggrclient == nil { if aggrclient == nil {
config, err := framework.LoadConfig() config, err := framework.LoadConfig()
if err != nil { if err != nil {
e2elog.Failf("could not load config: %v", err) framework.Failf("could not load config: %v", err)
} }
aggrclient, err = aggregatorclient.NewForConfig(config) aggrclient, err = aggregatorclient.NewForConfig(config)
if err != nil { if err != nil {
e2elog.Failf("could not create aggregator client: %v", err) framework.Failf("could not create aggregator client: %v", err)
} }
} }
}) })
@ -375,16 +374,16 @@ func TestSampleAPIServer(f *framework.Framework, aggrclient *aggregatorclient.Cl
}, "Waited %s for the sample-apiserver to be ready to handle requests.") }, "Waited %s for the sample-apiserver to be ready to handle requests.")
if err != nil { if err != nil {
currentAPIServiceJSON, _ := json.Marshal(currentAPIService) currentAPIServiceJSON, _ := json.Marshal(currentAPIService)
e2elog.Logf("current APIService: %s", string(currentAPIServiceJSON)) framework.Logf("current APIService: %s", string(currentAPIServiceJSON))
currentPodsJSON, _ := json.Marshal(currentPods) currentPodsJSON, _ := json.Marshal(currentPods)
e2elog.Logf("current pods: %s", string(currentPodsJSON)) framework.Logf("current pods: %s", string(currentPodsJSON))
if currentPods != nil { if currentPods != nil {
for _, pod := range currentPods.Items { for _, pod := range currentPods.Items {
for _, container := range pod.Spec.Containers { for _, container := range pod.Spec.Containers {
logs, err := e2epod.GetPodLogs(client, namespace, pod.Name, container.Name) logs, err := e2epod.GetPodLogs(client, namespace, pod.Name, container.Name)
e2elog.Logf("logs of %s/%s (error: %v): %s", pod.Name, container.Name, err, logs) framework.Logf("logs of %s/%s (error: %v): %s", pod.Name, container.Name, err, logs)
} }
} }
} }
@ -402,7 +401,7 @@ func TestSampleAPIServer(f *framework.Framework, aggrclient *aggregatorclient.Cl
var statusCode int var statusCode int
result.StatusCode(&statusCode) result.StatusCode(&statusCode)
if statusCode != 201 { if statusCode != 201 {
e2elog.Failf("Flunders client creation response was status %d, not 201", statusCode) framework.Failf("Flunders client creation response was status %d, not 201", statusCode)
} }
pods, err := client.CoreV1().Pods(namespace).List(metav1.ListOptions{}) pods, err := client.CoreV1().Pods(namespace).List(metav1.ListOptions{})
@ -416,7 +415,7 @@ func TestSampleAPIServer(f *framework.Framework, aggrclient *aggregatorclient.Cl
err = json.Unmarshal(contents, &flundersList) err = json.Unmarshal(contents, &flundersList)
validateErrorWithDebugInfo(f, err, pods, "Error in unmarshalling %T response from server %s", contents, "/apis/wardle.k8s.io/v1alpha1") validateErrorWithDebugInfo(f, err, pods, "Error in unmarshalling %T response from server %s", contents, "/apis/wardle.k8s.io/v1alpha1")
if len(flundersList.Items) != 1 { if len(flundersList.Items) != 1 {
e2elog.Failf("failed to get back the correct flunders list %v", flundersList) framework.Failf("failed to get back the correct flunders list %v", flundersList)
} }
// kubectl delete flunder test-flunder -v 9 // kubectl delete flunder test-flunder -v 9
@ -431,7 +430,7 @@ func TestSampleAPIServer(f *framework.Framework, aggrclient *aggregatorclient.Cl
err = json.Unmarshal(contents, &flundersList) err = json.Unmarshal(contents, &flundersList)
validateErrorWithDebugInfo(f, err, pods, "Error in unmarshalling %T response from server %s", contents, "/apis/wardle.k8s.io/v1alpha1") validateErrorWithDebugInfo(f, err, pods, "Error in unmarshalling %T response from server %s", contents, "/apis/wardle.k8s.io/v1alpha1")
if len(flundersList.Items) != 0 { if len(flundersList.Items) != 0 {
e2elog.Failf("failed to get back the correct deleted flunders list %v", flundersList) framework.Failf("failed to get back the correct deleted flunders list %v", flundersList)
} }
flunderName = generateFlunderName("dynamic-flunder") flunderName = generateFlunderName("dynamic-flunder")
@ -443,7 +442,7 @@ func TestSampleAPIServer(f *framework.Framework, aggrclient *aggregatorclient.Cl
gvr := schema.GroupVersionResource{Group: "wardle.k8s.io", Version: "v1alpha1", Resource: "flunders"} gvr := schema.GroupVersionResource{Group: "wardle.k8s.io", Version: "v1alpha1", Resource: "flunders"}
_, ok := groupVersionResources[gvr] _, ok := groupVersionResources[gvr]
if !ok { if !ok {
e2elog.Failf("could not find group version resource for dynamic client and wardle/flunders (discovery error: %v, discovery results: %#v)", discoveryErr, groupVersionResources) framework.Failf("could not find group version resource for dynamic client and wardle/flunders (discovery error: %v, discovery results: %#v)", discoveryErr, groupVersionResources)
} }
dynamicClient := f.DynamicClient.Resource(gvr).Namespace(namespace) dynamicClient := f.DynamicClient.Resource(gvr).Namespace(namespace)
@ -469,7 +468,7 @@ func TestSampleAPIServer(f *framework.Framework, aggrclient *aggregatorclient.Cl
unstructuredList, err := dynamicClient.List(metav1.ListOptions{}) unstructuredList, err := dynamicClient.List(metav1.ListOptions{})
framework.ExpectNoError(err, "listing flunders using dynamic client") framework.ExpectNoError(err, "listing flunders using dynamic client")
if len(unstructuredList.Items) != 1 { if len(unstructuredList.Items) != 1 {
e2elog.Failf("failed to get back the correct flunders list %v from the dynamic client", unstructuredList) framework.Failf("failed to get back the correct flunders list %v from the dynamic client", unstructuredList)
} }
// kubectl delete flunder test-flunder // kubectl delete flunder test-flunder
@ -480,19 +479,19 @@ func TestSampleAPIServer(f *framework.Framework, aggrclient *aggregatorclient.Cl
unstructuredList, err = dynamicClient.List(metav1.ListOptions{}) unstructuredList, err = dynamicClient.List(metav1.ListOptions{})
framework.ExpectNoError(err, "listing flunders using dynamic client") framework.ExpectNoError(err, "listing flunders using dynamic client")
if len(unstructuredList.Items) != 0 { if len(unstructuredList.Items) != 0 {
e2elog.Failf("failed to get back the correct deleted flunders list %v from the dynamic client", unstructuredList) framework.Failf("failed to get back the correct deleted flunders list %v from the dynamic client", unstructuredList)
} }
cleanTest(client, aggrclient, namespace) cleanTest(client, aggrclient, namespace)
} }
// pollTimed will call Poll but time how long Poll actually took. // pollTimed will call Poll but time how long Poll actually took.
// It will then e2elog.Logf the msg with the duration of the Poll. // It will then framework.Logf the msg with the duration of the Poll.
// It is assumed that msg will contain one %s for the elapsed time. // It is assumed that msg will contain one %s for the elapsed time.
func pollTimed(interval, timeout time.Duration, condition wait.ConditionFunc, msg string) error { func pollTimed(interval, timeout time.Duration, condition wait.ConditionFunc, msg string) error {
defer func(start time.Time, msg string) { defer func(start time.Time, msg string) {
elapsed := time.Since(start) elapsed := time.Since(start)
e2elog.Logf(msg, elapsed) framework.Logf(msg, elapsed)
}(time.Now(), msg) }(time.Now(), msg)
return wait.Poll(interval, timeout, condition) return wait.Poll(interval, timeout, condition)
} }
@ -513,7 +512,7 @@ func validateErrorWithDebugInfo(f *framework.Framework, err error, pods *v1.PodL
msg += fmt.Sprintf("\nOriginal pods in %s:\n%v", namespace, pods) msg += fmt.Sprintf("\nOriginal pods in %s:\n%v", namespace, pods)
} }
e2elog.Failf(msg) framework.Failf(msg)
} }
} }

26
test/e2e/apimachinery/certs.go
View File

@ -23,7 +23,7 @@ import (
"k8s.io/client-go/util/cert" "k8s.io/client-go/util/cert"
"k8s.io/client-go/util/keyutil" "k8s.io/client-go/util/keyutil"
e2elog "k8s.io/kubernetes/test/e2e/framework/log" "k8s.io/kubernetes/test/e2e/framework"
"k8s.io/kubernetes/test/utils" "k8s.io/kubernetes/test/utils"
) )
@ -38,27 +38,27 @@ type certContext struct {
func setupServerCert(namespaceName, serviceName string) *certContext { func setupServerCert(namespaceName, serviceName string) *certContext {
certDir, err := ioutil.TempDir("", "test-e2e-server-cert") certDir, err := ioutil.TempDir("", "test-e2e-server-cert")
if err != nil { if err != nil {
e2elog.Failf("Failed to create a temp dir for cert generation %v", err) framework.Failf("Failed to create a temp dir for cert generation %v", err)
} }
defer os.RemoveAll(certDir) defer os.RemoveAll(certDir)
signingKey, err := utils.NewPrivateKey() signingKey, err := utils.NewPrivateKey()
if err != nil { if err != nil {
e2elog.Failf("Failed to create CA private key %v", err) framework.Failf("Failed to create CA private key %v", err)
} }
signingCert, err := cert.NewSelfSignedCACert(cert.Config{CommonName: "e2e-server-cert-ca"}, signingKey) signingCert, err := cert.NewSelfSignedCACert(cert.Config{CommonName: "e2e-server-cert-ca"}, signingKey)
if err != nil { if err != nil {
e2elog.Failf("Failed to create CA cert for apiserver %v", err) framework.Failf("Failed to create CA cert for apiserver %v", err)
} }
caCertFile, err := ioutil.TempFile(certDir, "ca.crt") caCertFile, err := ioutil.TempFile(certDir, "ca.crt")
if err != nil { if err != nil {
e2elog.Failf("Failed to create a temp file for ca cert generation %v", err) framework.Failf("Failed to create a temp file for ca cert generation %v", err)
} }
if err := ioutil.WriteFile(caCertFile.Name(), utils.EncodeCertPEM(signingCert), 0644); err != nil { if err := ioutil.WriteFile(caCertFile.Name(), utils.EncodeCertPEM(signingCert), 0644); err != nil {
e2elog.Failf("Failed to write CA cert %v", err) framework.Failf("Failed to write CA cert %v", err)
} }
key, err := utils.NewPrivateKey() key, err := utils.NewPrivateKey()
if err != nil { if err != nil {
e2elog.Failf("Failed to create private key for %v", err) framework.Failf("Failed to create private key for %v", err)
} }
signedCert, err := utils.NewSignedCert( signedCert, err := utils.NewSignedCert(
&cert.Config{ &cert.Config{
@ -68,25 +68,25 @@ func setupServerCert(namespaceName, serviceName string) *certContext {
key, signingCert, signingKey, key, signingCert, signingKey,
) )
if err != nil { if err != nil {
e2elog.Failf("Failed to create cert%v", err) framework.Failf("Failed to create cert%v", err)
} }
certFile, err := ioutil.TempFile(certDir, "server.crt") certFile, err := ioutil.TempFile(certDir, "server.crt")
if err != nil { if err != nil {
e2elog.Failf("Failed to create a temp file for cert generation %v", err) framework.Failf("Failed to create a temp file for cert generation %v", err)
} }
keyFile, err := ioutil.TempFile(certDir, "server.key") keyFile, err := ioutil.TempFile(certDir, "server.key")
if err != nil { if err != nil {
e2elog.Failf("Failed to create a temp file for key generation %v", err) framework.Failf("Failed to create a temp file for key generation %v", err)
} }
if err = ioutil.WriteFile(certFile.Name(), utils.EncodeCertPEM(signedCert), 0600); err != nil { if err = ioutil.WriteFile(certFile.Name(), utils.EncodeCertPEM(signedCert), 0600); err != nil {
e2elog.Failf("Failed to write cert file %v", err) framework.Failf("Failed to write cert file %v", err)
} }
privateKeyPEM, err := keyutil.MarshalPrivateKeyToPEM(key) privateKeyPEM, err := keyutil.MarshalPrivateKeyToPEM(key)
if err != nil { if err != nil {
e2elog.Failf("Failed to marshal key %v", err) framework.Failf("Failed to marshal key %v", err)
} }
if err = ioutil.WriteFile(keyFile.Name(), privateKeyPEM, 0644); err != nil { if err = ioutil.WriteFile(keyFile.Name(), privateKeyPEM, 0644); err != nil {
e2elog.Failf("Failed to write key file %v", err) framework.Failf("Failed to write key file %v", err)
} }
return &certContext{ return &certContext{
cert: utils.EncodeCertPEM(signedCert), cert: utils.EncodeCertPEM(signedCert),

17
test/e2e/apimachinery/chunking.go
View File

@ -35,7 +35,6 @@ import (
utilfeature "k8s.io/apiserver/pkg/util/feature" utilfeature "k8s.io/apiserver/pkg/util/feature"
"k8s.io/client-go/util/workqueue" "k8s.io/client-go/util/workqueue"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
) )
func shouldCheckRemainingItem() bool { func shouldCheckRemainingItem() bool {
@ -69,9 +68,9 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
if err == nil { if err == nil {
return return
} }
e2elog.Logf("Got an error creating template %d: %v", i, err) framework.Logf("Got an error creating template %d: %v", i, err)
} }
e2elog.Fail("Unable to create template %d, exiting", i) framework.Failf("Unable to create template %d, exiting", i)
}) })
}) })
@ -88,7 +87,7 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
opts.Limit = int64(rand.Int31n(numberOfTotalResources/10) + 1) opts.Limit = int64(rand.Int31n(numberOfTotalResources/10) + 1)
list, err := client.List(opts) list, err := client.List(opts)
framework.ExpectNoError(err, "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit) framework.ExpectNoError(err, "failed to list pod templates in namespace: %s, given limit: %d", ns, opts.Limit)
e2elog.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, list.Continue) framework.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, list.Continue)
gomega.Expect(len(list.Items)).To(gomega.BeNumerically("<=", opts.Limit)) gomega.Expect(len(list.Items)).To(gomega.BeNumerically("<=", opts.Limit))
if len(lastRV) == 0 { if len(lastRV) == 0 {
@ -143,7 +142,7 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
gomega.Expect(int(*list.GetRemainingItemCount()) + len(list.Items)).To(gomega.BeNumerically("==", numberOfTotalResources)) gomega.Expect(int(*list.GetRemainingItemCount()) + len(list.Items)).To(gomega.BeNumerically("==", numberOfTotalResources))
} }
} }
e2elog.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, firstToken) framework.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, firstToken)
ginkgo.By("retrieving the second page until the token expires") ginkgo.By("retrieving the second page until the token expires")
opts.Continue = firstToken opts.Continue = firstToken
@ -151,13 +150,13 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
wait.Poll(20*time.Second, 2*storagebackend.DefaultCompactInterval, func() (bool, error) { wait.Poll(20*time.Second, 2*storagebackend.DefaultCompactInterval, func() (bool, error) {
_, err := client.List(opts) _, err := client.List(opts)
if err == nil { if err == nil {
e2elog.Logf("Token %s has not expired yet", firstToken) framework.Logf("Token %s has not expired yet", firstToken)
return false, nil return false, nil
} }
if err != nil && !errors.IsResourceExpired(err) { if err != nil && !errors.IsResourceExpired(err) {
return false, err return false, err
} }
e2elog.Logf("got error %s", err) framework.Logf("got error %s", err)
status, ok := err.(errors.APIStatus) status, ok := err.(errors.APIStatus)
if !ok { if !ok {
return false, fmt.Errorf("expect error to implement the APIStatus interface, got %v", reflect.TypeOf(err)) return false, fmt.Errorf("expect error to implement the APIStatus interface, got %v", reflect.TypeOf(err))
@ -166,7 +165,7 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
if len(inconsistentToken) == 0 { if len(inconsistentToken) == 0 {
return false, fmt.Errorf("expect non empty continue token") return false, fmt.Errorf("expect non empty continue token")
} }
e2elog.Logf("Retrieved inconsistent continue %s", inconsistentToken) framework.Logf("Retrieved inconsistent continue %s", inconsistentToken)
return true, nil return true, nil
}) })
@ -205,7 +204,7 @@ var _ = SIGDescribe("Servers with support for API chunking", func() {
gomega.Expect(int(*list.GetRemainingItemCount()) + len(list.Items) + found).To(gomega.BeNumerically("==", numberOfTotalResources)) gomega.Expect(int(*list.GetRemainingItemCount()) + len(list.Items) + found).To(gomega.BeNumerically("==", numberOfTotalResources))
} }
} }
e2elog.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, list.Continue) framework.Logf("Retrieved %d/%d results with rv %s and continue %s", len(list.Items), opts.Limit, list.ResourceVersion, list.Continue)
gomega.Expect(len(list.Items)).To(gomega.BeNumerically("<=", opts.Limit)) gomega.Expect(len(list.Items)).To(gomega.BeNumerically("<=", opts.Limit))
framework.ExpectEqual(list.ResourceVersion, lastRV) framework.ExpectEqual(list.ResourceVersion, lastRV)
for _, item := range list.Items { for _, item := range list.Items {

5
test/e2e/apimachinery/crd_conversion_webhook.go
View File

@ -35,7 +35,6 @@ import (
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2edeploy "k8s.io/kubernetes/test/e2e/framework/deployment" e2edeploy "k8s.io/kubernetes/test/e2e/framework/deployment"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"k8s.io/kubernetes/test/utils/crd" "k8s.io/kubernetes/test/utils/crd"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
"k8s.io/utils/pointer" "k8s.io/utils/pointer"
@ -238,7 +237,7 @@ func createAuthReaderRoleBindingForCRDConversion(f *framework.Framework, namespa
}, },
}) })
if err != nil && errors.IsAlreadyExists(err) { if err != nil && errors.IsAlreadyExists(err) {
e2elog.Logf("role binding %s already exists", roleBindingCRDName) framework.Logf("role binding %s already exists", roleBindingCRDName)
} else { } else {
framework.ExpectNoError(err, "creating role binding %s:webhook to access configMap", namespace) framework.ExpectNoError(err, "creating role binding %s:webhook to access configMap", namespace)
} }
@ -506,7 +505,7 @@ func waitWebhookConversionReady(f *framework.Framework, crd *apiextensionsv1.Cus
if err != nil { if err != nil {
// tolerate clusters that do not set --enable-aggregator-routing and have to wait for kube-proxy // tolerate clusters that do not set --enable-aggregator-routing and have to wait for kube-proxy
// to program the service network, during which conversion requests return errors // to program the service network, during which conversion requests return errors
e2elog.Logf("error waiting for conversion to succeed during setup: %v", err) framework.Logf("error waiting for conversion to succeed during setup: %v", err)
return false, nil return false, nil
} }

155
test/e2e/apimachinery/crd_publish_openapi.go
View File

@ -40,7 +40,6 @@ import (
"k8s.io/client-go/rest" "k8s.io/client-go/rest"
openapiutil "k8s.io/kube-openapi/pkg/util" openapiutil "k8s.io/kube-openapi/pkg/util"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"k8s.io/kubernetes/test/utils/crd" "k8s.io/kubernetes/test/utils/crd"
"sigs.k8s.io/yaml" "sigs.k8s.io/yaml"
) )
@ -65,7 +64,7 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
framework.ConformanceIt("works for CRD with validation schema", func() { framework.ConformanceIt("works for CRD with validation schema", func() {
crd, err := setupCRD(f, schemaFoo, "foo", "v1") crd, err := setupCRD(f, schemaFoo, "foo", "v1")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
meta := fmt.Sprintf(metaPattern, crd.Crd.Spec.Names.Kind, crd.Crd.Spec.Group, crd.Crd.Spec.Versions[0].Name, "test-foo") meta := fmt.Sprintf(metaPattern, crd.Crd.Spec.Names.Kind, crd.Crd.Spec.Group, crd.Crd.Spec.Versions[0].Name, "test-foo")
@ -74,59 +73,59 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("client-side validation (kubectl create and apply) allows request with known and required properties") ginkgo.By("client-side validation (kubectl create and apply) allows request with known and required properties")
validCR := fmt.Sprintf(`{%s,"spec":{"bars":[{"name":"test-bar"}]}}`, meta) validCR := fmt.Sprintf(`{%s,"spec":{"bars":[{"name":"test-bar"}]}}`, meta)
if _, err := framework.RunKubectlInput(validCR, ns, "create", "-f", "-"); err != nil { if _, err := framework.RunKubectlInput(validCR, ns, "create", "-f", "-"); err != nil {
e2elog.Failf("failed to create valid CR %s: %v", validCR, err) framework.Failf("failed to create valid CR %s: %v", validCR, err)
} }
if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-foo"); err != nil { if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-foo"); err != nil {
e2elog.Failf("failed to delete valid CR: %v", err) framework.Failf("failed to delete valid CR: %v", err)
} }
if _, err := framework.RunKubectlInput(validCR, ns, "apply", "-f", "-"); err != nil { if _, err := framework.RunKubectlInput(validCR, ns, "apply", "-f", "-"); err != nil {
e2elog.Failf("failed to apply valid CR %s: %v", validCR, err) framework.Failf("failed to apply valid CR %s: %v", validCR, err)
} }
if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-foo"); err != nil { if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-foo"); err != nil {
e2elog.Failf("failed to delete valid CR: %v", err) framework.Failf("failed to delete valid CR: %v", err)
} }
ginkgo.By("client-side validation (kubectl create and apply) rejects request with unknown properties when disallowed by the schema") ginkgo.By("client-side validation (kubectl create and apply) rejects request with unknown properties when disallowed by the schema")
unknownCR := fmt.Sprintf(`{%s,"spec":{"foo":true}}`, meta) unknownCR := fmt.Sprintf(`{%s,"spec":{"foo":true}}`, meta)
if _, err := framework.RunKubectlInput(unknownCR, ns, "create", "-f", "-"); err == nil || !strings.Contains(err.Error(), `unknown field "foo"`) { if _, err := framework.RunKubectlInput(unknownCR, ns, "create", "-f", "-"); err == nil || !strings.Contains(err.Error(), `unknown field "foo"`) {
e2elog.Failf("unexpected no error when creating CR with unknown field: %v", err) framework.Failf("unexpected no error when creating CR with unknown field: %v", err)
} }
if _, err := framework.RunKubectlInput(unknownCR, ns, "apply", "-f", "-"); err == nil || !strings.Contains(err.Error(), `unknown field "foo"`) { if _, err := framework.RunKubectlInput(unknownCR, ns, "apply", "-f", "-"); err == nil || !strings.Contains(err.Error(), `unknown field "foo"`) {
e2elog.Failf("unexpected no error when applying CR with unknown field: %v", err) framework.Failf("unexpected no error when applying CR with unknown field: %v", err)
} }
ginkgo.By("client-side validation (kubectl create and apply) rejects request without required properties") ginkgo.By("client-side validation (kubectl create and apply) rejects request without required properties")
noRequireCR := fmt.Sprintf(`{%s,"spec":{"bars":[{"age":"10"}]}}`, meta) noRequireCR := fmt.Sprintf(`{%s,"spec":{"bars":[{"age":"10"}]}}`, meta)
if _, err := framework.RunKubectlInput(noRequireCR, ns, "create", "-f", "-"); err == nil || !strings.Contains(err.Error(), `missing required field "name"`) { if _, err := framework.RunKubectlInput(noRequireCR, ns, "create", "-f", "-"); err == nil || !strings.Contains(err.Error(), `missing required field "name"`) {
e2elog.Failf("unexpected no error when creating CR without required field: %v", err) framework.Failf("unexpected no error when creating CR without required field: %v", err)
} }
if _, err := framework.RunKubectlInput(noRequireCR, ns, "apply", "-f", "-"); err == nil || !strings.Contains(err.Error(), `missing required field "name"`) { if _, err := framework.RunKubectlInput(noRequireCR, ns, "apply", "-f", "-"); err == nil || !strings.Contains(err.Error(), `missing required field "name"`) {
e2elog.Failf("unexpected no error when applying CR without required field: %v", err) framework.Failf("unexpected no error when applying CR without required field: %v", err)
} }
ginkgo.By("kubectl explain works to explain CR properties") ginkgo.By("kubectl explain works to explain CR properties")
if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural, `(?s)DESCRIPTION:.*Foo CRD for Testing.*FIELDS:.*apiVersion.*<string>.*APIVersion defines.*spec.*<Object>.*Specification of Foo`); err != nil { if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural, `(?s)DESCRIPTION:.*Foo CRD for Testing.*FIELDS:.*apiVersion.*<string>.*APIVersion defines.*spec.*<Object>.*Specification of Foo`); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("kubectl explain works to explain CR properties recursively") ginkgo.By("kubectl explain works to explain CR properties recursively")
if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural+".metadata", `(?s)DESCRIPTION:.*Standard object's metadata.*FIELDS:.*creationTimestamp.*<string>.*CreationTimestamp is a timestamp`); err != nil { if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural+".metadata", `(?s)DESCRIPTION:.*Standard object's metadata.*FIELDS:.*creationTimestamp.*<string>.*CreationTimestamp is a timestamp`); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural+".spec", `(?s)DESCRIPTION:.*Specification of Foo.*FIELDS:.*bars.*<\[\]Object>.*List of Bars and their specs`); err != nil { if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural+".spec", `(?s)DESCRIPTION:.*Specification of Foo.*FIELDS:.*bars.*<\[\]Object>.*List of Bars and their specs`); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural+".spec.bars", `(?s)RESOURCE:.*bars.*<\[\]Object>.*DESCRIPTION:.*List of Bars and their specs.*FIELDS:.*bazs.*<\[\]string>.*List of Bazs.*name.*<string>.*Name of Bar`); err != nil { if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural+".spec.bars", `(?s)RESOURCE:.*bars.*<\[\]Object>.*DESCRIPTION:.*List of Bars and their specs.*FIELDS:.*bazs.*<\[\]string>.*List of Bazs.*name.*<string>.*Name of Bar`); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("kubectl explain works to return error when explain is called on property that doesn't exist") ginkgo.By("kubectl explain works to return error when explain is called on property that doesn't exist")
if _, err := framework.RunKubectl("explain", crd.Crd.Spec.Names.Plural+".spec.bars2"); err == nil || !strings.Contains(err.Error(), `field "bars2" does not exist`) { if _, err := framework.RunKubectl("explain", crd.Crd.Spec.Names.Plural+".spec.bars2"); err == nil || !strings.Contains(err.Error(), `field "bars2" does not exist`) {
e2elog.Failf("unexpected no error when explaining property that doesn't exist: %v", err) framework.Failf("unexpected no error when explaining property that doesn't exist: %v", err)
} }
if err := cleanupCRD(f, crd); err != nil { if err := cleanupCRD(f, crd); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
@ -140,7 +139,7 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
framework.ConformanceIt("works for CRD without validation schema", func() { framework.ConformanceIt("works for CRD without validation schema", func() {
crd, err := setupCRD(f, nil, "empty", "v1") crd, err := setupCRD(f, nil, "empty", "v1")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
meta := fmt.Sprintf(metaPattern, crd.Crd.Spec.Names.Kind, crd.Crd.Spec.Group, crd.Crd.Spec.Versions[0].Name, "test-cr") meta := fmt.Sprintf(metaPattern, crd.Crd.Spec.Names.Kind, crd.Crd.Spec.Group, crd.Crd.Spec.Versions[0].Name, "test-cr")
@ -149,25 +148,25 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("client-side validation (kubectl create and apply) allows request with any unknown properties") ginkgo.By("client-side validation (kubectl create and apply) allows request with any unknown properties")
randomCR := fmt.Sprintf(`{%s,"a":{"b":[{"c":"d"}]}}`, meta) randomCR := fmt.Sprintf(`{%s,"a":{"b":[{"c":"d"}]}}`, meta)
if _, err := framework.RunKubectlInput(randomCR, ns, "create", "-f", "-"); err != nil { if _, err := framework.RunKubectlInput(randomCR, ns, "create", "-f", "-"); err != nil {
e2elog.Failf("failed to create random CR %s for CRD without schema: %v", randomCR, err) framework.Failf("failed to create random CR %s for CRD without schema: %v", randomCR, err)
} }
if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil { if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil {
e2elog.Failf("failed to delete random CR: %v", err) framework.Failf("failed to delete random CR: %v", err)
} }
if _, err := framework.RunKubectlInput(randomCR, ns, "apply", "-f", "-"); err != nil { if _, err := framework.RunKubectlInput(randomCR, ns, "apply", "-f", "-"); err != nil {
e2elog.Failf("failed to apply random CR %s for CRD without schema: %v", randomCR, err) framework.Failf("failed to apply random CR %s for CRD without schema: %v", randomCR, err)
} }
if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil { if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil {
e2elog.Failf("failed to delete random CR: %v", err) framework.Failf("failed to delete random CR: %v", err)
} }
ginkgo.By("kubectl explain works to explain CR without validation schema") ginkgo.By("kubectl explain works to explain CR without validation schema")
if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural, `(?s)DESCRIPTION:.*<empty>`); err != nil { if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural, `(?s)DESCRIPTION:.*<empty>`); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crd); err != nil { if err := cleanupCRD(f, crd); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
@ -181,7 +180,7 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
framework.ConformanceIt("works for CRD preserving unknown fields at the schema root", func() { framework.ConformanceIt("works for CRD preserving unknown fields at the schema root", func() {
crd, err := setupCRDAndVerifySchema(f, schemaPreserveRoot, nil, "unknown-at-root", "v1") crd, err := setupCRDAndVerifySchema(f, schemaPreserveRoot, nil, "unknown-at-root", "v1")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
meta := fmt.Sprintf(metaPattern, crd.Crd.Spec.Names.Kind, crd.Crd.Spec.Group, crd.Crd.Spec.Versions[0].Name, "test-cr") meta := fmt.Sprintf(metaPattern, crd.Crd.Spec.Names.Kind, crd.Crd.Spec.Group, crd.Crd.Spec.Versions[0].Name, "test-cr")
@ -190,25 +189,25 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("client-side validation (kubectl create and apply) allows request with any unknown properties") ginkgo.By("client-side validation (kubectl create and apply) allows request with any unknown properties")
randomCR := fmt.Sprintf(`{%s,"a":{"b":[{"c":"d"}]}}`, meta) randomCR := fmt.Sprintf(`{%s,"a":{"b":[{"c":"d"}]}}`, meta)
if _, err := framework.RunKubectlInput(randomCR, ns, "create", "-f", "-"); err != nil { if _, err := framework.RunKubectlInput(randomCR, ns, "create", "-f", "-"); err != nil {
e2elog.Failf("failed to create random CR %s for CRD that allows unknown properties at the root: %v", randomCR, err) framework.Failf("failed to create random CR %s for CRD that allows unknown properties at the root: %v", randomCR, err)
} }
if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil { if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil {
e2elog.Failf("failed to delete random CR: %v", err) framework.Failf("failed to delete random CR: %v", err)
} }
if _, err := framework.RunKubectlInput(randomCR, ns, "apply", "-f", "-"); err != nil { if _, err := framework.RunKubectlInput(randomCR, ns, "apply", "-f", "-"); err != nil {
e2elog.Failf("failed to apply random CR %s for CRD without schema: %v", randomCR, err) framework.Failf("failed to apply random CR %s for CRD without schema: %v", randomCR, err)
} }
if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil { if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil {
e2elog.Failf("failed to delete random CR: %v", err) framework.Failf("failed to delete random CR: %v", err)
} }
ginkgo.By("kubectl explain works to explain CR") ginkgo.By("kubectl explain works to explain CR")
if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural, fmt.Sprintf(`(?s)KIND:.*%s`, crd.Crd.Spec.Names.Kind)); err != nil { if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural, fmt.Sprintf(`(?s)KIND:.*%s`, crd.Crd.Spec.Names.Kind)); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crd); err != nil { if err := cleanupCRD(f, crd); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
@ -223,7 +222,7 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
framework.ConformanceIt("works for CRD preserving unknown fields in an embedded object", func() { framework.ConformanceIt("works for CRD preserving unknown fields in an embedded object", func() {
crd, err := setupCRDAndVerifySchema(f, schemaPreserveNested, nil, "unknown-in-nested", "v1") crd, err := setupCRDAndVerifySchema(f, schemaPreserveNested, nil, "unknown-in-nested", "v1")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
meta := fmt.Sprintf(metaPattern, crd.Crd.Spec.Names.Kind, crd.Crd.Spec.Group, crd.Crd.Spec.Versions[0].Name, "test-cr") meta := fmt.Sprintf(metaPattern, crd.Crd.Spec.Names.Kind, crd.Crd.Spec.Group, crd.Crd.Spec.Versions[0].Name, "test-cr")
@ -232,25 +231,25 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("client-side validation (kubectl create and apply) allows request with any unknown properties") ginkgo.By("client-side validation (kubectl create and apply) allows request with any unknown properties")
randomCR := fmt.Sprintf(`{%s,"spec":{"b":[{"c":"d"}]}}`, meta) randomCR := fmt.Sprintf(`{%s,"spec":{"b":[{"c":"d"}]}}`, meta)
if _, err := framework.RunKubectlInput(randomCR, ns, "create", "-f", "-"); err != nil { if _, err := framework.RunKubectlInput(randomCR, ns, "create", "-f", "-"); err != nil {
e2elog.Failf("failed to create random CR %s for CRD that allows unknown properties in a nested object: %v", randomCR, err) framework.Failf("failed to create random CR %s for CRD that allows unknown properties in a nested object: %v", randomCR, err)
} }
if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil { if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil {
e2elog.Failf("failed to delete random CR: %v", err) framework.Failf("failed to delete random CR: %v", err)
} }
if _, err := framework.RunKubectlInput(randomCR, ns, "apply", "-f", "-"); err != nil { if _, err := framework.RunKubectlInput(randomCR, ns, "apply", "-f", "-"); err != nil {
e2elog.Failf("failed to apply random CR %s for CRD without schema: %v", randomCR, err) framework.Failf("failed to apply random CR %s for CRD without schema: %v", randomCR, err)
} }
if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil { if _, err := framework.RunKubectl(ns, "delete", crd.Crd.Spec.Names.Plural, "test-cr"); err != nil {
e2elog.Failf("failed to delete random CR: %v", err) framework.Failf("failed to delete random CR: %v", err)
} }
ginkgo.By("kubectl explain works to explain CR") ginkgo.By("kubectl explain works to explain CR")
if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural, `(?s)DESCRIPTION:.*preserve-unknown-properties in nested field for Testing`); err != nil { if err := verifyKubectlExplain(crd.Crd.Spec.Names.Plural, `(?s)DESCRIPTION:.*preserve-unknown-properties in nested field for Testing`); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crd); err != nil { if err := cleanupCRD(f, crd); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
@ -264,26 +263,26 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("CRs in different groups (two CRDs) show up in OpenAPI documentation") ginkgo.By("CRs in different groups (two CRDs) show up in OpenAPI documentation")
crdFoo, err := setupCRD(f, schemaFoo, "foo", "v1") crdFoo, err := setupCRD(f, schemaFoo, "foo", "v1")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
crdWaldo, err := setupCRD(f, schemaWaldo, "waldo", "v1beta1") crdWaldo, err := setupCRD(f, schemaWaldo, "waldo", "v1beta1")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if crdFoo.Crd.Spec.Group == crdWaldo.Crd.Spec.Group { if crdFoo.Crd.Spec.Group == crdWaldo.Crd.Spec.Group {
e2elog.Failf("unexpected: CRDs should be of different group %v, %v", crdFoo.Crd.Spec.Group, crdWaldo.Crd.Spec.Group) framework.Failf("unexpected: CRDs should be of different group %v, %v", crdFoo.Crd.Spec.Group, crdWaldo.Crd.Spec.Group)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdWaldo, "v1beta1"), schemaWaldo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdWaldo, "v1beta1"), schemaWaldo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdFoo, "v1"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdFoo, "v1"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crdFoo); err != nil { if err := cleanupCRD(f, crdFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crdWaldo); err != nil { if err := cleanupCRD(f, crdWaldo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
@ -297,41 +296,41 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("CRs in the same group but different versions (one multiversion CRD) show up in OpenAPI documentation") ginkgo.By("CRs in the same group but different versions (one multiversion CRD) show up in OpenAPI documentation")
crdMultiVer, err := setupCRD(f, schemaFoo, "multi-ver", "v2", "v3") crdMultiVer, err := setupCRD(f, schemaFoo, "multi-ver", "v2", "v3")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v3"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v3"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v2"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v2"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crdMultiVer); err != nil { if err := cleanupCRD(f, crdMultiVer); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("CRs in the same group but different versions (two CRDs) show up in OpenAPI documentation") ginkgo.By("CRs in the same group but different versions (two CRDs) show up in OpenAPI documentation")
crdFoo, err := setupCRD(f, schemaFoo, "common-group", "v4") crdFoo, err := setupCRD(f, schemaFoo, "common-group", "v4")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
crdWaldo, err := setupCRD(f, schemaWaldo, "common-group", "v5") crdWaldo, err := setupCRD(f, schemaWaldo, "common-group", "v5")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if crdFoo.Crd.Spec.Group != crdWaldo.Crd.Spec.Group { if crdFoo.Crd.Spec.Group != crdWaldo.Crd.Spec.Group {
e2elog.Failf("unexpected: CRDs should be of the same group %v, %v", crdFoo.Crd.Spec.Group, crdWaldo.Crd.Spec.Group) framework.Failf("unexpected: CRDs should be of the same group %v, %v", crdFoo.Crd.Spec.Group, crdWaldo.Crd.Spec.Group)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdWaldo, "v5"), schemaWaldo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdWaldo, "v5"), schemaWaldo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdFoo, "v4"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdFoo, "v4"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crdFoo); err != nil { if err := cleanupCRD(f, crdFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crdWaldo); err != nil { if err := cleanupCRD(f, crdWaldo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
@ -345,26 +344,26 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("CRs in the same group and version but different kinds (two CRDs) show up in OpenAPI documentation") ginkgo.By("CRs in the same group and version but different kinds (two CRDs) show up in OpenAPI documentation")
crdFoo, err := setupCRD(f, schemaFoo, "common-group", "v6") crdFoo, err := setupCRD(f, schemaFoo, "common-group", "v6")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
crdWaldo, err := setupCRD(f, schemaWaldo, "common-group", "v6") crdWaldo, err := setupCRD(f, schemaWaldo, "common-group", "v6")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if crdFoo.Crd.Spec.Group != crdWaldo.Crd.Spec.Group { if crdFoo.Crd.Spec.Group != crdWaldo.Crd.Spec.Group {
e2elog.Failf("unexpected: CRDs should be of the same group %v, %v", crdFoo.Crd.Spec.Group, crdWaldo.Crd.Spec.Group) framework.Failf("unexpected: CRDs should be of the same group %v, %v", crdFoo.Crd.Spec.Group, crdWaldo.Crd.Spec.Group)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdWaldo, "v6"), schemaWaldo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdWaldo, "v6"), schemaWaldo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdFoo, "v6"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdFoo, "v6"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crdFoo); err != nil { if err := cleanupCRD(f, crdFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crdWaldo); err != nil { if err := cleanupCRD(f, crdWaldo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
@ -379,13 +378,13 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("set up a multi version CRD") ginkgo.By("set up a multi version CRD")
crdMultiVer, err := setupCRD(f, schemaFoo, "multi-ver", "v2", "v3") crdMultiVer, err := setupCRD(f, schemaFoo, "multi-ver", "v2", "v3")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v3"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v3"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v2"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v2"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("rename a version") ginkgo.By("rename a version")
@ -395,27 +394,27 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
]`) ]`)
crdMultiVer.Crd, err = crdMultiVer.APIExtensionClient.ApiextensionsV1().CustomResourceDefinitions().Patch(crdMultiVer.Crd.Name, types.JSONPatchType, patch) crdMultiVer.Crd, err = crdMultiVer.APIExtensionClient.ApiextensionsV1().CustomResourceDefinitions().Patch(crdMultiVer.Crd.Name, types.JSONPatchType, patch)
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("check the new version name is served") ginkgo.By("check the new version name is served")
if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v4"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v4"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("check the old version name is removed") ginkgo.By("check the old version name is removed")
if err := waitForDefinitionCleanup(f.ClientSet, definitionName(crdMultiVer, "v3")); err != nil { if err := waitForDefinitionCleanup(f.ClientSet, definitionName(crdMultiVer, "v3")); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("check the other version is not changed") ginkgo.By("check the other version is not changed")
if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v2"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crdMultiVer, "v2"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
// TestCrd.Versions is different from TestCrd.Crd.Versions, we have to manually // TestCrd.Versions is different from TestCrd.Crd.Versions, we have to manually
// update the name there. Used by cleanupCRD // update the name there. Used by cleanupCRD
crdMultiVer.Crd.Spec.Versions[1].Name = "v4" crdMultiVer.Crd.Spec.Versions[1].Name = "v4"
if err := cleanupCRD(f, crdMultiVer); err != nil { if err := cleanupCRD(f, crdMultiVer); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
@ -430,38 +429,38 @@ var _ = SIGDescribe("CustomResourcePublishOpenAPI [Privileged:ClusterAdmin]", fu
ginkgo.By("set up a multi version CRD") ginkgo.By("set up a multi version CRD")
crd, err := setupCRD(f, schemaFoo, "multi-to-single-ver", "v5", "v6alpha1") crd, err := setupCRD(f, schemaFoo, "multi-to-single-ver", "v5", "v6alpha1")
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
// just double check. setupCRD() checked this for us already // just double check. setupCRD() checked this for us already
if err := waitForDefinition(f.ClientSet, definitionName(crd, "v6alpha1"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crd, "v6alpha1"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := waitForDefinition(f.ClientSet, definitionName(crd, "v5"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crd, "v5"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("mark a version not serverd") ginkgo.By("mark a version not serverd")
crd.Crd, err = crd.APIExtensionClient.ApiextensionsV1().CustomResourceDefinitions().Get(crd.Crd.Name, metav1.GetOptions{}) crd.Crd, err = crd.APIExtensionClient.ApiextensionsV1().CustomResourceDefinitions().Get(crd.Crd.Name, metav1.GetOptions{})
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
crd.Crd.Spec.Versions[1].Served = false crd.Crd.Spec.Versions[1].Served = false
crd.Crd, err = crd.APIExtensionClient.ApiextensionsV1().CustomResourceDefinitions().Update(crd.Crd) crd.Crd, err = crd.APIExtensionClient.ApiextensionsV1().CustomResourceDefinitions().Update(crd.Crd)
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("check the unserved version gets removed") ginkgo.By("check the unserved version gets removed")
if err := waitForDefinitionCleanup(f.ClientSet, definitionName(crd, "v6alpha1")); err != nil { if err := waitForDefinitionCleanup(f.ClientSet, definitionName(crd, "v6alpha1")); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("check the other version is not changed") ginkgo.By("check the other version is not changed")
if err := waitForDefinition(f.ClientSet, definitionName(crd, "v5"), schemaFoo); err != nil { if err := waitForDefinition(f.ClientSet, definitionName(crd, "v5"), schemaFoo); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if err := cleanupCRD(f, crd); err != nil { if err := cleanupCRD(f, crd); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
}) })
}) })

9
test/e2e/apimachinery/crd_watch.go
View File

@ -30,7 +30,6 @@ import (
"k8s.io/apimachinery/pkg/watch" "k8s.io/apimachinery/pkg/watch"
"k8s.io/client-go/dynamic" "k8s.io/client-go/dynamic"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"github.com/onsi/ginkgo" "github.com/onsi/ginkgo"
) )
@ -55,24 +54,24 @@ var _ = SIGDescribe("CustomResourceDefinition Watch [Privileged:ClusterAdmin]",
config, err := framework.LoadConfig() config, err := framework.LoadConfig()
if err != nil { if err != nil {
e2elog.Failf("failed to load config: %v", err) framework.Failf("failed to load config: %v", err)
} }
apiExtensionClient, err := clientset.NewForConfig(config) apiExtensionClient, err := clientset.NewForConfig(config)
if err != nil { if err != nil {
e2elog.Failf("failed to initialize apiExtensionClient: %v", err) framework.Failf("failed to initialize apiExtensionClient: %v", err)
} }
noxuDefinition := fixtures.NewNoxuV1CustomResourceDefinition(apiextensionsv1.ClusterScoped) noxuDefinition := fixtures.NewNoxuV1CustomResourceDefinition(apiextensionsv1.ClusterScoped)
noxuDefinition, err = fixtures.CreateNewV1CustomResourceDefinition(noxuDefinition, apiExtensionClient, f.DynamicClient) noxuDefinition, err = fixtures.CreateNewV1CustomResourceDefinition(noxuDefinition, apiExtensionClient, f.DynamicClient)
if err != nil { if err != nil {
e2elog.Failf("failed to create CustomResourceDefinition: %v", err) framework.Failf("failed to create CustomResourceDefinition: %v", err)
} }
defer func() { defer func() {
err = fixtures.DeleteV1CustomResourceDefinition(noxuDefinition, apiExtensionClient) err = fixtures.DeleteV1CustomResourceDefinition(noxuDefinition, apiExtensionClient)
if err != nil { if err != nil {
e2elog.Failf("failed to delete CustomResourceDefinition: %v", err) framework.Failf("failed to delete CustomResourceDefinition: %v", err)
} }
}() }()

7
test/e2e/apimachinery/custom_resource_definition.go
View File

@ -32,7 +32,6 @@ import (
"k8s.io/client-go/dynamic" "k8s.io/client-go/dynamic"
"k8s.io/client-go/util/retry" "k8s.io/client-go/util/retry"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
) )
var _ = SIGDescribe("CustomResourceDefinition resources [Privileged:ClusterAdmin]", func() { var _ = SIGDescribe("CustomResourceDefinition resources [Privileged:ClusterAdmin]", func() {
@ -116,7 +115,7 @@ var _ = SIGDescribe("CustomResourceDefinition resources [Privileged:ClusterAdmin
} }
framework.ExpectNotEqual(expected, nil) framework.ExpectNotEqual(expected, nil)
if !equality.Semantic.DeepEqual(actual.Spec, expected.Spec) { if !equality.Semantic.DeepEqual(actual.Spec, expected.Spec) {
e2elog.Failf("Expected CustomResourceDefinition in list with name %s to match crd created with same name, but got different specs:\n%s", framework.Failf("Expected CustomResourceDefinition in list with name %s to match crd created with same name, but got different specs:\n%s",
actual.Name, diff.ObjectReflectDiff(expected.Spec, actual.Spec)) actual.Name, diff.ObjectReflectDiff(expected.Spec, actual.Spec))
} }
} }
@ -161,7 +160,7 @@ var _ = SIGDescribe("CustomResourceDefinition resources [Privileged:ClusterAdmin
framework.ExpectNoError(err, "getting CustomResourceDefinition status") framework.ExpectNoError(err, "getting CustomResourceDefinition status")
status := unstructuredToCRD(u) status := unstructuredToCRD(u)
if !equality.Semantic.DeepEqual(status.Spec, crd.Spec) { if !equality.Semantic.DeepEqual(status.Spec, crd.Spec) {
e2elog.Failf("Expected CustomResourceDefinition Spec to match status sub-resource Spec, but got:\n%s", diff.ObjectReflectDiff(status.Spec, crd.Spec)) framework.Failf("Expected CustomResourceDefinition Spec to match status sub-resource Spec, but got:\n%s", diff.ObjectReflectDiff(status.Spec, crd.Spec))
} }
status.Status.Conditions = append(status.Status.Conditions, updateCondition) status.Status.Conditions = append(status.Status.Conditions, updateCondition)
updated, err = apiExtensionClient.ApiextensionsV1().CustomResourceDefinitions().UpdateStatus(status) updated, err = apiExtensionClient.ApiextensionsV1().CustomResourceDefinitions().UpdateStatus(status)
@ -267,5 +266,5 @@ func expectCondition(conditions []v1.CustomResourceDefinitionCondition, expected
return return
} }
} }
e2elog.Failf("Condition %#v not found in conditions %#v", expected, conditions) framework.Failf("Condition %#v not found in conditions %#v", expected, conditions)
} }

7
test/e2e/apimachinery/discovery.go
View File

@ -20,7 +20,6 @@ import (
utilversion "k8s.io/apimachinery/pkg/util/version" utilversion "k8s.io/apimachinery/pkg/util/version"
"k8s.io/apiserver/pkg/endpoints/discovery" "k8s.io/apiserver/pkg/endpoints/discovery"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"k8s.io/kubernetes/test/utils/crd" "k8s.io/kubernetes/test/utils/crd"
"github.com/onsi/ginkgo" "github.com/onsi/ginkgo"
@ -50,7 +49,7 @@ var _ = SIGDescribe("Discovery", func() {
spec := testcrd.Crd.Spec spec := testcrd.Crd.Spec
resources, err := testcrd.APIExtensionClient.Discovery().ServerResourcesForGroupVersion(spec.Group + "/" + spec.Versions[0].Name) resources, err := testcrd.APIExtensionClient.Discovery().ServerResourcesForGroupVersion(spec.Group + "/" + spec.Versions[0].Name)
if err != nil { if err != nil {
e2elog.Failf("failed to find the discovery doc for %v: %v", resources, err) framework.Failf("failed to find the discovery doc for %v: %v", resources, err)
} }
found := false found := false
var storageVersion string var storageVersion string
@ -69,12 +68,12 @@ var _ = SIGDescribe("Discovery", func() {
if r.Name == spec.Names.Plural { if r.Name == spec.Names.Plural {
found = true found = true
if r.StorageVersionHash != expected { if r.StorageVersionHash != expected {
e2elog.Failf("expected storageVersionHash of %s/%s/%s to be %s, got %s", r.Group, r.Version, r.Name, expected, r.StorageVersionHash) framework.Failf("expected storageVersionHash of %s/%s/%s to be %s, got %s", r.Group, r.Version, r.Name, expected, r.StorageVersionHash)
} }
} }
} }
if !found { if !found {
e2elog.Failf("didn't find resource %s in the discovery doc", spec.Names.Plural) framework.Failf("didn't find resource %s in the discovery doc", spec.Names.Plural)
} }
}) })
}) })

7
test/e2e/apimachinery/etcd_failure.go
View File

@ -25,7 +25,6 @@ import (
podutil "k8s.io/kubernetes/pkg/api/v1/pod" podutil "k8s.io/kubernetes/pkg/api/v1/pod"
"k8s.io/kubernetes/test/e2e/apps" "k8s.io/kubernetes/test/e2e/apps"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
e2essh "k8s.io/kubernetes/test/e2e/framework/ssh" e2essh "k8s.io/kubernetes/test/e2e/framework/ssh"
testutils "k8s.io/kubernetes/test/utils" testutils "k8s.io/kubernetes/test/utils"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
@ -102,7 +101,7 @@ func masterExec(cmd string) {
framework.ExpectNoError(err, "failed to SSH to host %s on provider %s and run command: %q", host, framework.TestContext.Provider, cmd) framework.ExpectNoError(err, "failed to SSH to host %s on provider %s and run command: %q", host, framework.TestContext.Provider, cmd)
if result.Code != 0 { if result.Code != 0 {
e2essh.LogResult(result) e2essh.LogResult(result)
e2elog.Failf("master exec command returned non-zero") framework.Failf("master exec command returned non-zero")
} }
} }
@ -116,7 +115,7 @@ func checkExistingRCRecovers(f *framework.Framework) {
options := metav1.ListOptions{LabelSelector: rcSelector.String()} options := metav1.ListOptions{LabelSelector: rcSelector.String()}
pods, err := podClient.List(options) pods, err := podClient.List(options)
if err != nil { if err != nil {
e2elog.Logf("apiserver returned error, as expected before recovery: %v", err) framework.Logf("apiserver returned error, as expected before recovery: %v", err)
return false, nil return false, nil
} }
if len(pods.Items) == 0 { if len(pods.Items) == 0 {
@ -126,7 +125,7 @@ func checkExistingRCRecovers(f *framework.Framework) {
err = podClient.Delete(pod.Name, metav1.NewDeleteOptions(0)) err = podClient.Delete(pod.Name, metav1.NewDeleteOptions(0))
framework.ExpectNoError(err, "failed to delete pod %s in namespace: %s", pod.Name, f.Namespace.Name) framework.ExpectNoError(err, "failed to delete pod %s in namespace: %s", pod.Name, f.Namespace.Name)
} }
e2elog.Logf("apiserver has recovered") framework.Logf("apiserver has recovered")
return true, nil return true, nil
})) }))

187
test/e2e/apimachinery/garbage_collector.go
View File

@ -38,7 +38,6 @@ import (
"k8s.io/apiserver/pkg/storage/names" "k8s.io/apiserver/pkg/storage/names"
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
e2emetrics "k8s.io/kubernetes/test/e2e/framework/metrics" e2emetrics "k8s.io/kubernetes/test/e2e/framework/metrics"
"github.com/onsi/ginkgo" "github.com/onsi/ginkgo"
@ -244,14 +243,14 @@ func gatherMetrics(f *framework.Framework) {
var summary framework.TestDataSummary var summary framework.TestDataSummary
grabber, err := e2emetrics.NewMetricsGrabber(f.ClientSet, f.KubemarkExternalClusterClientSet, false, false, true, false, false) grabber, err := e2emetrics.NewMetricsGrabber(f.ClientSet, f.KubemarkExternalClusterClientSet, false, false, true, false, false)
if err != nil { if err != nil {
e2elog.Logf("Failed to create MetricsGrabber. Skipping metrics gathering.") framework.Logf("Failed to create MetricsGrabber. Skipping metrics gathering.")
} else { } else {
received, err := grabber.Grab() received, err := grabber.Grab()
if err != nil { if err != nil {
e2elog.Logf("MetricsGrabber failed grab metrics. Skipping metrics gathering.") framework.Logf("MetricsGrabber failed grab metrics. Skipping metrics gathering.")
} else { } else {
summary = (*e2emetrics.ComponentCollection)(&received) summary = (*e2emetrics.ComponentCollection)(&received)
e2elog.Logf(summary.PrintHumanReadable()) framework.Logf(summary.PrintHumanReadable())
} }
} }
} }
@ -317,7 +316,7 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.By("create the rc") ginkgo.By("create the rc")
rc, err := rcClient.Create(rc) rc, err := rcClient.Create(rc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create replication controller: %v", err) framework.Failf("Failed to create replication controller: %v", err)
} }
// wait for rc to create some pods // wait for rc to create some pods
if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) { if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) {
@ -335,13 +334,13 @@ var _ = SIGDescribe("Garbage collector", func() {
return false, nil return false, nil
}); err != nil { }); err != nil {
e2elog.Failf("failed to wait for the rc to create some pods: %v", err) framework.Failf("failed to wait for the rc to create some pods: %v", err)
} }
ginkgo.By("delete the rc") ginkgo.By("delete the rc")
deleteOptions := getBackgroundOptions() deleteOptions := getBackgroundOptions()
deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc.UID)) deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc.UID))
if err := rcClient.Delete(rc.ObjectMeta.Name, deleteOptions); err != nil { if err := rcClient.Delete(rc.ObjectMeta.Name, deleteOptions); err != nil {
e2elog.Failf("failed to delete the rc: %v", err) framework.Failf("failed to delete the rc: %v", err)
} }
ginkgo.By("wait for all pods to be garbage collected") ginkgo.By("wait for all pods to be garbage collected")
// wait for the RCs and Pods to reach the expected numbers. // wait for the RCs and Pods to reach the expected numbers.
@ -349,12 +348,12 @@ var _ = SIGDescribe("Garbage collector", func() {
objects := map[string]int{"ReplicationControllers": 0, "Pods": 0} objects := map[string]int{"ReplicationControllers": 0, "Pods": 0}
return verifyRemainingObjects(f, objects) return verifyRemainingObjects(f, objects)
}); err != nil { }); err != nil {
e2elog.Failf("failed to wait for all pods to be deleted: %v", err) framework.Failf("failed to wait for all pods to be deleted: %v", err)
remainingPods, err := podClient.List(metav1.ListOptions{}) remainingPods, err := podClient.List(metav1.ListOptions{})
if err != nil { if err != nil {
e2elog.Failf("failed to list pods post mortem: %v", err) framework.Failf("failed to list pods post mortem: %v", err)
} else { } else {
e2elog.Failf("remaining pods are: %#v", remainingPods) framework.Failf("remaining pods are: %#v", remainingPods)
} }
} }
gatherMetrics(f) gatherMetrics(f)
@ -375,7 +374,7 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.By("create the rc") ginkgo.By("create the rc")
rc, err := rcClient.Create(rc) rc, err := rcClient.Create(rc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create replication controller: %v", err) framework.Failf("Failed to create replication controller: %v", err)
} }
// wait for rc to create pods // wait for rc to create pods
if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) { if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) {
@ -389,13 +388,13 @@ var _ = SIGDescribe("Garbage collector", func() {
return false, nil return false, nil
}); err != nil { }); err != nil {
e2elog.Failf("failed to wait for the rc.Status.Replicas to reach rc.Spec.Replicas: %v", err) framework.Failf("failed to wait for the rc.Status.Replicas to reach rc.Spec.Replicas: %v", err)
} }
ginkgo.By("delete the rc") ginkgo.By("delete the rc")
deleteOptions := getOrphanOptions() deleteOptions := getOrphanOptions()
deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc.UID)) deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc.UID))
if err := rcClient.Delete(rc.ObjectMeta.Name, deleteOptions); err != nil { if err := rcClient.Delete(rc.ObjectMeta.Name, deleteOptions); err != nil {
e2elog.Failf("failed to delete the rc: %v", err) framework.Failf("failed to delete the rc: %v", err)
} }
ginkgo.By("wait for the rc to be deleted") ginkgo.By("wait for the rc to be deleted")
// Orphaning the 100 pods takes 100 PATCH operations. The default qps of // Orphaning the 100 pods takes 100 PATCH operations. The default qps of
@ -415,16 +414,16 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
return true, nil return true, nil
}); err != nil { }); err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
ginkgo.By("wait for 30 seconds to see if the garbage collector mistakenly deletes the pods") ginkgo.By("wait for 30 seconds to see if the garbage collector mistakenly deletes the pods")
time.Sleep(30 * time.Second) time.Sleep(30 * time.Second)
pods, err := podClient.List(metav1.ListOptions{}) pods, err := podClient.List(metav1.ListOptions{})
if err != nil { if err != nil {
e2elog.Failf("Failed to list pods: %v", err) framework.Failf("Failed to list pods: %v", err)
} }
if e, a := int(*(rc.Spec.Replicas)), len(pods.Items); e != a { if e, a := int(*(rc.Spec.Replicas)), len(pods.Items); e != a {
e2elog.Failf("expect %d pods, got %d pods", e, a) framework.Failf("expect %d pods, got %d pods", e, a)
} }
gatherMetrics(f) gatherMetrics(f)
}) })
@ -441,7 +440,7 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.By("create the rc") ginkgo.By("create the rc")
rc, err := rcClient.Create(rc) rc, err := rcClient.Create(rc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create replication controller: %v", err) framework.Failf("Failed to create replication controller: %v", err)
} }
// wait for rc to create some pods // wait for rc to create some pods
if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) { if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) {
@ -454,22 +453,22 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
return false, nil return false, nil
}); err != nil { }); err != nil {
e2elog.Failf("failed to wait for the rc.Status.Replicas to reach rc.Spec.Replicas: %v", err) framework.Failf("failed to wait for the rc.Status.Replicas to reach rc.Spec.Replicas: %v", err)
} }
ginkgo.By("delete the rc") ginkgo.By("delete the rc")
deleteOptions := &metav1.DeleteOptions{} deleteOptions := &metav1.DeleteOptions{}
deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc.UID)) deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc.UID))
if err := rcClient.Delete(rc.ObjectMeta.Name, deleteOptions); err != nil { if err := rcClient.Delete(rc.ObjectMeta.Name, deleteOptions); err != nil {
e2elog.Failf("failed to delete the rc: %v", err) framework.Failf("failed to delete the rc: %v", err)
} }
ginkgo.By("wait for 30 seconds to see if the garbage collector mistakenly deletes the pods") ginkgo.By("wait for 30 seconds to see if the garbage collector mistakenly deletes the pods")
time.Sleep(30 * time.Second) time.Sleep(30 * time.Second)
pods, err := podClient.List(metav1.ListOptions{}) pods, err := podClient.List(metav1.ListOptions{})
if err != nil { if err != nil {
e2elog.Failf("Failed to list pods: %v", err) framework.Failf("Failed to list pods: %v", err)
} }
if e, a := int(*(rc.Spec.Replicas)), len(pods.Items); e != a { if e, a := int(*(rc.Spec.Replicas)), len(pods.Items); e != a {
e2elog.Failf("expect %d pods, got %d pods", e, a) framework.Failf("expect %d pods, got %d pods", e, a)
} }
gatherMetrics(f) gatherMetrics(f)
}) })
@ -489,7 +488,7 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.By("create the deployment") ginkgo.By("create the deployment")
createdDeployment, err := deployClient.Create(deployment) createdDeployment, err := deployClient.Create(deployment)
if err != nil { if err != nil {
e2elog.Failf("Failed to create deployment: %v", err) framework.Failf("Failed to create deployment: %v", err)
} }
// wait for deployment to create some rs // wait for deployment to create some rs
ginkgo.By("Wait for the Deployment to create new ReplicaSet") ginkgo.By("Wait for the Deployment to create new ReplicaSet")
@ -502,14 +501,14 @@ var _ = SIGDescribe("Garbage collector", func() {
}) })
if err != nil { if err != nil {
e2elog.Failf("Failed to wait for the Deployment to create some ReplicaSet: %v", err) framework.Failf("Failed to wait for the Deployment to create some ReplicaSet: %v", err)
} }
ginkgo.By("delete the deployment") ginkgo.By("delete the deployment")
deleteOptions := getBackgroundOptions() deleteOptions := getBackgroundOptions()
deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(createdDeployment.UID)) deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(createdDeployment.UID))
if err := deployClient.Delete(deployment.ObjectMeta.Name, deleteOptions); err != nil { if err := deployClient.Delete(deployment.ObjectMeta.Name, deleteOptions); err != nil {
e2elog.Failf("failed to delete the deployment: %v", err) framework.Failf("failed to delete the deployment: %v", err)
} }
ginkgo.By("wait for all rs to be garbage collected") ginkgo.By("wait for all rs to be garbage collected")
err = wait.PollImmediate(500*time.Millisecond, 1*time.Minute, func() (bool, error) { err = wait.PollImmediate(500*time.Millisecond, 1*time.Minute, func() (bool, error) {
@ -526,7 +525,7 @@ var _ = SIGDescribe("Garbage collector", func() {
errList = append(errList, fmt.Errorf("remaining rs are: %#v", remainingRSs)) errList = append(errList, fmt.Errorf("remaining rs are: %#v", remainingRSs))
} }
aggregatedError := utilerrors.NewAggregate(errList) aggregatedError := utilerrors.NewAggregate(errList)
e2elog.Failf("Failed to wait for all rs to be garbage collected: %v", aggregatedError) framework.Failf("Failed to wait for all rs to be garbage collected: %v", aggregatedError)
} }
@ -548,7 +547,7 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.By("create the deployment") ginkgo.By("create the deployment")
createdDeployment, err := deployClient.Create(deployment) createdDeployment, err := deployClient.Create(deployment)
if err != nil { if err != nil {
e2elog.Failf("Failed to create deployment: %v", err) framework.Failf("Failed to create deployment: %v", err)
} }
// wait for deployment to create some rs // wait for deployment to create some rs
ginkgo.By("Wait for the Deployment to create new ReplicaSet") ginkgo.By("Wait for the Deployment to create new ReplicaSet")
@ -561,21 +560,21 @@ var _ = SIGDescribe("Garbage collector", func() {
}) })
if err != nil { if err != nil {
e2elog.Failf("Failed to wait for the Deployment to create some ReplicaSet: %v", err) framework.Failf("Failed to wait for the Deployment to create some ReplicaSet: %v", err)
} }
ginkgo.By("delete the deployment") ginkgo.By("delete the deployment")
deleteOptions := getOrphanOptions() deleteOptions := getOrphanOptions()
deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(createdDeployment.UID)) deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(createdDeployment.UID))
if err := deployClient.Delete(deployment.ObjectMeta.Name, deleteOptions); err != nil { if err := deployClient.Delete(deployment.ObjectMeta.Name, deleteOptions); err != nil {
e2elog.Failf("failed to delete the deployment: %v", err) framework.Failf("failed to delete the deployment: %v", err)
} }
ginkgo.By("wait for 30 seconds to see if the garbage collector mistakenly deletes the rs") ginkgo.By("wait for 30 seconds to see if the garbage collector mistakenly deletes the rs")
time.Sleep(30 * time.Second) time.Sleep(30 * time.Second)
objects := map[string]int{"Deployments": 0, "ReplicaSets": 1, "Pods": 2} objects := map[string]int{"Deployments": 0, "ReplicaSets": 1, "Pods": 2}
ok, err := verifyRemainingObjects(f, objects) ok, err := verifyRemainingObjects(f, objects)
if err != nil { if err != nil {
e2elog.Failf("Unexpected error while verifying remaining deployments, rs, and pods: %v", err) framework.Failf("Unexpected error while verifying remaining deployments, rs, and pods: %v", err)
} }
if !ok { if !ok {
errList := make([]error, 0) errList := make([]error, 0)
@ -592,15 +591,15 @@ var _ = SIGDescribe("Garbage collector", func() {
errList = append(errList, fmt.Errorf("remaining deployment's post mortem: %#v", remainingDSs)) errList = append(errList, fmt.Errorf("remaining deployment's post mortem: %#v", remainingDSs))
} }
aggregatedError := utilerrors.NewAggregate(errList) aggregatedError := utilerrors.NewAggregate(errList)
e2elog.Failf("Failed to verify remaining deployments, rs, and pods: %v", aggregatedError) framework.Failf("Failed to verify remaining deployments, rs, and pods: %v", aggregatedError)
} }
rs, err := clientSet.AppsV1().ReplicaSets(f.Namespace.Name).List(metav1.ListOptions{}) rs, err := clientSet.AppsV1().ReplicaSets(f.Namespace.Name).List(metav1.ListOptions{})
if err != nil { if err != nil {
e2elog.Failf("Failed to list ReplicaSet %v", err) framework.Failf("Failed to list ReplicaSet %v", err)
} }
for _, replicaSet := range rs.Items { for _, replicaSet := range rs.Items {
if metav1.GetControllerOf(&replicaSet.ObjectMeta) != nil { if metav1.GetControllerOf(&replicaSet.ObjectMeta) != nil {
e2elog.Failf("Found ReplicaSet with non nil ownerRef %v", replicaSet) framework.Failf("Found ReplicaSet with non nil ownerRef %v", replicaSet)
} }
} }
@ -622,7 +621,7 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.By("create the rc") ginkgo.By("create the rc")
rc, err := rcClient.Create(rc) rc, err := rcClient.Create(rc)
if err != nil { if err != nil {
e2elog.Failf("Failed to create replication controller: %v", err) framework.Failf("Failed to create replication controller: %v", err)
} }
// wait for rc to create pods // wait for rc to create pods
if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) { if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) {
@ -635,13 +634,13 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
return false, nil return false, nil
}); err != nil { }); err != nil {
e2elog.Failf("failed to wait for the rc.Status.Replicas to reach rc.Spec.Replicas: %v", err) framework.Failf("failed to wait for the rc.Status.Replicas to reach rc.Spec.Replicas: %v", err)
} }
ginkgo.By("delete the rc") ginkgo.By("delete the rc")
deleteOptions := getForegroundOptions() deleteOptions := getForegroundOptions()
deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc.UID)) deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc.UID))
if err := rcClient.Delete(rc.ObjectMeta.Name, deleteOptions); err != nil { if err := rcClient.Delete(rc.ObjectMeta.Name, deleteOptions); err != nil {
e2elog.Failf("failed to delete the rc: %v", err) framework.Failf("failed to delete the rc: %v", err)
} }
ginkgo.By("wait for the rc to be deleted") ginkgo.By("wait for the rc to be deleted")
// default client QPS is 20, deleting each pod requires 2 requests, so 30s should be enough // default client QPS is 20, deleting each pod requires 2 requests, so 30s should be enough
@ -653,15 +652,15 @@ var _ = SIGDescribe("Garbage collector", func() {
_, err := rcClient.Get(rc.Name, metav1.GetOptions{}) _, err := rcClient.Get(rc.Name, metav1.GetOptions{})
if err == nil { if err == nil {
pods, _ := podClient.List(metav1.ListOptions{}) pods, _ := podClient.List(metav1.ListOptions{})
e2elog.Logf("%d pods remaining", len(pods.Items)) framework.Logf("%d pods remaining", len(pods.Items))
count := 0 count := 0
for _, pod := range pods.Items { for _, pod := range pods.Items {
if pod.ObjectMeta.DeletionTimestamp == nil { if pod.ObjectMeta.DeletionTimestamp == nil {
count++ count++
} }
} }
e2elog.Logf("%d pods has nil DeletionTimestamp", count) framework.Logf("%d pods has nil DeletionTimestamp", count)
e2elog.Logf("") framework.Logf("")
return false, nil return false, nil
} }
if errors.IsNotFound(err) { if errors.IsNotFound(err) {
@ -671,22 +670,22 @@ var _ = SIGDescribe("Garbage collector", func() {
}); err != nil { }); err != nil {
pods, err2 := podClient.List(metav1.ListOptions{}) pods, err2 := podClient.List(metav1.ListOptions{})
if err2 != nil { if err2 != nil {
e2elog.Failf("%v", err2) framework.Failf("%v", err2)
} }
e2elog.Logf("%d remaining pods are:", len(pods.Items)) framework.Logf("%d remaining pods are:", len(pods.Items))
e2elog.Logf("The ObjectMeta of the remaining pods are:") framework.Logf("The ObjectMeta of the remaining pods are:")
for _, pod := range pods.Items { for _, pod := range pods.Items {
e2elog.Logf("%#v", pod.ObjectMeta) framework.Logf("%#v", pod.ObjectMeta)
} }
e2elog.Failf("failed to delete the rc: %v", err) framework.Failf("failed to delete the rc: %v", err)
} }
// There shouldn't be any pods // There shouldn't be any pods
pods, err := podClient.List(metav1.ListOptions{}) pods, err := podClient.List(metav1.ListOptions{})
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if len(pods.Items) != 0 { if len(pods.Items) != 0 {
e2elog.Failf("expected no pods, got %#v", pods) framework.Failf("expected no pods, got %#v", pods)
} }
gatherMetrics(f) gatherMetrics(f)
}) })
@ -709,7 +708,7 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.By("create the rc1") ginkgo.By("create the rc1")
rc1, err := rcClient.Create(rc1) rc1, err := rcClient.Create(rc1)
if err != nil { if err != nil {
e2elog.Failf("Failed to create replication controller: %v", err) framework.Failf("Failed to create replication controller: %v", err)
} }
rc2Name := "simpletest-rc-to-stay" rc2Name := "simpletest-rc-to-stay"
uniqLabelsStay := getUniqLabel("gctest_s", "valid_and_pending_owners_s") uniqLabelsStay := getUniqLabel("gctest_s", "valid_and_pending_owners_s")
@ -717,7 +716,7 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.By("create the rc2") ginkgo.By("create the rc2")
rc2, err = rcClient.Create(rc2) rc2, err = rcClient.Create(rc2)
if err != nil { if err != nil {
e2elog.Failf("Failed to create replication controller: %v", err) framework.Failf("Failed to create replication controller: %v", err)
} }
// wait for rc1 to be stable // wait for rc1 to be stable
if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) { if err := wait.Poll(5*time.Second, 30*time.Second, func() (bool, error) {
@ -730,7 +729,7 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
return false, nil return false, nil
}); err != nil { }); err != nil {
e2elog.Failf("failed to wait for the rc.Status.Replicas to reach rc.Spec.Replicas: %v", err) framework.Failf("failed to wait for the rc.Status.Replicas to reach rc.Spec.Replicas: %v", err)
} }
ginkgo.By(fmt.Sprintf("set half of pods created by rc %s to have rc %s as owner as well", rc1Name, rc2Name)) ginkgo.By(fmt.Sprintf("set half of pods created by rc %s to have rc %s as owner as well", rc1Name, rc2Name))
pods, err := podClient.List(metav1.ListOptions{}) pods, err := podClient.List(metav1.ListOptions{})
@ -746,7 +745,7 @@ var _ = SIGDescribe("Garbage collector", func() {
deleteOptions := getForegroundOptions() deleteOptions := getForegroundOptions()
deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc1.UID)) deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(rc1.UID))
if err := rcClient.Delete(rc1.ObjectMeta.Name, deleteOptions); err != nil { if err := rcClient.Delete(rc1.ObjectMeta.Name, deleteOptions); err != nil {
e2elog.Failf("failed to delete the rc: %v", err) framework.Failf("failed to delete the rc: %v", err)
} }
ginkgo.By("wait for the rc to be deleted") ginkgo.By("wait for the rc to be deleted")
// TODO: shorten the timeout when we make GC's periodic API rediscovery more efficient. // TODO: shorten the timeout when we make GC's periodic API rediscovery more efficient.
@ -755,15 +754,15 @@ var _ = SIGDescribe("Garbage collector", func() {
_, err := rcClient.Get(rc1.Name, metav1.GetOptions{}) _, err := rcClient.Get(rc1.Name, metav1.GetOptions{})
if err == nil { if err == nil {
pods, _ := podClient.List(metav1.ListOptions{}) pods, _ := podClient.List(metav1.ListOptions{})
e2elog.Logf("%d pods remaining", len(pods.Items)) framework.Logf("%d pods remaining", len(pods.Items))
count := 0 count := 0
for _, pod := range pods.Items { for _, pod := range pods.Items {
if pod.ObjectMeta.DeletionTimestamp == nil { if pod.ObjectMeta.DeletionTimestamp == nil {
count++ count++
} }
} }
e2elog.Logf("%d pods has nil DeletionTimestamp", count) framework.Logf("%d pods has nil DeletionTimestamp", count)
e2elog.Logf("") framework.Logf("")
return false, nil return false, nil
} }
if errors.IsNotFound(err) { if errors.IsNotFound(err) {
@ -773,30 +772,30 @@ var _ = SIGDescribe("Garbage collector", func() {
}); err != nil { }); err != nil {
pods, err2 := podClient.List(metav1.ListOptions{}) pods, err2 := podClient.List(metav1.ListOptions{})
if err2 != nil { if err2 != nil {
e2elog.Failf("%v", err2) framework.Failf("%v", err2)
} }
e2elog.Logf("%d remaining pods are:", len(pods.Items)) framework.Logf("%d remaining pods are:", len(pods.Items))
e2elog.Logf("ObjectMeta of remaining pods are:") framework.Logf("ObjectMeta of remaining pods are:")
for _, pod := range pods.Items { for _, pod := range pods.Items {
e2elog.Logf("%#v", pod.ObjectMeta) framework.Logf("%#v", pod.ObjectMeta)
} }
e2elog.Failf("failed to delete rc %s, err: %v", rc1Name, err) framework.Failf("failed to delete rc %s, err: %v", rc1Name, err)
} }
// half of the pods should still exist, // half of the pods should still exist,
pods, err = podClient.List(metav1.ListOptions{}) pods, err = podClient.List(metav1.ListOptions{})
if err != nil { if err != nil {
e2elog.Failf("%v", err) framework.Failf("%v", err)
} }
if len(pods.Items) != halfReplicas { if len(pods.Items) != halfReplicas {
e2elog.Failf("expected %d pods, got %d", halfReplicas, len(pods.Items)) framework.Failf("expected %d pods, got %d", halfReplicas, len(pods.Items))
} }
for _, pod := range pods.Items { for _, pod := range pods.Items {
if pod.ObjectMeta.DeletionTimestamp != nil { if pod.ObjectMeta.DeletionTimestamp != nil {
e2elog.Failf("expected pod DeletionTimestamp to be nil, got %#v", pod.ObjectMeta) framework.Failf("expected pod DeletionTimestamp to be nil, got %#v", pod.ObjectMeta)
} }
// they should only have 1 ownerReference left // they should only have 1 ownerReference left
if len(pod.ObjectMeta.OwnerReferences) != 1 { if len(pod.ObjectMeta.OwnerReferences) != 1 {
e2elog.Failf("expected pod to only have 1 owner, got %#v", pod.ObjectMeta.OwnerReferences) framework.Failf("expected pod to only have 1 owner, got %#v", pod.ObjectMeta.OwnerReferences)
} }
} }
gatherMetrics(f) gatherMetrics(f)
@ -830,15 +829,15 @@ var _ = SIGDescribe("Garbage collector", func() {
patch1 := addRefPatch(pod3.Name, pod3.UID) patch1 := addRefPatch(pod3.Name, pod3.UID)
pod1, err = podClient.Patch(pod1.Name, types.StrategicMergePatchType, patch1) pod1, err = podClient.Patch(pod1.Name, types.StrategicMergePatchType, patch1)
framework.ExpectNoError(err, "failed to apply to pod %s in namespace %s, a strategic merge patch: %s", pod1.Name, f.Namespace.Name, patch1) framework.ExpectNoError(err, "failed to apply to pod %s in namespace %s, a strategic merge patch: %s", pod1.Name, f.Namespace.Name, patch1)
e2elog.Logf("pod1.ObjectMeta.OwnerReferences=%#v", pod1.ObjectMeta.OwnerReferences) framework.Logf("pod1.ObjectMeta.OwnerReferences=%#v", pod1.ObjectMeta.OwnerReferences)
patch2 := addRefPatch(pod1.Name, pod1.UID) patch2 := addRefPatch(pod1.Name, pod1.UID)
pod2, err = podClient.Patch(pod2.Name, types.StrategicMergePatchType, patch2) pod2, err = podClient.Patch(pod2.Name, types.StrategicMergePatchType, patch2)
framework.ExpectNoError(err, "failed to apply to pod %s in namespace %s, a strategic merge patch: %s", pod2.Name, f.Namespace.Name, patch2) framework.ExpectNoError(err, "failed to apply to pod %s in namespace %s, a strategic merge patch: %s", pod2.Name, f.Namespace.Name, patch2)
e2elog.Logf("pod2.ObjectMeta.OwnerReferences=%#v", pod2.ObjectMeta.OwnerReferences) framework.Logf("pod2.ObjectMeta.OwnerReferences=%#v", pod2.ObjectMeta.OwnerReferences)
patch3 := addRefPatch(pod2.Name, pod2.UID) patch3 := addRefPatch(pod2.Name, pod2.UID)
pod3, err = podClient.Patch(pod3.Name, types.StrategicMergePatchType, patch3) pod3, err = podClient.Patch(pod3.Name, types.StrategicMergePatchType, patch3)
framework.ExpectNoError(err, "failed to apply to pod %s in namespace %s, a strategic merge patch: %s", pod3.Name, f.Namespace.Name, patch3) framework.ExpectNoError(err, "failed to apply to pod %s in namespace %s, a strategic merge patch: %s", pod3.Name, f.Namespace.Name, patch3)
e2elog.Logf("pod3.ObjectMeta.OwnerReferences=%#v", pod3.ObjectMeta.OwnerReferences) framework.Logf("pod3.ObjectMeta.OwnerReferences=%#v", pod3.ObjectMeta.OwnerReferences)
// delete one pod, should result in the deletion of all pods // delete one pod, should result in the deletion of all pods
deleteOptions := getForegroundOptions() deleteOptions := getForegroundOptions()
deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(pod1.UID)) deleteOptions.Preconditions = metav1.NewUIDPreconditions(string(pod1.UID))
@ -858,20 +857,20 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
return false, nil return false, nil
}); err != nil { }); err != nil {
e2elog.Logf("pods are %#v", pods.Items) framework.Logf("pods are %#v", pods.Items)
e2elog.Failf("failed to wait for all pods to be deleted: %v", err) framework.Failf("failed to wait for all pods to be deleted: %v", err)
} }
}) })
ginkgo.It("should support cascading deletion of custom resources", func() { ginkgo.It("should support cascading deletion of custom resources", func() {
config, err := framework.LoadConfig() config, err := framework.LoadConfig()
if err != nil { if err != nil {
e2elog.Failf("failed to load config: %v", err) framework.Failf("failed to load config: %v", err)
} }
apiExtensionClient, err := apiextensionsclientset.NewForConfig(config) apiExtensionClient, err := apiextensionsclientset.NewForConfig(config)
if err != nil { if err != nil {
e2elog.Failf("failed to initialize apiExtensionClient: %v", err) framework.Failf("failed to initialize apiExtensionClient: %v", err)
} }
// Create a random custom resource definition and ensure it's available for // Create a random custom resource definition and ensure it's available for
@ -880,12 +879,12 @@ var _ = SIGDescribe("Garbage collector", func() {
defer func() { defer func() {
err = apiextensionstestserver.DeleteV1CustomResourceDefinition(definition, apiExtensionClient) err = apiextensionstestserver.DeleteV1CustomResourceDefinition(definition, apiExtensionClient)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
e2elog.Failf("failed to delete CustomResourceDefinition: %v", err) framework.Failf("failed to delete CustomResourceDefinition: %v", err)
} }
}() }()
definition, err = apiextensionstestserver.CreateNewV1CustomResourceDefinition(definition, apiExtensionClient, f.DynamicClient) definition, err = apiextensionstestserver.CreateNewV1CustomResourceDefinition(definition, apiExtensionClient, f.DynamicClient)
if err != nil { if err != nil {
e2elog.Failf("failed to create CustomResourceDefinition: %v", err) framework.Failf("failed to create CustomResourceDefinition: %v", err)
} }
framework.ExpectEqual(len(definition.Spec.Versions), 1, "custom resource definition should have one version") framework.ExpectEqual(len(definition.Spec.Versions), 1, "custom resource definition should have one version")
version := definition.Spec.Versions[0] version := definition.Spec.Versions[0]
@ -909,9 +908,9 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
persistedOwner, err := resourceClient.Create(owner, metav1.CreateOptions{}) persistedOwner, err := resourceClient.Create(owner, metav1.CreateOptions{})
if err != nil { if err != nil {
e2elog.Failf("failed to create owner resource %q: %v", ownerName, err) framework.Failf("failed to create owner resource %q: %v", ownerName, err)
} }
e2elog.Logf("created owner resource %q", ownerName) framework.Logf("created owner resource %q", ownerName)
// Create a custom dependent resource. // Create a custom dependent resource.
dependentName := names.SimpleNameGenerator.GenerateName("dependent") dependentName := names.SimpleNameGenerator.GenerateName("dependent")
@ -934,15 +933,15 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
persistedDependent, err := resourceClient.Create(dependent, metav1.CreateOptions{}) persistedDependent, err := resourceClient.Create(dependent, metav1.CreateOptions{})
if err != nil { if err != nil {
e2elog.Failf("failed to create dependent resource %q: %v", dependentName, err) framework.Failf("failed to create dependent resource %q: %v", dependentName, err)
} }
e2elog.Logf("created dependent resource %q", dependentName) framework.Logf("created dependent resource %q", dependentName)
// Delete the owner. // Delete the owner.
background := metav1.DeletePropagationBackground background := metav1.DeletePropagationBackground
err = resourceClient.Delete(ownerName, &metav1.DeleteOptions{PropagationPolicy: &background}) err = resourceClient.Delete(ownerName, &metav1.DeleteOptions{PropagationPolicy: &background})
if err != nil { if err != nil {
e2elog.Failf("failed to delete owner resource %q: %v", ownerName, err) framework.Failf("failed to delete owner resource %q: %v", ownerName, err)
} }
// Ensure the dependent is deleted. // Ensure the dependent is deleted.
@ -950,18 +949,18 @@ var _ = SIGDescribe("Garbage collector", func() {
_, err := resourceClient.Get(dependentName, metav1.GetOptions{}) _, err := resourceClient.Get(dependentName, metav1.GetOptions{})
return errors.IsNotFound(err), nil return errors.IsNotFound(err), nil
}); err != nil { }); err != nil {
e2elog.Logf("owner: %#v", persistedOwner) framework.Logf("owner: %#v", persistedOwner)
e2elog.Logf("dependent: %#v", persistedDependent) framework.Logf("dependent: %#v", persistedDependent)
e2elog.Failf("failed waiting for dependent resource %q to be deleted", dependentName) framework.Failf("failed waiting for dependent resource %q to be deleted", dependentName)
} }
// Ensure the owner is deleted. // Ensure the owner is deleted.
_, err = resourceClient.Get(ownerName, metav1.GetOptions{}) _, err = resourceClient.Get(ownerName, metav1.GetOptions{})
if err == nil { if err == nil {
e2elog.Failf("expected owner resource %q to be deleted", ownerName) framework.Failf("expected owner resource %q to be deleted", ownerName)
} else { } else {
if !errors.IsNotFound(err) { if !errors.IsNotFound(err) {
e2elog.Failf("unexpected error getting owner resource %q: %v", ownerName, err) framework.Failf("unexpected error getting owner resource %q: %v", ownerName, err)
} }
} }
}) })
@ -969,12 +968,12 @@ var _ = SIGDescribe("Garbage collector", func() {
ginkgo.It("should support orphan deletion of custom resources", func() { ginkgo.It("should support orphan deletion of custom resources", func() {
config, err := framework.LoadConfig() config, err := framework.LoadConfig()
if err != nil { if err != nil {
e2elog.Failf("failed to load config: %v", err) framework.Failf("failed to load config: %v", err)
} }
apiExtensionClient, err := apiextensionsclientset.NewForConfig(config) apiExtensionClient, err := apiextensionsclientset.NewForConfig(config)
if err != nil { if err != nil {
e2elog.Failf("failed to initialize apiExtensionClient: %v", err) framework.Failf("failed to initialize apiExtensionClient: %v", err)
} }
// Create a random custom resource definition and ensure it's available for // Create a random custom resource definition and ensure it's available for
@ -983,12 +982,12 @@ var _ = SIGDescribe("Garbage collector", func() {
defer func() { defer func() {
err = apiextensionstestserver.DeleteV1CustomResourceDefinition(definition, apiExtensionClient) err = apiextensionstestserver.DeleteV1CustomResourceDefinition(definition, apiExtensionClient)
if err != nil && !errors.IsNotFound(err) { if err != nil && !errors.IsNotFound(err) {
e2elog.Failf("failed to delete CustomResourceDefinition: %v", err) framework.Failf("failed to delete CustomResourceDefinition: %v", err)
} }
}() }()
definition, err = apiextensionstestserver.CreateNewV1CustomResourceDefinition(definition, apiExtensionClient, f.DynamicClient) definition, err = apiextensionstestserver.CreateNewV1CustomResourceDefinition(definition, apiExtensionClient, f.DynamicClient)
if err != nil { if err != nil {
e2elog.Failf("failed to create CustomResourceDefinition: %v", err) framework.Failf("failed to create CustomResourceDefinition: %v", err)
} }
framework.ExpectEqual(len(definition.Spec.Versions), 1, "custom resource definition should have one version") framework.ExpectEqual(len(definition.Spec.Versions), 1, "custom resource definition should have one version")
version := definition.Spec.Versions[0] version := definition.Spec.Versions[0]
@ -1012,9 +1011,9 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
persistedOwner, err := resourceClient.Create(owner, metav1.CreateOptions{}) persistedOwner, err := resourceClient.Create(owner, metav1.CreateOptions{})
if err != nil { if err != nil {
e2elog.Failf("failed to create owner resource %q: %v", ownerName, err) framework.Failf("failed to create owner resource %q: %v", ownerName, err)
} }
e2elog.Logf("created owner resource %q", ownerName) framework.Logf("created owner resource %q", ownerName)
// Create a custom dependent resource. // Create a custom dependent resource.
dependentName := names.SimpleNameGenerator.GenerateName("dependent") dependentName := names.SimpleNameGenerator.GenerateName("dependent")
@ -1037,14 +1036,14 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
_, err = resourceClient.Create(dependent, metav1.CreateOptions{}) _, err = resourceClient.Create(dependent, metav1.CreateOptions{})
if err != nil { if err != nil {
e2elog.Failf("failed to create dependent resource %q: %v", dependentName, err) framework.Failf("failed to create dependent resource %q: %v", dependentName, err)
} }
e2elog.Logf("created dependent resource %q", dependentName) framework.Logf("created dependent resource %q", dependentName)
// Delete the owner and orphan the dependent. // Delete the owner and orphan the dependent.
err = resourceClient.Delete(ownerName, getOrphanOptions()) err = resourceClient.Delete(ownerName, getOrphanOptions())
if err != nil { if err != nil {
e2elog.Failf("failed to delete owner resource %q: %v", ownerName, err) framework.Failf("failed to delete owner resource %q: %v", ownerName, err)
} }
ginkgo.By("wait for the owner to be deleted") ginkgo.By("wait for the owner to be deleted")
@ -1058,7 +1057,7 @@ var _ = SIGDescribe("Garbage collector", func() {
} }
return true, nil return true, nil
}); err != nil { }); err != nil {
e2elog.Failf("timeout in waiting for the owner to be deleted: %v", err) framework.Failf("timeout in waiting for the owner to be deleted: %v", err)
} }
// Wait 30s and ensure the dependent is not deleted. // Wait 30s and ensure the dependent is not deleted.
@ -1067,7 +1066,7 @@ var _ = SIGDescribe("Garbage collector", func() {
_, err := resourceClient.Get(dependentName, metav1.GetOptions{}) _, err := resourceClient.Get(dependentName, metav1.GetOptions{})
return false, err return false, err
}); err != nil && err != wait.ErrWaitTimeout { }); err != nil && err != wait.ErrWaitTimeout {
e2elog.Failf("failed to ensure the dependent is not deleted: %v", err) framework.Failf("failed to ensure the dependent is not deleted: %v", err)
} }
}) })
@ -1088,12 +1087,12 @@ var _ = SIGDescribe("Garbage collector", func() {
return len(jobs.Items) > 0, nil return len(jobs.Items) > 0, nil
}) })
if err != nil { if err != nil {
e2elog.Failf("Failed to wait for the CronJob to create some Jobs: %v", err) framework.Failf("Failed to wait for the CronJob to create some Jobs: %v", err)
} }
ginkgo.By("Delete the cronjob") ginkgo.By("Delete the cronjob")
if err := f.ClientSet.BatchV1beta1().CronJobs(f.Namespace.Name).Delete(cronJob.Name, getBackgroundOptions()); err != nil { if err := f.ClientSet.BatchV1beta1().CronJobs(f.Namespace.Name).Delete(cronJob.Name, getBackgroundOptions()); err != nil {
e2elog.Failf("Failed to delete the CronJob: %v", err) framework.Failf("Failed to delete the CronJob: %v", err)
} }
ginkgo.By("Verify if cronjob does not leave jobs nor pods behind") ginkgo.By("Verify if cronjob does not leave jobs nor pods behind")
err = wait.PollImmediate(500*time.Millisecond, 1*time.Minute, func() (bool, error) { err = wait.PollImmediate(500*time.Millisecond, 1*time.Minute, func() (bool, error) {
@ -1101,7 +1100,7 @@ var _ = SIGDescribe("Garbage collector", func() {
return verifyRemainingObjects(f, objects) return verifyRemainingObjects(f, objects)
}) })
if err != nil { if err != nil {
e2elog.Failf("Failed to wait for all jobs and pods to be deleted: %v", err) framework.Failf("Failed to wait for all jobs and pods to be deleted: %v", err)
} }
gatherMetrics(f) gatherMetrics(f)

29
test/e2e/apimachinery/generated_clientset.go
View File

@ -30,7 +30,6 @@ import (
"k8s.io/apimachinery/pkg/util/uuid" "k8s.io/apimachinery/pkg/util/uuid"
"k8s.io/apimachinery/pkg/watch" "k8s.io/apimachinery/pkg/watch"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"github.com/onsi/ginkgo" "github.com/onsi/ginkgo"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
@ -70,10 +69,10 @@ func observeCreation(w watch.Interface) {
select { select {
case event, _ := <-w.ResultChan(): case event, _ := <-w.ResultChan():
if event.Type != watch.Added { if event.Type != watch.Added {
e2elog.Failf("Failed to observe the creation: %v", event) framework.Failf("Failed to observe the creation: %v", event)
} }
case <-time.After(30 * time.Second): case <-time.After(30 * time.Second):
e2elog.Failf("Timeout while waiting for observing the creation") framework.Failf("Timeout while waiting for observing the creation")
} }
} }
@ -94,7 +93,7 @@ func observerUpdate(w watch.Interface, expectedUpdate func(runtime.Object) bool)
} }
} }
if !updated { if !updated {
e2elog.Failf("Failed to observe pod update") framework.Failf("Failed to observe pod update")
} }
return return
} }
@ -113,7 +112,7 @@ var _ = SIGDescribe("Generated clientset", func() {
options := metav1.ListOptions{LabelSelector: selector} options := metav1.ListOptions{LabelSelector: selector}
pods, err := podClient.List(options) pods, err := podClient.List(options)
if err != nil { if err != nil {
e2elog.Failf("Failed to query for pods: %v", err) framework.Failf("Failed to query for pods: %v", err)
} }
framework.ExpectEqual(len(pods.Items), 0) framework.ExpectEqual(len(pods.Items), 0)
options = metav1.ListOptions{ options = metav1.ListOptions{
@ -122,13 +121,13 @@ var _ = SIGDescribe("Generated clientset", func() {
} }
w, err := podClient.Watch(options) w, err := podClient.Watch(options)
if err != nil { if err != nil {
e2elog.Failf("Failed to set up watch: %v", err) framework.Failf("Failed to set up watch: %v", err)
} }
ginkgo.By("creating the pod") ginkgo.By("creating the pod")
pod, err = podClient.Create(pod) pod, err = podClient.Create(pod)
if err != nil { if err != nil {
e2elog.Failf("Failed to create pod: %v", err) framework.Failf("Failed to create pod: %v", err)
} }
ginkgo.By("verifying the pod is in kubernetes") ginkgo.By("verifying the pod is in kubernetes")
@ -138,7 +137,7 @@ var _ = SIGDescribe("Generated clientset", func() {
} }
pods, err = podClient.List(options) pods, err = podClient.List(options)
if err != nil { if err != nil {
e2elog.Failf("Failed to query for pods: %v", err) framework.Failf("Failed to query for pods: %v", err)
} }
framework.ExpectEqual(len(pods.Items), 1) framework.ExpectEqual(len(pods.Items), 1)
@ -152,7 +151,7 @@ var _ = SIGDescribe("Generated clientset", func() {
ginkgo.By("deleting the pod gracefully") ginkgo.By("deleting the pod gracefully")
gracePeriod := int64(31) gracePeriod := int64(31)
if err := podClient.Delete(pod.Name, metav1.NewDeleteOptions(gracePeriod)); err != nil { if err := podClient.Delete(pod.Name, metav1.NewDeleteOptions(gracePeriod)); err != nil {
e2elog.Failf("Failed to delete pod: %v", err) framework.Failf("Failed to delete pod: %v", err)
} }
ginkgo.By("verifying the deletionTimestamp and deletionGracePeriodSeconds of the pod is set") ginkgo.By("verifying the deletionTimestamp and deletionGracePeriodSeconds of the pod is set")
@ -229,7 +228,7 @@ var _ = SIGDescribe("Generated clientset", func() {
options := metav1.ListOptions{LabelSelector: selector} options := metav1.ListOptions{LabelSelector: selector}
cronJobs, err := cronJobClient.List(options) cronJobs, err := cronJobClient.List(options)
if err != nil { if err != nil {
e2elog.Failf("Failed to query for cronJobs: %v", err) framework.Failf("Failed to query for cronJobs: %v", err)
} }
framework.ExpectEqual(len(cronJobs.Items), 0) framework.ExpectEqual(len(cronJobs.Items), 0)
options = metav1.ListOptions{ options = metav1.ListOptions{
@ -238,13 +237,13 @@ var _ = SIGDescribe("Generated clientset", func() {
} }
w, err := cronJobClient.Watch(options) w, err := cronJobClient.Watch(options)
if err != nil { if err != nil {
e2elog.Failf("Failed to set up watch: %v", err) framework.Failf("Failed to set up watch: %v", err)
} }
ginkgo.By("creating the cronJob") ginkgo.By("creating the cronJob")
cronJob, err = cronJobClient.Create(cronJob) cronJob, err = cronJobClient.Create(cronJob)
if err != nil { if err != nil {
e2elog.Failf("Failed to create cronJob: %v", err) framework.Failf("Failed to create cronJob: %v", err)
} }
ginkgo.By("verifying the cronJob is in kubernetes") ginkgo.By("verifying the cronJob is in kubernetes")
@ -254,7 +253,7 @@ var _ = SIGDescribe("Generated clientset", func() {
} }
cronJobs, err = cronJobClient.List(options) cronJobs, err = cronJobClient.List(options)
if err != nil { if err != nil {
e2elog.Failf("Failed to query for cronJobs: %v", err) framework.Failf("Failed to query for cronJobs: %v", err)
} }
framework.ExpectEqual(len(cronJobs.Items), 1) framework.ExpectEqual(len(cronJobs.Items), 1)
@ -265,13 +264,13 @@ var _ = SIGDescribe("Generated clientset", func() {
// Use DeletePropagationBackground so the CronJob is really gone when the call returns. // Use DeletePropagationBackground so the CronJob is really gone when the call returns.
propagationPolicy := metav1.DeletePropagationBackground propagationPolicy := metav1.DeletePropagationBackground
if err := cronJobClient.Delete(cronJob.Name, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy}); err != nil { if err := cronJobClient.Delete(cronJob.Name, &metav1.DeleteOptions{PropagationPolicy: &propagationPolicy}); err != nil {
e2elog.Failf("Failed to delete cronJob: %v", err) framework.Failf("Failed to delete cronJob: %v", err)
} }
options = metav1.ListOptions{LabelSelector: selector} options = metav1.ListOptions{LabelSelector: selector}
cronJobs, err = cronJobClient.List(options) cronJobs, err = cronJobClient.List(options)
if err != nil { if err != nil {
e2elog.Failf("Failed to list cronJobs to verify deletion: %v", err) framework.Failf("Failed to list cronJobs to verify deletion: %v", err)
} }
framework.ExpectEqual(len(cronJobs.Items), 0) framework.ExpectEqual(len(cronJobs.Items), 0)
}) })

3
test/e2e/apimachinery/namespace.go
View File

@ -28,7 +28,6 @@ import (
"k8s.io/apimachinery/pkg/util/intstr" "k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/wait" "k8s.io/apimachinery/pkg/util/wait"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
e2epod "k8s.io/kubernetes/test/e2e/framework/pod" e2epod "k8s.io/kubernetes/test/e2e/framework/pod"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
@ -75,7 +74,7 @@ func extinguish(f *framework.Framework, totalNS int, maxAllowedAfterDel int, max
} }
} }
if cnt > maxAllowedAfterDel { if cnt > maxAllowedAfterDel {
e2elog.Logf("Remaining namespaces : %v", cnt) framework.Logf("Remaining namespaces : %v", cnt)
return false, nil return false, nil
} }
return true, nil return true, nil

3
test/e2e/apimachinery/resource_quota.go
View File

@ -33,7 +33,6 @@ import (
clientset "k8s.io/client-go/kubernetes" clientset "k8s.io/client-go/kubernetes"
"k8s.io/kubernetes/pkg/quota/v1/evaluator/core" "k8s.io/kubernetes/pkg/quota/v1/evaluator/core"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"k8s.io/kubernetes/test/utils/crd" "k8s.io/kubernetes/test/utils/crd"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
@ -1688,7 +1687,7 @@ func waitForResourceQuota(c clientset.Interface, ns, quotaName string, used v1.R
// verify that the quota shows the expected used resource values // verify that the quota shows the expected used resource values
for k, v := range used { for k, v := range used {
if actualValue, found := resourceQuota.Status.Used[k]; !found || (actualValue.Cmp(v) != 0) { if actualValue, found := resourceQuota.Status.Used[k]; !found || (actualValue.Cmp(v) != 0) {
e2elog.Logf("resource %s, expected %s, actual %s", k, v.String(), actualValue.String()) framework.Logf("resource %s, expected %s, actual %s", k, v.String(), actualValue.String())
return false, nil return false, nil
} }
} }

15
test/e2e/apimachinery/table_conversion.go
View File

@ -35,7 +35,6 @@ import (
utilversion "k8s.io/apimachinery/pkg/util/version" utilversion "k8s.io/apimachinery/pkg/util/version"
"k8s.io/kubernetes/pkg/printers" "k8s.io/kubernetes/pkg/printers"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
) )
@ -53,7 +52,7 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
c := f.ClientSet c := f.ClientSet
podName := "pod-1" podName := "pod-1"
e2elog.Logf("Creating pod %s", podName) framework.Logf("Creating pod %s", podName)
_, err := c.CoreV1().Pods(ns).Create(newTablePod(podName)) _, err := c.CoreV1().Pods(ns).Create(newTablePod(podName))
framework.ExpectNoError(err, "failed to create pod %s in namespace: %s", podName, ns) framework.ExpectNoError(err, "failed to create pod %s in namespace: %s", podName, ns)
@ -61,7 +60,7 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
table := &metav1beta1.Table{} table := &metav1beta1.Table{}
err = c.CoreV1().RESTClient().Get().Resource("pods").Namespace(ns).Name(podName).SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").Do().Into(table) err = c.CoreV1().RESTClient().Get().Resource("pods").Namespace(ns).Name(podName).SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").Do().Into(table)
framework.ExpectNoError(err, "failed to get pod %s in Table form in namespace: %s", podName, ns) framework.ExpectNoError(err, "failed to get pod %s in Table form in namespace: %s", podName, ns)
e2elog.Logf("Table: %#v", table) framework.Logf("Table: %#v", table)
gomega.Expect(len(table.ColumnDefinitions)).To(gomega.BeNumerically(">", 2)) gomega.Expect(len(table.ColumnDefinitions)).To(gomega.BeNumerically(">", 2))
framework.ExpectEqual(len(table.Rows), 1) framework.ExpectEqual(len(table.Rows), 1)
@ -72,7 +71,7 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
out := printTable(table) out := printTable(table)
gomega.Expect(out).To(gomega.MatchRegexp("^NAME\\s")) gomega.Expect(out).To(gomega.MatchRegexp("^NAME\\s"))
gomega.Expect(out).To(gomega.MatchRegexp("\npod-1\\s")) gomega.Expect(out).To(gomega.MatchRegexp("\npod-1\\s"))
e2elog.Logf("Table:\n%s", out) framework.Logf("Table:\n%s", out)
}) })
ginkgo.It("should return chunks of table results for list calls", func() { ginkgo.It("should return chunks of table results for list calls", func() {
@ -98,9 +97,9 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
if err == nil { if err == nil {
return return
} }
e2elog.Logf("Got an error creating template %d: %v", i, err) framework.Logf("Got an error creating template %d: %v", i, err)
} }
e2elog.Fail("Unable to create template %d, exiting", i) framework.Failf("Unable to create template %d, exiting", i)
}) })
pagedTable := &metav1beta1.Table{} pagedTable := &metav1beta1.Table{}
@ -131,7 +130,7 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
table := &metav1beta1.Table{} table := &metav1beta1.Table{}
err := c.CoreV1().RESTClient().Get().Resource("nodes").SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").Do().Into(table) err := c.CoreV1().RESTClient().Get().Resource("nodes").SetHeader("Accept", "application/json;as=Table;v=v1beta1;g=meta.k8s.io").Do().Into(table)
framework.ExpectNoError(err, "failed to get nodes in Table form across all namespaces") framework.ExpectNoError(err, "failed to get nodes in Table form across all namespaces")
e2elog.Logf("Table: %#v", table) framework.Logf("Table: %#v", table)
gomega.Expect(len(table.ColumnDefinitions)).To(gomega.BeNumerically(">=", 2)) gomega.Expect(len(table.ColumnDefinitions)).To(gomega.BeNumerically(">=", 2))
gomega.Expect(len(table.Rows)).To(gomega.BeNumerically(">=", 1)) gomega.Expect(len(table.Rows)).To(gomega.BeNumerically(">=", 1))
@ -142,7 +141,7 @@ var _ = SIGDescribe("Servers with support for Table transformation", func() {
out := printTable(table) out := printTable(table)
gomega.Expect(out).To(gomega.MatchRegexp("^NAME\\s")) gomega.Expect(out).To(gomega.MatchRegexp("^NAME\\s"))
e2elog.Logf("Table:\n%s", out) framework.Logf("Table:\n%s", out)
}) })
/* /*

21
test/e2e/apimachinery/watch.go
View File

@ -27,7 +27,6 @@ import (
"k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/watch" "k8s.io/apimachinery/pkg/watch"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
"github.com/onsi/ginkgo" "github.com/onsi/ginkgo"
) )
@ -216,7 +215,7 @@ var _ = SIGDescribe("Watchers", func() {
expectEvent(testWatchBroken, watch.Added, testConfigMap) expectEvent(testWatchBroken, watch.Added, testConfigMap)
lastEvent, ok := waitForEvent(testWatchBroken, watch.Modified, nil, 1*time.Minute) lastEvent, ok := waitForEvent(testWatchBroken, watch.Modified, nil, 1*time.Minute)
if !ok { if !ok {
e2elog.Failf("Timed out waiting for second watch notification") framework.Failf("Timed out waiting for second watch notification")
} }
testWatchBroken.Stop() testWatchBroken.Stop()
@ -229,7 +228,7 @@ var _ = SIGDescribe("Watchers", func() {
ginkgo.By("creating a new watch on configmaps from the last resource version observed by the first watch") ginkgo.By("creating a new watch on configmaps from the last resource version observed by the first watch")
lastEventConfigMap, ok := lastEvent.Object.(*v1.ConfigMap) lastEventConfigMap, ok := lastEvent.Object.(*v1.ConfigMap)
if !ok { if !ok {
e2elog.Failf("Expected last notification to refer to a configmap but got: %v", lastEvent) framework.Failf("Expected last notification to refer to a configmap but got: %v", lastEvent)
} }
testWatchRestarted, err := watchConfigMaps(f, lastEventConfigMap.ObjectMeta.ResourceVersion, watchRestartedLabelValue) testWatchRestarted, err := watchConfigMaps(f, lastEventConfigMap.ObjectMeta.ResourceVersion, watchRestartedLabelValue)
framework.ExpectNoError(err, "failed to create a new watch on configmaps from the last resource version %s observed by the first watch", lastEventConfigMap.ObjectMeta.ResourceVersion) framework.ExpectNoError(err, "failed to create a new watch on configmaps from the last resource version %s observed by the first watch", lastEventConfigMap.ObjectMeta.ResourceVersion)
@ -352,7 +351,7 @@ var _ = SIGDescribe("Watchers", func() {
for _, wc := range wcs[1:] { for _, wc := range wcs[1:] {
e := waitForNextConfigMapEvent(wc) e := waitForNextConfigMapEvent(wc)
if resourceVersion != e.ResourceVersion { if resourceVersion != e.ResourceVersion {
e2elog.Failf("resource version mismatch, expected %s but got %s", resourceVersion, e.ResourceVersion) framework.Failf("resource version mismatch, expected %s but got %s", resourceVersion, e.ResourceVersion)
} }
} }
} }
@ -396,13 +395,13 @@ func setConfigMapData(cm *v1.ConfigMap, key, value string) {
func expectEvent(w watch.Interface, eventType watch.EventType, object runtime.Object) { func expectEvent(w watch.Interface, eventType watch.EventType, object runtime.Object) {
if event, ok := waitForEvent(w, eventType, object, 1*time.Minute); !ok { if event, ok := waitForEvent(w, eventType, object, 1*time.Minute); !ok {
e2elog.Failf("Timed out waiting for expected watch notification: %v", event) framework.Failf("Timed out waiting for expected watch notification: %v", event)
} }
} }
func expectNoEvent(w watch.Interface, eventType watch.EventType, object runtime.Object) { func expectNoEvent(w watch.Interface, eventType watch.EventType, object runtime.Object) {
if event, ok := waitForEvent(w, eventType, object, 10*time.Second); ok { if event, ok := waitForEvent(w, eventType, object, 10*time.Second); ok {
e2elog.Failf("Unexpected watch notification observed: %v", event) framework.Failf("Unexpected watch notification observed: %v", event)
} }
} }
@ -413,9 +412,9 @@ func waitForEvent(w watch.Interface, expectType watch.EventType, expectObject ru
select { select {
case actual, ok := <-w.ResultChan(): case actual, ok := <-w.ResultChan():
if ok { if ok {
e2elog.Logf("Got : %v %v", actual.Type, actual.Object) framework.Logf("Got : %v %v", actual.Type, actual.Object)
} else { } else {
e2elog.Failf("Watch closed unexpectedly") framework.Failf("Watch closed unexpectedly")
} }
if expectType == actual.Type && (expectObject == nil || apiequality.Semantic.DeepEqual(expectObject, actual.Object)) { if expectType == actual.Type && (expectObject == nil || apiequality.Semantic.DeepEqual(expectObject, actual.Object)) {
return actual, true return actual, true
@ -436,9 +435,9 @@ func waitForNextConfigMapEvent(watch watch.Interface) *v1.ConfigMap {
if configMap, ok := event.Object.(*v1.ConfigMap); ok { if configMap, ok := event.Object.(*v1.ConfigMap); ok {
return configMap return configMap
} }
e2elog.Failf("expected config map") framework.Failf("expected config map")
case <-time.After(10 * time.Second): case <-time.After(10 * time.Second):
e2elog.Failf("timed out waiting for watch event") framework.Failf("timed out waiting for watch event")
} }
return nil // should never happen return nil // should never happen
} }
@ -486,7 +485,7 @@ func produceConfigMapEvents(f *framework.Framework, stopc <-chan struct{}, minWa
framework.ExpectNoError(err, "Failed to delete configmap %s in namespace %s", name(existing[idx]), ns) framework.ExpectNoError(err, "Failed to delete configmap %s in namespace %s", name(existing[idx]), ns)
existing = append(existing[:idx], existing[idx+1:]...) existing = append(existing[:idx], existing[idx+1:]...)
default: default:
e2elog.Failf("Unsupported event operation: %d", op) framework.Failf("Unsupported event operation: %d", op)
} }
select { select {
case <-stopc: case <-stopc:

61
test/e2e/apimachinery/webhook.go
View File

@ -42,7 +42,6 @@ import (
"k8s.io/client-go/util/retry" "k8s.io/client-go/util/retry"
"k8s.io/kubernetes/test/e2e/framework" "k8s.io/kubernetes/test/e2e/framework"
e2edeploy "k8s.io/kubernetes/test/e2e/framework/deployment" e2edeploy "k8s.io/kubernetes/test/e2e/framework/deployment"
e2elog "k8s.io/kubernetes/test/e2e/framework/log"
e2epod "k8s.io/kubernetes/test/e2e/framework/pod" e2epod "k8s.io/kubernetes/test/e2e/framework/pod"
"k8s.io/kubernetes/test/utils/crd" "k8s.io/kubernetes/test/utils/crd"
imageutils "k8s.io/kubernetes/test/utils/image" imageutils "k8s.io/kubernetes/test/utils/image"
@ -742,7 +741,7 @@ func createAuthReaderRoleBinding(f *framework.Framework, namespace string) {
}, },
}) })
if err != nil && errors.IsAlreadyExists(err) { if err != nil && errors.IsAlreadyExists(err) {
e2elog.Logf("role binding %s already exists", roleBindingName) framework.Logf("role binding %s already exists", roleBindingName)
} else { } else {
framework.ExpectNoError(err, "creating role binding %s:webhook to access configMap", namespace) framework.ExpectNoError(err, "creating role binding %s:webhook to access configMap", namespace)
} }
@ -1004,7 +1003,7 @@ func testMutatingConfigMapWebhook(f *framework.Framework) {
"mutation-stage-2": "yes", "mutation-stage-2": "yes",
} }
if !reflect.DeepEqual(expectedConfigMapData, mutatedConfigMap.Data) { if !reflect.DeepEqual(expectedConfigMapData, mutatedConfigMap.Data) {
e2elog.Failf("\nexpected %#v\n, got %#v\n", expectedConfigMapData, mutatedConfigMap.Data) framework.Failf("\nexpected %#v\n, got %#v\n", expectedConfigMapData, mutatedConfigMap.Data)
} }
} }
@ -1065,13 +1064,13 @@ func testMutatingPodWebhook(f *framework.Framework) {
mutatedPod, err := client.CoreV1().Pods(f.Namespace.Name).Create(pod) mutatedPod, err := client.CoreV1().Pods(f.Namespace.Name).Create(pod)
gomega.Expect(err).To(gomega.BeNil()) gomega.Expect(err).To(gomega.BeNil())
if len(mutatedPod.Spec.InitContainers) != 1 { if len(mutatedPod.Spec.InitContainers) != 1 {
e2elog.Failf("expect pod to have 1 init container, got %#v", mutatedPod.Spec.InitContainers) framework.Failf("expect pod to have 1 init container, got %#v", mutatedPod.Spec.InitContainers)
} }
if got, expected := mutatedPod.Spec.InitContainers[0].Name, "webhook-added-init-container"; got != expected { if got, expected := mutatedPod.Spec.InitContainers[0].Name, "webhook-added-init-container"; got != expected {
e2elog.Failf("expect the init container name to be %q, got %q", expected, got) framework.Failf("expect the init container name to be %q, got %q", expected, got)
} }
if got, expected := mutatedPod.Spec.InitContainers[0].TerminationMessagePolicy, v1.TerminationMessageReadFile; got != expected { if got, expected := mutatedPod.Spec.InitContainers[0].TerminationMessagePolicy, v1.TerminationMessageReadFile; got != expected {
e2elog.Failf("expect the init terminationMessagePolicy to be default to %q, got %q", expected, got) framework.Failf("expect the init terminationMessagePolicy to be default to %q, got %q", expected, got)
} }
} }
@ -1100,11 +1099,11 @@ func testWebhook(f *framework.Framework) {
framework.ExpectError(err, "create pod %s in namespace %s should have been denied by webhook", pod.Name, f.Namespace.Name) framework.ExpectError(err, "create pod %s in namespace %s should have been denied by webhook", pod.Name, f.Namespace.Name)
expectedErrMsg1 := "the pod contains unwanted container name" expectedErrMsg1 := "the pod contains unwanted container name"
if !strings.Contains(err.Error(), expectedErrMsg1) { if !strings.Contains(err.Error(), expectedErrMsg1) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg1, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg1, err.Error())
} }
expectedErrMsg2 := "the pod contains unwanted label" expectedErrMsg2 := "the pod contains unwanted label"
if !strings.Contains(err.Error(), expectedErrMsg2) { if !strings.Contains(err.Error(), expectedErrMsg2) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg2, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg2, err.Error())
} }
ginkgo.By("create a pod that causes the webhook to hang") ginkgo.By("create a pod that causes the webhook to hang")
@ -1115,15 +1114,15 @@ func testWebhook(f *framework.Framework) {
framework.ExpectError(err, "create pod %s in namespace %s should have caused webhook to hang", pod.Name, f.Namespace.Name) framework.ExpectError(err, "create pod %s in namespace %s should have caused webhook to hang", pod.Name, f.Namespace.Name)
// ensure the error is webhook-related, not client-side // ensure the error is webhook-related, not client-side
if !strings.Contains(err.Error(), "webhook") { if !strings.Contains(err.Error(), "webhook") {
e2elog.Failf("expect error %q, got %q", "webhook", err.Error()) framework.Failf("expect error %q, got %q", "webhook", err.Error())
} }
// ensure the error is a timeout // ensure the error is a timeout
if !strings.Contains(err.Error(), "deadline") { if !strings.Contains(err.Error(), "deadline") {
e2elog.Failf("expect error %q, got %q", "deadline", err.Error()) framework.Failf("expect error %q, got %q", "deadline", err.Error())
} }
// ensure the pod was not actually created // ensure the pod was not actually created
if _, err := client.CoreV1().Pods(f.Namespace.Name).Get(pod.Name, metav1.GetOptions{}); !errors.IsNotFound(err) { if _, err := client.CoreV1().Pods(f.Namespace.Name).Get(pod.Name, metav1.GetOptions{}); !errors.IsNotFound(err) {
e2elog.Failf("expect notfound error looking for rejected pod, got %v", err) framework.Failf("expect notfound error looking for rejected pod, got %v", err)
} }
ginkgo.By("create a configmap that should be denied by the webhook") ginkgo.By("create a configmap that should be denied by the webhook")
@ -1133,7 +1132,7 @@ func testWebhook(f *framework.Framework) {
framework.ExpectError(err, "create configmap %s in namespace %s should have been denied by the webhook", configmap.Name, f.Namespace.Name) framework.ExpectError(err, "create configmap %s in namespace %s should have been denied by the webhook", configmap.Name, f.Namespace.Name)
expectedErrMsg := "the configmap contains unwanted key and value" expectedErrMsg := "the configmap contains unwanted key and value"
if !strings.Contains(err.Error(), expectedErrMsg) { if !strings.Contains(err.Error(), expectedErrMsg) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error())
} }
ginkgo.By("create a configmap that should be admitted by the webhook") ginkgo.By("create a configmap that should be admitted by the webhook")
@ -1159,7 +1158,7 @@ func testWebhook(f *framework.Framework) {
_, err = updateConfigMap(client, f.Namespace.Name, allowedConfigMapName, toNonCompliantFn) _, err = updateConfigMap(client, f.Namespace.Name, allowedConfigMapName, toNonCompliantFn)
framework.ExpectError(err, "update (PUT) admitted configmap %s in namespace %s to a non-compliant one should be rejected by webhook", allowedConfigMapName, f.Namespace.Name) framework.ExpectError(err, "update (PUT) admitted configmap %s in namespace %s to a non-compliant one should be rejected by webhook", allowedConfigMapName, f.Namespace.Name)
if !strings.Contains(err.Error(), expectedErrMsg) { if !strings.Contains(err.Error(), expectedErrMsg) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error())
} }
ginkgo.By("update (PATCH) the admitted configmap to a non-compliant one should be rejected by the webhook") ginkgo.By("update (PATCH) the admitted configmap to a non-compliant one should be rejected by the webhook")
@ -1167,7 +1166,7 @@ func testWebhook(f *framework.Framework) {
_, err = client.CoreV1().ConfigMaps(f.Namespace.Name).Patch(allowedConfigMapName, types.StrategicMergePatchType, []byte(patch)) _, err = client.CoreV1().ConfigMaps(f.Namespace.Name).Patch(allowedConfigMapName, types.StrategicMergePatchType, []byte(patch))
framework.ExpectError(err, "update admitted configmap %s in namespace %s by strategic merge patch to a non-compliant one should be rejected by webhook. Patch: %+v", allowedConfigMapName, f.Namespace.Name, patch) framework.ExpectError(err, "update admitted configmap %s in namespace %s by strategic merge patch to a non-compliant one should be rejected by webhook. Patch: %+v", allowedConfigMapName, f.Namespace.Name, patch)
if !strings.Contains(err.Error(), expectedErrMsg) { if !strings.Contains(err.Error(), expectedErrMsg) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error())
} }
ginkgo.By("create a namespace that bypass the webhook") ginkgo.By("create a namespace that bypass the webhook")
@ -1200,7 +1199,7 @@ func testBlockingConfigmapDeletion(f *framework.Framework) {
framework.ExpectError(err, "deleting configmap %s in namespace: %s should be denied", configmap.Name, f.Namespace.Name) framework.ExpectError(err, "deleting configmap %s in namespace: %s should be denied", configmap.Name, f.Namespace.Name)
expectedErrMsg1 := "the configmap cannot be deleted because it contains unwanted key and value" expectedErrMsg1 := "the configmap cannot be deleted because it contains unwanted key and value"
if !strings.Contains(err.Error(), expectedErrMsg1) { if !strings.Contains(err.Error(), expectedErrMsg1) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg1, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg1, err.Error())
} }
ginkgo.By("remove the offending key and value from the configmap data") ginkgo.By("remove the offending key and value from the configmap data")
@ -1233,7 +1232,7 @@ func testAttachingPodWebhook(f *framework.Framework) {
_, err = framework.NewKubectlCommand("attach", fmt.Sprintf("--namespace=%v", f.Namespace.Name), pod.Name, "-i", "-c=container1").WithTimeout(timer.C).Exec() _, err = framework.NewKubectlCommand("attach", fmt.Sprintf("--namespace=%v", f.Namespace.Name), pod.Name, "-i", "-c=container1").WithTimeout(timer.C).Exec()
framework.ExpectError(err, "'kubectl attach' the pod, should be denied by the webhook") framework.ExpectError(err, "'kubectl attach' the pod, should be denied by the webhook")
if e, a := "attaching to pod 'to-be-attached-pod' is not allowed", err.Error(); !strings.Contains(a, e) { if e, a := "attaching to pod 'to-be-attached-pod' is not allowed", err.Error(); !strings.Contains(a, e) {
e2elog.Failf("unexpected 'kubectl attach' error message. expected to contain %q, got %q", e, a) framework.Failf("unexpected 'kubectl attach' error message. expected to contain %q, got %q", e, a)
} }
} }
@ -1329,7 +1328,7 @@ func testFailClosedWebhook(f *framework.Framework) {
_, err = client.CoreV1().ConfigMaps(failNamespaceName).Create(configmap) _, err = client.CoreV1().ConfigMaps(failNamespaceName).Create(configmap)
framework.ExpectError(err, "create configmap in namespace: %s should be unconditionally rejected by the webhook", failNamespaceName) framework.ExpectError(err, "create configmap in namespace: %s should be unconditionally rejected by the webhook", failNamespaceName)
if !errors.IsInternalError(err) { if !errors.IsInternalError(err) {
e2elog.Failf("expect an internal error, got %#v", err) framework.Failf("expect an internal error, got %#v", err)
} }
} }
@ -1510,7 +1509,7 @@ func testWebhooksForWebhookConfigurations(f *framework.Framework, configName str
}) })
framework.ExpectNoError(err, "registering webhook config %s with namespace %s", configName, namespace) framework.ExpectNoError(err, "registering webhook config %s with namespace %s", configName, namespace)
if mutatedValidatingWebhookConfiguration.ObjectMeta.Labels != nil && mutatedValidatingWebhookConfiguration.ObjectMeta.Labels[addedLabelKey] == addedLabelValue { if mutatedValidatingWebhookConfiguration.ObjectMeta.Labels != nil && mutatedValidatingWebhookConfiguration.ObjectMeta.Labels[addedLabelKey] == addedLabelValue {
e2elog.Failf("expected %s not to be mutated by mutating webhooks but it was", configName) framework.Failf("expected %s not to be mutated by mutating webhooks but it was", configName)
} }
err = waitWebhookConfigurationReady(f) err = waitWebhookConfigurationReady(f)
@ -1566,7 +1565,7 @@ func testWebhooksForWebhookConfigurations(f *framework.Framework, configName str
}) })
framework.ExpectNoError(err, "registering webhook config %s with namespace %s", configName, namespace) framework.ExpectNoError(err, "registering webhook config %s with namespace %s", configName, namespace)
if mutatedMutatingWebhookConfiguration.ObjectMeta.Labels != nil && mutatedMutatingWebhookConfiguration.ObjectMeta.Labels[addedLabelKey] == addedLabelValue { if mutatedMutatingWebhookConfiguration.ObjectMeta.Labels != nil && mutatedMutatingWebhookConfiguration.ObjectMeta.Labels[addedLabelKey] == addedLabelValue {
e2elog.Failf("expected %s not to be mutated by mutating webhooks but it was", configName) framework.Failf("expected %s not to be mutated by mutating webhooks but it was", configName)
} }
err = waitWebhookConfigurationReady(f) err = waitWebhookConfigurationReady(f)
@ -1888,7 +1887,7 @@ func testCustomResourceWebhook(f *framework.Framework, crd *apiextensionsv1.Cust
framework.ExpectError(err, "create custom resource %s in namespace %s should be denied by webhook", crInstanceName, f.Namespace.Name) framework.ExpectError(err, "create custom resource %s in namespace %s should be denied by webhook", crInstanceName, f.Namespace.Name)
expectedErrMsg := "the custom resource contains unwanted data" expectedErrMsg := "the custom resource contains unwanted data"
if !strings.Contains(err.Error(), expectedErrMsg) { if !strings.Contains(err.Error(), expectedErrMsg) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error())
} }
} }
@ -1924,7 +1923,7 @@ func testBlockingCustomResourceUpdateDeletion(f *framework.Framework, crd *apiex
expectedErrMsg := "the custom resource contains unwanted data" expectedErrMsg := "the custom resource contains unwanted data"
if !strings.Contains(err.Error(), expectedErrMsg) { if !strings.Contains(err.Error(), expectedErrMsg) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error())
} }
ginkgo.By("Deleting the custom resource should be denied") ginkgo.By("Deleting the custom resource should be denied")
@ -1932,7 +1931,7 @@ func testBlockingCustomResourceUpdateDeletion(f *framework.Framework, crd *apiex
framework.ExpectError(err, "deleting custom resource %s in namespace: %s should be denied", crInstanceName, f.Namespace.Name) framework.ExpectError(err, "deleting custom resource %s in namespace: %s should be denied", crInstanceName, f.Namespace.Name)
expectedErrMsg1 := "the custom resource cannot be deleted because it contains unwanted key and value" expectedErrMsg1 := "the custom resource cannot be deleted because it contains unwanted key and value"
if !strings.Contains(err.Error(), expectedErrMsg1) { if !strings.Contains(err.Error(), expectedErrMsg1) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg1, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg1, err.Error())
} }
ginkgo.By("Remove the offending key and value from the custom resource data") ginkgo.By("Remove the offending key and value from the custom resource data")
@ -1978,7 +1977,7 @@ func testMutatingCustomResourceWebhook(f *framework.Framework, crd *apiextension
expectedCRData["mutation-stage-2"] = "yes" expectedCRData["mutation-stage-2"] = "yes"
} }
if !reflect.DeepEqual(expectedCRData, mutatedCR.Object["data"]) { if !reflect.DeepEqual(expectedCRData, mutatedCR.Object["data"]) {
e2elog.Failf("\nexpected %#v\n, got %#v\n", expectedCRData, mutatedCR.Object["data"]) framework.Failf("\nexpected %#v\n, got %#v\n", expectedCRData, mutatedCR.Object["data"])
} }
} }
@ -2038,10 +2037,10 @@ func testMultiVersionCustomResourceWebhook(f *framework.Framework, testcrd *crd.
"mutation-stage-2": "yes", "mutation-stage-2": "yes",
} }
if !reflect.DeepEqual(expectedCRData, mutatedCR.Object["data"]) { if !reflect.DeepEqual(expectedCRData, mutatedCR.Object["data"]) {
e2elog.Failf("\nexpected %#v\n, got %#v\n", expectedCRData, mutatedCR.Object["data"]) framework.Failf("\nexpected %#v\n, got %#v\n", expectedCRData, mutatedCR.Object["data"])
} }
if !reflect.DeepEqual("test", mutatedCR.Object["dummy"]) { if !reflect.DeepEqual("test", mutatedCR.Object["dummy"]) {
e2elog.Failf("\nexpected %#v\n, got %#v\n", "test", mutatedCR.Object["dummy"]) framework.Failf("\nexpected %#v\n, got %#v\n", "test", mutatedCR.Object["dummy"])
} }
} }
@ -2122,12 +2121,12 @@ func testCRDDenyWebhook(f *framework.Framework) {
// Creating a custom resource definition for use by assorted tests. // Creating a custom resource definition for use by assorted tests.
config, err := framework.LoadConfig() config, err := framework.LoadConfig()
if err != nil { if err != nil {
e2elog.Failf("failed to load config: %v", err) framework.Failf("failed to load config: %v", err)
return return
} }
apiExtensionClient, err := crdclientset.NewForConfig(config) apiExtensionClient, err := crdclientset.NewForConfig(config)
if err != nil { if err != nil {
e2elog.Failf("failed to initialize apiExtensionClient: %v", err) framework.Failf("failed to initialize apiExtensionClient: %v", err)
return return
} }
crd := &apiextensionsv1.CustomResourceDefinition{ crd := &apiextensionsv1.CustomResourceDefinition{
@ -2158,7 +2157,7 @@ func testCRDDenyWebhook(f *framework.Framework) {
framework.ExpectError(err, "create custom resource definition %s should be denied by webhook", crd.Name) framework.ExpectError(err, "create custom resource definition %s should be denied by webhook", crd.Name)
expectedErrMsg := "the crd contains unwanted label" expectedErrMsg := "the crd contains unwanted label"
if !strings.Contains(err.Error(), expectedErrMsg) { if !strings.Contains(err.Error(), expectedErrMsg) {
e2elog.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error()) framework.Failf("expect error contains %q, got %q", expectedErrMsg, err.Error())
} }
} }
@ -2241,7 +2240,7 @@ func testSlowWebhookTimeoutFailEarly(f *framework.Framework) {
isTimeoutError := strings.Contains(err.Error(), `context deadline exceeded`) || strings.Contains(err.Error(), `timeout`) isTimeoutError := strings.Contains(err.Error(), `context deadline exceeded`) || strings.Contains(err.Error(), `timeout`)
isErrorQueryingWebhook := strings.Contains(err.Error(), `/always-allow-delay-5s?timeout=1s`) isErrorQueryingWebhook := strings.Contains(err.Error(), `/always-allow-delay-5s?timeout=1s`)
if !isTimeoutError || !isErrorQueryingWebhook { if !isTimeoutError || !isErrorQueryingWebhook {
e2elog.Failf("expect an HTTP/dial timeout error querying the slow webhook, got: %q", err.Error()) framework.Failf("expect an HTTP/dial timeout error querying the slow webhook, got: %q", err.Error())
} }
} }
@ -2307,7 +2306,7 @@ func createValidatingWebhookConfiguration(f *framework.Framework, config *admiss
if webhook.ObjectSelector != nil && webhook.ObjectSelector.MatchLabels[f.UniqueName] == "true" { if webhook.ObjectSelector != nil && webhook.ObjectSelector.MatchLabels[f.UniqueName] == "true" {
continue continue
} }
e2elog.Failf(`webhook %s in config %s has no namespace or object selector with %s="true", and can interfere with other tests`, webhook.Name, config.Name, f.UniqueName) framework.Failf(`webhook %s in config %s has no namespace or object selector with %s="true", and can interfere with other tests`, webhook.Name, config.Name, f.UniqueName)
} }
return f.ClientSet.AdmissionregistrationV1().ValidatingWebhookConfigurations().Create(config) return f.ClientSet.AdmissionregistrationV1().ValidatingWebhookConfigurations().Create(config)
} }
@ -2322,7 +2321,7 @@ func createMutatingWebhookConfiguration(f *framework.Framework, config *admissio
if webhook.ObjectSelector != nil && webhook.ObjectSelector.MatchLabels[f.UniqueName] == "true" { if webhook.ObjectSelector != nil && webhook.ObjectSelector.MatchLabels[f.UniqueName] == "true" {
continue continue
} }
e2elog.Failf(`webhook %s in config %s has no namespace or object selector with %s="true", and can interfere with other tests`, webhook.Name, config.Name, f.UniqueName) framework.Failf(`webhook %s in config %s has no namespace or object selector with %s="true", and can interfere with other tests`, webhook.Name, config.Name, f.UniqueName)
} }
return f.ClientSet.AdmissionregistrationV1().MutatingWebhookConfigurations().Create(config) return f.ClientSet.AdmissionregistrationV1().MutatingWebhookConfigurations().Create(config)
} }