feat: Create an --output/-o flag for JSON or plain text responses (#195)

Create an --output/-o flag for JSON or plain text responses

* accepts either "json" or "plaintext
* defaults to plaintext

cmd/cliflags/flags.go

@@ -9,6 +9,7 @@ const (
 	EmailsFlag      = "emails"
 	EnvironmentFlag = "environment"
 	FlagFlag        = "flag"
+	OutputFlag      = "output"
 	ProjectFlag     = "project"
 	RoleFlag        = "role"
 )

cmd/config/testdata/help.golden

@@ -12,3 +12,4 @@ Flags:
 Global Flags:
       --access-token string   LaunchDarkly API token with write-level access
       --base-uri string       LaunchDarkly base URI (default "https://app.launchdarkly.com")
+  -o, --output string         Command response output format in either JSON or plain text (default "plaintext")

cmd/environments/get.go

@@ -10,6 +10,7 @@ import (
 	"ldcli/cmd/cliflags"
 	"ldcli/cmd/validators"
 	"ldcli/internal/environments"
+	"ldcli/internal/output"
 )
 
 func NewGetCmd(
@@ -65,7 +66,15 @@ func runGet(
 			return err
 		}
 
-		fmt.Fprintf(cmd.OutOrStdout(), string(response)+"\n")
+		output, err := output.CmdOutput(
+			viper.GetString(cliflags.OutputFlag),
+			output.NewSingularOutputterFn(response),
+		)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintf(cmd.OutOrStdout(), string(output)+"\n")
 
 		return nil
 	}

cmd/environments/get_test.go

@@ -20,27 +20,29 @@ func TestGet(t *testing.T) {
 		"test-env",
 		"test-proj",
 	}
+	stubbedResponse := `{"key": "test-key", "name": "test-name"}`
 
-	t.Run("with valid environments calls API", func(t *testing.T) {
+	t.Run("with valid flags calls API", func(t *testing.T) {
 		client := environments.MockClient{}
 		client.
 			On("Get", mockArgs...).
-			Return([]byte(cmd.ValidResponse), nil)
+			Return([]byte(stubbedResponse), nil)
 		clients := cmd.APIClients{
 			EnvironmentsClient: &client,
 		}
 		args := []string{
 			"environments", "get",
 			"--access-token", "testAccessToken",
 			"--base-uri", "http://test.com",
+			"--output", "json",
 			"--environment", "test-env",
 			"--project", "test-proj",
 		}
 
 		output, err := cmd.CallCmd(t, clients, &analytics.NoopClient{}, args)
 
 		require.NoError(t, err)
-		assert.JSONEq(t, `{"valid": true}`, string(output))
+		assert.JSONEq(t, stubbedResponse, string(output))
 	})
 
 	t.Run("with valid flags from environment variables calls API", func(t *testing.T) {
@@ -49,20 +51,21 @@ func TestGet(t *testing.T) {
 		client := environments.MockClient{}
 		client.
 			On("Get", mockArgs...).
-			Return([]byte(cmd.ValidResponse), nil)
+			Return([]byte(stubbedResponse), nil)
 		clients := cmd.APIClients{
 			EnvironmentsClient: &client,
 		}
 		args := []string{
 			"environments", "get",
+			"--output", "json",
 			"--environment", "test-env",
 			"--project", "test-proj",
 		}
 
 		output, err := cmd.CallCmd(t, clients, &analytics.NoopClient{}, args)
 
 		require.NoError(t, err)
-		assert.JSONEq(t, `{"valid": true}`, string(output))
+		assert.JSONEq(t, stubbedResponse, string(output))
 	})
 
 	t.Run("with an error response is an error", func(t *testing.T) {
@@ -77,6 +80,7 @@ func TestGet(t *testing.T) {
 			"environments", "get",
 			"--access-token", "testAccessToken",
 			"--base-uri", "http://test.com",
+			"--output", "json",
 			"--environment", "test-env",
 			"--project", "test-proj",
 		}
@@ -144,6 +148,23 @@ func TestGet(t *testing.T) {
 		assert.EqualError(t, err, "base-uri is invalid"+errorHelp)
 	})
 
+	t.Run("with invalid output is an error", func(t *testing.T) {
+		clients := cmd.APIClients{
+			EnvironmentsClient: &environments.MockClient{},
+		}
+		args := []string{
+			"environments", "get",
+			"--access-token", "testAccessToken",
+			"--output", "invalid",
+			"--environment", "test-env",
+			"--project", "test-proj",
+		}
+
+		_, err := cmd.CallCmd(t, clients, &analytics.NoopClient{}, args)
+
+		assert.EqualError(t, err, "output is invalid"+errorHelp)
+	})
+
 	t.Run("will track analytics for CLI Command Run event", func(t *testing.T) {
 		tracker := analytics.MockedTracker(
 			"environments",
@@ -154,7 +175,6 @@ func TestGet(t *testing.T) {
 				"environment",
 				"project",
 			})
-
 		client := environments.MockClient{}
 		client.
 			On("Get", mockArgs...).
@@ -172,6 +192,7 @@ func TestGet(t *testing.T) {
 		}
 
 		_, err := cmd.CallCmd(t, clients, tracker, args)
+
 		require.NoError(t, err)
 	})
 }

cmd/projects/list.go

@@ -9,6 +9,7 @@ import (
 
 	"ldcli/cmd/cliflags"
 	"ldcli/cmd/validators"
+	"ldcli/internal/output"
 	"ldcli/internal/projects"
 )
 
@@ -35,7 +36,15 @@ func runList(client projects.Client) func(*cobra.Command, []string) error {
 			return err
 		}
 
-		fmt.Fprintf(cmd.OutOrStdout(), string(response)+"\n")
+		output, err := output.CmdOutput(
+			viper.GetString(cliflags.OutputFlag),
+			output.NewMultipleOutputterFn(response),
+		)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintf(cmd.OutOrStdout(), string(output)+"\n")
 
 		return nil
 	}

cmd/projects/list_test.go

@@ -18,25 +18,34 @@ func TestList(t *testing.T) {
 		"testAccessToken",
 		"http://test.com",
 	}
+	stubbedResponse := `{
+		"items": [
+			{
+				"key": "test-key",
+				"name": "test-name"
+			}
+		]
+	}`
 
 	t.Run("with valid flags calls API", func(t *testing.T) {
 		client := projects.MockClient{}
 		client.
 			On("List", mockArgs...).
-			Return([]byte(cmd.ValidResponse), nil)
+			Return([]byte(stubbedResponse), nil)
 		clients := cmd.APIClients{
 			ProjectsClient: &client,
 		}
 		args := []string{
 			"projects", "list",
 			"--access-token", "testAccessToken",
 			"--base-uri", "http://test.com",
+			"--output", "json",
 		}
 
 		output, err := cmd.CallCmd(t, clients, &analytics.NoopClient{}, args)
 
 		require.NoError(t, err)
-		assert.JSONEq(t, `{"valid": true}`, string(output))
+		assert.JSONEq(t, stubbedResponse, string(output))
 	})
 
 	t.Run("with valid flags from environment variables calls API", func(t *testing.T) {
@@ -45,19 +54,20 @@ func TestList(t *testing.T) {
 		client := projects.MockClient{}
 		client.
 			On("List", mockArgs...).
-			Return([]byte(cmd.ValidResponse), nil)
+			Return([]byte(stubbedResponse), nil)
 		clients := cmd.APIClients{
 			ProjectsClient: &client,
 		}
 		args := []string{
 			"projects",
 			"list",
+			"--output", "json",
 		}
 
 		output, err := cmd.CallCmd(t, clients, &analytics.NoopClient{}, args)
 
 		require.NoError(t, err)
-		assert.JSONEq(t, `{"valid": true}`, string(output))
+		assert.JSONEq(t, stubbedResponse, string(output))
 	})
 
 	t.Run("with an error response is an error", func(t *testing.T) {

cmd/root.go

@@ -96,6 +96,17 @@ func NewRootCommand(
 		return nil, err
 	}
 
+	cmd.PersistentFlags().StringP(
+		cliflags.OutputFlag,
+		"o",
+		"plaintext",
+		"Command response output format in either JSON or plain text",
+	)
+	err = viper.BindPFlag(cliflags.OutputFlag, cmd.PersistentFlags().Lookup(cliflags.OutputFlag))
+	if err != nil {
+		return nil, err
+	}
+
 	environmentsCmd, err := envscmd.NewEnvironmentsCmd(analyticsTracker, clients.EnvironmentsClient)
 	if err != nil {
 		return nil, err

cmd/validators/validators.go

@@ -11,48 +11,54 @@ import (
 
 	"ldcli/cmd/cliflags"
 	errs "ldcli/internal/errors"
+	"ldcli/internal/output"
 )
 
 // Validate is a validator for commands to print an error when the user input is invalid.
 func Validate() cobra.PositionalArgs {
 	return func(cmd *cobra.Command, args []string) error {
 		rebindFlags(cmd, cmd.ValidArgs) // rebind flags before validating them below
-		commandPath := getCommandPath(cmd)
 
 		_, err := url.ParseRequestURI(viper.GetString(cliflags.BaseURIFlag))
 		if err != nil {
-			errorMessage := fmt.Sprintf(
-				"%s. See `%s --help` for supported flags and usage.",
-				errs.ErrInvalidBaseURI,
-				commandPath,
-			)
-			return errors.New(errorMessage)
+			return CmdError(errs.ErrInvalidBaseURI, cmd.CommandPath())
 		}
 
 		err = cmd.ValidateRequiredFlags()
 		if err != nil {
-			errorMessage := fmt.Sprintf(
-				"%s. See `%s --help` for supported flags and usage.",
-				err.Error(),
-				commandPath,
-			)
+			return CmdError(err, cmd.CommandPath())
+		}
 
-			return errors.New(errorMessage)
+		err = validateOutput(viper.GetString(cliflags.OutputFlag))
+		if err != nil {
+			return CmdError(err, cmd.CommandPath())
 		}
 
 		return nil
 	}
 }
 
-func getCommandPath(cmd *cobra.Command) string {
-	var commandPath string
-	if cmd.Annotations["scope"] == "plugin" {
-		commandPath = fmt.Sprintf("stripe %s", cmd.CommandPath())
-	} else {
-		commandPath = cmd.CommandPath()
+func CmdError(err error, commandPath string) error {
+	errorMessage := fmt.Sprintf(
+		"%s. See `%s --help` for supported flags and usage.",
+		err.Error(),
+		commandPath,
+	)
+
+	return errors.New(errorMessage)
+}
+
+func validateOutput(outputFlag string) error {
+	validKinds := map[string]struct{}{
+		"json":      {},
+		"plaintext": {},
+	}
+	_, ok := validKinds[outputFlag]
+	if !ok {
+		return output.ErrInvalidOutputKind
 	}
 
-	return commandPath
+	return nil
 }
 
 // rebindFlags sets the command's flags based on the values stored in viper because they may not

internal/environments/client.go

@@ -38,10 +38,11 @@ func (c EnvironmentsClient) Get(
 
 	}
 
-	responseJSON, err := json.Marshal(environment)
+	output, err := json.Marshal(environment)
 	if err != nil {
-		return nil, err
+		return nil, errors.NewLDAPIError(err)
+
 	}
 
-	return responseJSON, nil
+	return output, nil
 }

internal/output/multiple_outputter.go

@@ -0,0 +1,49 @@
+package output
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+var multiplePlaintextOutputFn = func(r resource) string {
+	return fmt.Sprintf("* %s (%s)", r.Name, r.Key)
+}
+
+// TODO: rename this to be "cleaner"? -- NewMultipleOutput()
+func NewMultipleOutputterFn(input []byte) multipleOutputterFn {
+	return multipleOutputterFn{
+		input: input,
+	}
+}
+
+type multipleOutputterFn struct {
+	input []byte
+}
+
+func (o multipleOutputterFn) New() (Outputter, error) {
+	var r resources
+	err := json.Unmarshal(o.input, &r)
+	if err != nil {
+		return MultipleOutputter{}, err
+	}
+
+	return MultipleOutputter{
+		outputFn:     multiplePlaintextOutputFn,
+		resources:    r,
+		resourceJSON: o.input,
+	}, nil
+}
+
+type MultipleOutputter struct {
+	outputFn     PlaintextOutputFn
+	resources    resources
+	resourceJSON []byte
+}
+
+func (o MultipleOutputter) JSON() string {
+	return string(o.resourceJSON)
+}
+
+func (o MultipleOutputter) String() string {
+	return formatColl(o.resources.Items, o.outputFn)
+}