Merge pull request #62 from grafana/use-input-from-stdin

Use input from stdin

Author: pablochacin

README.md

@@ -136,6 +136,8 @@ Analyze the k6 test script and extract the extensions that the script depends on
 
 Dependencies can come from three sources: k6 test script, manifest file, `K6_DEPENDENCIES` environment variable. Instead of these three sources, a k6 archive can also be specified, which can contain all three sources (currently two actually, because the manifest file is not yet included in the k6 archive).
 
+The name of k6 test script or archive can be specified as the positional argument in the command invocation. Alternatively, the content can be provided in the stdin. If stdin is used, the input format ('js' for script of or 'tar' for archive) must be specified using the `--input` parameter.
+
 Primarily, the k6 test script is the source of dependencies. The test script and the local and remote JavaScript modules it uses are recursively analyzed. The extensions used by the test script are collected. In addition to the require function and import expression, the `"use k6 ..."` directive can be used to specify additional extension dependencies. If necessary, the `"use k6 ..."` directive can also be used to specify version constraints.
 
     "use k6 > 0.54";
@@ -189,6 +191,7 @@ k6deps [flags] [script-file]
       --ignore-manifest       disable package.json detection and processing
       --ignore-script         disable script processing
       --ingnore-env           ignore K6_DEPENDENCIES environment variable processing
