// Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get. func TestGetUnknownSchemaObject(t *testing.T) { f, tf, codec, ns := cmdtesting.NewTestFactory() tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ NegotiatedSerializer: ns, Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalType("", "", "foo"))}, } tf.Namespace = "test" tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: ®istered.GroupOrDie(api.GroupName).GroupVersion}} buf := bytes.NewBuffer([]byte{}) errBuf := bytes.NewBuffer([]byte{}) cmd := NewCmdGet(f, buf, errBuf) cmd.SetOutput(buf) cmd.Run(cmd, []string{"type", "foo"}) expected := cmdtesting.NewInternalType("", "", "foo") actual := tf.Printer.(*testPrinter).Objects[0] if !reflect.DeepEqual(expected, actual) { t.Errorf("unexpected object: %#v", actual) } if buf.String() != fmt.Sprintf("%#v", expected) { t.Errorf("unexpected output: %s", buf.String()) } }
// Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get. func TestGetUnknownSchemaObject(t *testing.T) { f, tf, _, _ := cmdtesting.NewAPIFactory() _, _, codec, _ := cmdtesting.NewTestFactory() tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ NegotiatedSerializer: unstructuredSerializer, Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalType("", "", "foo"))}, } tf.Namespace = "test" tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: ®istered.GroupOrDie(api.GroupName).GroupVersion}} buf := bytes.NewBuffer([]byte{}) errBuf := bytes.NewBuffer([]byte{}) cmd := NewCmdGet(f, buf, errBuf) cmd.SetOutput(buf) cmd.Run(cmd, []string{"type", "foo"}) expected := []runtime.Object{cmdtesting.NewInternalType("", "", "foo")} actual := tf.Printer.(*testPrinter).Objects if len(actual) != len(expected) { t.Fatal(actual) } for i, obj := range actual { expectedJSON := runtime.EncodeOrDie(codec, expected[i]) expectedMap := map[string]interface{}{} if err := encjson.Unmarshal([]byte(expectedJSON), &expectedMap); err != nil { t.Fatal(err) } actualJSON := runtime.EncodeOrDie(api.Codecs.LegacyCodec(), obj) actualMap := map[string]interface{}{} if err := encjson.Unmarshal([]byte(actualJSON), &actualMap); err != nil { t.Fatal(err) } if !reflect.DeepEqual(expectedMap, actualMap) { t.Errorf("unexpected object: \n%#v\n%#v", expectedMap, actualMap) } } }
func TestRunValidations(t *testing.T) { tests := []struct { args []string flags map[string]string expectedErr string }{ { expectedErr: "NAME is required", }, { args: []string{"test"}, expectedErr: "Invalid image name", }, { args: []string{"test"}, flags: map[string]string{ "image": "busybox", "stdin": "true", "replicas": "2", }, expectedErr: "stdin requires that replicas is 1", }, { args: []string{"test"}, flags: map[string]string{ "image": "busybox", "rm": "true", }, expectedErr: "rm should only be used for attached containers", }, { args: []string{"test"}, flags: map[string]string{ "image": "busybox", "attach": "true", "dry-run": "true", }, expectedErr: "can't be used with attached containers options", }, { args: []string{"test"}, flags: map[string]string{ "image": "busybox", "stdin": "true", "dry-run": "true", }, expectedErr: "can't be used with attached containers options", }, { args: []string{"test"}, flags: map[string]string{ "image": "busybox", "tty": "true", "stdin": "true", "dry-run": "true", }, expectedErr: "can't be used with attached containers options", }, { args: []string{"test"}, flags: map[string]string{ "image": "busybox", "tty": "true", }, expectedErr: "stdin is required for containers with -t/--tty", }, } for _, test := range tests { f, tf, codec, ns := cmdtesting.NewTestFactory() tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ NegotiatedSerializer: ns, Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalType("", "", ""))}, } tf.Namespace = "test" tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: &schema.GroupVersion{Version: "v1"}}} inBuf := bytes.NewReader([]byte{}) outBuf := bytes.NewBuffer([]byte{}) errBuf := bytes.NewBuffer([]byte{}) cmd := NewCmdRun(f, inBuf, outBuf, errBuf) for flagName, flagValue := range test.flags { cmd.Flags().Set(flagName, flagValue) } err := Run(f, inBuf, outBuf, errBuf, cmd, test.args, cmd.ArgsLenAtDash()) if err != nil && len(test.expectedErr) > 0 { if !strings.Contains(err.Error(), test.expectedErr) { t.Errorf("unexpected error: %v", err) } } } }
// Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get. func TestDescribeUnknownSchemaObject(t *testing.T) { d := &testDescriber{Output: "test output"} f, tf, codec, ns := cmdtesting.NewTestFactory() tf.Describer = d tf.Client = &fake.RESTClient{ NegotiatedSerializer: ns, Resp: &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalType("", "", "foo"))}, } tf.Namespace = "non-default" buf := bytes.NewBuffer([]byte{}) buferr := bytes.NewBuffer([]byte{}) cmd := NewCmdDescribe(f, buf, buferr) cmd.Run(cmd, []string{"type", "foo"}) if d.Name != "foo" || d.Namespace != "non-default" { t.Errorf("unexpected describer: %#v", d) } if buf.String() != fmt.Sprintf("%s", d.Output) { t.Errorf("unexpected output: %s", buf.String()) } }
// Verifies that schemas that are not in the master tree of Kubernetes can be retrieved via Get. // Because api.List is part of the Kube API, resource.Builder has to perform a conversion on // api.Scheme, which may not have access to all objects, and not all objects are at the same // internal versioning scheme. This test verifies that two isolated schemes (Test, and api.Scheme) // can be conjoined into a single output object. // // The expected behavior of the `kubectl get` command is: // 1. objects using unrecognized schemes will always be returned using that scheme/version, "unlikelyversion" in this test; // 2. if the specified output-version is a recognized, valid Scheme, then the list should use that scheme, and otherwise it will default to the client version, registered.GroupOrDie(api.GroupName).GroupVersion.String() in this test; // 3a. if the specified output-version is a recognized, valid Scheme, in which the requested object (replicationcontroller) can be represented, then the object should be returned using that version; // 3b. otherwise if the specified output-version is unrecognized, but the requested object (replicationcontroller) is recognized by the client's codec, then it will be converted to the client version, registered.GroupOrDie(api.GroupName).GroupVersion.String() in this test. func TestGetUnknownSchemaObjectListGeneric(t *testing.T) { testCases := map[string]struct { outputVersion string listVersion string testtypeVersion string rcVersion string }{ "handles specific version": { outputVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(), listVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(), testtypeVersion: cmdtesting.UnlikelyGV.String(), rcVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(), }, "handles second specific version": { outputVersion: "unlikely.group/unlikelyversion", listVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(), testtypeVersion: cmdtesting.UnlikelyGV.String(), rcVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(), // see expected behavior 3b }, "handles common version": { outputVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(), listVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(), testtypeVersion: cmdtesting.UnlikelyGV.String(), rcVersion: registered.GroupOrDie(api.GroupName).GroupVersion.String(), }, } for k, test := range testCases { apiCodec := testapi.Default.Codec() apiNegotiatedSerializer := testapi.Default.NegotiatedSerializer() regularClient := &fake.RESTClient{ NegotiatedSerializer: apiNegotiatedSerializer, Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(apiCodec, &api.ReplicationController{ObjectMeta: api.ObjectMeta{Name: "foo"}})}, nil }), } f, tf, codec := cmdtesting.NewMixedFactory(regularClient) negotiatedSerializer := serializer.NegotiatedSerializerWrapper(runtime.SerializerInfo{Serializer: codec}) tf.Printer = &testPrinter{} tf.Client = &fake.RESTClient{ NegotiatedSerializer: negotiatedSerializer, Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, cmdtesting.NewInternalType("", "", "foo"))}, nil }), } tf.Namespace = "test" tf.ClientConfig = &restclient.Config{ContentConfig: restclient.ContentConfig{GroupVersion: ®istered.GroupOrDie(api.GroupName).GroupVersion}} buf := bytes.NewBuffer([]byte{}) errBuf := bytes.NewBuffer([]byte{}) cmd := NewCmdGet(f, buf, errBuf) cmd.SetOutput(buf) cmd.Flags().Set("output", "json") cmd.Flags().Set("output-version", test.outputVersion) err := RunGet(f, buf, errBuf, cmd, []string{"type/foo", "replicationcontrollers/foo"}, &GetOptions{}) if err != nil { t.Errorf("%s: unexpected error: %v", k, err) continue } out := make(map[string]interface{}) if err := encjson.Unmarshal(buf.Bytes(), &out); err != nil { t.Errorf("%s: unexpected error: %v\n%s", k, err, buf.String()) continue } if out["apiVersion"] != test.listVersion { t.Errorf("%s: unexpected list: %#v", k, out) } arr := out["items"].([]interface{}) if arr[0].(map[string]interface{})["apiVersion"] != test.testtypeVersion { t.Errorf("%s: unexpected list: %#v", k, out) } if arr[1].(map[string]interface{})["apiVersion"] != test.rcVersion { t.Errorf("%s: unexpected list: %#v", k, out) } } }