Introduce k6 cloud upload to replace --upload-only

cmd/cloud.go

@@ -12,18 +12,17 @@ import (
  "sync"
  "time"
 
- "github.com/fatih/color"
  "go.k6.io/k6/cloudapi"
+ "go.k6.io/k6/cmd/state"
  "go.k6.io/k6/errext"
  "go.k6.io/k6/errext/exitcodes"
  "go.k6.io/k6/lib"
  "go.k6.io/k6/lib/consts"
  "go.k6.io/k6/ui/pb"
 
+ "github.com/fatih/color"
  "github.com/spf13/cobra"
  "github.com/spf13/pflag"
-
- "go.k6.io/k6/cmd/state"
 )
 
 // cmdCloud handles the `k6 cloud` sub-command
@@ -335,6 +334,9 @@ func (c *cmdCloud) flagSet() *pflag.FlagSet {
  "enable showing of logs when a test is executed in the cloud")
  flags.BoolVar(&c.uploadOnly, "upload-only", c.uploadOnly,
  "only upload the test to the cloud without actually starting a test run")
+ if err := flags.MarkDeprecated("upload-only", "use \"k6 cloud upload\" instead"); err != nil {
+ panic(err)
+ }
 
  return flags
 }
@@ -383,6 +385,7 @@ service. Be sure to run the "k6 cloud login" command prior to authenticate with
  // Register `k6 cloud` subcommands
  cloudCmd.AddCommand(getCmdCloudRun(gs))
  cloudCmd.AddCommand(getCmdCloudLogin(gs))
+ cloudCmd.AddCommand(getCmdCloudUpload(c))
 
  cloudCmd.Flags().SortFlags = false
  cloudCmd.Flags().AddFlagSet(c.flagSet())

cmd/cloud_login.go

