test: Add test files for migrated list commands

Add test coverage for newly migrated list subcommands following the same
patterns as existing tests. All tests pass with the new flag handler pattern.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Claude (via Conductor)

cmd/list/components_test.go

@@ -0,0 +1,74 @@
+//nolint:dupl // Test structure similarity is intentional for consistency
+package list
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestListComponentsFlags tests that the list components command has the correct flags.
+func TestListComponentsFlags(t *testing.T) {
+	cmd := &cobra.Command{
+		Use:   "components",
+		Short: "List all Atmos components or filter by stack",
+		Long:  "List Atmos components, with options to filter results by specific stacks.",
+		Args:  cobra.NoArgs,
+	}
+
+	cmd.PersistentFlags().StringP("stack", "s", "", "Filter by stack name or pattern")
+
+	stackFlag := cmd.PersistentFlags().Lookup("stack")
+	assert.NotNil(t, stackFlag, "Expected stack flag to exist")
+	assert.Equal(t, "", stackFlag.DefValue)
+	assert.Equal(t, "s", stackFlag.Shorthand)
+}
+
+// TestListComponentsValidatesArgs tests that the command validates arguments.
+func TestListComponentsValidatesArgs(t *testing.T) {
+	cmd := &cobra.Command{
+		Use:  "components",
+		Args: cobra.NoArgs,
+	}
+
+	err := cmd.ValidateArgs([]string{})
+	assert.NoError(t, err, "Validation should pass with no arguments")
+
+	err = cmd.ValidateArgs([]string{"extra"})
+	assert.Error(t, err, "Validation should fail with arguments")
+}
+
+// TestListComponentsCommand tests the components command structure.
+func TestListComponentsCommand(t *testing.T) {
+	assert.Equal(t, "components", componentsCmd.Use)
+	assert.Contains(t, componentsCmd.Short, "List all Atmos components")
+	assert.NotNil(t, componentsCmd.RunE)
+
+	// Check that NoArgs validator is set
+	err := componentsCmd.Args(componentsCmd, []string{"unexpected"})
+	assert.Error(t, err, "Should reject extra arguments")
+
+	err = componentsCmd.Args(componentsCmd, []string{})
+	assert.NoError(t, err, "Should accept no arguments")
+}
+
+// TestListComponentsWithOptions_EmptyStack tests filtering with empty stack pattern.
+func TestListComponentsWithOptions_EmptyStack(t *testing.T) {
+	opts := &ComponentsOptions{
+		Stack: "",
+	}
+
+	// Test that the options are properly structured
+	assert.Equal(t, "", opts.Stack)
+}
+
+// TestListComponentsWithOptions_StackPattern tests filtering with stack pattern.
+func TestListComponentsWithOptions_StackPattern(t *testing.T) {
+	opts := &ComponentsOptions{
+		Stack: "prod-*",
+	}
+
+	// Test that the options are properly structured
+	assert.Equal(t, "prod-*", opts.Stack)
+}

cmd/list/instances_test.go

