check / check (push) Waiting to run
The flag is defined on the root command rather than enabled through cobra's Version field: cobra's flag prints a one-line template, not the full report that `vaultik version` prints. Model: opus-5-5
139 lines
3.9 KiB
Go
139 lines
3.9 KiB
Go
package cli_test
|
|
|
|
import (
|
|
"bytes"
|
|
"runtime"
|
|
"strings"
|
|
"testing"
|
|
|
|
"sneak.berlin/go/vaultik/internal/cli"
|
|
"sneak.berlin/go/vaultik/internal/globals"
|
|
)
|
|
|
|
// runVersionCommand executes `vaultik version` with its output
|
|
// captured, and returns what it printed.
|
|
func runVersionCommand(t *testing.T) string {
|
|
t.Helper()
|
|
|
|
cmd := cli.NewVersionCommand()
|
|
|
|
var out bytes.Buffer
|
|
|
|
cmd.SetOut(&out)
|
|
cmd.SetErr(&out)
|
|
cmd.SetArgs([]string{})
|
|
|
|
err := cmd.Execute()
|
|
if err != nil {
|
|
t.Fatalf("version command failed: %v", err)
|
|
}
|
|
|
|
return out.String()
|
|
}
|
|
|
|
// TestVersionCommandReportsBuildVersion checks that the first line of
|
|
// the report is the version the binary was actually built with. The
|
|
// test binary carries no -ldflags, so that is the "dev" default -- the
|
|
// same string an untagged `make vaultik` build stamps a prefix of.
|
|
//
|
|
//nolint:paralleltest // executes a command that reads the global rootFlags
|
|
func TestVersionCommandReportsBuildVersion(t *testing.T) {
|
|
out := runVersionCommand(t)
|
|
|
|
wantFirst := "vaultik " + globals.Version
|
|
if first, _, _ := strings.Cut(out, "\n"); first != wantFirst {
|
|
t.Errorf("first line = %q, want %q", first, wantFirst)
|
|
}
|
|
|
|
if !strings.Contains(out, "commit:") {
|
|
t.Error("output does not report the commit")
|
|
}
|
|
}
|
|
|
|
// TestVersionCommandReportLines checks the label, padding and value of
|
|
// every line of the report. Commit and CommitDate get different values,
|
|
// so a line that prints the wrong one fails.
|
|
//
|
|
//nolint:paralleltest // sets globals.Commit and globals.CommitDate
|
|
func TestVersionCommandReportLines(t *testing.T) {
|
|
const (
|
|
commit = "abc1234"
|
|
commitDate = "2026-11-09"
|
|
)
|
|
|
|
previousCommit, previousCommitDate := globals.Commit, globals.CommitDate
|
|
|
|
t.Cleanup(func() {
|
|
globals.Commit = previousCommit
|
|
globals.CommitDate = previousCommitDate
|
|
})
|
|
|
|
globals.Commit = commit
|
|
globals.CommitDate = commitDate
|
|
|
|
want := "vaultik " + globals.Version + "\n" +
|
|
" commit: " + commit + "\n" +
|
|
" commit date: " + commitDate + "\n" +
|
|
" go: " + runtime.Version() + "\n" +
|
|
" os/arch: " + runtime.GOOS + "/" + runtime.GOARCH + "\n" +
|
|
" author: " + globals.Author + "\n" +
|
|
" homepage: " + globals.Homepage + "\n" +
|
|
" license: " + globals.License + "\n"
|
|
|
|
out := runVersionCommand(t)
|
|
if !strings.HasPrefix(out, want) {
|
|
t.Errorf("report:\n%s\nwant it to start with:\n%s", out, want)
|
|
}
|
|
}
|
|
|
|
// TestVersionFlagPrintsVersionReport checks that `vaultik --version`
|
|
// prints exactly the report of `vaultik version`.
|
|
//
|
|
//nolint:paralleltest // executes commands that read the global rootFlags
|
|
func TestVersionFlagPrintsVersionReport(t *testing.T) {
|
|
cmd := cli.NewRootCommand()
|
|
|
|
var out bytes.Buffer
|
|
|
|
cmd.SetOut(&out)
|
|
cmd.SetErr(&out)
|
|
cmd.SetArgs([]string{"--version"})
|
|
|
|
err := cmd.Execute()
|
|
if err != nil {
|
|
t.Fatalf("vaultik --version failed: %v", err)
|
|
}
|
|
|
|
want := runVersionCommand(t)
|
|
if out.String() != want {
|
|
t.Errorf("vaultik --version printed:\n%s\nwant:\n%s", out.String(), want)
|
|
}
|
|
}
|
|
|
|
// TestVersionCommandFlagsDevelopmentBuild is the regression test for
|
|
// the thing this command exists to prevent: a build that is not a
|
|
// release must say so. The notice used to be gated on the version
|
|
// being exactly "dev", so once untagged builds started carrying their
|
|
// commit sha it would have gone silent and an unreleased binary would
|
|
// have looked like a release.
|
|
//
|
|
//nolint:paralleltest // executes a command that reads the global rootFlags
|
|
func TestVersionCommandFlagsDevelopmentBuild(t *testing.T) {
|
|
if !globals.IsDevVersion(globals.Version) {
|
|
t.Skipf("test binary was stamped with release version %q",
|
|
globals.Version)
|
|
}
|
|
|
|
out := runVersionCommand(t)
|
|
|
|
if !strings.Contains(out, "development build") {
|
|
t.Errorf("dev build did not print the development-build notice:\n%s",
|
|
out)
|
|
}
|
|
|
|
if !strings.Contains(out, globals.ReleasesURL) {
|
|
t.Errorf("development-build notice does not point at %s:\n%s",
|
|
globals.ReleasesURL, out)
|
|
}
|
|
}
|