add pager to describe workflow

cmd/describe_affected.go

@@ -37,6 +37,11 @@
 		checkAtmosConfig()
 		props, err := parseDescribeAffectedCliArgs(cmd, args)
 		checkErrorAndExit(err)
+    if cmd.Flags().Changed("pager") {
+        // TODO: update this post pr:https://github.com/cloudposse/atmos/pull/1174 is merged
+        props.CLIConfig.Settings.Terminal.Pager, err = cmd.Flags().GetString("pager")
+        checkErrorAndExit(err)
+    }
 		err = newDescribeAffectedExec(props.CLIConfig).Execute(&props)
 		checkErrorAndExit(err)
 	}

cmd/describe_stacks.go

@@ -56,6 +56,12 @@ func getRunnableDescribeStacksCmd(
 		printErrorAndExit(err)
 		describe := &exec.DescribeStacksArgs{}
 		err = setCliArgsForDescribeStackCli(cmd.Flags(), describe)
+		printErrorAndExit(err)
+		if cmd.Flags().Changed("pager") {
+			// TODO: update this post pr:https://github.com/cloudposse/atmos/pull/1174 is merged
+			atmosConfig.Settings.Terminal.Pager, err = cmd.Flags().GetString("pager")
+		}
+
 		printErrorAndExit(err)
 		err = g.newDescribeStacksExec.Execute(&atmosConfig, describe)
 		printErrorAndExit(err)

cmd/describe_stacks_test.go

@@ -123,40 +123,4 @@ func TestSetFlagValueInDescribeStacksCliArgs(t *testing.T) {
 			assert.Equal(t, tt.expected, tt.describe, "Describe struct does not match expected")
 		})
 	}
-
-	// Test panic for unsupported type
-	t.Run("Unsupported flag type", func(t *testing.T) {
-		fs := pflag.NewFlagSet("test", pflag.ContinueOnError)
-		fs.Int("invalid", 0, "Invalid flag") // Int type is not supported
-		fs.Set("invalid", "42")
-
-		defer func() {
-			if r := recover(); r != nil {
-				expected := "unsupported type *int for flag invalid"
-				if fmt.Sprintf("%v", r) != expected {
-					t.Errorf("Expected panic message %q, got %v", expected, r)
-				}
-			} else {
-				t.Error("Expected panic but none occurred")
-			}
-		}()
-
-		// Override flagsKeyValue to include an int type
-		originalFlagsKeyValue := map[string]any{
-			"invalid": new(int),
-		}
-		for k, v := range originalFlagsKeyValue {
-			if !fs.Changed(k) {
-				continue
-			}
-			switch v := v.(type) {
-			case *string:
-				*v, _ = fs.GetString(k)
-			case *bool:
-				*v, _ = fs.GetBool(k)
-			default:
-				panic(fmt.Sprintf("unsupported type %T for flag %s", v, k))
-			}
-		}
-	})
 }

cmd/describe_workflows.go

@@ -1,10 +1,14 @@
 package cmd
 
 import (
+	"fmt"
+
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 
-	e "github.com/cloudposse/atmos/internal/exec"
-	u "github.com/cloudposse/atmos/pkg/utils"
+	"github.com/cloudposse/atmos/internal/exec"
+	cfg "github.com/cloudposse/atmos/pkg/config"
+	"github.com/cloudposse/atmos/pkg/schema"
 )
 
 // describeWorkflowsCmd executes 'atmos describe workflows' CLI commands
