improve BasePathComputing func

pkg/config/base-path.go → pkg/config/base_path.go

@@ -11,41 +11,45 @@ import (
 )
 
 func (cl *ConfigLoader) BasePathComputing(configAndStacksInfo schema.ConfigAndStacksInfo) (string, error) {
-	// Is --base-path Provided?
-	if configAndStacksInfo.BasePathFromArg != "" {
-		absPath, err := filepath.Abs(configAndStacksInfo.BasePathFromArg)
-		if err != nil {
-			return "", err
-		}
 
-		return absPath, nil
+	// Check base path from CLI argument
+	if configAndStacksInfo.BasePathFromArg != "" {
+		return cl.resolveAndValidatePath(configAndStacksInfo.BasePathFromArg, "CLI argument")
 	}
-	// Is ATMOS_BASE_PATH Set ?
-	if os.Getenv("ATMOS_BASE_PATH") != "" {
-		absPath, err := filepath.Abs(os.Getenv("ATMOS_BASE_PATH"))
-		if err != nil {
-			return "", err
-		}
-		return absPath, nil
+
+	// Check base path from ATMOS_BASE_PATH environment variable
+	if envBasePath := os.Getenv("ATMOS_BASE_PATH"); envBasePath != "" {
+		return cl.resolveAndValidatePath(envBasePath, "ENV var")
 	}
-	// Is base_path Set in Configuration?
+
+	// Check base path from configuration
 	if cl.atmosConfig.BasePath != "" {
-		//Is base_path Absolute?
-		absPath, err := filepath.Abs(configAndStacksInfo.BasePath)
-		if err == nil {
-			return absPath, nil
-		}
-		//Resolve base_path relative to current working directory
-		pwd, err := os.Getwd()
-		if err != nil {
-			return "", err
-		}
-		absPath, err = filepath.Abs(pwd)
-		if err != nil {
-			return "", err
+
+		if !filepath.IsAbs(cl.atmosConfig.BasePath) {
+			source := "atmos config relative"
+			// If relative, make it absolute based on the current working directory
+			absPath, err := filepath.Abs(cl.atmosConfig.BasePath)
+			if err != nil {
+				return "", fmt.Errorf("failed to resolve relative base path from %s: %w", source, err)
+			}
+			currentDir, err := os.Getwd()
+			if err != nil {
+				return "", err
+			}
+			relativePath, err := filepath.Rel(currentDir, absPath)
+			if err != nil {
+				return "", fmt.Errorf("Error base path from from atmos config can not resolving relative path:%w", err)
+			}
+			_, err = cl.resolveAndValidatePath(relativePath, source)
+			if err != nil {
+				return "", err
+			}
+			return relativePath, nil
 		}
-		return absPath, nil
+		source := "atmos config"
+		return cl.resolveAndValidatePath(cl.atmosConfig.BasePath, source)
 	}
+
 	//Infer base_path
 	pwd, err := os.Getwd()
 	if err != nil {
@@ -57,35 +61,69 @@ func (cl *ConfigLoader) BasePathComputing(configAndStacksInfo schema.ConfigAndSt
 		if err != nil {
 			return "", err
 		}
+		cl.logging(fmt.Sprintf("base path from %s: %s", "infra", absPath))
 		return absPath, nil
 	}
-	// TODO : Update ATMOS_BASE_PATH with absolute path is that mean set env  ATMOS_BASE_PATH=base_path
 	//Set base_path to absolute path of ./
-	return "./", nil
+	absPath, err := filepath.Abs("./")
+	if err != nil {
+		return "", err
+	}
+	cl.logging(fmt.Sprintf("base path from %s: %s", "PWD", pwd))
+	return absPath, nil
 }
+
+// Helper to resolve and validate base path
+func (cl *ConfigLoader) resolveAndValidatePath(path string, source string) (string, error) {
+	absPath, err := filepath.Abs(path)
+	if err != nil {
+		return "", fmt.Errorf("base path from %s does not exist: %w", source, err)
+	}
+
+	isDir, err := u.IsDirectory(absPath)
+	if err != nil {
+		if err == os.ErrNotExist {
+			return "", fmt.Errorf("base path from %s does not exist: %w", source, err)
+		}
+		return "", err
+	}
+
+	if !isDir {
+		return "", fmt.Errorf("base path from %s is not a directory: %w", source, err)
+	}
+
+	cl.logging(fmt.Sprintf("base path from %s: %s", source, path))
+	return absPath, nil
+}
+
 func (cl *ConfigLoader) infraBasePath(cwd string) (string, bool) {
 	// CWD Check CWD for atmos.yaml, .atmos.yaml, atmos.d/**/*, .github/atmos.yaml
 	// if found Set base_path to absolute path containing directory
 	filePath, found := cl.SearchConfigFilePath(filepath.Join(cwd, "atmos"))
 	if found {
+		cl.logging(fmt.Sprintf("base path from infra %s: %s", "atmos", filePath))
 		return filepath.Dir(filePath), found
 	}
 	filePath, found = cl.SearchConfigFilePath(filepath.Join(cwd, ".atmos"))
 	if found {
+		cl.logging(fmt.Sprintf("base path from infra %s: %s", ".atmos", filePath))
 		return filepath.Dir(filePath), found
 	}
 	filePaths, _ := u.GetGlobMatches(filepath.ToSlash(filepath.Join(cwd, "atmos.d/**/*.yaml")))
 	if len(filePaths) == 0 {
 		filePaths, _ = u.GetGlobMatches(filepath.ToSlash(filepath.Join(cwd, "atmos.d/**/*.yml")))
 	}
 	if len(filePaths) > 0 {
+		cl.logging(fmt.Sprintf("base path from infra %s: %s", "atmos.d", filePath))
 		filePaths = cl.sortFilesByDepth(filePaths)
 		return filepath.Dir(filePaths[0]), true
 	}
 	gitTopLevel, err := GetGitRoot(cwd)
 	if err == nil {
 		dirAbs, found := cl.SearchConfigFilePath(filepath.Join(gitTopLevel, "atmos"))
 		if found {
+			cl.logging(fmt.Sprintf("base path from infra %s: %s", "git root", filePath))
+
 			return dirAbs, found
 		}
 	}

pkg/config/base_path_test.go

@@ -0,0 +1,114 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/cloudposse/atmos/pkg/schema"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBasePathComputingWithBasePathArg(t *testing.T) {
+	configLoader := &ConfigLoader{}
+
+	info := schema.ConfigAndStacksInfo{
+		BasePathFromArg: ".",
+	}
+
+	expectedPath, _ := filepath.Abs(".")
+
+	result, err := configLoader.BasePathComputing(info)
+
+	assert.NoError(t, err)
+	assert.Equal(t, expectedPath, result)
+	// test non-existent base path
+	info.BasePathFromArg = "invalid/path"
+	expectedPath, _ = filepath.Abs("invalid/path")
+	result, err = configLoader.BasePathComputing(info)
+	assert.Error(t, err)
+	assert.Equal(t, "", result)
+
+	// test base pat not directory
+	tempDir, err := os.MkdirTemp("", "config-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	tempDir = filepath.FromSlash(tempDir)
+	defer os.RemoveAll(tempDir)
+	configFile1 := filepath.Join(tempDir, "config1.yaml")
+	err = os.WriteFile(configFile1, []byte("key1: value1"), 0644)
+	assert.NoError(t, err)
+	info.BasePathFromArg = configFile1
+	result, err = configLoader.BasePathComputing(info)
+	assert.Error(t, err)
+	assert.Equal(t, "", result)
+
+}
+
+// test env base path
+func TestBasePathComputingWithEnvVar(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+	configLoader := &ConfigLoader{}
+	// set env
+	os.Setenv("ATMOS_BASE_PATH", tempDir)
+	defer os.Unsetenv("ATMOS_BASE_PATH")
+	info := schema.ConfigAndStacksInfo{
+		BasePathFromArg: "",
+	}
+	expectedPath, _ := filepath.Abs(tempDir)
+	result, err := configLoader.BasePathComputing(info)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedPath, result)
+}
+
+// test  base_path Set in Configuration
+func TestBasePathComputingWithBasePathSetInConfiguration(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tempDir)
+	configLoader := &ConfigLoader{}
+	configLoader.atmosConfig.BasePath = tempDir
+	info := schema.ConfigAndStacksInfo{
+		BasePathFromArg: "",
+	}
+	expectedPath, _ := filepath.Abs(tempDir)
+	result, err := configLoader.BasePathComputing(info)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedPath, result)
+	// test base pat not abs directory
+	// change pwd to temp
+	startingDir, err := os.Getwd()
+	if err != nil {
+		fmt.Printf("Failed to get the current working directory: %v\n", err)
+		os.Exit(1) // Exit with a non-zero code to indicate failure
+	}
+	defer func() {
+		// Change back to the original working directory after the test
+		if err := os.Chdir(startingDir); err != nil {
+			t.Fatalf("Failed to change back to the starting directory: %v", err)
+		}
+	}()
+	err = os.Chdir(tempDir)
+	if err != nil {
+		t.Fatalf("Failed to change directory to %q: %v", tempDir, err)
+	}
+	// dir under temp
+	subDirTemp := filepath.Join(tempDir, "sub-dir")
+	err = os.Mkdir(subDirTemp, 0755)
+	if err != nil {
+		t.Fatalf("Failed to create directory %q: %v", subDirTemp, err)
+	}
+	configLoader.atmosConfig.BasePath = "sub-dir"
+	result, err = configLoader.BasePathComputing(info)
+	assert.NoError(t, err)
+	assert.Equal(t, "sub-dir", result)
+
+}

pkg/config/imports_test.go

@@ -73,7 +73,7 @@ func TestProcessImports(t *testing.T) {
 	}
 
 	// Step 5: Run the processImports method
-	resolvedPaths, err := configLoader.processImports(imports, "./test", 0, 10)
+	resolvedPaths, err := configLoader.processImports(imports, baseDir, 0, 10)
 
 	// Step 6: Assertions
 	assert.NoError(t, err, "processImports should not return an error")