cli-plugins/hooks: update tests

- add basic unit-test for the template utilities
- make sure the template parsing tests test both the current
  template produced by the utilities, as well as a fixture
- rewrite the printer test to use fixtures
- use blackbox testing ("hooks_test")

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

cli-plugins/hooks/hooks_utils_test.go

@@ -0,0 +1,50 @@
+package hooks_test
+
+import (
+	"testing"
+
+	"github.com/docker/cli/cli-plugins/hooks"
+)
+
+func TestTemplateHelpers(t *testing.T) {
+	tests := []struct {
+		doc  string
+		got  func() string
+		want string
+	}{
+		{
+			doc:  "subcommand name",
+			got:  hooks.TemplateReplaceSubcommandName,
+			want: `{{.Name}}`,
+		},
+		{
+			doc: "flag value",
+			got: func() string {
+				return hooks.TemplateReplaceFlagValue("name")
+			},
+			want: `{{flag . "name"}}`,
+		},
+		{
+			doc: "arg",
+			got: func() string {
+				return hooks.TemplateReplaceArg(0)
+			},
+			want: `{{arg . 0}}`,
+		},
+		{
+			doc: "arg",
+			got: func() string {
+				return hooks.TemplateReplaceArg(3)
+			},
+			want: `{{arg . 3}}`,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.doc, func(t *testing.T) {
+			if got := tc.got(); got != tc.want {
+				t.Fatalf("expected %q, got %q", tc.want, got)
+			}
+		})
+	}
+}

cli-plugins/hooks/printer_test.go

