vendor update for CSI 0.3.0

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/wait/BUILD

@@ -0,0 +1,56 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["wait.go"],
+    importpath = "k8s.io/kubernetes/pkg/kubectl/cmd/wait",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/kubectl/cmd/util:go_default_library",
+        "//pkg/kubectl/genericclioptions:go_default_library",
+        "//pkg/kubectl/genericclioptions/printers:go_default_library",
+        "//pkg/kubectl/genericclioptions/resource:go_default_library",
+        "//vendor/github.com/spf13/cobra:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/errors:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/dynamic:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["wait_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//pkg/kubectl/genericclioptions:go_default_library",
+        "//pkg/kubectl/genericclioptions/printers:go_default_library",
+        "//pkg/kubectl/genericclioptions/resource:go_default_library",
+        "//vendor/github.com/davecgh/go-spew/spew:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/meta:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1/unstructured:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/watch:go_default_library",
+        "//vendor/k8s.io/client-go/dynamic/fake:go_default_library",
+        "//vendor/k8s.io/client-go/testing:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/wait/wait.go

@@ -0,0 +1,324 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package wait
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/dynamic"
+	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions/printers"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions/resource"
+)
+
+// WaitFlags directly reflect the information that CLI is gathering via flags.  They will be converted to Options, which
+// reflect the runtime requirements for the command.  This structure reduces the transformation to wiring and makes
+// the logic itself easy to unit test
+type WaitFlags struct {
+	RESTClientGetter     genericclioptions.RESTClientGetter
+	PrintFlags           *genericclioptions.PrintFlags
+	ResourceBuilderFlags *genericclioptions.ResourceBuilderFlags
+
+	Timeout      time.Duration
+	ForCondition string
+
+	genericclioptions.IOStreams
+}
+
+// NewWaitFlags returns a default WaitFlags
+func NewWaitFlags(restClientGetter genericclioptions.RESTClientGetter, streams genericclioptions.IOStreams) *WaitFlags {
+	return &WaitFlags{
+		RESTClientGetter: restClientGetter,
+		PrintFlags:       genericclioptions.NewPrintFlags("condition met"),
+		ResourceBuilderFlags: genericclioptions.NewResourceBuilderFlags().
+			WithLabelSelector("").
+			WithAllNamespaces(false).
+			WithLatest(),
+
+		Timeout: 30 * time.Second,
+
+		IOStreams: streams,
+	}
+}
+
+// NewCmdWait returns a cobra command for waiting
+func NewCmdWait(restClientGetter genericclioptions.RESTClientGetter, streams genericclioptions.IOStreams) *cobra.Command {
+	flags := NewWaitFlags(restClientGetter, streams)
+
+	cmd := &cobra.Command{
+		Use: "wait resource.group/name [--for=delete|--for condition=available]",
+		DisableFlagsInUseLine: true,
+		Short: "Experimental: Wait for one condition on one or many resources",
+		Run: func(cmd *cobra.Command, args []string) {
+			o, err := flags.ToOptions(args)
+			cmdutil.CheckErr(err)
+			err = o.RunWait()
+			cmdutil.CheckErr(err)
+		},
+		SuggestFor: []string{"list", "ps"},
+	}
+
+	flags.AddFlags(cmd)
+
+	return cmd
+}
+
+// AddFlags registers flags for a cli
+func (flags *WaitFlags) AddFlags(cmd *cobra.Command) {
+	flags.PrintFlags.AddFlags(cmd)
+	flags.ResourceBuilderFlags.AddFlags(cmd.Flags())
+
+	cmd.Flags().DurationVar(&flags.Timeout, "timeout", flags.Timeout, "The length of time to wait before giving up.  Zero means check once and don't wait, negative means wait for a week.")
+	cmd.Flags().StringVar(&flags.ForCondition, "for", flags.ForCondition, "The condition to wait on: [delete|condition=condition-name].")
+}
+
+// ToOptions converts from CLI inputs to runtime inputs
+func (flags *WaitFlags) ToOptions(args []string) (*WaitOptions, error) {
+	printer, err := flags.PrintFlags.ToPrinter()
+	if err != nil {
+		return nil, err
+	}
+	builder := flags.ResourceBuilderFlags.ToBuilder(flags.RESTClientGetter, args)
+	clientConfig, err := flags.RESTClientGetter.ToRESTConfig()
+	if err != nil {
+		return nil, err
+	}
+	dynamicClient, err := dynamic.NewForConfig(clientConfig)
+	if err != nil {
+		return nil, err
+	}
+	conditionFn, err := conditionFuncFor(flags.ForCondition)
+	if err != nil {
+		return nil, err
+	}
+
+	effectiveTimeout := flags.Timeout
+	if effectiveTimeout < 0 {
+		effectiveTimeout = 168 * time.Hour
+	}
+
+	o := &WaitOptions{
+		ResourceFinder: builder,
+		DynamicClient:  dynamicClient,
+		Timeout:        effectiveTimeout,
+
+		Printer:     printer,
+		ConditionFn: conditionFn,
+		IOStreams:   flags.IOStreams,
+	}
+
+	return o, nil
+}
+
+func conditionFuncFor(condition string) (ConditionFunc, error) {
+	if strings.ToLower(condition) == "delete" {
+		return IsDeleted, nil
+	}
+	if strings.HasPrefix(condition, "condition=") {
+		conditionName := condition[len("condition="):]
+		return ConditionalWait{
+			conditionName: conditionName,
+			// TODO allow specifying a false
+			conditionStatus: "true",
+		}.IsConditionMet, nil
+	}
+
+	return nil, fmt.Errorf("unrecognized condition: %q", condition)
+}
+
+// WaitOptions is a set of options that allows you to wait.  This is the object reflects the runtime needs of a wait
+// command, making the logic itself easy to unit test with our existing mocks.
+type WaitOptions struct {
+	ResourceFinder genericclioptions.ResourceFinder
+	DynamicClient  dynamic.Interface
+	Timeout        time.Duration
+
+	Printer     printers.ResourcePrinter
+	ConditionFn ConditionFunc
+	genericclioptions.IOStreams
+}
+
+// ConditionFunc is the interface for providing condition checks
+type ConditionFunc func(info *resource.Info, o *WaitOptions) (finalObject runtime.Object, done bool, err error)
+
+// RunWait runs the waiting logic
+func (o *WaitOptions) RunWait() error {
+	return o.ResourceFinder.Do().Visit(func(info *resource.Info, err error) error {
+		if err != nil {
+			return err
+		}
+
+		finalObject, success, err := o.ConditionFn(info, o)
+		if success {
+			o.Printer.PrintObj(finalObject, o.Out)
+			return nil
+		}
+		if err == nil {
+			return fmt.Errorf("%v unsatisified for unknown reason", finalObject)
+		}
+		return err
+	})
+}
+
+// IsDeleted is a condition func for waiting for something to be deleted
+func IsDeleted(info *resource.Info, o *WaitOptions) (runtime.Object, bool, error) {
+	endTime := time.Now().Add(o.Timeout)
+	for {
+		gottenObj, err := o.DynamicClient.Resource(info.Mapping.Resource).Namespace(info.Namespace).Get(info.Name, metav1.GetOptions{})
+		if errors.IsNotFound(err) {
+			return info.Object, true, nil
+		}
+		if err != nil {
+			// TODO this could do something slightly fancier if we wish
+			return info.Object, false, err
+		}
+
+		watchOptions := metav1.ListOptions{}
+		watchOptions.FieldSelector = "metadata.name=" + info.Name
+		watchOptions.ResourceVersion = gottenObj.GetResourceVersion()
+		objWatch, err := o.DynamicClient.Resource(info.Mapping.Resource).Namespace(info.Namespace).Watch(watchOptions)
+		if err != nil {
+			return gottenObj, false, err
+		}
+
+		timeout := endTime.Sub(time.Now())
+		if timeout < 0 {
+			// we're out of time
+			return gottenObj, false, wait.ErrWaitTimeout
+		}
+		watchEvent, err := watch.Until(o.Timeout, objWatch, isDeleted)
+		switch {
+		case err == nil:
+			return watchEvent.Object, true, nil
+		case err == watch.ErrWatchClosed:
+			continue
+		case err == wait.ErrWaitTimeout:
+			if watchEvent != nil {
+				return watchEvent.Object, false, wait.ErrWaitTimeout
+			}
+			return gottenObj, false, wait.ErrWaitTimeout
+		default:
+			return gottenObj, false, err
+		}
+	}
+}
+
+func isDeleted(event watch.Event) (bool, error) {
+	return event.Type == watch.Deleted, nil
+}
+
+// ConditionalWait hold information to check an API status condition
+type ConditionalWait struct {
+	conditionName   string
+	conditionStatus string
+}
+
+// IsConditionMet is a conditionfunc for waiting on an API condition to be met
+func (w ConditionalWait) IsConditionMet(info *resource.Info, o *WaitOptions) (runtime.Object, bool, error) {
+	endTime := time.Now().Add(o.Timeout)
+	for {
+		resourceVersion := ""
+		gottenObj, err := o.DynamicClient.Resource(info.Mapping.Resource).Namespace(info.Namespace).Get(info.Name, metav1.GetOptions{})
+		switch {
+		case errors.IsNotFound(err):
+			resourceVersion = "0"
+		case err != nil:
+			return info.Object, false, err
+		default:
+			conditionMet, err := w.checkCondition(gottenObj)
+			if conditionMet {
+				return gottenObj, true, nil
+			}
+			if err != nil {
+				return gottenObj, false, err
+			}
+			resourceVersion = gottenObj.GetResourceVersion()
+		}
+
+		watchOptions := metav1.ListOptions{}
+		watchOptions.FieldSelector = "metadata.name=" + info.Name
+		watchOptions.ResourceVersion = resourceVersion
+		objWatch, err := o.DynamicClient.Resource(info.Mapping.Resource).Namespace(info.Namespace).Watch(watchOptions)
+		if err != nil {
+			return gottenObj, false, err
+		}
+
+		timeout := endTime.Sub(time.Now())
+		if timeout < 0 {
+			// we're out of time
+			return gottenObj, false, wait.ErrWaitTimeout
+		}
+		watchEvent, err := watch.Until(o.Timeout, objWatch, w.isConditionMet)
+		switch {
+		case err == nil:
+			return watchEvent.Object, true, nil
+		case err == watch.ErrWatchClosed:
+			continue
+		case err == wait.ErrWaitTimeout:
+			if watchEvent != nil {
+				return watchEvent.Object, false, wait.ErrWaitTimeout
+			}
+			return gottenObj, false, wait.ErrWaitTimeout
+		default:
+			return gottenObj, false, err
+		}
+	}
+}
+
+func (w ConditionalWait) checkCondition(obj *unstructured.Unstructured) (bool, error) {
+	conditions, found, err := unstructured.NestedSlice(obj.Object, "status", "conditions")
+	if err != nil {
+		return false, err
+	}
+	if !found {
+		return false, nil
+	}
+	for _, conditionUncast := range conditions {
+		condition := conditionUncast.(map[string]interface{})
+		name, found, err := unstructured.NestedString(condition, "type")
+		if !found || err != nil || strings.ToLower(name) != strings.ToLower(w.conditionName) {
+			continue
+		}
+		status, found, err := unstructured.NestedString(condition, "status")
+		if !found || err != nil {
+			continue
+		}
+		return strings.ToLower(status) == strings.ToLower(w.conditionStatus), nil
+	}
+
+	return false, nil
+}
+
+func (w ConditionalWait) isConditionMet(event watch.Event) (bool, error) {
+	if event.Type == watch.Deleted {
+		// this will chain back out, result in another get and an return false back up the chain
+		return false, nil
+	}
+	obj := event.Object.(*unstructured.Unstructured)
+	return w.checkCondition(obj)
+}