@@ -14,12 +18,31 @@ var describeWorkflowsCmd = &cobra.Command{
 	Long:               "List all Atmos workflows, showing their associated files and workflow names for easy reference.",
 	FParseErrWhitelist: struct{ UnknownFlags bool }{UnknownFlags: false},
 	Args:               cobra.NoArgs,
-	Run: func(cmd *cobra.Command, args []string) {
-		err := e.ExecuteDescribeWorkflowsCmd(cmd, args)
-		if err != nil {
-			u.PrintErrorMarkdownAndExit("", err, "")
-		}
-	},
+	Run:                getRunnableDescribeWorkflowsCmd(checkAtmosConfig, exec.ProcessCommandLineArgs, cfg.InitCliConfig, exec.NewDescribeWorkflowsExec()),
+}
+
+func getRunnableDescribeWorkflowsCmd(
+	checkAtmosConfig func(opts ...AtmosValidateOption),
+	processCommandLineArgs func(componentType string, cmd *cobra.Command, args []string, additionalArgsAndFlags []string) (schema.ConfigAndStacksInfo, error),
+	initCliConfig func(info schema.ConfigAndStacksInfo, validate bool) (schema.AtmosConfiguration, error),
+	describeWorkflowsExec exec.DescribeWorkflowsExec,
+) func(cmd *cobra.Command, args []string) {
+	return func(cmd *cobra.Command, args []string) {
+		// Check Atmos configuration
+		checkAtmosConfig()
+		info, err := processCommandLineArgs("terraform", cmd, args, nil)
+		checkErrorAndExit(err)
+		atmosConfig, err := initCliConfig(info, true)
+		checkErrorAndExit(err)
+		describeWorkflowArgs := &exec.DescribeWorkflowsArgs{}
+		err = flagsToDescribeWorkflowsArgs(cmd.Flags(), describeWorkflowArgs)
+		checkErrorAndExit(err)
+		pager, err := cmd.Flags().GetString("pager")
+		checkFlagNotPresentError(err)
+		atmosConfig.Settings.Terminal.Pager = pager
+		err = describeWorkflowsExec.Execute(&atmosConfig, describeWorkflowArgs)
+		checkErrorAndExit(err)
+	}
 }
 
 func init() {
@@ -28,3 +51,53 @@ func init() {
 
 	describeCmd.AddCommand(describeWorkflowsCmd)
 }
+
+func flagsToDescribeWorkflowsArgs(flags *pflag.FlagSet, describe *exec.DescribeWorkflowsArgs) error {
+	if err := setStringFlagIfChanged(flags, "format", &describe.Format); err != nil {
+		return err
+	}
+	if err := setStringFlagIfChanged(flags, "output", &describe.OutputType); err != nil {
+		return err
+	}
+	if err := setStringFlagIfChanged(flags, "query", &describe.Query); err != nil {
+		return err
+	}
+
+	if err := validateAndSetDefaults(describe); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func setStringFlagIfChanged(flags *pflag.FlagSet, name string, target *string) error {
+	if flags.Changed(name) {
+		val, err := flags.GetString(name)
+		if err != nil {
+			return err
+		}
+		*target = val
+	}
+	return nil
+}
+
+var (
+	ErrInvalidOutputType = fmt.Errorf("invalid output type specified. Valid values are 'list', 'map', and 'all'")
+	ErrInvalidFormat     = fmt.Errorf("invalid format specified. Valid values are 'yaml' and 'json'")
+)
+
+func validateAndSetDefaults(describe *exec.DescribeWorkflowsArgs) error {
+	if describe.Format == "" {
+		describe.Format = "yaml"
+	} else if describe.Format != "yaml" && describe.Format != "json" {
+		return ErrInvalidFormat
+	}
+
+	if describe.OutputType == "" {
+		describe.OutputType = "list"
+	} else if describe.OutputType != "list" && describe.OutputType != "map" && describe.OutputType != "all" {
+		return ErrInvalidOutputType
+	}
+
+	return nil
+}

cmd/describe_workflows_test.go

@@ -0,0 +1,94 @@
+package cmd
+
+import (
+	"testing"
+
+	"github.com/cloudposse/atmos/internal/exec"
+	"github.com/cloudposse/atmos/pkg/schema"
+	"github.com/golang/mock/gomock"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSetFlagInDescribeWorkflow(t *testing.T) {
+	// Initialize test cases
+	tests := []struct {
+		name        string
+		setFlags    func(*pflag.FlagSet)
+		expected    *exec.DescribeWorkflowsArgs
+		expectedErr bool
+	}{
+		{
+			name: "Set string flags",
+			setFlags: func(fs *pflag.FlagSet) {
+				fs.Set("format", "json")
+				fs.Set("output", "map")
+			},
+			expected: &exec.DescribeWorkflowsArgs{
+				Format:     "json",
+				OutputType: "map",
+			},
+		},
+		{
+			name: "No flags changed, set default format",
+			setFlags: func(fs *pflag.FlagSet) {
+				// No flags set
+			},
+			expected: &exec.DescribeWorkflowsArgs{
+				Format:     "yaml",
+				OutputType: "list",
+			},
+		},
+		{
+			name: "Set invalid format, no override",
+			setFlags: func(fs *pflag.FlagSet) {
+				fs.Set("format", "invalid_format")
+			},
+			expectedErr: true,
+		},
+		{
+			name: "Set invalid output type, no override",
+			setFlags: func(fs *pflag.FlagSet) {
+				fs.Set("output", "invalid_output")
+			},
+			expectedErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fs := pflag.NewFlagSet("test", pflag.ContinueOnError)
+			fs.StringP("format", "f", "yaml", "Specify the output format (`yaml` is default)")
+			fs.StringP("output", "o", "list", "Specify the output type (`list` is default)")
+			fs.StringP("query", "q", "", "Specify a query to filter the output")
+			tt.setFlags(fs)
+			describeWorkflowsArgs := &exec.DescribeWorkflowsArgs{}
+			err := flagsToDescribeWorkflowsArgs(fs, describeWorkflowsArgs)
+			if tt.expectedErr {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expected, describeWorkflowsArgs)
+		})
+	}
+}
+
+func TestDescribeWorklows(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	describeWorkflowsMock := exec.NewMockDescribeWorkflowsExec(ctrl)
+	describeWorkflowsMock.EXPECT().Execute(gomock.Any(), gomock.Any()).Return(nil).Times(1)
+	run := getRunnableDescribeWorkflowsCmd(
+		func(opts ...AtmosValidateOption) {},
+		func(componentType string, cmd *cobra.Command, args, additionalArgsAndFlags []string) (schema.ConfigAndStacksInfo, error) {
+			return schema.ConfigAndStacksInfo{}, nil
+		},
+		func(info schema.ConfigAndStacksInfo, validate bool) (schema.AtmosConfiguration, error) {
+			return schema.AtmosConfiguration{}, nil
+		},
+		describeWorkflowsMock,
+	)
+	run(describeWorkflowsCmd, []string{})
+	ctrl.Finish()
+}

internal/exec/describe_stacks.go

@@ -91,7 +91,7 @@ func (d *describeStacksExec) Execute(atmosConfig *schema.AtmosConfiguration, arg
 	}
 
 	return viewWithScroll(&viewWithScrollProps{
-		pageCreator:           pager.New(),
+		pageCreator:           d.pageCreator,
 		isTTYSupportForStdout: d.isTTYSupportForStdout,
 		printOrWriteToFile:    d.printOrWriteToFile,
 		atmosConfig:           atmosConfig,

internal/exec/describe_workflows.go

@@ -1,62 +1,46 @@
 package exec
 
 import (
-	"fmt"
-
+	"github.com/cloudposse/atmos/internal/tui/templates/term"
+	"github.com/cloudposse/atmos/pkg/pager"
+	"github.com/cloudposse/atmos/pkg/schema"
 	u "github.com/cloudposse/atmos/pkg/utils"
-
-	cfg "github.com/cloudposse/atmos/pkg/config"
-	"github.com/spf13/cobra"
 )
 
-// ExecuteDescribeWorkflowsCmd executes `atmos describe workflows` CLI command
-func ExecuteDescribeWorkflowsCmd(cmd *cobra.Command, args []string) error {
-	info, err := ProcessCommandLineArgs("terraform", cmd, args, nil)
-	if err != nil {
-		return err
-	}
-
-	info.CliArgs = []string{"describe", "workflows"}
-
-	atmosConfig, err := cfg.InitCliConfig(info, true)
-	if err != nil {
-		return err
-	}
-
-	flags := cmd.Flags()
-
-	format, err := flags.GetString("format")
-	if err != nil {
-		return err
-	}
-
-	if format != "" && format != "yaml" && format != "json" {
-		return fmt.Errorf("invalid '--format' flag '%s'. Valid values are 'yaml' (default) and 'json'", format)
-	}
-
-	if format == "" {
-		format = "yaml"
-	}
+type DescribeWorkflowsArgs struct {
+	Format     string
+	OutputType string
+	Query      string
+}
 
-	outputType, err := flags.GetString("output")
-	if err != nil {
-		return err
-	}
+//go:generate mockgen -source=$GOFILE -destination=mock_$GOFILE -package=$GOPACKAGE
+type DescribeWorkflowsExec interface {
+	Execute(*schema.AtmosConfiguration, *DescribeWorkflowsArgs) error
+}
 
-	if outputType != "" && outputType != "list" && outputType != "map" && outputType != "all" {
-		return fmt.Errorf("invalid '--output' flag '%s'. Valid values are 'list' (default), 'map' and 'all'", outputType)
-	}
+type describeWorkflowsExec struct {
+	printOrWriteToFile       func(atmosConfig *schema.AtmosConfiguration, format, file string, data any) error
+	IsTTYSupportForStdout    func() bool
+	pagerCreator             pager.PageCreator
+	executeDescribeWorkflows func(atmosConfig schema.AtmosConfiguration) ([]schema.DescribeWorkflowsItem, map[string][]string, map[string]schema.WorkflowManifest, error)
+}
 
-	if outputType == "" {
-		outputType = "list"
+func NewDescribeWorkflowsExec() DescribeWorkflowsExec {
+	return &describeWorkflowsExec{
+		printOrWriteToFile:       printOrWriteToFile,
+		IsTTYSupportForStdout:    term.IsTTYSupportForStdout,
+		executeDescribeWorkflows: ExecuteDescribeWorkflows,
+		pagerCreator:             pager.New(),
 	}
+}
 
-	query, err := flags.GetString("query")
-	if err != nil {
-		return err
-	}
+// ExecuteDescribeWorkflowsCmd executes `atmos describe workflows` CLI command.
+func (d *describeWorkflowsExec) Execute(atmosConfig *schema.AtmosConfiguration, describeWorkflowsArgs *DescribeWorkflowsArgs) error {
+	outputType := describeWorkflowsArgs.OutputType
+	query := describeWorkflowsArgs.Query
+	format := describeWorkflowsArgs.Format
 
-	describeWorkflowsList, describeWorkflowsMap, describeWorkflowsAll, err := ExecuteDescribeWorkflows(atmosConfig)
+	describeWorkflowsList, describeWorkflowsMap, describeWorkflowsAll, err := d.executeDescribeWorkflows(*atmosConfig)
 	if err != nil {
 		return err
 	}
@@ -72,13 +56,22 @@ func ExecuteDescribeWorkflowsCmd(cmd *cobra.Command, args []string) error {
 	}
 
 	if query != "" {
-		res, err = u.EvaluateYqExpression(&atmosConfig, res, query)
+		res, err = u.EvaluateYqExpression(atmosConfig, res, query)
 		if err != nil {
 			return err
 		}
 	}
 
-	err = printOrWriteToFile(&atmosConfig, format, "", res)
+	err = viewWithScroll(&viewWithScrollProps{
+		pageCreator:           d.pagerCreator,
+		isTTYSupportForStdout: d.IsTTYSupportForStdout,
+		printOrWriteToFile:    d.printOrWriteToFile,
+		atmosConfig:           atmosConfig,
+		displayName:           "Describe Workflows",
+		format:                format,
+		file:                  "",
+		res:                   res,
+	})
 	if err != nil {
 		return err
 	}