Allow to set working directory per target

We also add further tests for stock targets using Docker.

_test_docker/Dockerfile

@@ -0,0 +1,4 @@
+FROM alpine:latest
+
+RUN exit 1 # we want `docker build` to fail
+ENTRYPOINT ["date"]

main_test.go

@@ -0,0 +1,37 @@
+// Copyright (c) 2023, Geert JM Vanderkelen
+
+package gomake
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"testing"
+)
+
+var (
+	testExitCode int
+	testErr      error
+)
+
+var (
+	haveDocker bool
+)
+
+func testTearDown() {
+	if testErr != nil {
+		testExitCode = 1
+		fmt.Println(testErr)
+	}
+}
+
+func TestMain(m *testing.M) {
+	defer func() { os.Exit(testExitCode) }()
+	defer testTearDown()
+
+	if _, err := exec.LookPath("docker"); err == nil {
+		haveDocker = true
+	}
+
+	testExitCode = m.Run()
+}

stock_docker.go

@@ -63,6 +63,10 @@ var TargetDockerBuild = Target{
 		cmd := exec.Command("docker", execArgs...)
 		cmd.Stdout = target.Maker.StdOut
 		cmd.Stderr = target.Maker.StdErr
+		if target.WorkDir != "" {
+			fmt.Println("executing in directory:", target.WorkDir)
+			cmd.Dir = target.WorkDir
+		}
 		if err := cmd.Run(); err != nil {
 			return err
 		}
@@ -128,6 +132,8 @@ var TargetDockerBuildXPush = Target{
 			target.Flags["platform"] = platform
 		}
 
+		fmt.Println("### flags", target.Flags)
+
 		return flagSet, nil
 	},
 	Do: func(target *Target) error {
@@ -146,6 +152,10 @@ var TargetDockerBuildXPush = Target{
 		cmd := exec.Command("docker", execArgs...)
 		cmd.Stdout = target.Maker.StdOut
 		cmd.Stderr = target.Maker.StdErr
+		if target.WorkDir != "" {
+			fmt.Println("executing in directory:", target.WorkDir)
+			cmd.Dir = target.WorkDir
+		}
 		if err := cmd.Run(); err != nil {
 			return err
 		}

stock_go.go

@@ -59,8 +59,8 @@ var TargetVendor = Target{
 
 var TargetCleanupVendor = Target{
 	Name:         "clean-vendor",
-	PreMessages:  []string{"removing vendor folder..."},
-	PostMessages: []string{"done removing vendor folder."},
+	PreMessages:  []string{"removing vendor folder"},
+	PostMessages: []string{"done removing vendor folder"},
 	HandleFlags:  targetVendorHandleFlags,
 	Do: func(target *Target) error {
 		if _, err := target.HandleFlags(target); err != nil {

stocker_docker_test.go

@@ -0,0 +1,141 @@
+// Copyright (c) 2023, Geert JM Vanderkelen
+
+package gomake
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/golistic/xt"
+)
+
+func TestTargetDockerBuild(t *testing.T) {
+	if !haveDocker {
+		t.Skip("the 'docker' command is not available in PATH")
+	}
+
+	wd, err := filepath.Abs("_test_docker")
+	xt.OK(t, err)
+
+	t.Run("target is executed", func(t *testing.T) {
+		target := TargetDockerBuild
+		target.Flags = map[string]any{"image": "example", "tag": "0.9.0"}
+		target.WorkDir = wd
+
+		var bufOut strings.Builder
+		var bufErr strings.Builder
+		m := NewMaker()
+		m.StdOut = &bufOut
+		m.StdErr = &bufErr
+		m.registerTargets(&target)
+
+		exit := m.make(target.Name)
+		dataOut := bufOut.String()
+		dataErr := bufErr.String()
+
+		fmt.Println("###", dataOut)
+
+		xt.Eq(t, 1, exit)
+		xt.Assert(t, strings.Contains(dataOut, target.PreMessages[0]))
+		xt.Assert(t, strings.Contains(dataOut, target.PostMessages[0]))
+		xt.Assert(t, strings.Contains(dataErr, "RUN exit 1 # we want `docker build` to fail"))
+	})
+
+	t.Run("required flags", func(t *testing.T) {
+		cases := []struct {
+			missing string
+			given   []string
+		}{
+			{
+				missing: "-image",
+				given:   []string{"-tag", "0.9.0"},
+			},
+			{
+				missing: "-tag",
+				given:   []string{"-image", "example"},
+			},
+		}
+
+		for _, c := range cases {
+			t.Run(c.missing+" is required", func(t *testing.T) {
+				exp := fmt.Sprintf(`Error: docker-build: flag %s is required`, c.missing)
+
+				var bufErr strings.Builder
+				m := NewMaker()
+				m.StdErr = &bufErr
+				m.registerTargets(&TargetDockerBuild)
+
+				xt.Eq(t, 1, m.make(append([]string{TargetDockerBuild.Name}, c.given...)...))
+				xt.Eq(t, exp, strings.TrimSpace(bufErr.String()))
+			})
+		}
+	})
+}
+
+func TestTargetDockerBuildX(t *testing.T) {
+	if !haveDocker {
+		t.Skip("the 'docker' command is not available in PATH")
+	}
+
+	wd, err := filepath.Abs("_test_docker")
+	xt.OK(t, err)
+
+	t.Run("target is executed", func(t *testing.T) {
+		target := TargetDockerBuildXPush
+		target.Flags = map[string]any{"image": "example", "registry": "fake.example.com", "tag": "0.9.0"}
+		target.WorkDir = wd
+
+		var bufOut strings.Builder
+		var bufErr strings.Builder
+		m := NewMaker()
+		m.StdOut = &bufOut
+		m.StdErr = &bufErr
+		m.registerTargets(&target)
+
+		exit := m.make(target.Name)
+		dataOut := bufOut.String()
+		dataErr := bufErr.String()
+
+		xt.Eq(t, 1, exit)
+
+		xt.Assert(t, strings.Contains(dataOut, target.PreMessages[0]))
+		xt.Assert(t, strings.Contains(dataErr, "RUN exit 1 # we want `docker build` to fail"))
+	})
+
+	t.Run("required flags", func(t *testing.T) {
+		cases := []struct {
+			missing string
+			given   []string
+		}{
+			{
+				missing: "image",
+				given:   []string{"-registry", "fake.example.com", "-tag", "0.9.0"},
+			},
+			{
+				missing: "registry",
+				given:   []string{"-image", "example", "-tag", "0.9.0"},
+			},
+			{
+				missing: "tag",
+				given:   []string{"-image", "example", "-registry", "fake.example.com"},
+			},
+		}
+
+		for _, c := range cases {
+			t.Run(c.missing+" is required", func(t *testing.T) {
+				target := TargetDockerBuildXPush
+				exp := fmt.Sprintf(`Error: docker-buildx: flag -%s is required`, c.missing)
+
+				var bufErr strings.Builder
+				m := NewMaker()
+				m.StdErr = &bufErr
+				m.registerTargets(&target)
+
+				xt.Eq(t, 1, m.make(append([]string{target.Name}, c.given...)...))
+				xt.Eq(t, exp, strings.TrimSpace(bufErr.String()))
+			})
+		}
+	})
+}

target.go

@@ -18,4 +18,5 @@ type Target struct {
 	DeferredTargets []*Target
 	PreTargets      []*Target
 	Do              func(*Target) error
+	WorkDir         string
 }