@@ -29,16 +29,16 @@ func getCmdCloudLogin(gs *state.GlobalState) *cobra.Command {
  // loginCloudCommand represents the 'cloud login' command
  exampleText := getExampleText(gs, `
  # Prompt for a Grafana Cloud k6 token
- {{.}} cloud login
+ $ {{.}} cloud login
 
  # Store a token in k6's persistent configuration
- {{.}} cloud login -t <YOUR_TOKEN>
+ $ {{.}} cloud login -t <YOUR_TOKEN>
 
  # Display the stored token
- {{.}} cloud login -s
+ $ {{.}} cloud login -s
 
  # Reset the stored token
- {{.}} cloud login -r`[1:])
+ $ {{.}} cloud login -r`[1:])
 
  loginCloudCommand := &cobra.Command{
  Use: cloudLoginCommandName,

cmd/cloud_upload.go

@@ -0,0 +1,67 @@
+package cmd
+
+import (
+ "go.k6.io/k6/cmd/state"
+
+ "github.com/spf13/cobra"
+ "github.com/spf13/pflag"
+)
+
+const cloudUploadCommandName = "upload"
+
+type cmdCloudUpload struct {
+ globalState *state.GlobalState
+
+ // deprecatedCloudCmd holds an instance of the k6 cloud command that we store
+ // in order to be able to call its run method to support the cloud upload
+ // feature
+ deprecatedCloudCmd *cmdCloud
+}
+
+func getCmdCloudUpload(cloudCmd *cmdCloud) *cobra.Command {
+ c := &cmdCloudUpload{
+ globalState: cloudCmd.gs,
+ deprecatedCloudCmd: cloudCmd,
+ }
+
+ // uploadCloudCommand represents the 'cloud upload' command
+ exampleText := getExampleText(cloudCmd.gs, `
+ # Upload the test to the Grafana Cloud k6 without actually starting a test run
+ $ {{.}} cloud upload script.js`[1:])
+
+ uploadCloudCommand := &cobra.Command{
+ Use: cloudUploadCommandName,
+ Short: "Upload the test to the Grafana Cloud k6",
+ Long: `Upload the test to the Grafana Cloud k6.
+
+This will upload the test to the Grafana Cloud k6 service. Using this command requires to be authenticated
+against the Grafana Cloud k6. Use the "k6 cloud login" command to authenticate.
+`,
+ Example: exampleText,
+ Args: exactArgsWithMsg(1, "arg should either be \"-\", if reading script from stdin, or a path to a script file"),
+ PreRunE: c.preRun,
+ RunE: c.run,
+ }
+
+ uploadCloudCommand.Flags().AddFlagSet(c.flagSet())
+
+ return uploadCloudCommand
+}
+
+func (c *cmdCloudUpload) preRun(cmd *cobra.Command, args []string) error {
+ return c.deprecatedCloudCmd.preRun(cmd, args)
+}
+
+// run is the code that runs when the user executes `k6 cloud upload`
+func (c *cmdCloudUpload) run(cmd *cobra.Command, args []string) error {
+ c.deprecatedCloudCmd.uploadOnly = true
+ return c.deprecatedCloudCmd.run(cmd, args)
+}
+
+func (c *cmdCloudUpload) flagSet() *pflag.FlagSet {
+ flags := pflag.NewFlagSet("", pflag.ContinueOnError)
+ flags.SortFlags = false
+ flags.AddFlagSet(optionFlagSet())
+ flags.AddFlagSet(runtimeOptionFlagSet(false))
+ return flags
+}

cmd/tests/cmd_cloud_upload_test.go

@@ -0,0 +1,157 @@
+package tests
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "go.k6.io/k6/cloudapi"
+ "go.k6.io/k6/cmd"
+ "go.k6.io/k6/lib/fsext"
+ "go.k6.io/k6/lib/testutils"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestK6CloudUpload(t *testing.T) {
+ t.Parallel()
+
+ t.Run("TestCloudUploadNotLoggedIn", func(t *testing.T) {
+ t.Parallel()
+
+ ts := getSimpleCloudTestState(t, nil, setupK6CloudUploadCmd, nil, nil, nil)
+ delete(ts.Env, "K6_CLOUD_TOKEN")
+ ts.ExpectedExitCode = -1 // TODO: use a more specific exit code?
+ cmd.ExecuteWithGlobalState(ts.GlobalState)
+
+ stdout := ts.Stdout.String()
+ t.Log(stdout)
+ assert.Contains(t, stdout, `not logged in`)
+ })
+
+ t.Run("TestCloudUploadWithScript", func(t *testing.T) {
+ t.Parallel()
+
+ cs := func() cloudapi.TestProgressResponse {
+ return cloudapi.TestProgressResponse{
+ RunStatusText: "Archived",
+ RunStatus: cloudapi.RunStatusArchived,
+ }
+ }
+
+ ts := getSimpleCloudTestState(t, nil, setupK6CloudUploadCmd, nil, nil, cs)
+ cmd.ExecuteWithGlobalState(ts.GlobalState)
+
+ stdout := ts.Stdout.String()
+ t.Log(stdout)
+ assert.Contains(t, stdout, `execution: cloud`)
+ assert.Contains(t, stdout, `output: https://app.k6.io/runs/123`)
+ assert.Contains(t, stdout, `test status: Archived`)
+ })
+
+ // TestCloudUploadWithArchive tests that if k6 uses a static archive with the script inside that has cloud options like:
+ //
+ // export let options = {
+ // ext: {
+ // loadimpact: {
+ // name: "my load test",
+ // projectID: 124,
+ // note: "lorem ipsum",
+ // },
+ // }
+ // };
+ //
+ // actually sends to the cloud the archive with the correct metadata (metadata.json), like:
+ //
+ // "ext": {
+ // "loadimpact": {
+ // "name": "my load test",
+ // "note": "lorem ipsum",
+ // "projectID": 124
+ // }
+ // }
+ t.Run("TestCloudUploadWithArchive", func(t *testing.T) {
+ t.Parallel()
+
+ testRunID := 123
+ ts := NewGlobalTestState(t)
+
+ archiveUpload := http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+ // check the archive
+ file, _, err := req.FormFile("file")
+ assert.NoError(t, err)
+ assert.NotNil(t, file)
+
+ // temporary write the archive for file system
+ data, err := io.ReadAll(file)
+ assert.NoError(t, err)
+
+ tmpPath := filepath.Join(ts.Cwd, "archive_to_cloud.tar")
+ require.NoError(t, fsext.WriteFile(ts.FS, tmpPath, data, 0o644))
+
+ // check what inside
+ require.NoError(t, testutils.Untar(t, ts.FS, tmpPath, "tmp/"))
+
+ metadataRaw, err := fsext.ReadFile(ts.FS, "tmp/metadata.json")
+ require.NoError(t, err)
+
+ metadata := struct {
+ Options struct {
+ Cloud struct {
+ Name string `json:"name"`
+ Note string `json:"note"`
+ ProjectID int `json:"projectID"`
+ } `json:"cloud"`
+ } `json:"options"`
+ }{}
+
+ // then unpacked metadata should not contain any environment variables passed at the moment of archive creation
+ require.NoError(t, json.Unmarshal(metadataRaw, &metadata))
+ require.Equal(t, "my load test", metadata.Options.Cloud.Name)
+ require.Equal(t, "lorem ipsum", metadata.Options.Cloud.Note)
+ require.Equal(t, 124, metadata.Options.Cloud.ProjectID)
+
+ // respond with the test run ID
+ resp.WriteHeader(http.StatusOK)
+ _, err = fmt.Fprintf(resp, `{"reference_id": "%d"}`, testRunID)
+ assert.NoError(t, err)
+ })
+
+ cs := func() cloudapi.TestProgressResponse {
+ return cloudapi.TestProgressResponse{
+ RunStatusText: "Archived",
+ RunStatus: cloudapi.RunStatusArchived,
+ }
+ }
+
+ srv := getMockCloud(t, testRunID, archiveUpload, cs)
+
+ data, err := os.ReadFile(filepath.Join("testdata/archives", "archive_v0.46.0_with_loadimpact_option.tar")) //nolint:forbidigo // it's a test
+ require.NoError(t, err)
+
+ require.NoError(t, fsext.WriteFile(ts.FS, filepath.Join(ts.Cwd, "archive.tar"), data, 0o644))
+
+ ts.CmdArgs = []string{"k6", "cloud", "upload", "archive.tar"}
+ ts.Env["K6_SHOW_CLOUD_LOGS"] = "false" // no mock for the logs yet
+ ts.Env["K6_CLOUD_HOST"] = srv.URL
+ ts.Env["K6_CLOUD_TOKEN"] = "foo" // doesn't matter, we mock the cloud
+
+ cmd.ExecuteWithGlobalState(ts.GlobalState)
+
+ stdout := ts.Stdout.String()
+ t.Log(stdout)
+ assert.NotContains(t, stdout, `not logged in`)
+ assert.Contains(t, stdout, `execution: cloud`)
+ assert.Contains(t, stdout, `output: https://app.k6.io/runs/123`)
+ assert.Contains(t, stdout, `test status: Archived`)
+ })
+}
+
+func setupK6CloudUploadCmd(cliFlags []string) []string {
+ return append([]string{"k6", "cloud", "upload"}, append(cliFlags, "test.js")...)
+}