Bumping k8s dependencies to 1.13

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

@@ -17,42 +17,29 @@ limitations under the License.
 package cmd
 
 import (
-	"bytes"
 	"errors"
-	"io/ioutil"
-	"net/http"
+	"fmt"
+	"io"
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/spf13/cobra"
-
-	"fmt"
-
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/cli-runtime/pkg/genericclioptions"
 	restclient "k8s.io/client-go/rest"
-	"k8s.io/client-go/rest/fake"
-	"k8s.io/kubernetes/pkg/api/legacyscheme"
-	api "k8s.io/kubernetes/pkg/apis/core"
-	"k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
 	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
-	"k8s.io/kubernetes/pkg/kubectl/genericclioptions"
-	"k8s.io/kubernetes/pkg/kubectl/polymorphichelpers"
-	"k8s.io/kubernetes/pkg/kubectl/scheme"
 )
 
 func TestLog(t *testing.T) {
 	tests := []struct {
 		name, version, podPath, logPath string
-		pod                             *api.Pod
+		pod                             *corev1.Pod
 	}{
 		{
-			name:    "v1 - pod log",
-			version: "v1",
-			podPath: "/namespaces/test/pods/foo",
-			logPath: "/api/v1/namespaces/test/pods/foo/log",
-			pod:     testPod(),
+			name: "v1 - pod log",
+			pod:  testPod(),
 		},
 	}
 	for _, test := range tests {
@@ -61,41 +48,19 @@ func TestLog(t *testing.T) {
 			tf := cmdtesting.NewTestFactory().WithNamespace("test")
 			defer tf.Cleanup()
 
-			codec := legacyscheme.Codecs.LegacyCodec(scheme.Scheme.PrioritizedVersionsAllGroups()...)
-			ns := legacyscheme.Codecs
-
-			tf.Client = &fake.RESTClient{
-				NegotiatedSerializer: ns,
-				Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
-					switch p, m := req.URL.Path, req.Method; {
-					case p == test.podPath && m == "GET":
-						body := objBody(codec, test.pod)
-						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
-					case p == test.logPath && m == "GET":
-						body := ioutil.NopCloser(bytes.NewBufferString(logContent))
-						return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: body}, nil
-					default:
-						t.Errorf("%s: unexpected request: %#v\n%#v", test.name, req.URL, req)
-						return nil, nil
-					}
-				}),
-			}
-			tf.ClientConfigVal = defaultClientConfig()
-			oldLogFn := polymorphichelpers.LogsForObjectFn
-			defer func() {
-				polymorphichelpers.LogsForObjectFn = oldLogFn
-			}()
-			clientset, err := tf.ClientSet()
-			if err != nil {
-				t.Fatal(err)
-			}
-			polymorphichelpers.LogsForObjectFn = logTestMock{client: clientset}.logsForObject
-
 			streams, _, buf, _ := genericclioptions.NewTestIOStreams()
 
-			cmd := NewCmdLogs(tf, streams)
-			cmd.Flags().Set("namespace", "test")
-			cmd.Run(cmd, []string{"foo"})
+			mock := &logTestMock{
+				logsContent: logContent,
+			}
+
+			opts := NewLogsOptions(streams, false)
+			opts.Namespace = "test"
+			opts.Object = test.pod
+			opts.Options = &corev1.PodLogOptions{}
+			opts.LogsForObject = mock.mockLogsForObject
+			opts.ConsumeRequestFn = mock.mockConsumeRequest
+			opts.RunLogs()
 
 			if buf.String() != logContent {
 				t.Errorf("%s: did not get expected log content. Got: %s", test.name, buf.String())
@@ -104,13 +69,13 @@ func TestLog(t *testing.T) {
 	}
 }
 
