feat: add version command output fields

Author: huhouhua

cmd/kops/version.go

@@ -18,9 +18,12 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 
+	"sigs.k8s.io/yaml"
+
 	"github.com/spf13/cobra"
 	"k8s.io/kops"
 	"k8s.io/kops/cmd/kops/util"
@@ -57,6 +60,7 @@ func NewCmdVersion(f *util.Factory, out io.Writer) *cobra.Command {
 
 	cmd.Flags().BoolVar(&options.short, "short", options.short, "only print the main kOps version. Useful for scripting.")
 	cmd.Flags().BoolVar(&options.server, "server", options.server, "show the kOps version that made the last change to the state store.")
+	cmd.Flags().StringVarP(&options.Output, "output", "o", options.Output, "One of 'yaml' or 'json'.")
 
 	return cmd
 }
@@ -65,43 +69,69 @@ type VersionOptions struct {
 	short       bool
 	server      bool
 	ClusterName string
+	Output      string
+}
+
+// Version is a struct for version information
+type Version struct {
+	ClientVersion *kops.Info `json:"clientVersion,omitempty" yaml:"clientVersion,omitempty"`
+	ServerVersion string     `json:"serverVersion,omitempty" yaml:"serverVersion,omitempty"`
 }
 
 // RunVersion implements the version command logic
 func RunVersion(f *util.Factory, out io.Writer, options *VersionOptions) error {
-	if options.short {
-		s := kops.Version
-		_, err := fmt.Fprintf(out, "%s\n", s)
-		if err != nil {
-			return err
-		}
-		if options.server {
-			server := serverVersion(f, options)
-
-			_, err := fmt.Fprintf(out, "%s\n", server)
-			return err
-		}
-
-		return nil
-	} else {
-		client := kops.Version
-		if kops.GitVersion != "" {
-			client += " (git-" + kops.GitVersion + ")"
-		}
-
-		{
-			_, err := fmt.Fprintf(out, "Client version: %s\n", client)
+	var versionInfo Version
+	clientVersion := kops.Get()
+	versionInfo.ClientVersion = &clientVersion
+	if options.server {
+		versionInfo.ServerVersion = serverVersion(f, options)
+	}
+	switch options.Output {
+	case "":
+		if options.short {
+			_, err := fmt.Fprintf(out, "%s\n", versionInfo.ClientVersion.Version)
 			if err != nil {
 				return err
 			}
-		}
-		if options.server {
-			server := serverVersion(f, options)
+			if options.server {
+				_, err := fmt.Fprintf(out, "%s\n", versionInfo.ServerVersion)
+				return err
+			}
+			return nil
+		} else {
+			client := versionInfo.ClientVersion.Version
+			if versionInfo.ClientVersion.GitVersion != "" {
+				client += " (git-" + versionInfo.ClientVersion.GitVersion + ")"
+			}
 
-			_, err := fmt.Fprintf(out, "Last applied server version: %s\n", server)
+			{
+				_, err := fmt.Fprintf(out, "Client Version: %s\n", client)
+				if err != nil {
+					return err
+				}
+			}
+			if options.server {
+				_, err := fmt.Fprintf(out, "Last applied server version: %s\n", versionInfo.ServerVersion)
+				return err
+			}
+			return nil
+		}
+	case OutputYaml:
+		marshalled, err := yaml.Marshal(&versionInfo)
+		if err != nil {
+			return err
+		}
+		_, err = fmt.Fprintln(out, string(marshalled))
+		return err
+	case OutputJSON:
+		marshalled, err := json.MarshalIndent(&versionInfo, "", "  ")
+		if err != nil {
 			return err
 		}
-		return nil
+		_, err = fmt.Fprintln(out, string(marshalled))
+		return err
+	default:
+		return fmt.Errorf("VersionOptions were not validated: --output=%q should have been rejected", options.Output)
 	}
 }
 

cmd/kops/version_test.go

@@ -0,0 +1,86 @@
+/*
+Copyright 2019 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 main
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"k8s.io/kops/cmd/kops/util"
+	"testing"
+)
+
+func TestRunVersion(t *testing.T) {
+	factoryOptions := &util.FactoryOptions{}
+	factory := util.NewFactory(factoryOptions)
+
+	tests := []struct {
+		name           string
+		opt            *VersionOptions
+		expectedOutput string
+		wantErr        error
+	}{
+		{
+			name: "client Version",
+			opt: &VersionOptions{
+				Output: "",
+			},
+			expectedOutput: "Client Version",
+		},
+		{
+			name: "output yaml format",
+			opt: &VersionOptions{
+				Output: OutputYaml,
+			},
+			expectedOutput: "clientVersion",
+		},
+		{
+			name: "output json format",
+			opt: &VersionOptions{
+				Output: OutputJSON,
+			},
+			expectedOutput: "\"clientVersion\"",
+		},
+		{
+			name: "unknown output format",
+			opt: &VersionOptions{
+				Output: "Xml",
+			},
+			wantErr: fmt.Errorf("VersionOptions were not validated: --output=%q should have been rejected", "Xml"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var stdout bytes.Buffer
+			err := RunVersion(factory, &stdout, tt.opt)
+			require.Equal(t, tt.wantErr, err)
+			if err != nil {
+				return
+			}
+			assert.Containsf(
+				t,
+				stdout.String(),
+				tt.expectedOutput,
+				"%s : Unexpected output! Expected\n%s\ngot\n%s",
+				tt.name,
+				tt.expectedOutput,
+				stdout,
+			)
+		})
+	}
+}