add unit test for cli

cmd/notation/cache_test.go

@@ -0,0 +1,115 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestCacheListCommand_BasicArgs(t *testing.T) {
+	opts := &cacheListOpts{}
+	cmd := cacheListCommand(opts)
+	expected := &cacheListOpts{
+		RemoteFlagOpts: RemoteFlagOpts{
+			SecureFlagOpts: SecureFlagOpts{
+				Username: "user",
+			},
+			CommonFlagOpts: CommonFlagOpts{
+				Local:     true,
+				MediaType: defaultMediaType,
+			},
+		},
+		reference: "ref",
+	}
+	if err := cmd.ParseFlags([]string{
+		"-l",
+		expected.reference,
+		"-u", expected.Username}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if *expected != *opts {
+		t.Fatalf("Expect cache list opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestCachePruneCommand_BasicArgs(t *testing.T) {
+	opts := &cachePruneOpts{}
+	cmd := cachePruneCommand(opts)
+	expected := &cachePruneOpts{
+		RemoteFlagOpts: RemoteFlagOpts{
+			CommonFlagOpts: CommonFlagOpts{
+				MediaType: defaultMediaType,
+			},
+		},
+		all:        true,
+		force:      true,
+		purge:      true,
+		references: []string{"ref0", "ref1", "ref2", "ref3"},
+	}
+	if err := cmd.ParseFlags([]string{
+		"-a",
+		"--purge",
+		"ref0", "ref1", "ref2", "ref3",
+		"-f"}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if !reflect.DeepEqual(*expected, *opts) {
+		t.Fatalf("Expect cache prune opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestCachePruneCommand_MissingArgs(t *testing.T) {
+	cmd := cachePruneCommand(nil)
+	if err := cmd.ParseFlags([]string{}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err == nil {
+		t.Fatal("Parse Args expected error, but ok")
+	}
+}
+
+func TestCacheRemoveCommand_BasicArgs(t *testing.T) {
+	opts := &cacheRemoveOpts{}
+	cmd := cacheRemoveCommand(opts)
+	expected := &cacheRemoveOpts{
+		RemoteFlagOpts: RemoteFlagOpts{
+			CommonFlagOpts: CommonFlagOpts{
+				MediaType: defaultMediaType,
+			},
+			SecureFlagOpts: SecureFlagOpts{
+				Password:  "password",
+				PlainHTTP: true,
+			},
+		},
+		reference:  "ref",
+		sigDigests: []string{"digest0", "digest1"},
+	}
+	if err := cmd.ParseFlags([]string{
+		"--plain-http",
+		"ref",
+		"digest0", "digest1",
+		"--password", expected.Password}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if !reflect.DeepEqual(*expected, *opts) {
+		t.Fatalf("Expect cache remove opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestCacheRemoveCommand_MissingArgs(t *testing.T) {
+	cmd := cacheRemoveCommand(nil)
+	if err := cmd.ParseFlags([]string{"reference"}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err == nil {
+		t.Fatal("Parse Args expected error, but ok")
+	}
+}

cmd/notation/cert_test.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestCertAddCommand_BasicArgs(t *testing.T) {
+	opts := &certAddOpts{}
+	cmd := certAddCommand(opts)
+	expected := &certAddOpts{
+		path: "path",
+		name: "cert",
+	}
+	if err := cmd.ParseFlags([]string{
+		expected.path,
+		"-n", expected.name}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if *expected != *opts {
+		t.Fatalf("Expect cert add opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestCertAddCommand_MissingArgs(t *testing.T) {
+	cmd := certAddCommand(nil)
+	if err := cmd.ParseFlags([]string{}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err == nil {
+		t.Fatal("Parse Args expected error, but ok")
+	}
+}
+
+func TestCertRemoveCommand_BasicArgs(t *testing.T) {
+	opts := &certRemoveOpts{}
+	cmd := certRemoveCommand(opts)
+	expected := &certRemoveOpts{
+		names: []string{"cert0", "cert1", "cert2"},
+	}
+	if err := cmd.ParseFlags(expected.names); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if !reflect.DeepEqual(*expected, *opts) {
+		t.Fatalf("Expect cert remove opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestCertRemoveCommand_MissingArgs(t *testing.T) {
+	cmd := certRemoveCommand(nil)
+	if err := cmd.ParseFlags([]string{}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err == nil {
+		t.Fatal("Parse Args expected error, but ok")
+	}
+}
+
+func TestCertGenerateCommand_WithExpiry(t *testing.T) {
+	opts := &certGenerateTestOpts{}
+	cmd := certGenerateTestCommand(opts)
+	expected := &certGenerateTestOpts{
+		hosts:     []string{"host0", "host1", "host2"},
+		name:      "name",
+		bits:      2048,
+		isDefault: true,
+		expiry:    365 * 24 * time.Hour,
+	}
+	if err := cmd.ParseFlags([]string{
+		"host0", "host1",
+		"-n", expected.name,
+		"--bits", fmt.Sprint(expected.bits),
+		"host2",
+		"--default"}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if !reflect.DeepEqual(*expected, *opts) {
+		t.Fatalf("Expect cert generate test opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestCertGenerateTestCommand_MissingArgs(t *testing.T) {
+	cmd := certGenerateTestCommand(nil)
+	if err := cmd.ParseFlags(nil); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err == nil {
+		t.Fatal("Parse Args expected error, but ok")
+	}
+}

cmd/notation/key_test.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestKeyAddCommand_BasicArgs(t *testing.T) {
+	opts := &keyAddOpts{}
+	cmd := keyAddCommand(opts)
+	expected := &keyAddOpts{
+		name:         "name",
+		plugin:       "pluginname",
+		id:           "pluginid",
+		keyPath:      "keypath",
+		certPath:     "certpath",
+		pluginConfig: "pluginconfig",
+	}
+	if err := cmd.ParseFlags([]string{
+		"-n", expected.name,
+		"--plugin", expected.plugin,
+		"--id", expected.id,
+		"-c", expected.pluginConfig,
+		expected.keyPath, expected.certPath}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if *expected != *opts {
+		t.Fatalf("Expect key add opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestKeyUpdateCommand_BasicArgs(t *testing.T) {
+	opts := &keyUpdateOpts{}
+	cmd := keyUpdateCommand(opts)
+	expected := &keyUpdateOpts{
+		name:      "name",
+		isDefault: true,
+	}
+	if err := cmd.ParseFlags([]string{
+		expected.name,
+		"--default"}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if *expected != *opts {
+		t.Fatalf("Expect key update opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestKeyUpdateCommand_MissingArgs(t *testing.T) {
+	cmd := keyUpdateCommand(nil)
+	if err := cmd.ParseFlags(nil); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err == nil {
+		t.Fatal("Parse Args expected error, but ok")
+	}
+}
+
+func TestKeyRemoveCommand_BasicArgs(t *testing.T) {
+	opts := &keyRemoveOpts{}
+	cmd := keyRemoveCommand(opts)
+	expected := &keyRemoveOpts{
+		names: []string{"key0", "key1", "key2"},
+	}
+	if err := cmd.ParseFlags(expected.names); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if !reflect.DeepEqual(*expected, *opts) {
+		t.Fatalf("Expect key remove opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestKeyRemoveCommand_MissingArgs(t *testing.T) {
+	cmd := keyRemoveCommand(nil)
+	if err := cmd.ParseFlags(nil); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err == nil {
+		t.Fatal("Parse Args expected error, but ok")
+	}
+}

cmd/notation/list_test.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"testing"
+)
+
+func TestListCommand_SecretsFromArgs(t *testing.T) {
+	opts := &listOpts{}
+	cmd := listCommand(opts)
+	expected := &listOpts{
+		reference: "ref",
+		SecureFlagOpts: SecureFlagOpts{
+			Password:  "password",
+			PlainHTTP: true,
+			Username:  "user",
+		},
+	}
+	if err := cmd.ParseFlags([]string{
+		"--password", expected.Password,
+		expected.reference,
+		"-u", expected.Username,
+		"--plain-http"}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if *opts != *expected {
+		t.Fatalf("Expect list opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestListCommand_SecretsFromEnv(t *testing.T) {
+	t.Setenv(defaultUsernameEnv, "user")
+	t.Setenv(defaultPasswordEnv, "password")
+	opts := &listOpts{}
+	expected := &listOpts{
+		reference: "ref",
+		SecureFlagOpts: SecureFlagOpts{
+			Password: "password",
+			Username: "user",
+		},
+	}
+	cmd := listCommand(opts)
+	if err := cmd.ParseFlags([]string{
+		expected.reference}); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err != nil {
+		t.Fatalf("Parse Args failed: %v", err)
+	}
+	if *opts != *expected {
+		t.Fatalf("Expect list opts: %v, got: %v", expected, opts)
+	}
+}
+
+func TestListCommand_MissingArgs(t *testing.T) {
+	cmd := listCommand(nil)
+	if err := cmd.ParseFlags(nil); err != nil {
+		t.Fatalf("Parse Flag failed: %v", err)
+	}
+	if err := cmd.Args(cmd, cmd.Flags().Args()); err == nil {
+		t.Fatal("Parse Args expected error, but ok")
+	}
+}