refactor newGoBuildCommand

Signed-off-by: Mohammed Al Sahaf <msaa1990@gmail.com>

builder.go

@@ -97,7 +97,10 @@ func (b Builder) Build(ctx context.Context, outputFile string) error {
 	// generating windows resources for embedding
 	if b.OS == "windows" {
 		// get version string, we need to parse the output to get the exact version instead tag, branch or commit
-		cmd := buildEnv.newGoBuildCommand(ctx, "list", "-m", buildEnv.caddyModulePath)
+		cmd, err := buildEnv.newGoBuildCommand(ctx, "list", "-m", buildEnv.caddyModulePath)
+		if err != nil {
+			return err
+		}
 		var buffer bytes.Buffer
 		cmd.Stdout = &buffer
 		err = buildEnv.runCommand(ctx, cmd)
@@ -147,9 +150,12 @@ func (b Builder) Build(ctx context.Context, outputFile string) error {
 	}
 
 	// compile
-	cmd := buildEnv.newGoBuildCommand(ctx, "build",
+	cmd, err := buildEnv.newGoBuildCommand(ctx, "build",
 		"-o", absOutputFile,
 	)
+	if err != nil {
+		return err
+	}
 	if b.Debug {
 		// support dlv
 		cmd.Args = append(cmd.Args, "-gcflags", "all=-N -l")

environment.go

@@ -246,11 +246,16 @@ func (env environment) newCommand(ctx context.Context, command string, args ...s
 
 // newGoBuildCommand creates a new *exec.Cmd which assumes the first element in `args` is one of: build, clean, get, install, list, run, or test. The
 // created command will also have the value of `XCADDY_GO_BUILD_FLAGS` appended to its arguments, if set.
-func (env environment) newGoBuildCommand(ctx context.Context, args ...string) *exec.Cmd {
-	cmd := env.newCommand(ctx, utils.GetGo(), args[0])
+func (env environment) newGoBuildCommand(ctx context.Context, goCommand string, args ...string) (*exec.Cmd, error) {
+	switch goCommand {
+	case "build", "clean", "get", "install", "list", "run", "test":
+	default:
+		return nil, fmt.Errorf("unsupported command of 'go': %s", goCommand)
+	}
+	cmd := env.newCommand(ctx, utils.GetGo(), goCommand)
 	cmd = parseAndAppendFlags(cmd, env.buildFlags)
-	cmd.Args = append(cmd.Args, args[1:]...)
-	return cmd
+	cmd.Args = append(cmd.Args, args...)
+	return cmd, nil
 }
 
 // newGoModCommand creates a new *exec.Cmd which assumes `args` are the args for `go mod` command. The
@@ -338,7 +343,10 @@ func (env environment) execGoGet(ctx context.Context, modulePath, moduleVersion,
 		caddy += "@" + caddyVersion
 	}
 
-	cmd := env.newGoBuildCommand(ctx, "get", "-v")
+	cmd, err := env.newGoBuildCommand(ctx, "get", "-v")
+	if err != nil {
+		return err
+	}
 	// using an empty string as an additional argument to "go get"
 	// breaks the command since it treats the empty string as a
 	// distinct argument, so we're using an if statement to avoid it.

environment_test.go

@@ -27,57 +27,60 @@ func Test_environment_newGoBuildCommand(t *testing.T) {
 		buildFlags string
 	}
 	type args struct {
-		args []string
+		goCommand string
+		args      []string
 	}
 	tests := []struct {
 		name     string
 		fields   fields
 		args     args
 		wantArgs []string
+		wantErr  bool
 	}{
 		{
-			name:     "no flags + no args",
-			fields:   fields{},
-			args:     args{[]string{}},
-			wantArgs: []string{utils.GetGo()},
+			name:    "no flags + no args",
+			fields:  fields{},
+			args:    args{},
+			wantErr: true,
 		},
 
 		{
 			name:     "no flags + single arg",
 			fields:   fields{},
-			args:     args{[]string{"build"}},
+			args:     args{"build", []string{}},
 			wantArgs: []string{utils.GetGo(), "build"},
 		},
 
 		{
 			name:     "no flags + multi arg",
 			fields:   fields{},
-			args:     args{[]string{"build", "main.go"}},
+			args:     args{"build", []string{"main.go"}},
 			wantArgs: []string{utils.GetGo(), "build", "main.go"},
 		},
 
 		{
 			name:     "single flag + no arg",
 			fields:   fields{"-trimpath"},
-			args:     args{[]string{}},
+			args:     args{"", []string{}},
 			wantArgs: []string{utils.GetGo(), "-trimpath"},
+			wantErr:  true,
 		},
 
 		{
 			name: "multi flag + no arg",
 			fields: fields{
 				"-ldflags '-w -s -extldflags=-static'",
 			},
-			args:     args{},
-			wantArgs: []string{utils.GetGo(), "-ldflags", "-w -s -extldflags=-static"},
+			args:    args{},
+			wantErr: true,
 		},
 
 		{
 			name: "multi flag + one arg",
 			fields: fields{
 				"-ldflags '-w -s -extldflags=-static'",
 			},
-			args:     args{[]string{"build"}},
+			args:     args{"build", []string{}},
 			wantArgs: []string{utils.GetGo(), "build", "-ldflags", "-w -s -extldflags=-static"},
 		},
 
@@ -86,7 +89,7 @@ func Test_environment_newGoBuildCommand(t *testing.T) {
 			fields: fields{
 				buildFlags: "-ldflags '-w -s -extldflags=-static'",
 			},
-			args:     args{[]string{"build", "main.go"}},
+			args:     args{"build", []string{"main.go"}},
 			wantArgs: []string{utils.GetGo(), "build", "-ldflags", "-w -s -extldflags=-static", "main.go"},
 		},
 	}
@@ -95,8 +98,16 @@ func Test_environment_newGoBuildCommand(t *testing.T) {
 			env := environment{
 				buildFlags: tt.fields.buildFlags,
 			}
-			if got := env.newGoBuildCommand(context.TODO(), tt.args.args...); !reflect.DeepEqual(got.Args, tt.wantArgs) {
-				t.Errorf("(environment.newGoBuildCommand()).Args = %#v, want %#v", got.Args, tt.wantArgs)
+			got, err := env.newGoBuildCommand(context.TODO(), tt.args.goCommand, tt.args.args...)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("environment.newGoBuildCommand() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if (err != nil) && tt.wantErr {
+				return // expected error, continue
+			}
+			if !reflect.DeepEqual(got.Args, tt.wantArgs) {
+				t.Errorf("environment.newGoBuildCommand() = %#v, want %#v", got.Args, tt.wantArgs)
 			}
 		})
 	}