@@ -1,38 +1,45 @@
-package hooks
+package hooks_test
 
 import (
-	"bytes"
+	"strings"
 	"testing"
 
-	"github.com/morikuni/aec"
+	"github.com/docker/cli/cli-plugins/hooks"
 	"gotest.tools/v3/assert"
 )
 
 func TestPrintHookMessages(t *testing.T) {
-	testCases := []struct {
+	const header = "\x1b[1m\nWhat's next:\x1b[0m\n"
+
+	tests := []struct {
+		doc            string
 		messages       []string
 		expectedOutput string
 	}{
 		{
-			messages:       []string{},
+			doc:            "no messages",
+			messages:       nil,
 			expectedOutput: "",
 		},
 		{
+			doc:      "single message",
 			messages: []string{"Bork!"},
-			expectedOutput: aec.Bold.Apply("\nWhat's next:") + "\n" +
+			expectedOutput: header +
 				"    Bork!\n",
 		},
 		{
+			doc:      "multiple messages",
 			messages: []string{"Foo", "bar"},
-			expectedOutput: aec.Bold.Apply("\nWhat's next:") + "\n" +
+			expectedOutput: header +
 				"    Foo\n" +
 				"    bar\n",
 		},
 	}
-
-	for _, tc := range testCases {
-		w := bytes.Buffer{}
-		PrintNextSteps(&w, tc.messages)
-		assert.Equal(t, w.String(), tc.expectedOutput)
+	for _, tc := range tests {
+		t.Run(tc.doc, func(t *testing.T) {
+			var w strings.Builder
+			hooks.PrintNextSteps(&w, tc.messages)
+			assert.Equal(t, w.String(), tc.expectedOutput)
+		})
 	}
 }

cli-plugins/hooks/template_test.go

@@ -1,43 +1,67 @@
-package hooks
+package hooks_test
 
 import (
 	"testing"
 
+	"github.com/docker/cli/cli-plugins/hooks"
 	"github.com/spf13/cobra"
 	"gotest.tools/v3/assert"
 )
 
+// TestParseTemplate tests parsing templates as returned by plugins.
+//
+// It uses fixed string fixtures to lock in compatibility with existing
+// plugin templates, so older formats continue to work even if we add new
+// template forms.
+//
+// For helper-backed cases, it also verifies that templates produced by the
+// current TemplateReplace* helpers parse to the same output. This lets us
+// evolve the emitted template format without breaking older plugins.
 func TestParseTemplate(t *testing.T) {
 	type testFlag struct {
 		name  string
 		value string
 	}
-	testCases := []struct {
-		template       string
+	tests := []struct {
+		doc            string
+		template       string // compatibility fixture; keep even if helpers emit a newer form
+		templateFunc   func() string
 		flags          []testFlag
 		args           []string
 		expectedOutput []string
 	}{
 		{
+			doc:            "empty template",
 			template:       "",
 			expectedOutput: []string{""},
 		},
 		{
+			doc:            "plain message",
 			template:       "a plain template message",
 			expectedOutput: []string{"a plain template message"},
 		},
 		{
-			template: TemplateReplaceFlagValue("tag"),
+			doc:          "subcommand name",
+			template:     "hello {{.Name}}", // NOTE: fixture; do not modify without considering plugin compatibility
+			templateFunc: func() string { return "hello " + hooks.TemplateReplaceSubcommandName() },
+
+			expectedOutput: []string{"hello pull"},
+		},
+		{
+			doc:          "single flag",
+			template:     `{{flag . "tag"}}`, // NOTE: fixture; do not modify without considering plugin compatibility
+			templateFunc: func() string { return hooks.TemplateReplaceFlagValue("tag") },
 			flags: []testFlag{
-				{
-					name:  "tag",
-					value: "my-tag",
-				},
+				{name: "tag", value: "my-tag"},
 			},
 			expectedOutput: []string{"my-tag"},
 		},
 		{
-			template: TemplateReplaceFlagValue("test-one") + " " + TemplateReplaceFlagValue("test2"),
+			doc:      "multiple flags",
+			template: `{{flag . "test-one"}} {{flag . "test2"}}`, // NOTE: fixture; do not modify without considering plugin compatibility
+			templateFunc: func() string {
+				return hooks.TemplateReplaceFlagValue("test-one") + " " + hooks.TemplateReplaceFlagValue("test2")
+			},
 			flags: []testFlag{
 				{
 					name:  "test-one",
@@ -51,36 +75,51 @@ func TestParseTemplate(t *testing.T) {
 			expectedOutput: []string{"value value2"},
 		},
 		{
-			template:       TemplateReplaceArg(0) + " " + TemplateReplaceArg(1),
+			doc:            "multiple args",
+			template:       `{{arg . 0}} {{arg . 1}}`, // NOTE: fixture; do not modify without considering plugin compatibility
+			templateFunc:   func() string { return hooks.TemplateReplaceArg(0) + " " + hooks.TemplateReplaceArg(1) },
 			args:           []string{"zero", "one"},
 			expectedOutput: []string{"zero one"},
 		},
 		{
-			template:       "You just pulled " + TemplateReplaceArg(0),
+			doc:            "arg in sentence",
+			template:       "You just pulled {{arg . 0}}", // NOTE: fixture; do not modify without considering plugin compatibility
+			templateFunc:   func() string { return "You just pulled " + hooks.TemplateReplaceArg(0) },
 			args:           []string{"alpine"},
 			expectedOutput: []string{"You just pulled alpine"},
 		},
 		{
+			doc:            "multiline output",
 			template:       "one line\nanother line!",
 			expectedOutput: []string{"one line", "another line!"},
 		},
 	}
 
-	for _, tc := range testCases {
-		testCmd := &cobra.Command{
-			Use:  "pull",
-			Args: cobra.ExactArgs(len(tc.args)),
-		}
-		for _, f := range tc.flags {
-			_ = testCmd.Flags().String(f.name, "", "")
-			err := testCmd.Flag(f.name).Value.Set(f.value)
+	for _, tc := range tests {
+		t.Run(tc.doc, func(t *testing.T) {
+			testCmd := &cobra.Command{
+				Use:  "pull",
+				Args: cobra.ExactArgs(len(tc.args)),
+			}
+			for _, f := range tc.flags {
+				_ = testCmd.Flags().String(f.name, "", "")
+				err := testCmd.Flag(f.name).Value.Set(f.value)
+				assert.NilError(t, err)
+			}
+			err := testCmd.Flags().Parse(tc.args)
+			assert.NilError(t, err)
+
+			// Validate using fixtures.
+			out, err := hooks.ParseTemplate(tc.template, testCmd)
 			assert.NilError(t, err)
-		}
-		err := testCmd.Flags().Parse(tc.args)
-		assert.NilError(t, err)
+			assert.DeepEqual(t, out, tc.expectedOutput)
 
-		out, err := ParseTemplate(tc.template, testCmd)
-		assert.NilError(t, err)
-		assert.DeepEqual(t, out, tc.expectedOutput)
+			if tc.templateFunc != nil {
+				// Validate using the current template function equivalent.
+				out, err = hooks.ParseTemplate(tc.templateFunc(), testCmd)
+				assert.NilError(t, err)
+				assert.DeepEqual(t, out, tc.expectedOutput)
+			}
+		})
 	}
 }