@@ -0,0 +1,105 @@
+package list
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestListInstancesFlags tests that the list instances command has the correct flags.
+func TestListInstancesFlags(t *testing.T) {
+	cmd := &cobra.Command{
+		Use:   "instances",
+		Short: "List all Atmos instances",
+		Long:  "This command lists all Atmos instances or is used to upload instances to the pro API.",
+		Args:  cobra.NoArgs,
+	}
+
+	cmd.PersistentFlags().String("format", "", "Output format")
+	cmd.PersistentFlags().String("delimiter", "", "Delimiter for CSV/TSV output")
+	cmd.PersistentFlags().String("stack", "", "Stack pattern")
+	cmd.PersistentFlags().String("query", "", "JQ query")
+	cmd.PersistentFlags().Int("max-columns", 0, "Maximum columns")
+	cmd.PersistentFlags().Bool("upload", false, "Upload instances to pro API")
+
+	formatFlag := cmd.PersistentFlags().Lookup("format")
+	assert.NotNil(t, formatFlag, "Expected format flag to exist")
+	assert.Equal(t, "", formatFlag.DefValue)
+
+	delimiterFlag := cmd.PersistentFlags().Lookup("delimiter")
+	assert.NotNil(t, delimiterFlag, "Expected delimiter flag to exist")
+	assert.Equal(t, "", delimiterFlag.DefValue)
+
+	stackFlag := cmd.PersistentFlags().Lookup("stack")
+	assert.NotNil(t, stackFlag, "Expected stack flag to exist")
+	assert.Equal(t, "", stackFlag.DefValue)
+
+	queryFlag := cmd.PersistentFlags().Lookup("query")
+	assert.NotNil(t, queryFlag, "Expected query flag to exist")
+	assert.Equal(t, "", queryFlag.DefValue)
+
+	maxColumnsFlag := cmd.PersistentFlags().Lookup("max-columns")
+	assert.NotNil(t, maxColumnsFlag, "Expected max-columns flag to exist")
+	assert.Equal(t, "0", maxColumnsFlag.DefValue)
+
+	uploadFlag := cmd.PersistentFlags().Lookup("upload")
+	assert.NotNil(t, uploadFlag, "Expected upload flag to exist")
+	assert.Equal(t, "false", uploadFlag.DefValue)
+}
+
+// TestListInstancesValidatesArgs tests that the command validates arguments.
+func TestListInstancesValidatesArgs(t *testing.T) {
+	cmd := &cobra.Command{
+		Use:  "instances",
+		Args: cobra.NoArgs,
+	}
+
+	err := cmd.ValidateArgs([]string{})
+	assert.NoError(t, err, "Validation should pass with no arguments")
+
+	err = cmd.ValidateArgs([]string{"extra"})
+	assert.Error(t, err, "Validation should fail with arguments")
+}
+
+// TestListInstancesCommand tests the instances command structure.
+func TestListInstancesCommand(t *testing.T) {
+	assert.Equal(t, "instances", instancesCmd.Use)
+	assert.Contains(t, instancesCmd.Short, "List all Atmos instances")
+	assert.NotNil(t, instancesCmd.RunE)
+
+	// Check that NoArgs validator is set
+	err := instancesCmd.Args(instancesCmd, []string{"unexpected"})
+	assert.Error(t, err, "Should reject extra arguments")
+
+	err = instancesCmd.Args(instancesCmd, []string{})
+	assert.NoError(t, err, "Should accept no arguments")
+}
+
+// TestListInstancesOptions tests the InstancesOptions structure.
+func TestListInstancesOptions(t *testing.T) {
+	opts := &InstancesOptions{
+		Format:     "json",
+		MaxColumns: 10,
+		Delimiter:  ",",
+		Stack:      "prod-*",
+		Query:      ".component",
+		Upload:     false,
+	}
+
+	assert.Equal(t, "json", opts.Format)
+	assert.Equal(t, 10, opts.MaxColumns)
+	assert.Equal(t, ",", opts.Delimiter)
+	assert.Equal(t, "prod-*", opts.Stack)
+	assert.Equal(t, ".component", opts.Query)
+	assert.False(t, opts.Upload)
+}
+
+// TestListInstancesOptions_Upload tests the upload flag behavior.
+func TestListInstancesOptions_Upload(t *testing.T) {
+	opts := &InstancesOptions{
+		Upload: true,
+	}
+
+	assert.True(t, opts.Upload)
+}

cmd/list/metadata_test.go

