88 lines
3.1 KiB
Go
88 lines
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
// A file has a trailing newline and a password does not.
|
|
//
|
|
// The failure this prevents is the worst kind to diagnose: the credential is delivered, the
|
|
// machine applies it, everything reports success, and authentication fails one byte from correct
|
|
// somewhere else entirely.
|
|
func TestATrailingNewlineIsNotPartOfTheSecret(t *testing.T) {
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "password")
|
|
if err := os.WriteFile(path, []byte("the-database-password\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := valueFor("anchor", "umami", "database", path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if asSupplied(got) != "the-database-password" {
|
|
t.Fatalf("read %q", got)
|
|
}
|
|
}
|
|
|
|
// A password may contain spaces, and they are the operator's.
|
|
//
|
|
// Trimming both ends is the obvious thing and it is wrong: a value chosen with a leading space is
|
|
// a value the mesh would silently deliver as a different one.
|
|
func TestOnlyLineEndingsAreRemoved(t *testing.T) {
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "password")
|
|
if err := os.WriteFile(path, []byte(" spaces matter \n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := valueFor("anchor", "umami", "database", path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if asSupplied(got) != " spaces matter " {
|
|
t.Fatalf("the value was altered beyond its line ending: %q", got)
|
|
}
|
|
}
|
|
|
|
// A file that is not there is said plainly, rather than becoming an empty secret.
|
|
func TestAMissingFileIsRefused(t *testing.T) {
|
|
if _, err := valueFor("anchor", "umami", "database",
|
|
filepath.Join(t.TempDir(), "absent")); err == nil {
|
|
t.Fatal("a missing file produced a value")
|
|
}
|
|
}
|
|
|
|
// The command refuses what it cannot act on, rather than acting on part of it.
|
|
|
|
// The invocation that actually gets used, which the first version of these tests never tried.
|
|
//
|
|
// Every case here was a rejection, so the command was broken in the one way that matters — it
|
|
// refused what it is for — and the tests were green. The lab found it at the first call.
|
|
func TestTheArgumentsAndTheFlagAreBothSeen(t *testing.T) {
|
|
rest, flags := split([]string{"anchor", "umami", "database", "--from", "-"})
|
|
assert(t, len(rest) == 3, "the three positionals were not kept: %v", rest)
|
|
assert(t, len(flags) == 2, "the flag was not separated: %v", flags)
|
|
|
|
// And with no flag at all, which is the interactive form.
|
|
rest, flags = split([]string{"anchor", "umami", "database"})
|
|
assert(t, len(rest) == 3 && len(flags) == 0, "%v / %v", rest, flags)
|
|
|
|
// A flag before the positionals still works, because somebody will write it that way.
|
|
rest, flags = split([]string{"--from", "/tmp/x"})
|
|
assert(t, len(rest) == 0 && len(flags) == 2, "%v / %v", rest, flags)
|
|
}
|
|
|
|
// And the wiring, not just the helper.
|
|
//
|
|
// Testing `split` alone left the command able to ignore it entirely — removing the call changed
|
|
// no test. This reaches secretCommand: with a `--from` naming a file that is not there, the
|
|
// complaint must be about the file. A complaint about usage would mean the flag was never seen.
|
|
|
|
func assert(t *testing.T, ok bool, format string, args ...any) {
|
|
t.Helper()
|
|
if !ok {
|
|
t.Fatalf(format, args...)
|
|
}
|
|
}
|