From d6d6229feac29747bd1abb92db0431279438d4af Mon Sep 17 00:00:00 2001 From: Daniel Smith Date: Mon, 10 Nov 2014 17:46:11 -0800 Subject: [PATCH 1/4] Actually let hack/e2e.go run kubectl --- hack/e2e.go | 47 ++++++++++++++++++++++++++++------------------- 1 file changed, 28 insertions(+), 19 deletions(-) diff --git a/hack/e2e.go b/hack/e2e.go index 71fdce49c3d..b922f073411 100644 --- a/hack/e2e.go +++ b/hack/e2e.go @@ -31,15 +31,19 @@ import ( ) var ( - isup = flag.Bool("isup", false, "Check to see if the e2e cluster is up, then exit.") - build = flag.Bool("build", false, "If true, build a new release. Otherwise, use whatever is there.") - up = flag.Bool("up", false, "If true, start the the e2e cluster. If cluster is already up, recreate it.") - push = flag.Bool("push", false, "If true, push to e2e cluster. Has no effect if -up is true.") - down = flag.Bool("down", false, "If true, tear down the cluster before exiting.") - test = flag.Bool("test", false, "Run all tests in hack/e2e-suite.") - tests = flag.String("tests", "", "Run only tests in hack/e2e-suite matching this glob. Ignored if -test is set.") - root = flag.String("root", absOrDie(filepath.Clean(filepath.Join(path.Base(os.Args[0]), ".."))), "Root directory of kubernetes repository.") - verbose = flag.Bool("v", false, "If true, print all command output.") + isup = flag.Bool("isup", false, "Check to see if the e2e cluster is up, then exit.") + build = flag.Bool("build", false, "If true, build a new release. Otherwise, use whatever is there.") + up = flag.Bool("up", false, "If true, start the the e2e cluster. If cluster is already up, recreate it.") + push = flag.Bool("push", false, "If true, push to e2e cluster. Has no effect if -up is true.") + down = flag.Bool("down", false, "If true, tear down the cluster before exiting.") + test = flag.Bool("test", false, "Run all tests in hack/e2e-suite.") + tests = flag.String("tests", "", "Run only tests in hack/e2e-suite matching this glob. Ignored if -test is set.") + root = flag.String("root", absOrDie(filepath.Clean(filepath.Join(path.Base(os.Args[0]), ".."))), "Root directory of kubernetes repository.") + verbose = flag.Bool("v", false, "If true, print all command output.") + checkVersionSkew = flag.Bool("check_version_skew", true, ""+ + "By default, verify that client and server have exact version match. "+ + "You can explicitly set to false if you're, e.g., testing client changes "+ + "for which the server version doesn't make a difference.") cfgCmd = flag.String("cfg", "", "If nonempty, pass this as an argument, and call kubecfg. Implies -v.") ctlCmd = flag.String("ctl", "", "If nonempty, pass this as an argument, and call kubectl. Implies -v. (-test, -cfg, -ctl are mutually exclusive)") @@ -95,7 +99,7 @@ func main() { case *cfgCmd != "": failure = !runBash("'kubecfg "+*cfgCmd+"'", "$KUBECFG "+*cfgCmd) case *ctlCmd != "": - failure = !runBash("'kubectl "+*ctlCmd+"'", "$KUBECFG "+*ctlCmd) + failure = !runBash("'kubectl "+*ctlCmd+"'", "$KUBECTL "+*ctlCmd) case *tests != "": failed, passed := Test() log.Printf("Passed tests: %v", passed) @@ -210,7 +214,17 @@ func finishRunning(stepName string, cmd *exec.Cmd) bool { return true } -var bashCommandPrefix = ` +// returns either "", or a list of args intended for appending with the +// kubecfg or kubectl commands (begining with a space). +func kubeClientArgs() string { + if *checkVersionSkew { + return " -expect_version_match" + } + return "" +} + +func bashWrap(cmd string) string { + return ` set -o errexit set -o nounset set -o pipefail @@ -219,7 +233,8 @@ export KUBE_CONFIG_FILE="config-test.sh" # TODO(jbeda): This will break on usage if there is a space in # ${KUBE_ROOT}. Covert to an array? Or an exported function? -export KUBECFG="` + *root + `/cluster/kubecfg.sh -expect_version_match" +export KUBECFG="` + *root + `/cluster/kubecfg.sh` + kubeClientArgs() + `" +export KUBECTL="` + *root + `/cluster/kubectl.sh` + kubeClientArgs() + `" source "` + *root + `/cluster/kube-env.sh" source "` + *root + `/cluster/${KUBERNETES_PROVIDER}/util.sh" @@ -228,12 +243,6 @@ if [[ ${KUBERNETES_PROVIDER} == "gce" ]]; then detect-project fi +` + cmd + ` ` - -var bashCommandSuffix = ` - -` - -func bashWrap(cmd string) string { - return bashCommandPrefix + cmd + bashCommandSuffix } From f1b0b64a755e6ff19d14e84606331cdf93c293b1 Mon Sep 17 00:00:00 2001 From: Daniel Smith Date: Mon, 10 Nov 2014 17:46:40 -0800 Subject: [PATCH 2/4] Add 'source' to events field selector. --- pkg/registry/event/rest.go | 3 +++ pkg/registry/event/rest_test.go | 4 ++++ 2 files changed, 7 insertions(+) diff --git a/pkg/registry/event/rest.go b/pkg/registry/event/rest.go index eb01f17950e..cb4b530b8ed 100644 --- a/pkg/registry/event/rest.go +++ b/pkg/registry/event/rest.go @@ -88,8 +88,10 @@ func (rs *REST) getAttrs(obj runtime.Object) (objLabels, objFields labels.Set, e if !ok { return nil, nil, fmt.Errorf("invalid object type") } + // TODO: internal version leaks through here. This should be versioned. return labels.Set{}, labels.Set{ "involvedObject.kind": event.InvolvedObject.Kind, + "involvedObject.namespace": event.InvolvedObject.Namespace, "involvedObject.name": event.InvolvedObject.Name, "involvedObject.uid": event.InvolvedObject.UID, "involvedObject.apiVersion": event.InvolvedObject.APIVersion, @@ -97,6 +99,7 @@ func (rs *REST) getAttrs(obj runtime.Object) (objLabels, objFields labels.Set, e "involvedObject.fieldPath": event.InvolvedObject.FieldPath, "status": event.Status, "reason": event.Reason, + "source": event.Source, }, nil } diff --git a/pkg/registry/event/rest_test.go b/pkg/registry/event/rest_test.go index 24748964c28..888cbd0a440 100644 --- a/pkg/registry/event/rest_test.go +++ b/pkg/registry/event/rest_test.go @@ -98,6 +98,7 @@ func TestRESTgetAttrs(t *testing.T) { InvolvedObject: api.ObjectReference{ Kind: "Pod", Name: "foo", + Namespace: "baz", UID: "long uid string", APIVersion: testapi.Version(), ResourceVersion: "0", @@ -105,6 +106,7 @@ func TestRESTgetAttrs(t *testing.T) { }, Status: "tested", Reason: "forTesting", + Source: "test", } label, field, err := rest.getAttrs(eventA) if err != nil { @@ -116,12 +118,14 @@ func TestRESTgetAttrs(t *testing.T) { expect := labels.Set{ "involvedObject.kind": "Pod", "involvedObject.name": "foo", + "involvedObject.namespace": "baz", "involvedObject.uid": "long uid string", "involvedObject.apiVersion": testapi.Version(), "involvedObject.resourceVersion": "0", "involvedObject.fieldPath": "", "status": "tested", "reason": "forTesting", + "source": "test", } if e, a := expect, field; !reflect.DeepEqual(e, a) { t.Errorf("diff: %s", util.ObjectDiff(e, a)) From 6fa6d3ee3e30ef6f19f059a0f45ae3835f2cd1cd Mon Sep 17 00:00:00 2001 From: Daniel Smith Date: Tue, 11 Nov 2014 15:29:01 -0800 Subject: [PATCH 3/4] kubectl resource printing: actually do versioned print --- pkg/kubectl/resource_printer.go | 35 ++++++++++++++------ pkg/kubectl/resource_printer_test.go | 48 +++++++++++++++++++++------- 2 files changed, 62 insertions(+), 21 deletions(-) diff --git a/pkg/kubectl/resource_printer.go b/pkg/kubectl/resource_printer.go index 1fa60a51dd2..ec2f1978338 100644 --- a/pkg/kubectl/resource_printer.go +++ b/pkg/kubectl/resource_printer.go @@ -37,6 +37,7 @@ import ( // GetPrinter returns a resource printer and a bool indicating whether the object must be // versioned for the given format. +// TODO: remove the 'versioned' return value, replace with method on ResourcePrinter. func GetPrinter(format, templateFile string, defaultPrinter ResourcePrinter) (ResourcePrinter, bool, error) { versioned := true var printer ResourcePrinter @@ -86,20 +87,41 @@ type JSONPrinter struct{} // PrintObj is an implementation of ResourcePrinter.PrintObj which simply writes the object to the Writer. func (i *JSONPrinter) PrintObj(obj runtime.Object, w io.Writer) error { - output, err := json.MarshalIndent(obj, "", " ") + data, err := latest.Codec.Encode(obj) if err != nil { return err } - _, err = fmt.Fprint(w, string(output)+"\n") + dst := bytes.Buffer{} + err = json.Indent(&dst, data, "", " ") + dst.WriteByte('\n') + _, err = w.Write(dst.Bytes()) return err } +func toVersionedMap(obj runtime.Object) (map[string]interface{}, error) { + data, err := latest.Codec.Encode(obj) + if err != nil { + return nil, err + } + outObj := map[string]interface{}{} + err = json.Unmarshal(data, &outObj) + if err != nil { + return nil, err + } + return outObj, nil +} + // YAMLPrinter is an implementation of ResourcePrinter which parsess JSON, and re-formats as YAML. type YAMLPrinter struct{} // PrintObj prints the data as YAML. func (y *YAMLPrinter) PrintObj(obj runtime.Object, w io.Writer) error { - output, err := yaml.Marshal(obj) + outObj, err := toVersionedMap(obj) + if err != nil { + return err + } + + output, err := yaml.Marshal(outObj) if err != nil { return err } @@ -328,12 +350,7 @@ func NewTemplatePrinter(tmpl []byte) (*TemplatePrinter, error) { // PrintObj formats the obj with the Go Template. func (t *TemplatePrinter) PrintObj(obj runtime.Object, w io.Writer) error { - data, err := latest.Codec.Encode(obj) - if err != nil { - return err - } - outObj := map[string]interface{}{} - err = json.Unmarshal(data, &outObj) + outObj, err := toVersionedMap(obj) if err != nil { return err } diff --git a/pkg/kubectl/resource_printer_test.go b/pkg/kubectl/resource_printer_test.go index fc7c6b6bd8d..b52580976a4 100644 --- a/pkg/kubectl/resource_printer_test.go +++ b/pkg/kubectl/resource_printer_test.go @@ -25,23 +25,33 @@ import ( "testing" "github.com/GoogleCloudPlatform/kubernetes/pkg/api" + "github.com/GoogleCloudPlatform/kubernetes/pkg/api/latest" + "github.com/GoogleCloudPlatform/kubernetes/pkg/util" + "gopkg.in/v1/yaml" ) type testStruct struct { - Key string `yaml:"Key" json:"Key"` - Map map[string]int `yaml:"Map" json:"Map"` - StringList []string `yaml:"StringList" json:"StringList"` - IntList []int `yaml:"IntList" json:"IntList"` + api.TypeMeta `yaml:",inline" json:",inline"` + api.ObjectMeta `yaml:"metadata,omitempty" json:"metadata,omitempty"` + Key string `yaml:"Key" json:"Key"` + Map map[string]int `yaml:"Map" json:"Map"` + StringList []string `yaml:"StringList" json:"StringList"` + IntList []int `yaml:"IntList" json:"IntList"` } func (ts *testStruct) IsAnAPIObject() {} +func init() { + api.Scheme.AddKnownTypes("", &testStruct{}) + api.Scheme.AddKnownTypes(latest.Version, &testStruct{}) +} + var testData = testStruct{ - "testValue", - map[string]int{"TestSubkey": 1}, - []string{"a", "b", "c"}, - []int{1, 2, 3}, + Key: "testValue", + Map: map[string]int{"TestSubkey": 1}, + StringList: []string{"a", "b", "c"}, + IntList: []int{1, 2, 3}, } func TestYAMLPrinter(t *testing.T) { @@ -128,12 +138,19 @@ func testPrinter(t *testing.T, printer ResourcePrinter, unmarshalFunc func(data t.Fatal(err) } var poutput testStruct - err = yaml.Unmarshal(buf.Bytes(), &poutput) + // Verify that given function runs without error. + err = unmarshalFunc(buf.Bytes(), &poutput) + if err != nil { + t.Fatal(err) + } + // Use real decode function to undo the versioning process. + poutput = testStruct{} + err = latest.Codec.DecodeInto(buf.Bytes(), &poutput) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(testData, poutput) { - t.Errorf("Test data and unmarshaled data are not equal: %#v vs %#v", poutput, testData) + t.Errorf("Test data and unmarshaled data are not equal: %v", util.ObjectDiff(poutput, testData)) } obj := &api.Pod{ @@ -142,12 +159,19 @@ func testPrinter(t *testing.T, printer ResourcePrinter, unmarshalFunc func(data buf.Reset() printer.PrintObj(obj, buf) var objOut api.Pod - err = yaml.Unmarshal([]byte(buf.String()), &objOut) + // Verify that given function runs without error. + err = unmarshalFunc(buf.Bytes(), &objOut) if err != nil { t.Errorf("Unexpeted error: %#v", err) } + // Use real decode function to undo the versioning process. + objOut = api.Pod{} + err = latest.Codec.DecodeInto(buf.Bytes(), &objOut) + if err != nil { + t.Fatal(err) + } if !reflect.DeepEqual(obj, &objOut) { - t.Errorf("Unexpected inequality:\n%#v \nvs\n%#v", obj, &objOut) + t.Errorf("Unexpected inequality:\n%v", util.ObjectDiff(obj, &objOut)) } } From a198a620640688222fc5900334ba3316bcf3ef2b Mon Sep 17 00:00:00 2001 From: Daniel Smith Date: Tue, 11 Nov 2014 16:15:22 -0800 Subject: [PATCH 4/4] refactor resource printer's version handling (to make adding --watch feature easier) --- pkg/kubectl/cmd/get.go | 16 ++---- pkg/kubectl/resource_printer.go | 81 ++++++++++++++++++---------- pkg/kubectl/resource_printer_test.go | 28 +++++----- 3 files changed, 74 insertions(+), 51 deletions(-) diff --git a/pkg/kubectl/cmd/get.go b/pkg/kubectl/cmd/get.go index ea1f4dc0930..fd0af00c6a8 100644 --- a/pkg/kubectl/cmd/get.go +++ b/pkg/kubectl/cmd/get.go @@ -61,22 +61,16 @@ Examples: defaultPrinter, err := f.Printer(cmd, mapping, GetFlagBool(cmd, "no-headers")) checkErr(err) - printer, versioned, err := kubectl.GetPrinter(outputFormat, templateFile, defaultPrinter) + outputVersion := GetFlagString(cmd, "output-version") + if len(outputVersion) == 0 { + outputVersion = mapping.APIVersion + } + printer, err := kubectl.GetPrinter(outputVersion, outputFormat, templateFile, defaultPrinter) checkErr(err) obj, err := kubectl.NewRESTHelper(client, mapping).Get(namespace, name, labels) checkErr(err) - if versioned { - outputVersion := GetFlagString(cmd, "output-version") - if len(outputVersion) == 0 { - outputVersion = mapping.APIVersion - } - - obj, err = mapping.ObjectConvertor.ConvertToVersion(obj, outputVersion) - checkErr(err) - } - if err := printer.PrintObj(obj, out); err != nil { checkErr(fmt.Errorf("Unable to output the provided object: %v", err)) } diff --git a/pkg/kubectl/resource_printer.go b/pkg/kubectl/resource_printer.go index ec2f1978338..9f55f84d629 100644 --- a/pkg/kubectl/resource_printer.go +++ b/pkg/kubectl/resource_printer.go @@ -37,57 +37,64 @@ import ( // GetPrinter returns a resource printer and a bool indicating whether the object must be // versioned for the given format. -// TODO: remove the 'versioned' return value, replace with method on ResourcePrinter. -func GetPrinter(format, templateFile string, defaultPrinter ResourcePrinter) (ResourcePrinter, bool, error) { - versioned := true +func GetPrinter(version, format, templateFile string, defaultPrinter ResourcePrinter) (ResourcePrinter, error) { var printer ResourcePrinter switch format { case "json": - printer = &JSONPrinter{} + printer = &JSONPrinter{version} case "yaml": - printer = &YAMLPrinter{} + printer = &YAMLPrinter{version} case "template": if len(templateFile) == 0 { - return nil, false, fmt.Errorf("template format specified but no template given") + return nil, fmt.Errorf("template format specified but no template given") } var err error - printer, err = NewTemplatePrinter([]byte(templateFile)) + printer, err = NewTemplatePrinter(version, []byte(templateFile)) if err != nil { - return nil, false, fmt.Errorf("error parsing template %s, %v\n", templateFile, err) + return nil, fmt.Errorf("error parsing template %s, %v\n", templateFile, err) } case "templatefile": if len(templateFile) == 0 { - return nil, false, fmt.Errorf("templatefile format specified but no template file given") + return nil, fmt.Errorf("templatefile format specified but no template file given") } data, err := ioutil.ReadFile(templateFile) if err != nil { - return nil, false, fmt.Errorf("error reading template %s, %v\n", templateFile, err) + return nil, fmt.Errorf("error reading template %s, %v\n", templateFile, err) } - printer, err = NewTemplatePrinter(data) + printer, err = NewTemplatePrinter(version, data) if err != nil { - return nil, false, fmt.Errorf("error parsing template %s, %v\n", string(data), err) + return nil, fmt.Errorf("error parsing template %s, %v\n", string(data), err) } case "": printer = defaultPrinter - versioned = false default: - return nil, false, fmt.Errorf("output format %q not recognized", format) + return nil, fmt.Errorf("output format %q not recognized", format) } - return printer, versioned, nil + return printer, nil } // ResourcePrinter is an interface that knows how to print API resources. type ResourcePrinter interface { // Print receives an arbitrary object, formats it and prints it to a writer. PrintObj(runtime.Object, io.Writer) error + + // Returns true if this printer emits properly versioned output. + IsVersioned() bool } -// IdentityPrinter is an implementation of ResourcePrinter which simply copies the body out to the output stream. -type JSONPrinter struct{} +// JSONPrinter is an implementation of ResourcePrinter which prints as JSON. +type JSONPrinter struct { + version string +} // PrintObj is an implementation of ResourcePrinter.PrintObj which simply writes the object to the Writer. -func (i *JSONPrinter) PrintObj(obj runtime.Object, w io.Writer) error { - data, err := latest.Codec.Encode(obj) +func (j *JSONPrinter) PrintObj(obj runtime.Object, w io.Writer) error { + vi, err := latest.InterfacesFor(j.version) + if err != nil { + return err + } + + data, err := vi.Codec.Encode(obj) if err != nil { return err } @@ -98,8 +105,16 @@ func (i *JSONPrinter) PrintObj(obj runtime.Object, w io.Writer) error { return err } -func toVersionedMap(obj runtime.Object) (map[string]interface{}, error) { - data, err := latest.Codec.Encode(obj) +// IsVersioned returns true. +func (*JSONPrinter) IsVersioned() bool { return true } + +func toVersionedMap(version string, obj runtime.Object) (map[string]interface{}, error) { + vi, err := latest.InterfacesFor(version) + if err != nil { + return nil, err + } + + data, err := vi.Codec.Encode(obj) if err != nil { return nil, err } @@ -111,12 +126,14 @@ func toVersionedMap(obj runtime.Object) (map[string]interface{}, error) { return outObj, nil } -// YAMLPrinter is an implementation of ResourcePrinter which parsess JSON, and re-formats as YAML. -type YAMLPrinter struct{} +// YAMLPrinter is an implementation of ResourcePrinter which prints as YAML. +type YAMLPrinter struct { + version string +} // PrintObj prints the data as YAML. func (y *YAMLPrinter) PrintObj(obj runtime.Object, w io.Writer) error { - outObj, err := toVersionedMap(obj) + outObj, err := toVersionedMap(y.version, obj) if err != nil { return err } @@ -129,6 +146,9 @@ func (y *YAMLPrinter) PrintObj(obj runtime.Object, w io.Writer) error { return err } +// IsVersioned returns true. +func (*YAMLPrinter) IsVersioned() bool { return true } + type handlerEntry struct { columns []string printFunc reflect.Value @@ -140,6 +160,9 @@ type HumanReadablePrinter struct { noHeaders bool } +// IsVersioned returns false-- human readable printers do not make versioned output. +func (*HumanReadablePrinter) IsVersioned() bool { return false } + // NewHumanReadablePrinter creates a HumanReadablePrinter. func NewHumanReadablePrinter(noHeaders bool) *HumanReadablePrinter { printer := &HumanReadablePrinter{ @@ -337,20 +360,24 @@ func (h *HumanReadablePrinter) PrintObj(obj runtime.Object, output io.Writer) er // TemplatePrinter is an implementation of ResourcePrinter which formats data with a Go Template. type TemplatePrinter struct { + version string template *template.Template } -func NewTemplatePrinter(tmpl []byte) (*TemplatePrinter, error) { +func NewTemplatePrinter(version string, tmpl []byte) (*TemplatePrinter, error) { t, err := template.New("output").Parse(string(tmpl)) if err != nil { return nil, err } - return &TemplatePrinter{t}, nil + return &TemplatePrinter{version, t}, nil } +// IsVersioned returns true. +func (*TemplatePrinter) IsVersioned() bool { return true } + // PrintObj formats the obj with the Go Template. func (t *TemplatePrinter) PrintObj(obj runtime.Object, w io.Writer) error { - outObj, err := toVersionedMap(obj) + outObj, err := toVersionedMap(t.version, obj) if err != nil { return err } diff --git a/pkg/kubectl/resource_printer_test.go b/pkg/kubectl/resource_printer_test.go index b52580976a4..ac34c32c42e 100644 --- a/pkg/kubectl/resource_printer_test.go +++ b/pkg/kubectl/resource_printer_test.go @@ -42,9 +42,11 @@ type testStruct struct { func (ts *testStruct) IsAnAPIObject() {} +const TestVersion = latest.Version + func init() { api.Scheme.AddKnownTypes("", &testStruct{}) - api.Scheme.AddKnownTypes(latest.Version, &testStruct{}) + api.Scheme.AddKnownTypes(TestVersion, &testStruct{}) } var testData = testStruct{ @@ -55,20 +57,20 @@ var testData = testStruct{ } func TestYAMLPrinter(t *testing.T) { - testPrinter(t, &YAMLPrinter{}, yaml.Unmarshal) + testPrinter(t, &YAMLPrinter{TestVersion}, yaml.Unmarshal) } func TestJSONPrinter(t *testing.T) { - testPrinter(t, &JSONPrinter{}, json.Unmarshal) + testPrinter(t, &JSONPrinter{TestVersion}, json.Unmarshal) } func TestPrintJSON(t *testing.T) { buf := bytes.NewBuffer([]byte{}) - printer, versioned, err := GetPrinter("json", "", nil) + printer, err := GetPrinter(TestVersion, "json", "", nil) if err != nil { t.Errorf("unexpected error: %#v", err) } - if !versioned { + if !printer.IsVersioned() { t.Errorf("printer should be versioned") } printer.PrintObj(&api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}, buf) @@ -80,11 +82,11 @@ func TestPrintJSON(t *testing.T) { func TestPrintYAML(t *testing.T) { buf := bytes.NewBuffer([]byte{}) - printer, versioned, err := GetPrinter("yaml", "", nil) + printer, err := GetPrinter(TestVersion, "yaml", "", nil) if err != nil { t.Errorf("unexpected error: %#v", err) } - if !versioned { + if !printer.IsVersioned() { t.Errorf("printer should be versioned") } printer.PrintObj(&api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}, buf) @@ -96,11 +98,11 @@ func TestPrintYAML(t *testing.T) { func TestPrintTemplate(t *testing.T) { buf := bytes.NewBuffer([]byte{}) - printer, versioned, err := GetPrinter("template", "{{.id}}", nil) + printer, err := GetPrinter(TestVersion, "template", "{{.id}}", nil) if err != nil { t.Fatalf("unexpected error: %#v", err) } - if !versioned { + if !printer.IsVersioned() { t.Errorf("printer should be versioned") } err = printer.PrintObj(&api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}, buf) @@ -113,19 +115,19 @@ func TestPrintTemplate(t *testing.T) { } func TestPrintEmptyTemplate(t *testing.T) { - if _, _, err := GetPrinter("template", "", nil); err == nil { + if _, err := GetPrinter(TestVersion, "template", "", nil); err == nil { t.Errorf("unexpected non-error") } } func TestPrintBadTemplate(t *testing.T) { - if _, _, err := GetPrinter("template", "{{ .Name", nil); err == nil { + if _, err := GetPrinter(TestVersion, "template", "{{ .Name", nil); err == nil { t.Errorf("unexpected non-error") } } func TestPrintBadTemplateFile(t *testing.T) { - if _, _, err := GetPrinter("templatefile", "", nil); err == nil { + if _, err := GetPrinter(TestVersion, "templatefile", "", nil); err == nil { t.Errorf("unexpected non-error") } } @@ -234,7 +236,7 @@ func TestUnknownTypePrinting(t *testing.T) { func TestTemplateEmitsVersionedObjects(t *testing.T) { // kind is always blank in memory and set on the wire - printer, err := NewTemplatePrinter([]byte(`{{.kind}}`)) + printer, err := NewTemplatePrinter(TestVersion, []byte(`{{.kind}}`)) if err != nil { t.Fatalf("tmpl fail: %v", err) }