mirror of https://github.com/knative/client.git
136 lines
3.7 KiB
Go
136 lines
3.7 KiB
Go
// Copyright © 2018 The Knative 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 version
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"testing"
|
|
"text/template"
|
|
|
|
"github.com/spf13/cobra"
|
|
"gotest.tools/v3/assert"
|
|
"sigs.k8s.io/yaml"
|
|
|
|
"knative.dev/client/pkg/commands"
|
|
"knative.dev/client/pkg/util"
|
|
)
|
|
|
|
var versionOutputTemplate = `Version: {{.Version}}
|
|
Build Date: {{.BuildDate}}
|
|
Git Revision: {{.GitRevision}}
|
|
Supported APIs:
|
|
* Serving{{range $apis := .SupportedAPIs.serving }}
|
|
- {{$apis}}{{end}}
|
|
* Eventing{{range $apis := .SupportedAPIs.eventing }}
|
|
- {{$apis}}{{end}}
|
|
`
|
|
|
|
const (
|
|
fakeVersion = "fake-version"
|
|
fakeBuildDate = "fake-build-date"
|
|
fakeGitRevision = "fake-git-revision"
|
|
)
|
|
|
|
var apiVersions = map[string][]string{
|
|
"serving": {
|
|
fmt.Sprintf("serving.knative.dev/v1 (knative-serving %s)", VersionServing),
|
|
},
|
|
"eventing": {
|
|
fmt.Sprintf("sources.knative.dev/v1 (knative-eventing %s)", VersionEventing),
|
|
fmt.Sprintf("eventing.knative.dev/v1 (knative-eventing %s)", VersionEventing),
|
|
},
|
|
}
|
|
|
|
func TestVersion(t *testing.T) {
|
|
var (
|
|
versionCmd *cobra.Command
|
|
knParams *commands.KnParams
|
|
expectedOutput string
|
|
knVersionObj knVersion
|
|
output *bytes.Buffer
|
|
)
|
|
|
|
setup := func() {
|
|
Version = fakeVersion
|
|
BuildDate = fakeBuildDate
|
|
GitRevision = fakeGitRevision
|
|
knVersionObj = knVersion{fakeVersion, fakeBuildDate, fakeGitRevision, apiVersions}
|
|
expectedOutput = genVersionOutput(t, knVersionObj)
|
|
knParams = &commands.KnParams{}
|
|
versionCmd = NewVersionCommand(knParams)
|
|
output = new(bytes.Buffer)
|
|
versionCmd.SetOutput(output)
|
|
}
|
|
|
|
runVersionCmd := func(args []string) error {
|
|
setup()
|
|
versionCmd.SetArgs(args)
|
|
return versionCmd.Execute()
|
|
}
|
|
|
|
t.Run("creates a VersionCommand", func(t *testing.T) {
|
|
setup()
|
|
assert.Equal(t, versionCmd.Use, "version")
|
|
assert.Assert(t, util.ContainsAll(versionCmd.Short, "version"))
|
|
assert.Assert(t, versionCmd.RunE != nil)
|
|
})
|
|
|
|
t.Run("prints version, build date, git revision, supported APIs", func(t *testing.T) {
|
|
err := runVersionCmd([]string{})
|
|
assert.NilError(t, err)
|
|
assert.Equal(t, output.String(), expectedOutput)
|
|
})
|
|
|
|
t.Run("print version command with machine readable output", func(t *testing.T) {
|
|
t.Run("json", func(t *testing.T) {
|
|
err := runVersionCmd([]string{"-oJSON"})
|
|
assert.NilError(t, err)
|
|
in := knVersion{}
|
|
err = json.Unmarshal(output.Bytes(), &in)
|
|
assert.NilError(t, err)
|
|
assert.DeepEqual(t, in, knVersionObj)
|
|
})
|
|
|
|
t.Run("yaml", func(t *testing.T) {
|
|
err := runVersionCmd([]string{"-oyaml"})
|
|
assert.NilError(t, err)
|
|
jsonData, err := yaml.YAMLToJSON(output.Bytes())
|
|
assert.NilError(t, err)
|
|
in := knVersion{}
|
|
err = json.Unmarshal(jsonData, &in)
|
|
assert.NilError(t, err)
|
|
assert.DeepEqual(t, in, knVersionObj)
|
|
})
|
|
|
|
t.Run("invalid format", func(t *testing.T) {
|
|
err := runVersionCmd([]string{"-o", "jsonpath"})
|
|
assert.Assert(t, err != nil)
|
|
assert.ErrorContains(t, err, "invalid", "output", "flag", "choose", "among")
|
|
})
|
|
})
|
|
|
|
}
|
|
|
|
func genVersionOutput(t *testing.T, obj knVersion) string {
|
|
tmpl, err := template.New("versionOutput").Parse(versionOutputTemplate)
|
|
assert.NilError(t, err)
|
|
buf := bytes.Buffer{}
|
|
err = tmpl.Execute(&buf, obj)
|
|
assert.NilError(t, err)
|
|
return buf.String()
|
|
}
|