+  -i, --input string          input format ('js' or 'tar' for archives)
       --manifest string       manifest file to analyze (default 'package.json' nearest to script-file)
   -o, --output string         write output to file (default stdout)
 ```

cmd/cmd.go

@@ -2,6 +2,7 @@
 package cmd
 
 import (
+	"bytes"
 	_ "embed"
 	"encoding/json"
 	"fmt"
@@ -36,6 +37,7 @@ const (
 
 type options struct {
 	k6deps.Options
+	input  string
 	format format
 	output string
 }
@@ -69,11 +71,13 @@ func New() *cobra.Command {
 		"ignore "+k6deps.EnvDependencies+" environment variable processing")
 	flags.BoolVar(&opts.Manifest.Ignore, "ignore-manifest", false, "disable package.json detection and processing")
 	flags.BoolVar(&opts.Script.Ignore, "ignore-script", false, "disable script processing")
-
+	flags.StringVarP(&opts.input, "input", "i", "", "input format ('js' or 'tar' for archives)")
 	return cmd
 }
 
 func deps(opts *options, args []string) error {
+	var ignoreStdin bool
+
 	if len(args) > 0 {
 		filename := args[0]
 		switch filepath.Ext(filename) {
@@ -84,6 +88,23 @@ func deps(opts *options, args []string) error {
 		default:
 			return fmt.Errorf("unsupported file extension: %s", filepath.Ext(filename))
 		}
+		ignoreStdin = true
+	}
+
+	if opts.input != "" && !ignoreStdin {
+		buffer := &bytes.Buffer{}
+		buffer.ReadFrom(os.Stdin) //nolint:errcheck,forbidigo,gosec
+
+		switch opts.input {
+		case "js":
+			opts.Script.Name = "stdin"
+			opts.Script.Contents = buffer.Bytes()
+		case "tar":
+			opts.Archive.Name = "stdin"
+			opts.Archive.Contents = buffer.Bytes()
+		default:
+			return fmt.Errorf("unsupported input format: %s", opts.input)
+		}
 	}
 
 	var out io.Writer

cmd/cmd_test.go

@@ -10,63 +10,121 @@ import (
 )
 
 //nolint:forbidigo
-func Test_New(t *testing.T) {
+func Test_Root(t *testing.T) {
 	t.Parallel()
 
-	root := cmd.New()
-	require.Equal(t, "k6deps [flags] [script-file]", root.Use)
+	t.Run("New", func(t *testing.T) {
+		t.Parallel()
 
-	dir := t.TempDir()
+		root := cmd.New()
+		require.Equal(t, "k6deps [flags] [script-file]", root.Use)
+	})
 
 	scriptfile := filepath.Join("testdata", "script.js")
 	archive := filepath.Join("testdata", "archive.tar")
 
-	out := filepath.Clean(filepath.Join(dir, "output"))
-
-	root = cmd.New()
-	root.SetArgs([]string{"--ingnore-env", "--ignore-manifest", "-o", out, scriptfile})
-	err := root.Execute()
-	require.NoError(t, err)
-
-	contents, err := os.ReadFile(out)
-	require.NoError(t, err)
-	require.Equal(t, `{"k6/x/faker":">v0.3.0","xk6-top":"*"}`+"\n", string(contents))
-
-	root = cmd.New()
-	root.SetArgs([]string{"--ingnore-env", "--ignore-manifest", "-o", out, archive})
-	err = root.Execute()
-	require.NoError(t, err)
-
-	contents, err = os.ReadFile(out)
-	require.NoError(t, err)
-	require.Equal(t, `{"k6":">0.54","k6/x/faker":">0.4.0","k6/x/sql":">=1.0.1","k6/x/sql/driver/ramsql":"*"}`+"\n", string(contents))
-
-	root = cmd.New()
-	root.SetArgs([]string{"--ingnore-env", "--ignore-manifest", "--format", "json", "-o", out, scriptfile})
-	err = root.Execute()
-	require.NoError(t, err)
-
-	contents, err = os.ReadFile(out)
-	require.NoError(t, err)
-	require.Equal(t, `{"k6/x/faker":">v0.3.0","xk6-top":"*"}`+"\n", string(contents))
-
-	root = cmd.New()
-	root.SetArgs([]string{"--ingnore-env", "--ignore-manifest", "--format", "text", "-o", out, scriptfile})
-	err = root.Execute()
-	require.NoError(t, err)
-
-	contents, err = os.ReadFile(out)
-	require.NoError(t, err)
-	require.Equal(t, `k6/x/faker>v0.3.0;xk6-top*`+"\n", string(contents))
-
-	root = cmd.New()
-	root.SetArgs([]string{"--ingnore-env", "--ignore-manifest", "--format", "js", "-o", out, scriptfile})
-	err = root.Execute()
-	require.NoError(t, err)
-
-	contents, err = os.ReadFile(out)
-	require.NoError(t, err)
-	require.Equal(t, `"use k6 with k6/x/faker>v0.3.0";
-"use k6 with xk6-top*";
-`, string(contents))
+	testCases := []struct {
+		name     string
+		args     []string
+		source   string
+		expected string
+	}{
+		{
+			name:     "script default format",
+			args:     []string{"--ingnore-env", "--ignore-manifest"},
+			source:   scriptfile,
+			expected: `{"k6/x/faker":">v0.3.0","xk6-top":"*"}` + "\n",
+		},
+		{
+			name:     "script json format",
+			args:     []string{"--ingnore-env", "--ignore-manifest", "--format", "json"},
+			source:   scriptfile,
+			expected: `{"k6/x/faker":">v0.3.0","xk6-top":"*"}` + "\n",
+		},
+		{
+			name:     "script text format",
+			args:     []string{"--ingnore-env", "--ignore-manifest", "--format", "text"},
+			source:   scriptfile,
+			expected: `k6/x/faker>v0.3.0;xk6-top*` + "\n",
+		},
+		{
+			name:     "script js format",
+			args:     []string{"--ingnore-env", "--ignore-manifest", "--format", "js"},
+			source:   scriptfile,
+			expected: `"use k6 with k6/x/faker>v0.3.0";` + "\n" + `"use k6 with xk6-top*";` + "\n",
+		},
+		{
+			name:     "archive",
+			args:     []string{"--ingnore-env", "--ignore-manifest"},
+			source:   archive,
+			expected: `{"k6":">0.54","k6/x/faker":">0.4.0","k6/x/sql":">=1.0.1","k6/x/sql/driver/ramsql":"*"}` + "\n",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			out := filepath.Clean(filepath.Join(t.TempDir(), "output"))
+
+			root := cmd.New()
+			args := tc.args
+			args = append(args, "-o", out, tc.source)
+			root.SetArgs(args)
+			err := root.Execute()
+			require.NoError(t, err)
+
+			contents, err := os.ReadFile(out)
+			require.NoError(t, err)
+			require.Equal(t, tc.expected, string(contents))
+		})
+	}
+
+	t.Run("using input", func(t *testing.T) {
+		t.Parallel()
+
+		testCases := []struct {
+			name     string
+			source   string
+			input    string
+			expected string
+		}{
+			{
+				name:     "script",
+				input:    "js",
+				source:   scriptfile,
+				expected: `{"k6/x/faker":">v0.3.0","xk6-top":"*"}` + "\n",
+			},
+			{
+				name:     "archive",
+				input:    "tar",
+				source:   archive,
+				expected: `{"k6":">0.54","k6/x/faker":">0.4.0","k6/x/sql":">=1.0.1","k6/x/sql/driver/ramsql":"*"}` + "\n",
+			},
+		}
+
+		// the following tests cannot be executed in parallel because they modify the stdin
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				var err error
+				stdin := os.Stdin
+				t.Cleanup(func() { os.Stdin = stdin })
+
+				out := filepath.Clean(filepath.Join(t.TempDir(), "output"))
+
+				root := cmd.New()
+				os.Stdin, err = os.Open(tc.source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				root.SetArgs([]string{"--ingnore-env", "--ignore-manifest", "--input", tc.input, "--format", "json", "-o", out})
+				err = root.Execute()
+
+				require.NoError(t, err)
+
+				contents, err := os.ReadFile(out)
+				require.NoError(t, err)
+				require.Equal(t, tc.expected, string(contents))
+			})
+		}
+	})
 }

cmd/help.md

@@ -4,6 +4,8 @@ Analyze the k6 test script and extract the extensions that the script depends on
 
 Dependencies can come from three sources: k6 test script, manifest file, `K6_DEPENDENCIES` environment variable. Instead of these three sources, a k6 archive can also be specified, which can contain all three sources (currently two actually, because the manifest file is not yet included in the k6 archive).
 
+The name of k6 test script or archive can be specified as the positional argument in the command invocation. Alternatively, the content can be provided in the stdin. If stdin is used, the input format ('js' for script of or 'tar' for archive) must be specified using the `--input` parameter.
+
 Primarily, the k6 test script is the source of dependencies. The test script and the local and remote JavaScript modules it uses are recursively analyzed. The extensions used by the test script are collected. In addition to the require function and import expression, the `"use k6 ..."` directive can be used to specify additional extension dependencies. If necessary, the `"use k6 ..."` directive can also be used to specify version constraints.
 
     "use k6 > 0.54";