add support for dependencies manifest

Signed-off-by: Pablo Chacin <pablochacin@gmail.com>

Author: pablochacin

cmd/state/state.go

@@ -28,6 +28,9 @@ const (
 	// AutoExtensionResolution defines the environment variable that enables using extensions natively
 	AutoExtensionResolution = "K6_AUTO_EXTENSION_RESOLUTION"
 
+	// DependenciesManifest defines the default values for dependency resolution
+	DependenciesManifest = "K6_DEPENDENCIES_MANIFEST"
+
 	// communityExtensionsCatalog defines the catalog for community extensions
 	communityExtensionsCatalog = "oss"
 
@@ -185,6 +188,7 @@ type GlobalFlags struct {
 	BuildServiceURL           string
 	BinaryCache               string
 	EnableCommunityExtensions bool
+	DependenciesManifest      string
 }
 
 // GetDefaultFlags returns the default global flags.
@@ -250,6 +254,9 @@ func getFlags(defaultFlags GlobalFlags, env map[string]string, args []string) Gl
 			result.EnableCommunityExtensions = vb
 		}
 	}
+	if val, ok := env["K6_DEPENDENCIES_MANIFEST"]; ok {
+		result.DependenciesManifest = val
+	}
 
 	// adjust BuildServiceURL if community extensions are enable
 	// community extensions flag only takes effect if the default build service is used

internal/cmd/deps.go

@@ -38,6 +38,12 @@ func getCmdDeps(gs *state.GlobalState) *cobra.Command {
 				}
 				depsMap[name] = constraint.String()
 			}
+
+			depsMap, err = mergeManifest(depsMap, gs.Flags.DependenciesManifest)
+			if err != nil {
+				return err
+			}
+
 			imports := test.Imports()
 			slices.Sort(imports)
 
@@ -69,3 +75,5 @@ func getCmdDeps(gs *state.GlobalState) *cobra.Command {
 
 	return depsCmd
 }
+
+

internal/cmd/launcher.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"bytes"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"os"
@@ -299,3 +300,32 @@ func findDirectives(text []byte) []string {
 	}
 	return result
 }
+
+func mergeManifest(deps map[string]string, manifestString string) (map[string]string, error) {
+	if manifestString == "" {
+		return deps, nil
+	}
+
+	manifest := make(map[string]string)
+	if err := json.Unmarshal([]byte(manifestString), &manifest); err != nil {
+		return nil, fmt.Errorf("invalid dependencies manifest %w", err)
+	}
+
+	result := make(map[string]string)
+	for dep, constraint := range deps {
+		result[dep] = constraint
+
+		// if deps has a non default constrain, keep ip
+		if constraint != "" && constraint != "*" {
+			continue
+		}
+
+		// check if there's an override in the manifest
+		manifestConstrain := manifest[dep]
+		if manifestConstrain != "" && manifestConstrain != "*" {
+			result[dep] = manifestConstrain
+		}
+	}
+
+	return result, nil
+}

internal/cmd/launcher_test.go

@@ -314,3 +314,77 @@ const l = 5
 		})
 	}
 }
+
+func TestMergeManifest(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name          string
+		deps          map[string]string
+		manifest      string
+		expected      map[string]string
+		expectedError string
+	}{
+		{
+			name:     "default constrain with no manifest",
+			deps:     map[string]string{"k6/x/dep": "*"},
+			manifest: "",
+			expected: map[string]string{"k6/x/dep": "*"},
+		},
+		{
+			name:     "empty constrain with no manifest",
+			deps:     map[string]string{"k6/x/dep": ""},
+			manifest: "",
+			expected: map[string]string{"k6/x/dep": ""},
+		},
+		{
+			name:     "default constrain with empty manifest",
+			deps:     map[string]string{"k6/x/dep": "*"},
+			manifest: "{}",
+			expected: map[string]string{"k6/x/dep": "*"},
+		},
+		{
+			name:     "default constrain with manifest overrides",
+			deps:     map[string]string{"k6/x/dep": "*"},
+			manifest: `{"k6/x/dep": "=v0.0.0"}`,
+			expected: map[string]string{"k6/x/dep": "=v0.0.0"},
+		},
+		{
+			name:     "dependency with version constraint",
+			deps:     map[string]string{"k6/x/dep": "=v0.0.1"},
+			manifest: `{"k6/x/dep": "=v0.0.0"}`,
+			expected: map[string]string{"k6/x/dep": "=v0.0.1"},
+		},
+		{
+			name:     "manifest with different dependency",
+			deps:     map[string]string{"k6/x/dep": "*"},
+			manifest: `{"k6/x/another": "=v0.0.0"}`,
+			expected: map[string]string{"k6/x/dep": "*"},
+		},
+		{
+			name:     "no dependencies",
+			deps:     map[string]string{},
+			manifest: `{"k6/x/dep": "=v0.0.0"}`,
+			expected: map[string]string{},
+		},
+		{
+			name:          "malformed manifest",
+			deps:          map[string]string{"k6/x/dep": "*"},
+			manifest:      `{"k6/x/dep": }`,
+			expectedError: "invalid dependencies manifest",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			merged, err := mergeManifest(test.deps, test.manifest)
+
+			if len(test.expectedError) > 0 {
+				require.ErrorContains(t, err, test.expectedError)
+			} else {
+				require.EqualValues(t, test.expected, merged)
+			}
+		})
+	}
+}

internal/cmd/root.go

@@ -166,7 +166,20 @@ func handleUnsatisfiedDependencies(err error, c *rootCommand) (exitcodes.ExitCod
 			" it's required to provision a custom binary.")
 	provisioner := newK6BuildProvisioner(c.globalState)
 	var customBinary commandExecutor
-	customBinary, err = provisioner.provision(constraintsMapToProvisionDependency(deps))
+
+	// merge the script dependencies with the dependencies manifest, if specified
+	manifest := c.globalState.Flags.DependenciesManifest
+	depsMap, err := mergeManifest(constraintsMapToProvisionDependency(deps), manifest)
+	if err != nil {
+		c.globalState.Logger.
+			WithField("deps", deps).
+			WithField("manifest", manifest).
+			WithError(err).
+			Error("Failed to process the dependecies manifest for automatic dependency resolution")
+		return 0, err
+	}
+
+	customBinary, err = provisioner.provision(depsMap)
 	if err != nil {
 		err = errext.WithExitCodeIfNone(err, exitcodes.ScriptException)
 		c.globalState.Logger.