test(act): add tests for tooling versions (go, node) and js package manager detection logic (#517)

Author: xnyo

actions/internal/plugins/setup/action.yml

@@ -49,6 +49,20 @@ inputs:
     description: mage version to use.
     required: true
 
+outputs:
+  node-version:
+    description: The Node.js version that was installed.
+    value: ${{ steps.node.outputs.node-version }}
+  go-version:
+    description: The Go version that was installed.
+    value: ${{ steps.go.outputs.go-version }}
+  node-package-manager-name:
+    description: The name of the detected Node.js package manager (npm, yarn, or pnpm).
+    value: ${{ steps.package-manager.outputs.name }}
+  node-package-manager-version:
+    description: The version of the detected Node.js package manager.
+    value: ${{ steps.package-manager.outputs.version }}
+
 runs:
   using: composite
   steps:
@@ -66,6 +80,7 @@ runs:
         version: ${{ steps.package-manager.outputs.version }}
 
     - name: Node
+      id: node
       uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
       with:
         node-version: "${{ inputs.node-version }}"

tests/act/go.mod

@@ -6,6 +6,7 @@ require (
 	github.com/goccy/go-yaml v1.18.0
 	github.com/google/uuid v1.6.0
 	github.com/spf13/afero v1.15.0
+	golang.org/x/mod v0.32.0
 )
 
 require golang.org/x/text v0.28.0 // indirect

tests/act/go.sum

@@ -10,6 +10,8 @@ github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
 github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
+golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
 golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
 golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=

tests/act/internal/versions/versions.go

@@ -0,0 +1,103 @@
+// Package versions provides functions to fetch the latest versions of Node.js and Go
+// from their official release APIs.
+package versions
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"golang.org/x/mod/semver"
+)
+
+const (
+	nodeReleasesURL = "https://nodejs.org/download/release/index.json"
+	goReleasesURL   = "https://golang.org/dl/?mode=json&include=all"
+	httpTimeout     = 30 * time.Second
+)
+
+type nodeRelease struct {
+	Version string `json:"version"` // e.g., "v24.12.0"
+}
+
+type goRelease struct {
+	Version string `json:"version"` // e.g., "go1.25.6"
+	Stable  bool   `json:"stable"`
+}
+
+// LatestNodeVersion returns the latest Node.js version for a given major version.
+// For example, LatestNodeVersion("24") might return "v24.12.0".
+func LatestNodeVersion(major string) (string, error) {
+	releases, err := fetchJSON[[]nodeRelease](nodeReleasesURL)
+	if err != nil {
+		return "", fmt.Errorf("fetch node releases: %w", err)
+	}
+
+	// Match versions like "v24.x.y" for major "24"
+	prefix := "v" + major + "."
+	for _, r := range releases {
+		if strings.HasPrefix(r.Version, prefix) {
+			// The releases are sorted newest first, so the first match is the latest
+			return r.Version, nil
+		}
+	}
+
+	return "", fmt.Errorf("no releases found for Node.js major version %q", major)
+}
+
+// LatestGoVersion returns the latest Go version for a given major.minor version.
+// For example, LatestGoVersion("1.25") might return "1.25.6".
+func LatestGoVersion(majorMinor string) (string, error) {
+	releases, err := fetchJSON[[]goRelease](goReleasesURL)
+	if err != nil {
+		return "", fmt.Errorf("fetch go releases: %w", err)
+	}
+
+	prefix := "go" + majorMinor
+	var candidates []string
+
+	for _, r := range releases {
+		if !r.Stable {
+			continue
+		}
+		// Match "go1.25" or "go1.25.x"
+		if r.Version == prefix || strings.HasPrefix(r.Version, prefix+".") {
+			// Convert to semver format: "go1.25.6" -> "v1.25.6"
+			v := "v" + strings.TrimPrefix(r.Version, "go")
+			candidates = append(candidates, v)
+		}
+	}
+
+	if len(candidates) == 0 {
+		return "", fmt.Errorf("no stable releases found for Go version %q", majorMinor)
+	}
+
+	semver.Sort(candidates)
+	latest := candidates[len(candidates)-1]
+
+	// Convert back: "v1.25.6" -> "1.25.6"
+	return strings.TrimPrefix(latest, "v"), nil
+}
+
+func fetchJSON[T any](url string) (T, error) {
+	var result T
+
+	client := &http.Client{Timeout: httpTimeout}
+	resp, err := client.Get(url)
+	if err != nil {
+		return result, fmt.Errorf("fetch %s: %w", url, err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	if resp.StatusCode != http.StatusOK {
+		return result, fmt.Errorf("fetch %s: status %d", url, resp.StatusCode)
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return result, fmt.Errorf("decode JSON from %s: %w", url, err)
+	}
+
+	return result, nil
+}

tests/act/internal/versions/versions_test.go

@@ -0,0 +1,21 @@
+package versions
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestLatestNodeVersion(t *testing.T) {
+	version, err := LatestNodeVersion("24")
+	require.NoError(t, err)
+	require.Regexp(t, `^v24\.\d+\.\d+$`, version, "should match v24.x.y pattern")
+	t.Logf("Latest Node.js 24.x: %s", version)
+}
+
+func TestLatestGoVersion(t *testing.T) {
+	version, err := LatestGoVersion("1.25")
+	require.NoError(t, err)
+	require.Regexp(t, `^1\.25(\.\d+)?$`, version, "should match 1.25 or 1.25.x pattern")
+	t.Logf("Latest Go 1.25.x: %s", version)
+}

tests/act/internal/workflow/ci/ci.go

@@ -95,6 +95,12 @@ type WorkflowInputs struct {
 	PluginVersionSuffix *string
 	DistArtifactsPrefix *string
 
+	GoVersion           *string
+	NodeVersion         *string
+	GolangciLintVersion *string
+	MageVersion         *string
+	TrufflehogVersion   *string
+
 	RunPlaywright *bool
 
 	RunPluginValidator    *bool
@@ -112,10 +118,20 @@ func SetCIInputs(dst *workflow.Job, inputs WorkflowInputs) {
 	workflow.SetJobInput(dst, "plugin-directory", inputs.PluginDirectory)
 	workflow.SetJobInput(dst, "plugin-version-suffix", inputs.PluginVersionSuffix)
 	workflow.SetJobInput(dst, "dist-artifacts-prefix", inputs.DistArtifactsPrefix)
+
+	workflow.SetJobInput(dst, "go-version", inputs.GoVersion)
+	workflow.SetJobInput(dst, "node-version", inputs.NodeVersion)
+	workflow.SetJobInput(dst, "golangci-lint-version", inputs.GolangciLintVersion)
+	workflow.SetJobInput(dst, "mage-version", inputs.MageVersion)
+	workflow.SetJobInput(dst, "trufflehog-version", inputs.TrufflehogVersion)
+
 	workflow.SetJobInput(dst, "run-playwright", inputs.RunPlaywright)
+
 	workflow.SetJobInput(dst, "run-plugin-validator", inputs.RunPluginValidator)
 	workflow.SetJobInput(dst, "plugin-validator-config", inputs.PluginValidatorConfig)
+
 	workflow.SetJobInput(dst, "run-trufflehog", inputs.RunTruffleHog)
+
 	workflow.SetJobInput(dst, "allow-unsigned", inputs.AllowUnsigned)
 	workflow.SetJobInput(dst, "testing", inputs.Testing)
 }

tests/act/internal/workflow/testing.go

@@ -161,21 +161,27 @@ func NewTestingWorkflow(baseName string, workflow BaseWorkflow, opts ...TestingW
 // TestingWorkflowOption defines a function type for configuring TestingWorkflow instances.
 type TestingWorkflowOption func(*TestingWorkflow)
 
-// WithOnlyOneJob keeps only the given job ID and its dependencies
-// in the workflow, removing all other jobs.
-// This can be used to run only a specific job for testing purposes.
-func WithOnlyOneJob(t *testing.T, jobID string) TestingWorkflowOption {
+// WithOnlyOneJob keeps only the given job ID, removing all other jobs.
+// If removeDependencies is true, it will also remove all dependencies of the given job.
+// You normally don't want to remove dependencies, otherwise the workflow might fail if it consumes the output of a dependency.
+func WithOnlyOneJob(t *testing.T, jobID string, removeDependencies bool) TestingWorkflowOption {
 	return func(twf *TestingWorkflow) {
 		onlyJob, ok := twf.BaseWorkflow.Jobs[jobID]
 		require.True(t, ok, fmt.Errorf("job %q not found", jobID))
 
-		// Remove all jobs except the given one and its dependencies
+		// Remove all jobs
 		for k := range twf.BaseWorkflow.Jobs {
-			if k == jobID || slices.Contains(onlyJob.Needs, k) {
+			// Do not remove the given job if it's a dependency and we don't want to remove dependencies
+			if k == jobID || (slices.Contains(onlyJob.Needs, k) && !removeDependencies) {
 				continue
 			}
 			delete(twf.BaseWorkflow.Jobs, k)
 		}
+		// Remove all dependencies from the only job left in the workflow, otherwise it won't run
+		// because it depends on a job that has been removed.
+		if removeDependencies {
+			onlyJob.Needs = nil
+		}
 	}
 }
 
@@ -209,6 +215,67 @@ func WithNoOpStep(t *testing.T, jobID, stepID string) TestingWorkflowOption {
 	}
 }
 
+// InjectedStepsOptions defines options for injecting steps into a job via WithInjectedSteps.
+type InjectedStepsOptions struct {
+	// Position indicates whether to inject the new steps before or after the injection step.
+	Position InjectedStepsOptionsPosition
+
+	// InjectionStepID is the ID of the step where the new steps will be injected.
+	// Either InjectionStepID or InjectionStepIndex must be set, but not both.
+	InjectionStepID string
+
+	// InjectionStepIndex is the index of the step where the new steps will be injected.
+	// You can use 0 to inject before the first step.
+	// You can use -1 to inject after the last step.
+	// Otherwise, provide a valid step index to inject before/after that step, depending on Position.
+	// Either InjectionStepID or InjectionStepIndex must be set, but not both.
+	InjectionStepIndex int
+
+	// Steps are the steps to be injected.
+	Steps Steps
+}
+
+// InjectedStepsOptionsPosition indicates the position where the new steps will be injected.
+type InjectedStepsOptionsPosition int
+
+const (
+	// InjectedStepsOptionsPositionBefore indicates that the new steps will be injected before the injection step.
+	InjectedStepsOptionsPositionBefore InjectedStepsOptionsPosition = iota
+
+	// InjectedStepsOptionsPositionAfter indicates that the new steps will be injected after the injection step.
+	InjectedStepsOptionsPositionAfter
+)
+
+// WithInjectedSteps injects the given steps into the given job at the specified position
+// relative to the step identified by InjectionStepID or InjectionStepIndex (see InjectedStepsOptions).
+// This can be used to add custom steps for testing purposes.
+func WithInjectedSteps(t *testing.T, jobID string, opts InjectedStepsOptions) TestingWorkflowOption {
+	return func(twf *TestingWorkflow) {
+		job, ok := twf.BaseWorkflow.Jobs[jobID]
+		require.True(t, ok, fmt.Errorf("job %q not found", jobID))
+
+		var injectionStepIndex int
+		if opts.InjectionStepID != "" {
+			injectionStepIndex = job.getStepIndex(opts.InjectionStepID)
+			require.GreaterOrEqual(t, injectionStepIndex, 0, "injection step with id %q not found", opts.InjectionStepID)
+		} else {
+			injectionStepIndex = opts.InjectionStepIndex
+			require.GreaterOrEqual(t, injectionStepIndex, -1, "injection step index is < -1. it should be -1 (for injecting at the end) or a valid index.")
+			if injectionStepIndex == -1 {
+				injectionStepIndex = len(job.Steps) - 1
+			}
+			require.Less(t, injectionStepIndex, len(job.Steps), "injection step index %d out of bounds (steps length: %d)", injectionStepIndex, len(job.Steps))
+		}
+
+		switch opts.Position {
+		case InjectedStepsOptionsPositionBefore:
+			job.Steps = append(job.Steps[:injectionStepIndex], append(opts.Steps, job.Steps[injectionStepIndex:]...)...)
+		case InjectedStepsOptionsPositionAfter:
+			job.Steps = append(job.Steps[:injectionStepIndex+1], append(opts.Steps, job.Steps[injectionStepIndex+1:]...)...)
+		}
+	}
+}
+
 // WithMatrix sets the matrix for the given job.
 // This can be used to test workflows that use a dynamic matrix.
 // act doesn't support dynamic matrix values, so this is a workaround to set the matrix for the given job.