Add sutil CLI in cmd/sutil with internal/cli command tree

internal/cli/cli_test.go

@@ -0,0 +1,177 @@
+package cli_test
+
+import (
+	"bytes"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"sneak.berlin/go/x/internal/cli"
+	"sneak.berlin/go/x/internal/pwgen"
+	"sneak.berlin/go/x/pkg/bip39wordlist"
+	"sneak.berlin/go/x/pkg/cbk"
+)
+
+const (
+	testVersion = "v1.2.3-test"
+
+	// vectorRepeats is how many times "abandon" appears in the standard
+	// BIP39 test vector for all-zero 128-bit entropy, which ends with
+	// "about".
+	vectorRepeats = bip39wordlist.MinWordCount - 1
+)
+
+// vectorMnemonic returns the standard BIP39 test vector for all-zero
+// 128-bit entropy.
+func vectorMnemonic() string {
+	return strings.Repeat("abandon ", vectorRepeats) + "about"
+}
+
+func TestVersionCommand(t *testing.T) {
+	t.Parallel()
+
+	output, err := execute(t, "", "version")
+	require.NoError(t, err)
+	assert.Equal(t, testVersion+"\n", output)
+}
+
+func TestVersionFlag(t *testing.T) {
+	t.Parallel()
+
+	output, err := execute(t, "", "--version")
+	require.NoError(t, err)
+	assert.Contains(t, output, testVersion)
+}
+
+func TestInfoCommand(t *testing.T) {
+	t.Parallel()
+
+	output, err := execute(t, "", "info")
+	require.NoError(t, err)
+	assert.Contains(t, output, "version: "+testVersion+"\n")
+	assert.Contains(t, output, "go: go")
+	assert.Contains(t, output, "module: sneak.berlin/go/x\n")
+}
+
+func TestGenerateRandomSeededIsDeterministic(t *testing.T) {
+	t.Parallel()
+
+	first, err := execute(t, "", "generate", "random", "--count", "4096", "seed")
+	require.NoError(t, err)
+	assert.Len(t, first, 4096)
+
+	second, err := execute(t, "", "generate", "random", "--count", "4096", "seed")
+	require.NoError(t, err)
+	assert.Equal(t, first, second)
+
+	other, err := execute(t, "", "gen", "random", "-c", "4096", "other seed")
+	require.NoError(t, err)
+	assert.NotEqual(t, first, other)
+}
+
+func TestGenerateRandomUnseeded(t *testing.T) {
+	t.Parallel()
+
+	first, err := execute(t, "", "generate", "random", "--count", "1024")
+	require.NoError(t, err)
+	assert.Len(t, first, 1024)
+
+	second, err := execute(t, "", "generate", "random", "--count", "1024")
+	require.NoError(t, err)
+	assert.NotEqual(t, first, second)
+}
+
+func TestGenerateRandomRejectsExtraArguments(t *testing.T) {
+	t.Parallel()
+
+	_, err := execute(t, "", "generate", "random", "one", "two")
+	require.Error(t, err)
+}
+
+func TestGenerateMnemonic(t *testing.T) {
+	t.Parallel()
+
+	output, err := execute(t, "", "generate", "mnemonic")
+	require.NoError(t, err)
+
+	mnemonic := strings.TrimSuffix(output, "\n")
+	require.NoError(t, bip39wordlist.ValidateWordlist(mnemonic))
+	assert.Len(t, strings.Fields(mnemonic), bip39wordlist.MaxWordCount)
+
+	output, err = execute(t, "", "generate", "mnemonic", "--words", "12")
+	require.NoError(t, err)
+	assert.Len(t, strings.Fields(output), bip39wordlist.MinWordCount)
+
+	_, err = execute(t, "", "generate", "mnemonic", "--words", "13")
+	require.ErrorIs(t, err, bip39wordlist.ErrInvalidWordCount)
+}
+
+func TestGeneratePassword(t *testing.T) {
+	t.Parallel()
+
+	_, err := pwgen.New(pwgen.Params{Words: nil, MinWordLength: 0, MaxWordLength: 0})
+	if errors.Is(err, pwgen.ErrNoUsableWords) {
+		t.Skip("this system has no word list")
+	}
+
+	require.NoError(t, err)
+
+	output, err := execute(t, "", "generate", "password")
+	require.NoError(t, err)
+
+	password := strings.TrimSuffix(output, "\n")
+	assert.NotContains(t, password, "\n")
+	assert.GreaterOrEqual(t, len(password), 3*(pwgen.DefaultMinWordLength+1)+2)
+	assert.True(t, strings.ContainsAny(password, "0123456789"), password)
+	assert.True(t, strings.ContainsAny(password, pwgen.Delimiters), password)
+}
+
+func TestCBKDerive(t *testing.T) {
+	t.Parallel()
+
+	expected, err := cbk.FromMnemonic(vectorMnemonic())
+	require.NoError(t, err)
+
+	stdin := "  " + strings.ToUpper(vectorMnemonic()) + "\n"
+
+	output, err := execute(t, stdin, "cbk", "derive")
+	require.NoError(t, err)
+	assert.Equal(t,
+		"public: "+expected.PublicKeyHex()+"\n"+
+			"private: "+expected.PrivateKeyHex()+"\n",
+		output,
+	)
+
+	output, err = execute(t, vectorMnemonic(), "cbk", "derive", "--public")
+	require.NoError(t, err)
+	assert.Equal(t, expected.PublicKeyHex()+"\n", output)
+}
+
+func TestCBKDeriveRejectsInvalidMnemonic(t *testing.T) {
+	t.Parallel()
+
+	_, err := execute(t, "not a mnemonic\n", "cbk", "derive")
+	require.ErrorIs(t, err, bip39wordlist.ErrInvalidWordCount)
+}
+
+// execute runs sutil with the given stdin and arguments and returns
+// everything it wrote to stdout and stderr.
+func execute(t *testing.T, stdin string, args ...string) (string, error) {
+	t.Helper()
+
+	root := cli.New(cli.Params{Version: testVersion})
+
+	var output bytes.Buffer
+
+	root.SetOut(&output)
+	root.SetErr(&output)
+	root.SetIn(strings.NewReader(stdin))
+	root.SetArgs(args)
+
+	err := root.Execute()
+
+	return output.String(), err
+}