Decouple repository root resolver from internal logic

cmd/build.go

@@ -61,6 +61,17 @@ func buildCommandAction(cmd *cobra.Command, args []string) error {
 		}
 	}
 
+	repoRoot, err := files.FindRepositoryRoot()
+	if err != nil {
+		return fmt.Errorf("locating repository root failed: %w", err)
+	}
+	defer repoRoot.Close()
+
+	linksFilePath, err := docs.LinksDefinitionsFilePath(repoRoot)
+	if err != nil {
+		return fmt.Errorf("locating links file failed: %w", err)
+	}
+
 	packageRoot, err := packages.MustFindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
@@ -72,7 +83,7 @@ func buildCommandAction(cmd *cobra.Command, args []string) error {
 	}
 	logger.Debugf("Use build directory: %s", buildDir)
 
-	targets, err := docs.UpdateReadmes(packageRoot, buildDir)
+	targets, err := docs.UpdateReadmes(linksFilePath, packageRoot, buildDir)
 	if err != nil {
 		return fmt.Errorf("updating files failed: %w", err)
 	}

cmd/links.go

@@ -56,8 +56,14 @@ func linksCheckCommandAction(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return fmt.Errorf("reading current working directory failed: %w", err)
 	}
+	// Find the repository root to create the links filesystem reference tied to the repository root
+	repoRoot, err := files.FindRepositoryRoot()
+	if err != nil {
+		return fmt.Errorf("finding repository root: %w", err)
+	}
+	defer repoRoot.Close()
 
-	linksFS, err := files.CreateLinksFSFromPath(pwd)
+	linksFS, err := files.CreateLinksFSFromPath(repoRoot, pwd)
 	if err != nil {
 		return fmt.Errorf("creating links filesystem failed: %w", err)
 	}
@@ -95,7 +101,14 @@ func linksUpdateCommandAction(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("reading current working directory failed: %w", err)
 	}
 
-	linksFS, err := files.CreateLinksFSFromPath(pwd)
+	// Find the repository root to create the links filesystem reference tied to the repository root
+	repoRoot, err := files.FindRepositoryRoot()
+	if err != nil {
+		return fmt.Errorf("finding repository root: %w", err)
+	}
+	defer repoRoot.Close()
+
+	linksFS, err := files.CreateLinksFSFromPath(repoRoot, pwd)
 	if err != nil {
 		return fmt.Errorf("creating links filesystem failed: %w", err)
 	}
@@ -135,7 +148,14 @@ func linksListCommandAction(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("reading current working directory failed: %w", err)
 	}
 
-	linksFS, err := files.CreateLinksFSFromPath(pwd)
+	// Find the repository root to create the links filesystem reference tied to the repository root
+	repoRoot, err := files.FindRepositoryRoot()
+	if err != nil {
+		return fmt.Errorf("finding repository root: %w", err)
+	}
+	defer repoRoot.Close()
+
+	linksFS, err := files.CreateLinksFSFromPath(repoRoot, pwd)
 	if err != nil {
 		return fmt.Errorf("creating links filesystem failed: %w", err)
 	}

cmd/lint.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/elastic/elastic-package/internal/cobraext"
 	"github.com/elastic/elastic-package/internal/docs"
+	"github.com/elastic/elastic-package/internal/files"
 	"github.com/elastic/elastic-package/internal/logger"
 	"github.com/elastic/elastic-package/internal/packages"
 	"github.com/elastic/elastic-package/internal/validation"