vendor/k8s.io/kubernetes/pkg/kubectl/cmd/wait/wait_test.go

@@ -0,0 +1,478 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package wait
+
+import (
+	"testing"
+
+	"time"
+
+	"strings"
+
+	"github.com/davecgh/go-spew/spew"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/apimachinery/pkg/watch"
+	dynamicfakeclient "k8s.io/client-go/dynamic/fake"
+	clienttesting "k8s.io/client-go/testing"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions/printers"
+	"k8s.io/kubernetes/pkg/kubectl/genericclioptions/resource"
+)
+
+func newUnstructured(apiVersion, kind, namespace, name string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": apiVersion,
+			"kind":       kind,
+			"metadata": map[string]interface{}{
+				"namespace": namespace,
+				"name":      name,
+			},
+		},
+	}
+}
+
+func addCondition(in *unstructured.Unstructured, name, status string) *unstructured.Unstructured {
+	conditions, _, _ := unstructured.NestedSlice(in.Object, "status", "conditions")
+	conditions = append(conditions, map[string]interface{}{
+		"type":   name,
+		"status": status,
+	})
+	unstructured.SetNestedSlice(in.Object, conditions, "status", "conditions")
+	return in
+}
+
+func TestWaitForDeletion(t *testing.T) {
+	scheme := runtime.NewScheme()
+
+	tests := []struct {
+		name       string
+		info       *resource.Info
+		fakeClient func() *dynamicfakeclient.FakeDynamicClient
+		timeout    time.Duration
+
+		expectedErr     string
+		validateActions func(t *testing.T, actions []clienttesting.Action)
+	}{
+		{
+			name: "missing on get",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				return dynamicfakeclient.NewSimpleDynamicClient(scheme)
+			},
+			timeout: 10 * time.Second,
+
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 1 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+		{
+			name: "times out",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				fakeClient := dynamicfakeclient.NewSimpleDynamicClient(scheme)
+				fakeClient.PrependReactor("get", "theresource", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
+					return true, newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"), nil
+				})
+				return fakeClient
+			},
+			timeout: 1 * time.Second,
+
+			expectedErr: wait.ErrWaitTimeout.Error(),
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 2 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[1].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+		{
+			name: "handles watch close out",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				fakeClient := dynamicfakeclient.NewSimpleDynamicClient(scheme)
+				fakeClient.PrependReactor("get", "theresource", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
+					return true, newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"), nil
+				})
+				count := 0
+				fakeClient.PrependWatchReactor("theresource", func(action clienttesting.Action) (handled bool, ret watch.Interface, err error) {
+					if count == 0 {
+						count++
+						fakeWatch := watch.NewRaceFreeFake()
+						go func() {
+							time.Sleep(100 * time.Millisecond)
+							fakeWatch.Stop()
+						}()
+						return true, fakeWatch, nil
+					}
+					fakeWatch := watch.NewRaceFreeFake()
+					return true, fakeWatch, nil
+				})
+				return fakeClient
+			},
+			timeout: 3 * time.Second,
+
+			expectedErr: wait.ErrWaitTimeout.Error(),
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 4 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[1].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[2].Matches("get", "theresource") || actions[2].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[3].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+		{
+			name: "handles watch delete",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				fakeClient := dynamicfakeclient.NewSimpleDynamicClient(scheme)
+				fakeClient.PrependReactor("get", "theresource", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
+					return true, newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"), nil
+				})
+				fakeClient.PrependWatchReactor("theresource", func(action clienttesting.Action) (handled bool, ret watch.Interface, err error) {
+					fakeWatch := watch.NewRaceFreeFake()
+					fakeWatch.Action(watch.Deleted, newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"))
+					return true, fakeWatch, nil
+				})
+				return fakeClient
+			},
+			timeout: 10 * time.Second,
+
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 2 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[1].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fakeClient := test.fakeClient()
+			o := &WaitOptions{
+				ResourceFinder: genericclioptions.NewSimpleFakeResourceFinder(test.info),
+				DynamicClient:  fakeClient,
+				Timeout:        test.timeout,
+
+				Printer:     printers.NewDiscardingPrinter(),
+				ConditionFn: IsDeleted,
+				IOStreams:   genericclioptions.NewTestIOStreamsDiscard(),
+			}
+			err := o.RunWait()
+			switch {
+			case err == nil && len(test.expectedErr) == 0:
+			case err != nil && len(test.expectedErr) == 0:
+				t.Fatal(err)
+			case err == nil && len(test.expectedErr) != 0:
+				t.Fatalf("missing: %q", test.expectedErr)
+			case err != nil && len(test.expectedErr) != 0:
+				if !strings.Contains(err.Error(), test.expectedErr) {
+					t.Fatalf("expected %q, got %q", test.expectedErr, err.Error())
+				}
+			}
+
+			test.validateActions(t, fakeClient.Actions())
+		})
+	}
+}
+
+func TestWaitForCondition(t *testing.T) {
+	scheme := runtime.NewScheme()
+
+	tests := []struct {
+		name       string
+		info       *resource.Info
+		fakeClient func() *dynamicfakeclient.FakeDynamicClient
+		timeout    time.Duration
+
+		expectedErr     string
+		validateActions func(t *testing.T, actions []clienttesting.Action)
+	}{
+		{
+			name: "present on get",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				fakeClient := dynamicfakeclient.NewSimpleDynamicClient(scheme)
+				fakeClient.PrependReactor("get", "theresource", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
+					return true, addCondition(
+						newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
+						"the-condition", "status-value",
+					), nil
+				})
+				return fakeClient
+			},
+			timeout: 10 * time.Second,
+
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 1 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+		{
+			name: "times out",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				fakeClient := dynamicfakeclient.NewSimpleDynamicClient(scheme)
+				fakeClient.PrependReactor("get", "theresource", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
+					return true, addCondition(
+						newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
+						"some-other-condition", "status-value",
+					), nil
+				})
+				return fakeClient
+			},
+			timeout: 1 * time.Second,
+
+			expectedErr: wait.ErrWaitTimeout.Error(),
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 2 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[1].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+		{
+			name: "handles watch close out",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				fakeClient := dynamicfakeclient.NewSimpleDynamicClient(scheme)
+				fakeClient.PrependReactor("get", "theresource", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
+					return true, newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"), nil
+				})
+				count := 0
+				fakeClient.PrependWatchReactor("theresource", func(action clienttesting.Action) (handled bool, ret watch.Interface, err error) {
+					if count == 0 {
+						count++
+						fakeWatch := watch.NewRaceFreeFake()
+						go func() {
+							time.Sleep(100 * time.Millisecond)
+							fakeWatch.Stop()
+						}()
+						return true, fakeWatch, nil
+					}
+					fakeWatch := watch.NewRaceFreeFake()
+					return true, fakeWatch, nil
+				})
+				return fakeClient
+			},
+			timeout: 3 * time.Second,
+
+			expectedErr: wait.ErrWaitTimeout.Error(),
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 4 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[1].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[2].Matches("get", "theresource") || actions[2].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[3].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+		{
+			name: "handles watch condition change",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				fakeClient := dynamicfakeclient.NewSimpleDynamicClient(scheme)
+				fakeClient.PrependReactor("get", "theresource", func(action clienttesting.Action) (handled bool, ret runtime.Object, err error) {
+					return true, newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"), nil
+				})
+				fakeClient.PrependWatchReactor("theresource", func(action clienttesting.Action) (handled bool, ret watch.Interface, err error) {
+					fakeWatch := watch.NewRaceFreeFake()
+					fakeWatch.Action(watch.Modified, addCondition(
+						newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
+						"the-condition", "status-value",
+					))
+					return true, fakeWatch, nil
+				})
+				return fakeClient
+			},
+			timeout: 10 * time.Second,
+
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 2 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[1].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+		{
+			name: "handles watch created",
+			info: &resource.Info{
+				Mapping: &meta.RESTMapping{
+					Resource: schema.GroupVersionResource{Group: "group", Version: "version", Resource: "theresource"},
+				},
+				Name:      "name-foo",
+				Namespace: "ns-foo",
+			},
+			fakeClient: func() *dynamicfakeclient.FakeDynamicClient {
+				fakeClient := dynamicfakeclient.NewSimpleDynamicClient(scheme)
+				fakeClient.PrependWatchReactor("theresource", func(action clienttesting.Action) (handled bool, ret watch.Interface, err error) {
+					fakeWatch := watch.NewRaceFreeFake()
+					fakeWatch.Action(watch.Added, addCondition(
+						newUnstructured("group/version", "TheKind", "ns-foo", "name-foo"),
+						"the-condition", "status-value",
+					))
+					return true, fakeWatch, nil
+				})
+				return fakeClient
+			},
+			timeout: 10 * time.Second,
+
+			validateActions: func(t *testing.T, actions []clienttesting.Action) {
+				if len(actions) != 2 {
+					t.Fatal(spew.Sdump(actions))
+				}
+				if !actions[0].Matches("get", "theresource") || actions[0].(clienttesting.GetAction).GetName() != "name-foo" {
+					t.Error(spew.Sdump(actions))
+				}
+				if !actions[1].Matches("watch", "theresource") {
+					t.Error(spew.Sdump(actions))
+				}
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fakeClient := test.fakeClient()
+			o := &WaitOptions{
+				ResourceFinder: genericclioptions.NewSimpleFakeResourceFinder(test.info),
+				DynamicClient:  fakeClient,
+				Timeout:        test.timeout,
+
+				Printer:     printers.NewDiscardingPrinter(),
+				ConditionFn: ConditionalWait{conditionName: "the-condition", conditionStatus: "status-value"}.IsConditionMet,
+				IOStreams:   genericclioptions.NewTestIOStreamsDiscard(),
+			}
+			err := o.RunWait()
+			switch {
+			case err == nil && len(test.expectedErr) == 0:
+			case err != nil && len(test.expectedErr) == 0:
+				t.Fatal(err)
+			case err == nil && len(test.expectedErr) != 0:
+				t.Fatalf("missing: %q", test.expectedErr)
+			case err != nil && len(test.expectedErr) != 0:
+				if !strings.Contains(err.Error(), test.expectedErr) {
+					t.Fatalf("expected %q, got %q", test.expectedErr, err.Error())
+				}
+			}
+
+			test.validateActions(t, fakeClient.Actions())
+		})
+	}
+}