updates

Author: aknysh

cmd/root_test.go

@@ -30,15 +30,8 @@ func TestNoColorLog(t *testing.T) {
 		t.Fatalf("Failed to get current working directory: %v", err)
 	}
 
-	// Change back to original directory IMMEDIATELY to ensure paths work.
-	// Previous tests may have left us in a temp directory.
-	if err := os.Chdir(originalWd); err != nil {
-		t.Fatalf("Failed to restore working directory: %v", err)
-	}
-
-	t.Cleanup(func() {
-		_ = os.Chdir(originalWd)
-	})
+	// Change back to original directory and automatically restore when test ends.
+	t.Chdir(originalWd)
 
 	// Ensure ATMOS_CHDIR is not set BEFORE anything else.
 	// Previous tests may have set it, and we need to clear it before RootCmd.Execute().

pkg/config/load_config_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	errUtils "github.com/cloudposse/atmos/errors"
 	"github.com/cloudposse/atmos/pkg/schema"
 )
 
@@ -175,3 +176,220 @@ func TestConnectPaths_WindowsPaths(t *testing.T) {
 		})
 	}
 }
+
+// TestValidatedIsFiles_EdgeCases tests edge cases for file validation.
+func TestValidatedIsFiles_EdgeCases(t *testing.T) {
+	tmpDir := t.TempDir()
+	validFile := filepath.Join(tmpDir, "test.yaml")
+	require.NoError(t, os.WriteFile(validFile, []byte("test: value"), 0o644))
+
+	tests := []struct {
+		name      string
+		files     []string
+		wantError string
+		checkErr  error
+	}{
+		{
+			name:      "empty file path",
+			files:     []string{""},
+			wantError: "requires a non-empty file path",
+			checkErr:  errUtils.ErrEmptyConfigFile,
+		},
+		{
+			name:      "directory instead of file",
+			files:     []string{tmpDir},
+			wantError: "",
+			checkErr:  errUtils.ErrExpectedFile,
+		},
+		{
+			name:      "multiple files with one invalid",
+			files:     []string{validFile, ""},
+			wantError: "requires a non-empty file path",
+			checkErr:  errUtils.ErrEmptyConfigFile,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validatedIsFiles(tt.files)
+			assert.Error(t, err)
+			if tt.wantError != "" {
+				assert.Contains(t, err.Error(), tt.wantError)
+			}
+			if tt.checkErr != nil {
+				assert.ErrorIs(t, err, tt.checkErr)
+			}
+		})
+	}
+}
+
+// TestValidatedIsDirs_EdgeCases tests edge cases for directory validation.
+func TestValidatedIsDirs_EdgeCases(t *testing.T) {
+	tmpDir := t.TempDir()
+	validDir := filepath.Join(tmpDir, "valid")
+	require.NoError(t, os.Mkdir(validDir, 0o755))
+
+	testFile := filepath.Join(tmpDir, "file.txt")
+	require.NoError(t, os.WriteFile(testFile, []byte("test"), 0o644))
+
+	tests := []struct {
+		name      string
+		dirs      []string
+		wantError string
+		checkErr  error
+	}{
+		{
+			name:      "empty directory path",
+			dirs:      []string{""},
+			wantError: "requires a non-empty directory path",
+			checkErr:  errUtils.ErrEmptyConfigPath,
+		},
+		{
+			name:      "file instead of directory",
+			dirs:      []string{testFile},
+			wantError: "requires a directory but found a file",
+			checkErr:  errUtils.ErrAtmosDirConfigNotFound,
+		},
+		{
+			name:      "non-existent directory",
+			dirs:      []string{filepath.Join(tmpDir, "nonexistent")},
+			wantError: "does not exist",
+			checkErr:  errUtils.ErrAtmosDirConfigNotFound,
+		},
+		{
+			name:      "multiple dirs with one invalid",
+			dirs:      []string{validDir, ""},
+			wantError: "requires a non-empty directory path",
+			checkErr:  errUtils.ErrEmptyConfigPath,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validatedIsDirs(tt.dirs)
+			assert.Error(t, err)
+			if tt.wantError != "" {
+				assert.Contains(t, err.Error(), tt.wantError)
+			}
+			if tt.checkErr != nil {
+				assert.ErrorIs(t, err, tt.checkErr)
+			}
+		})
+	}
+}
+
+// TestMergeConfigFromDirectories_ConfigFileVariants tests finding both atmos.yaml and .atmos.yaml.
+func TestMergeConfigFromDirectories_ConfigFileVariants(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	// Directory with atmos.yaml
+	dir1 := filepath.Join(tmpDir, "dir1")
+	require.NoError(t, os.Mkdir(dir1, 0o755))
+	require.NoError(t, os.WriteFile(
+		filepath.Join(dir1, "atmos.yaml"),
+		[]byte("base_path: /test1"),
+		0o644,
+	))
+
+	// Directory with .atmos.yaml
+	dir2 := filepath.Join(tmpDir, "dir2")
+	require.NoError(t, os.Mkdir(dir2, 0o755))
+	require.NoError(t, os.WriteFile(
+		filepath.Join(dir2, ".atmos.yaml"),
+		[]byte("base_path: /test2"),
+		0o644,
+	))
+
+	// Directory with no config file
+	emptyDir := filepath.Join(tmpDir, "empty")
+	require.NoError(t, os.Mkdir(emptyDir, 0o755))
+
+	tests := []struct {
+		name         string
+		dirs         []string
+		expectError  bool
+		expectedDirs int
+	}{
+		{
+			name:         "finds atmos.yaml",
+			dirs:         []string{dir1},
+			expectError:  false,
+			expectedDirs: 1,
+		},
+		{
+			name:         "finds .atmos.yaml",
+			dirs:         []string{dir2},
+			expectError:  false,
+			expectedDirs: 1,
+		},
+		{
+			name:         "finds both variants in different directories",
+			dirs:         []string{dir1, dir2},
+			expectError:  false,
+			expectedDirs: 2,
+		},
+		{
+			name:        "fails for directory without config",
+			dirs:        []string{emptyDir},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			configInfo := schema.ConfigAndStacksInfo{
+				AtmosConfigDirsFromArg: tt.dirs,
+			}
+
+			_, err := InitCliConfig(configInfo, false)
+
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
+
+// TestLoadConfigFromCLIArgs_ErrorPaths tests error paths in config loading.
+func TestLoadConfigFromCLIArgs_ErrorPaths(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	// Create invalid YAML file
+	invalidYaml := filepath.Join(tmpDir, "invalid.yaml")
+	require.NoError(t, os.WriteFile(invalidYaml, []byte("invalid: [unclosed"), 0o644))
+
+	tests := []struct {
+		name        string
+		files       []string
+		dirs        []string
+		expectError bool
+		description string
+	}{
+		{
+			name:        "invalid YAML syntax",
+			files:       []string{invalidYaml},
+			dirs:        []string{},
+			expectError: true,
+			description: "Should fail for invalid YAML syntax",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			configInfo := schema.ConfigAndStacksInfo{
+				AtmosConfigFilesFromArg: tt.files,
+				AtmosConfigDirsFromArg:  tt.dirs,
+			}
+
+			_, err := InitCliConfig(configInfo, false)
+
+			if tt.expectError {
+				assert.Error(t, err, tt.description)
+			} else {
+				assert.NoError(t, err, tt.description)
+			}
+		})
+	}
+}

tools/lintroller/rule_os_chdir.go

@@ -24,6 +24,11 @@ func (r *OsChdirInTestRule) Check(pass *analysis.Pass, file *ast.File) error {
 		return nil // Only check test files.
 	}
 
+	// Allow os.Chdir in test files that are explicitly testing chdir functionality.
+	if strings.Contains(filename, "chdir_test.go") {
+		return nil
+	}
+
 	// Find benchmark functions to exclude from checks.
 	benchmarks := findBenchmarksForChdir(file)