@@ -45,7 +46,19 @@ func setupLintCommand() *cobraext.Command {
 
 func lintCommandAction(cmd *cobra.Command, args []string) error {
 	cmd.Println("Lint the package")
-	readmeFiles, err := docs.AreReadmesUpToDate()
+
+	repoRoot, err := files.FindRepositoryRoot()
+	if err != nil {
+		return fmt.Errorf("locating repository root failed: %w", err)
+	}
+	defer repoRoot.Close()
+
+	linksFilePath, err := docs.LinksDefinitionsFilePath(repoRoot)
+	if err != nil {
+		return fmt.Errorf("locating links file failed: %w", err)
+	}
+
+	readmeFiles, err := docs.AreReadmesUpToDate(linksFilePath)
 	if err != nil {
 		for _, f := range readmeFiles {
 			if !f.UpToDate {

internal/builder/packages.go

@@ -28,6 +28,7 @@ var repositoryLicenseEnv = environment.WithElasticPackagePrefix("REPOSITORY_LICE
 type BuildOptions struct {
 	PackageRoot string
 	BuildDir    string
+	RepoRoot    *os.Root
 
 	CreateZip      bool
 	SignPackage    bool
@@ -182,7 +183,8 @@ func BuildPackage(ctx context.Context, options BuildOptions) (string, error) {
 	}
 
 	logger.Debug("Copy license file if needed")
-	err = copyLicenseTextFile(filepath.Join(destinationDir, licenseTextFileName))
+	destinationLicenseFilePath := filepath.Join(destinationDir, licenseTextFileName)
+	err = copyLicenseTextFile(options.RepoRoot, destinationLicenseFilePath)
 	if err != nil {
 		return "", fmt.Errorf("copying license text file: %w", err)
 	}
@@ -205,7 +207,7 @@ func BuildPackage(ctx context.Context, options BuildOptions) (string, error) {
 	}
 
 	logger.Debug("Include linked files")
-	linksFS, err := files.CreateLinksFSFromPath(options.PackageRoot)
+	linksFS, err := files.CreateLinksFSFromPath(options.RepoRoot, options.PackageRoot)
 	if err != nil {
 		return "", fmt.Errorf("creating links filesystem failed: %w", err)
 	}
@@ -290,19 +292,23 @@ func signZippedPackage(options BuildOptions, zippedPackagePath string) error {
 	return nil
 }
 
-func copyLicenseTextFile(licensePath string) error {
-	_, err := os.Stat(licensePath)
-	if err == nil {
+func copyLicenseTextFile(repoRoot *os.Root, licensePath string) error {
+	// if the given path exist, skip copying
+	if info, err := os.Stat(licensePath); err == nil && !info.IsDir() {
 		logger.Debug("License file in the package will be used")
 		return nil
 	}
 
+	// lookup for the license file in the repository
+	// default license name can be overridden by the user
 	repositoryLicenseTextFileName, userDefined := os.LookupEnv(repositoryLicenseEnv)
 	if !userDefined {
 		repositoryLicenseTextFileName = licenseTextFileName
 	}
 
-	sourceLicensePath, err := findRepositoryLicense(repositoryLicenseTextFileName)
+	path := filepath.Join(repoRoot.Name(), repositoryLicenseTextFileName)
+
+	sourceLicensePath, err := findRepositoryLicense(path)
 	if !userDefined && errors.Is(err, os.ErrNotExist) {
 		logger.Debug("No license text file is included in package")
 		return nil
@@ -341,17 +347,22 @@ func createBuildDirectory(dirs ...string) (string, error) {
 	return buildDir, nil
 }
 
-func findRepositoryLicense(licenseTextFileName string) (string, error) {
-	dir, err := files.FindRepositoryRootDirectory()
-	if err != nil {
-		return "", err
-	}
-
-	sourceFileName := filepath.Join(dir, licenseTextFileName)
-	_, err = os.Stat(sourceFileName)
-	if err != nil {
+// findRepositoryLicense checks if a license file exists at the specified path.
+// If the file exists, it returns the path; otherwise, it returns an error indicating
+// that the repository license could not be found.
+//
+// Parameters:
+//
+//	licensePath - the path to the license file.
+//
+// Returns:
+//
+//	string - the license file path if found.
+//	error  - an error if the license file does not exist.
+func findRepositoryLicense(licensePath string) (string, error) {
+	if _, err := os.Stat(licensePath); err != nil {
 		return "", fmt.Errorf("failed to find repository license: %w", err)
 	}
 
-	return sourceFileName, nil
+	return licensePath, nil
 }

internal/builder/packages_test.go

@@ -0,0 +1,122 @@
+package builder
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFindRepositoryLicense_FileExists(t *testing.T) {
+	dir := t.TempDir()
+	licensePath := filepath.Join(dir, "LICENSE.txt")
+	err := os.WriteFile(licensePath, []byte("license content"), 0644)
+	require.NoError(t, err)
+
+	path, err := findRepositoryLicense(licensePath)
+	require.NoError(t, err)
+	assert.Equal(t, licensePath, path)
+}
+
+func TestFindRepositoryLicense_FileDoesNotExist(t *testing.T) {
+	dir := t.TempDir()
+	licensePath := filepath.Join(dir, "NON_EXISTENT_LICENSE.txt")
+
+	path, err := findRepositoryLicense(licensePath)
+	require.Error(t, err)
+	assert.Empty(t, path)
+}
+func TestCopyLicenseTextFile_UsesExistingLicenseFile(t *testing.T) {
+	dir := t.TempDir()
+	licensePath := filepath.Join(dir, "LICENSE.txt")
+	err := os.WriteFile(licensePath, []byte("existing license"), 0644)
+	require.NoError(t, err)
+
+	repoRoot, err := os.OpenRoot(t.TempDir())
+	require.NoError(t, err)
+	defer repoRoot.Close()
+
+	// Should not attempt to copy, just return nil
+	err = copyLicenseTextFile(repoRoot, licensePath)
+	assert.NoError(t, err)
+
+	// License file should remain unchanged
+	content, err := os.ReadFile(licensePath)
+	require.NoError(t, err)
+	assert.Equal(t, "existing license", string(content))
+}
+
+func TestCopyLicenseTextFile_CopiesFromRepo(t *testing.T) {
+	repoRoot, err := os.OpenRoot(t.TempDir())
+	require.NoError(t, err)
+	defer repoRoot.Close()
+
+	licensePath := filepath.Join(repoRoot.Name(), "LICENSE.txt")
+	err = os.WriteFile(licensePath, []byte("repo license"), 0644)
+	require.NoError(t, err)
+
+	destDir := t.TempDir()
+	destLicensePath := filepath.Join(destDir, "LICENSE.txt")
+
+	err = copyLicenseTextFile(repoRoot, destLicensePath)
+	assert.NoError(t, err)
+
+	content, err := os.ReadFile(destLicensePath)
+	require.NoError(t, err)
+	assert.Equal(t, "repo license", string(content))
+}
+
+func TestCopyLicenseTextFile_NoRepoLicense_ReturnsNil(t *testing.T) {
+	repoRoot, err := os.OpenRoot(t.TempDir())
+	require.NoError(t, err)
+	defer repoRoot.Close()
+
+	destDir := t.TempDir()
+	destLicensePath := filepath.Join(destDir, "LICENSE.txt")
+
+	err = copyLicenseTextFile(repoRoot, destLicensePath)
+	assert.NoError(t, err)
+
+	_, err = os.Stat(destLicensePath)
+	assert.True(t, os.IsNotExist(err))
+}
+
+func TestCopyLicenseTextFile_EnvOverridesLicenseName(t *testing.T) {
+	repoRoot, err := os.OpenRoot(t.TempDir())
+	require.NoError(t, err)
+	defer repoRoot.Close()
+
+	customLicenseName := "CUSTOM_LICENSE.txt"
+	customLicensePath := filepath.Join(repoRoot.Name(), customLicenseName)
+	err = os.WriteFile(customLicensePath, []byte("custom license"), 0644)
+	require.NoError(t, err)
+
+	destDir := t.TempDir()
+	destLicensePath := filepath.Join(destDir, "LICENSE.txt")
+
+	t.Setenv(repositoryLicenseEnv, customLicenseName)
+	err = copyLicenseTextFile(repoRoot, destLicensePath)
+	assert.NoError(t, err)
+
+	content, err := os.ReadFile(destLicensePath)
+	require.NoError(t, err)
+	assert.Equal(t, "custom license", string(content))
+}
+
+func TestCopyLicenseTextFile_ErrorCopyingFile(t *testing.T) {
+	repoRoot, err := os.OpenRoot(t.TempDir())
+	require.NoError(t, err)
+	defer repoRoot.Close()
+
+	licensePath := filepath.Join(repoRoot.Name(), "LICENSE.txt")
+	err = os.WriteFile(licensePath, []byte("repo license"), 0644)
+	require.NoError(t, err)
+
+	// Use a destination path that is a directory, so sh.Copy should fail
+	destDir := t.TempDir()
+
+	err = copyLicenseTextFile(repoRoot, destDir)
+	assert.Error(t, err)
+}