-func testPod() *api.Pod {
-	return &api.Pod{
+func testPod() *corev1.Pod {
+	return &corev1.Pod{
 		ObjectMeta: metav1.ObjectMeta{Name: "foo", Namespace: "test", ResourceVersion: "10"},
-		Spec: api.PodSpec{
-			RestartPolicy: api.RestartPolicyAlways,
-			DNSPolicy:     api.DNSClusterFirst,
-			Containers: []api.Container{
+		Spec: corev1.PodSpec{
+			RestartPolicy: corev1.RestartPolicyAlways,
+			DNSPolicy:     corev1.DNSClusterFirst,
+			Containers: []corev1.Container{
 				{
 					Name: "bar",
 				},
@@ -119,66 +84,152 @@ func testPod() *api.Pod {
 	}
 }
 
-func TestValidateLogFlags(t *testing.T) {
+func TestValidateLogOptions(t *testing.T) {
 	f := cmdtesting.NewTestFactory()
 	defer f.Cleanup()
 	f.WithNamespace("")
 
 	tests := []struct {
 		name     string
-		flags    map[string]string
 		args     []string
+		opts     func(genericclioptions.IOStreams) *LogsOptions
 		expected string
 	}{
 		{
-			name:     "since & since-time",
-			flags:    map[string]string{"since": "1h", "since-time": "2006-01-02T15:04:05Z"},
+			name: "since & since-time",
+			opts: func(streams genericclioptions.IOStreams) *LogsOptions {
+				o := NewLogsOptions(streams, false)
+				o.SinceSeconds = time.Hour
+				o.SinceTime = "2006-01-02T15:04:05Z"
+
+				var err error
+				o.Options, err = o.ToLogOptions()
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+
+				return o
+			},
 			args:     []string{"foo"},
 			expected: "at most one of `sinceTime` or `sinceSeconds` may be specified",
 		},
 		{
-			name:     "negative since-time",
-			flags:    map[string]string{"since": "-1s"},
+			name: "negative since-time",
+			opts: func(streams genericclioptions.IOStreams) *LogsOptions {
+				o := NewLogsOptions(streams, false)
+				o.SinceSeconds = -1 * time.Second
+
+				var err error
+				o.Options, err = o.ToLogOptions()
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+
+				return o
+			},
 			args:     []string{"foo"},
 			expected: "must be greater than 0",
 		},
 		{
-			name:     "negative limit-bytes",
-			flags:    map[string]string{"limit-bytes": "-100"},
+			name: "negative limit-bytes",
+			opts: func(streams genericclioptions.IOStreams) *LogsOptions {
+				o := NewLogsOptions(streams, false)
+				o.LimitBytes = -100
+
+				var err error
+				o.Options, err = o.ToLogOptions()
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+
+				return o
+			},
 			args:     []string{"foo"},
 			expected: "must be greater than 0",
 		},
 		{
-			name:     "negative tail",
-			flags:    map[string]string{"tail": "-100"},
+			name: "negative tail",
+			opts: func(streams genericclioptions.IOStreams) *LogsOptions {
+				o := NewLogsOptions(streams, false)
+				o.Tail = -100
+
+				var err error
+				o.Options, err = o.ToLogOptions()
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+
+				return o
+			},
 			args:     []string{"foo"},
 			expected: "must be greater than or equal to 0",
 		},
 		{
-			name:     "container name combined with --all-containers",
-			flags:    map[string]string{"all-containers": "true"},
+			name: "container name combined with --all-containers",
+			opts: func(streams genericclioptions.IOStreams) *LogsOptions {
+				o := NewLogsOptions(streams, true)
+				o.Container = "my-container"
+
+				var err error
+				o.Options, err = o.ToLogOptions()
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+
+				return o
+			},
 			args:     []string{"my-pod", "my-container"},
 			expected: "--all-containers=true should not be specified with container",
 		},
+		{
+			name: "container name combined with second argument",
+			opts: func(streams genericclioptions.IOStreams) *LogsOptions {
+				o := NewLogsOptions(streams, false)
+				o.Container = "my-container"
+				o.ContainerNameSpecified = true
+
+				var err error
+				o.Options, err = o.ToLogOptions()
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+
+				return o
+			},
+			args:     []string{"my-pod", "my-container"},
+			expected: "only one of -c or an inline",
+		},
+		{
+			name: "follow and selector conflict",
+			opts: func(streams genericclioptions.IOStreams) *LogsOptions {
+				o := NewLogsOptions(streams, false)
+				o.Selector = "foo"
+				o.Follow = true
+
+				var err error
+				o.Options, err = o.ToLogOptions()
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+
+				return o
+			},
+			expected: "only one of follow (-f) or selector (-l) is allowed",
+		},
 	}
 	for _, test := range tests {
 		streams := genericclioptions.NewTestIOStreamsDiscard()
-		cmd := NewCmdLogs(f, streams)
-		out := ""
-		for flag, value := range test.flags {
-			cmd.Flags().Set(flag, value)
-		}
-		// checkErr breaks tests in case of errors, plus we just
-		// need to check errors returned by the command validation
-		o := NewLogsOptions(streams, test.flags["all-containers"] == "true")
-		cmd.Run = func(cmd *cobra.Command, args []string) {
-			o.Complete(f, cmd, args)
-			out = o.Validate().Error()
-		}
-		cmd.Run(cmd, test.args)
 
-		if !strings.Contains(out, test.expected) {
-			t.Errorf("%s: expected to find:\n\t%s\nfound:\n\t%s\n", test.name, test.expected, out)
+		o := test.opts(streams)
+		o.Resources = test.args
+
+		err := o.Validate()
+		if err == nil {
+			t.Fatalf("expected error %q, got none", test.expected)
+		}
+
+		if !strings.Contains(err.Error(), test.expected) {
+			t.Errorf("%s: expected to find:\n\t%s\nfound:\n\t%s\n", test.name, test.expected, err.Error())
 		}
 	}
 }
@@ -190,49 +241,32 @@ func TestLogComplete(t *testing.T) {
 	tests := []struct {
 		name     string
 		args     []string
-		flags    map[string]string
+		opts     func(genericclioptions.IOStreams) *LogsOptions
 		expected string
 	}{
 		{
-			name:     "No args case",
-			flags:    map[string]string{"selector": ""},
-			expected: "'logs (POD | TYPE/NAME) [CONTAINER_NAME]'.\nPOD or TYPE/NAME is a required argument for the logs command",
-		},
-		{
-			name:     "One args case",
-			args:     []string{"foo"},
-			flags:    map[string]string{"selector": "foo"},
+			name: "One args case",
+			args: []string{"foo"},
+			opts: func(streams genericclioptions.IOStreams) *LogsOptions {
+				o := NewLogsOptions(streams, false)
+				o.Selector = "foo"
+				return o
+			},
 			expected: "only a selector (-l) or a POD name is allowed",
 		},
-		{
-			name:     "Two args case",
-			args:     []string{"foo", "foo1"},
-			flags:    map[string]string{"container": "foo1"},
-			expected: "only one of -c or an inline [CONTAINER] arg is allowed",
-		},
-		{
-			name:     "More than two args case",
-			args:     []string{"foo", "foo1", "foo2"},
-			flags:    map[string]string{"tail": "1"},
-			expected: "'logs (POD | TYPE/NAME) [CONTAINER_NAME]'.\nPOD or TYPE/NAME is a required argument for the logs command",
-		},
-		{
-			name:     "follow and selecter conflict",
-			flags:    map[string]string{"selector": "foo", "follow": "true"},
-			expected: "only one of follow (-f) or selector (-l) is allowed",
-		},
 	}
 	for _, test := range tests {
 		cmd := NewCmdLogs(f, genericclioptions.NewTestIOStreamsDiscard())
-		var err error
 		out := ""
-		for flag, value := range test.flags {
-			cmd.Flags().Set(flag, value)
-		}
+
 		// checkErr breaks tests in case of errors, plus we just
 		// need to check errors returned by the command validation
-		o := NewLogsOptions(genericclioptions.NewTestIOStreamsDiscard(), false)
-		err = o.Complete(f, cmd, test.args)
+		o := test.opts(genericclioptions.NewTestIOStreamsDiscard())
+		err := o.Complete(f, cmd, test.args)
+		if err == nil {
+			t.Fatalf("expected error %q, got none", test.expected)
+		}
+
 		out = err.Error()
 		if !strings.Contains(out, test.expected) {
 			t.Errorf("%s: expected to find:\n\t%s\nfound:\n\t%s\n", test.name, test.expected, out)
@@ -241,17 +275,23 @@ func TestLogComplete(t *testing.T) {
 }
 
 type logTestMock struct {
-	client internalclientset.Interface
+	logsContent string
 }
 
-func (m logTestMock) logsForObject(restClientGetter genericclioptions.RESTClientGetter, object, options runtime.Object, timeout time.Duration) (*restclient.Request, error) {
-	switch t := object.(type) {
-	case *api.Pod:
-		opts, ok := options.(*api.PodLogOptions)
+func (l *logTestMock) mockConsumeRequest(req *restclient.Request, out io.Writer) error {
+	fmt.Fprintf(out, l.logsContent)
+	return nil
+}
+
+func (l *logTestMock) mockLogsForObject(restClientGetter genericclioptions.RESTClientGetter, object, options runtime.Object, timeout time.Duration, allContainers bool) ([]*restclient.Request, error) {
+	switch object.(type) {
+	case *corev1.Pod:
+		_, ok := options.(*corev1.PodLogOptions)
 		if !ok {
 			return nil, errors.New("provided options object is not a PodLogOptions")
 		}
-		return m.client.Core().Pods(t.Namespace).GetLogs(t.Name, opts), nil
+
+		return []*restclient.Request{{}}, nil
 	default:
 		return nil, fmt.Errorf("cannot get the logs from %T", object)
 	}