feat: add spinner UI to validation commands (#1951)

* feat: add spinner UI to validation commands

Integrate spinner UI feedback into authentication, EditorConfig, and
YAML schema validation commands. This enhances user experience by
providing visual progress indicators during validation processes.

* [autofix.ci] apply automated fixes

* feat: output validation success for scripts/pipelines

Add explicit success messages to authentication and EditorConfig
validation commands for improved script and pipeline integration.
Update test snapshots to reflect new output.

* fix: improve error handling in validation commands

Refactor error reporting in authentication and editorconfig validation
commands. Now, errors are printed directly from the returned error
object, and editorconfig validation only prints errors if present,
otherwise logs the error. This ensures clearer and more accurate error
messages for users and scripts.

* chore: address godot linting

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* feat: improve EditorConfig validation UX and error handling

Refactor EditorConfig validation to use the UI package for output,
providing clearer success and error messages. Add specific error
constants for EditorConfig validation failures, version mismatches,
and file retrieval issues. Update error wrapping for better context.

* refactor: use ui package for auth validate output

Replaced utils markdown output with ui.Info, ui.Error, and ui.Success
for consistent messaging in the auth validate command. This improves
clarity and aligns output with other commands using the ui package.

* feat: remove success messages from validation commands

Removed final success output from authentication and editorconfig
validation commands to streamline script and pipeline usage.

* feat: update validation and describe config output snapshots

Update test snapshots for authentication validation and configuration
describe commands to reflect new output, including pager usage,
validation messages, and improved error reporting.

* fix(tests): expect validation messages on stderr

Update test cases to expect validation success messages on stderr
instead of stdout for authentication and editorconfig validation
commands. This aligns test expectations with recent output changes.
```

* test: improve test robustness for env and version differences

Update test cases to ignore or normalize output that varies by
environment, pager settings, or tool versions (e.g., Terraform).
This reduces false negatives in CI and local runs by filtering
out lines and normalizing values that are not relevant to test
logic.

* feat: improve auth config validation test coverage

Add checks for orphaned continuation lines in authentication
configuration validation tests to ensure more robust error detection.

* test(cmd): add unit tests for editorconfig validation logic

Add comprehensive unit tests for the editorconfig validation command,
including dry-run logic, version checking, and integration with atmos
configuration. Tests cover config path parsing, flag overrides, and
various config scenarios to ensure robust behavior.

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

Author: 3 people

cmd/auth_validate.go

@@ -10,7 +10,8 @@ import (
 	cfg "github.com/cloudposse/atmos/pkg/config"
 	log "github.com/cloudposse/atmos/pkg/logger"
 	"github.com/cloudposse/atmos/pkg/schema"
-	u "github.com/cloudposse/atmos/pkg/utils"
+	"github.com/cloudposse/atmos/pkg/ui"
+	"github.com/cloudposse/atmos/pkg/ui/spinner"
 )
 
 // authValidateCmd validates the auth configuration.
@@ -28,7 +29,7 @@ func executeAuthValidateCommand(cmd *cobra.Command, args []string) error {
 	// Get verbose flag
 	verbose := viper.GetBool("auth.validate.verbose")
 	if verbose {
-		u.PrintfMarkdown("**Validating authentication configuration...**\n")
+		ui.Info("Validating authentication configuration...")
 	}
 
 	// Load atmos config
@@ -40,14 +41,19 @@ func executeAuthValidateCommand(cmd *cobra.Command, args []string) error {
 	// Create validator
 	validator := validation.NewValidator()
 
-	// Validate auth configuration
-	if err := validator.ValidateAuthConfig(&atmosConfig.Auth); err != nil {
-		u.PrintfMarkdown("**❌ Authentication configuration validation failed:**\n")
-		u.PrintfMarkdown("%s\n", err.Error())
+	// Validate auth configuration with spinner.
+	err = spinner.ExecWithSpinner(
+		"Validating authentication configuration...",
+		"Authentication configuration is valid",
+		func() error {
+			return validator.ValidateAuthConfig(&atmosConfig.Auth)
+		},
+	)
+	if err != nil {
+		ui.Error(fmt.Sprintf("Authentication configuration validation failed: %v", err))
 		return err
 	}
 
-	u.PrintfMarkdown("**✅ Authentication configuration is valid**\n")
 	return nil
 }
 

cmd/validate_editorconfig.go

@@ -15,6 +15,8 @@ import (
 	errUtils "github.com/cloudposse/atmos/errors"
 	log "github.com/cloudposse/atmos/pkg/logger"
 	"github.com/cloudposse/atmos/pkg/schema"
+	"github.com/cloudposse/atmos/pkg/ui"
+	"github.com/cloudposse/atmos/pkg/ui/spinner"
 	u "github.com/cloudposse/atmos/pkg/utils"
 	"github.com/cloudposse/atmos/pkg/version"
 )
@@ -163,33 +165,53 @@ func runMainLogic() {
 		errUtils.CheckErrorPrintAndExit(err, "", "")
 	}
 
-	filePaths, err := files.GetFiles(config)
-	errUtils.CheckErrorPrintAndExit(err, "", "")
-
+	// Dry-run mode - just list files without spinner.
 	if config.DryRun {
+		filePaths, err := files.GetFiles(config)
+		errUtils.CheckErrorPrintAndExit(err, "", "")
 		for _, file := range filePaths {
 			log.Info(file)
 		}
 		return
 	}
 
-	errors := validation.ProcessValidation(filePaths, config)
-	log.Debug("Files checked", "count", len(filePaths))
-	errorCount := er.GetErrorCount(errors)
-	if errorCount != 0 {
-		er.PrintErrors(errors, config)
+	var filePaths []string
+	var validationErrors []er.ValidationErrors
+
+	err := spinner.ExecWithSpinner(
+		"Validating EditorConfig...",
+		"EditorConfig validation passed",
+		func() error {
+			var err error
+			filePaths, err = files.GetFiles(config)
+			if err != nil {
+				return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrEditorConfigGetFiles, err)
+			}
+			validationErrors = validation.ProcessValidation(filePaths, config)
+			log.Debug("Files checked", "count", len(filePaths))
+			if er.GetErrorCount(validationErrors) != 0 {
+				return errUtils.ErrEditorConfigValidationFailed
+			}
+			return nil
+		},
+	)
+	if err != nil {
+		if len(validationErrors) > 0 {
+			er.PrintErrors(validationErrors, config)
+		} else {
+			ui.Error(fmt.Sprintf("Validation failed: %v", err))
+		}
 		errUtils.Exit(1)
 	}
-	u.PrintMessage("No errors found")
 }
 
 func checkVersion(config config.Config) error {
 	if !utils.FileExists(config.Path) || config.Version == "" {
 		return nil
 	}
 	if config.Version != version.Version {
-		return fmt.Errorf("version mismatch: binary=%s, config=%s",
-			version.Version, config.Version)
+		return fmt.Errorf("%w: binary=%s, config=%s",
+			errUtils.ErrEditorConfigVersionMismatch, version.Version, config.Version)
 	}
 
 	return nil

cmd/validate_editorconfig_test.go

@@ -3,9 +3,12 @@ package cmd
 import (
 	"testing"
 
+	"github.com/editorconfig-checker/editorconfig-checker/v3/pkg/config"
 	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/cloudposse/atmos/pkg/schema"
 )
 
 // TestParseConfigPaths tests the pure parseConfigPaths function.
@@ -70,3 +73,213 @@ func TestInitConfig(t *testing.T) {
 	// Call function with no assertions - test passes if no panic occurs.
 	initializeConfig(editorConfigCmd)
 }
+
+// TestRunMainLogicDryRun tests the dry-run path in runMainLogic.
+func TestRunMainLogicDryRun(t *testing.T) {
+	// Save original state.
+	originalConfig := currentConfig
+	originalCliConfig := cliConfig
+	defer func() {
+		currentConfig = originalConfig
+		cliConfig = originalCliConfig
+	}()
+
+	// Create a minimal config for dry-run mode.
+	cfg := config.NewConfig([]string{})
+	cfg.DryRun = true
+	currentConfig = cfg
+	cliConfig = config.Config{DryRun: true}
+
+	// This should not panic and should list files (if any match).
+	// In dry-run mode, runMainLogic just lists files without validation.
+	runMainLogic()
+}
+
+// TestCheckVersion tests the version checking logic.
+func TestCheckVersion(t *testing.T) {
+	tests := []struct {
+		name        string
+		config      config.Config
+		expectError bool
+	}{
+		{
+			name: "no config file exists",
+			config: config.Config{
+				Path:    "/nonexistent/path",
+				Version: "",
+			},
+			expectError: false,
+		},
+		{
+			name: "empty version in config",
+			config: config.Config{
+				Path:    ".",
+				Version: "",
+			},
+			expectError: false,
+		},
+		{
+			name: "version mismatch",
+			config: config.Config{
+				Path:    ".", // Current directory exists
+				Version: "999.999.999",
+			},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := checkVersion(tt.config)
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+// TestReplaceAtmosConfigInConfig tests that atmos config values are properly applied.
+func TestReplaceAtmosConfigInConfig(t *testing.T) {
+	// Reset module-level variables before test.
+	originalConfigFilePaths := configFilePaths
+	originalTmpExclude := tmpExclude
+	originalInitEditorConfig := initEditorConfig
+	originalCliConfig := cliConfig
+	defer func() {
+		configFilePaths = originalConfigFilePaths
+		tmpExclude = originalTmpExclude
+		initEditorConfig = originalInitEditorConfig
+		cliConfig = originalCliConfig
+	}()
+
+	tests := []struct {
+		name        string
+		atmosConfig schema.AtmosConfiguration
+		flagChanged map[string]bool
+		setup       func(*cobra.Command)
+		validate    func(t *testing.T)
+	}{
+		{
+			name: "applies config file paths from atmos config",
+			atmosConfig: schema.AtmosConfiguration{
+				Validate: schema.Validate{
+					EditorConfig: schema.EditorConfig{
+						ConfigFilePaths: []string{".custom-editorconfig"},
+					},
+				},
+			},
+			validate: func(t *testing.T) {
+				assert.Equal(t, []string{".custom-editorconfig"}, configFilePaths)
+			},
+		},
+		{
+			name: "applies exclude patterns from atmos config",
+			atmosConfig: schema.AtmosConfiguration{
+				Validate: schema.Validate{
+					EditorConfig: schema.EditorConfig{
+						Exclude: []string{"vendor/**", "node_modules/**"},
+					},
+				},
+			},
+			validate: func(t *testing.T) {
+				assert.Equal(t, "vendor/**,node_modules/**", tmpExclude)
+			},
+		},
+		{
+			name: "applies init flag from atmos config",
+			atmosConfig: schema.AtmosConfiguration{
+				Validate: schema.Validate{
+					EditorConfig: schema.EditorConfig{
+						Init: true,
+					},
+				},
+			},
+			validate: func(t *testing.T) {
+				assert.True(t, initEditorConfig)
+			},
+		},
+		{
+			name: "applies ignore defaults from atmos config",
+			atmosConfig: schema.AtmosConfiguration{
+				Validate: schema.Validate{
+					EditorConfig: schema.EditorConfig{
+						IgnoreDefaults: true,
+					},
+				},
+			},
+			validate: func(t *testing.T) {
+				assert.True(t, cliConfig.IgnoreDefaults)
+			},
+		},
+		{
+			name: "applies dry run from atmos config",
+			atmosConfig: schema.AtmosConfiguration{
+				Validate: schema.Validate{
+					EditorConfig: schema.EditorConfig{
+						DryRun: true,
+					},
+				},
+			},
+			validate: func(t *testing.T) {
+				assert.True(t, cliConfig.DryRun)
+			},
+		},
+		{
+			name: "applies disable flags from atmos config",
+			atmosConfig: schema.AtmosConfiguration{
+				Validate: schema.Validate{
+					EditorConfig: schema.EditorConfig{
+						DisableTrimTrailingWhitespace: true,
+						DisableEndOfLine:              true,
+						DisableInsertFinalNewline:     true,
+						DisableIndentation:            true,
+						DisableIndentSize:             true,
+						DisableMaxLineLength:          true,
+					},
+				},
+			},
+			validate: func(t *testing.T) {
+				assert.True(t, cliConfig.Disable.TrimTrailingWhitespace)
+				assert.True(t, cliConfig.Disable.EndOfLine)
+				assert.True(t, cliConfig.Disable.InsertFinalNewline)
+				assert.True(t, cliConfig.Disable.Indentation)
+				assert.True(t, cliConfig.Disable.IndentSize)
+				assert.True(t, cliConfig.Disable.MaxLineLength)
+			},
+		},
+		{
+			name: "applies no color from atmos config",
+			atmosConfig: schema.AtmosConfiguration{
+				Settings: schema.AtmosSettings{
+					Terminal: schema.Terminal{
+						NoColor: true,
+					},
+				},
+			},
+			validate: func(t *testing.T) {
+				assert.True(t, cliConfig.NoColor)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Reset state.
+			configFilePaths = nil
+			tmpExclude = ""
+			initEditorConfig = false
+
+			cmd := &cobra.Command{}
+			addPersistentFlags(cmd)
+
+			if tt.setup != nil {
+				tt.setup(cmd)
+			}
+
+			replaceAtmosConfigInConfig(cmd, tt.atmosConfig)
+			tt.validate(t)
+		})
+	}
+}

errors/errors.go

@@ -408,6 +408,11 @@ var (
 	// Validation errors.
 	ErrValidationFailed = errors.New("validation failed")
 
+	// EditorConfig validation errors.
+	ErrEditorConfigValidationFailed = errors.New("EditorConfig validation failed")
+	ErrEditorConfigVersionMismatch  = errors.New("EditorConfig version mismatch")
+	ErrEditorConfigGetFiles         = errors.New("failed to get files for EditorConfig validation")
+
 	// Global/Stack-level section errors.
 	ErrInvalidVarsSection               = errors.New("invalid vars section")
 	ErrInvalidSettingsSection           = errors.New("invalid settings section")