@@ -0,0 +1,170 @@
+package list
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+
+	l "github.com/cloudposse/atmos/pkg/list"
+)
+
+// TestListMetadataFlags tests that the list metadata command has the correct flags.
+func TestListMetadataFlags(t *testing.T) {
+	cmd := &cobra.Command{
+		Use:   "metadata [component]",
+		Short: "List metadata across stacks",
+		Long:  "List metadata information across all stacks or for a specific component",
+	}
+
+	cmd.PersistentFlags().String("format", "", "Output format")
+	cmd.PersistentFlags().String("delimiter", "", "Delimiter for CSV/TSV output")
+	cmd.PersistentFlags().String("stack", "", "Stack pattern")
+	cmd.PersistentFlags().String("query", "", "JQ query")
+	cmd.PersistentFlags().Int("max-columns", 0, "Maximum columns")
+	cmd.PersistentFlags().Bool("process-templates", true, "Enable/disable Go template processing")
+	cmd.PersistentFlags().Bool("process-functions", true, "Enable/disable YAML functions processing")
+
+	formatFlag := cmd.PersistentFlags().Lookup("format")
+	assert.NotNil(t, formatFlag, "Expected format flag to exist")
+	assert.Equal(t, "", formatFlag.DefValue)
+
+	delimiterFlag := cmd.PersistentFlags().Lookup("delimiter")
+	assert.NotNil(t, delimiterFlag, "Expected delimiter flag to exist")
+	assert.Equal(t, "", delimiterFlag.DefValue)
+
+	stackFlag := cmd.PersistentFlags().Lookup("stack")
+	assert.NotNil(t, stackFlag, "Expected stack flag to exist")
+	assert.Equal(t, "", stackFlag.DefValue)
+
+	queryFlag := cmd.PersistentFlags().Lookup("query")
+	assert.NotNil(t, queryFlag, "Expected query flag to exist")
+	assert.Equal(t, "", queryFlag.DefValue)
+
+	maxColumnsFlag := cmd.PersistentFlags().Lookup("max-columns")
+	assert.NotNil(t, maxColumnsFlag, "Expected max-columns flag to exist")
+	assert.Equal(t, "0", maxColumnsFlag.DefValue)
+
+	processTemplatesFlag := cmd.PersistentFlags().Lookup("process-templates")
+	assert.NotNil(t, processTemplatesFlag, "Expected process-templates flag to exist")
+	assert.Equal(t, "true", processTemplatesFlag.DefValue)
+
+	processFunctionsFlag := cmd.PersistentFlags().Lookup("process-functions")
+	assert.NotNil(t, processFunctionsFlag, "Expected process-functions flag to exist")
+	assert.Equal(t, "true", processFunctionsFlag.DefValue)
+}
+
+// TestListMetadataCommand tests the metadata command structure.
+func TestListMetadataCommand(t *testing.T) {
+	assert.Equal(t, "metadata [component]", metadataCmd.Use)
+	assert.Contains(t, metadataCmd.Short, "List metadata across stacks")
+	assert.NotNil(t, metadataCmd.RunE)
+	assert.NotEmpty(t, metadataCmd.Example)
+}
+
+// TestSetupMetadataOptions tests the setupMetadataOptions function.
+func TestSetupMetadataOptions(t *testing.T) {
+	testCases := []struct {
+		name            string
+		opts            *MetadataOptions
+		componentFilter string
+		expectedQuery   string
+		expectedComp    string
+	}{
+		{
+			name: "with component and custom query",
+			opts: &MetadataOptions{
+				Query:      ".metadata.component",
+				MaxColumns: 10,
+				Format:     "json",
+				Delimiter:  ",",
+				Stack:      "prod-*",
+			},
+			componentFilter: "vpc",
+			expectedQuery:   ".metadata.component",
+			expectedComp:    l.KeyMetadata,
+		},
+		{
+			name: "without component and default query",
+			opts: &MetadataOptions{
+				Query:      "",
+				MaxColumns: 5,
+				Format:     "yaml",
+				Delimiter:  "\t",
+				Stack:      "",
+			},
+			componentFilter: "",
+			expectedQuery:   ".metadata",
+			expectedComp:    l.KeyMetadata,
+		},
+		{
+			name: "with component but no query",
+			opts: &MetadataOptions{
+				Query:      "",
+				MaxColumns: 0,
+				Format:     "",
+				Delimiter:  "",
+				Stack:      "*-dev-*",
+			},
+			componentFilter: "app",
+			expectedQuery:   ".metadata",
+			expectedComp:    l.KeyMetadata,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			filterOpts := setupMetadataOptions(tc.opts, tc.componentFilter)
+
+			assert.Equal(t, tc.expectedComp, filterOpts.Component)
+			assert.Equal(t, tc.componentFilter, filterOpts.ComponentFilter)
+			assert.Equal(t, tc.expectedQuery, filterOpts.Query)
+			assert.False(t, filterOpts.IncludeAbstract)
+			assert.Equal(t, tc.opts.MaxColumns, filterOpts.MaxColumns)
+			assert.Equal(t, tc.opts.Format, filterOpts.FormatStr)
+			assert.Equal(t, tc.opts.Delimiter, filterOpts.Delimiter)
+			assert.Equal(t, tc.opts.Stack, filterOpts.StackPattern)
+		})
+	}
+}
+
+// TestMetadataOptions tests the MetadataOptions structure.
+func TestMetadataOptions(t *testing.T) {
+	opts := &MetadataOptions{
+		Format:           "json",
+		MaxColumns:       10,
+		Delimiter:        ",",
+		Stack:            "prod-*",
+		Query:            ".metadata.component",
+		ProcessTemplates: true,
+		ProcessFunctions: false,
+	}
+
+	assert.Equal(t, "json", opts.Format)
+	assert.Equal(t, 10, opts.MaxColumns)
+	assert.Equal(t, ",", opts.Delimiter)
+	assert.Equal(t, "prod-*", opts.Stack)
+	assert.Equal(t, ".metadata.component", opts.Query)
+	assert.True(t, opts.ProcessTemplates)
+	assert.False(t, opts.ProcessFunctions)
+}
+
+// TestListMetadataWithOptions_DefaultQuery tests that default query is applied.
+func TestListMetadataWithOptions_DefaultQuery(t *testing.T) {
+	opts := &MetadataOptions{
+		Query: "",
+	}
+
+	filterOpts := setupMetadataOptions(opts, "")
+	assert.Equal(t, ".metadata", filterOpts.Query, "Should apply default .metadata query")
+}
+
+// TestListMetadataWithOptions_CustomQuery tests that custom query is preserved.
+func TestListMetadataWithOptions_CustomQuery(t *testing.T) {
+	opts := &MetadataOptions{
+		Query: ".metadata.custom",
+	}
+
+	filterOpts := setupMetadataOptions(opts, "")
+	assert.Equal(t, ".metadata.custom", filterOpts.Query, "Should preserve custom query")
+}