[chore][cmd/mdatagen] Fix RootPackage to use go module root instead of git repo root

Author: jkoronaAtCisco

cmd/mdatagen/internal/command_test.go

@@ -9,7 +9,6 @@ import (
 	"go/parser"
 	"go/token"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -280,9 +279,6 @@ func TestRunContents(t *testing.T) {
 			tmpdir := filepath.Join(t.TempDir(), "shortname")
 			err := os.MkdirAll(tmpdir, 0o750)
 			require.NoError(t, err)
-			// Init a git repo so helpers.RootPackage can resolve the repo root
-			// when generateConfigGoStruct is called for components with config.
-			gitInit(t, tmpdir)
 			ymlContent, err := os.ReadFile(filepath.Join("testdata", tt.yml))
 			require.NoError(t, err)
 			metadataFile := filepath.Join(tmpdir, "metadata.yaml")
@@ -526,7 +522,6 @@ func TestGenerateConfigFiles(t *testing.T) {
 			tmpdir := filepath.Join(root, "shortname")
 			require.NoError(t, os.MkdirAll(tmpdir, 0o700))
 
-			gitInit(t, root)
 			require.NoError(t, os.WriteFile(filepath.Join(root, "go.mod"), []byte("module testmodule\n"), 0o600))
 			err := generateConfigFiles(tt.md, tmpdir, "testmodule")
 			if tt.wantErr {
@@ -544,7 +539,7 @@ func TestGenerateConfigFiles(t *testing.T) {
 }
 
 func TestGenerateConfigGoStruct_RootPackageError(t *testing.T) {
-	// tmpdir is not inside any git repo, so helpers.RootPackage fails
+	// tmpdir has no go.mod in any ancestor, so helpers.RootPackage fails
 	md := Metadata{
 		Type:        "test",
 		PackageName: "shortname",
@@ -557,7 +552,7 @@ func TestGenerateConfigGoStruct_RootPackageError(t *testing.T) {
 }
 
 func TestGenerateConfigFiles_GoStructError(t *testing.T) {
-	// generateConfigGoStruct fails because tmpdir is not inside a git repo
+	// generateConfigGoStruct fails because tmpdir has no go.mod in any ancestor
 	md := Metadata{
 		Type:        "test",
 		PackageName: "shortname",
@@ -1103,11 +1098,3 @@ func TestGenerateConfigSchema_LocalizesSameRootRefs(t *testing.T) {
 	require.Contains(t, string(actual), "$ref: /filter.config")
 	require.NotContains(t, string(actual), "$ref: go.opentelemetry.io/collector/filter.config")
 }
-
-func gitInit(t *testing.T, dir string) {
-	t.Helper()
-	cmd := exec.Command("git", "init")
-	cmd.Dir = dir
-	out, err := cmd.CombinedOutput()
-	require.NoError(t, err, "git init failed: %s", out)
-}

cmd/mdatagen/internal/helpers/packages.go

@@ -4,42 +4,52 @@
 package helpers // import "go.opentelemetry.io/collector/cmd/mdatagen/internal/helpers"
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
 )
 
-// RootPackage determines the root Go module path by reading the module directive
-// from the go.mod at the repository root. This is used to resolve local absolute
-// references (e.g., "/config/confighttp.client_config") into full Go import paths.
+// RootPackage determines the root Go module path by finding the highest go.mod above componentDir
+// and running "go list -m" in that directory. This is used to resolve local absolute references
+// (e.g., "/config/confighttp.client_config") into full Go import paths.
 func RootPackage(componentDir string) (string, error) {
-	repoRoot, err := repoRoot(componentDir)
+	rootModDir, err := rootModuleDir(componentDir)
 	if err != nil {
 		return "", err
 	}
 
-	goModData, err := os.ReadFile(filepath.Clean(filepath.Join(repoRoot, "go.mod")))
+	cmd := exec.Command("go", "list", "-m")
+	cmd.Dir = rootModDir
+	output, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve root module path: %w", err)
+	}
+	return strings.TrimSpace(string(output)), nil
+}
+
+func rootModuleDir(componentDir string) (string, error) {
+	absDir, err := filepath.Abs(componentDir)
 	if err != nil {
-		return "", fmt.Errorf("failed to read root go.mod: %w", err)
+		return "", fmt.Errorf("failed to get absolute path: %w", err)
 	}
 
-	for line := range strings.SplitSeq(string(goModData), "\n") {
-		if after, ok := strings.CutPrefix(strings.TrimSpace(line), "module "); ok {
-			return strings.TrimSpace(after), nil
+	var found string
+	dir := absDir
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			found = dir
 		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			break
+		}
+		dir = parent
 	}
-	return "", errors.New("module directive not found in root go.mod")
-}
 
-func repoRoot(dir string) (string, error) {
-	cmd := exec.Command("git", "rev-parse", "--show-toplevel")
-	cmd.Dir = dir
-	output, err := cmd.Output()
-	if err != nil {
-		return "", fmt.Errorf("failed to find repo root: %w", err)
+	if found == "" {
+		return "", fmt.Errorf("no go.mod found in any parent of %s", componentDir)
 	}
-	return strings.TrimSpace(string(output)), nil
+	return found, nil
 }

cmd/mdatagen/internal/helpers/packages_test.go

@@ -5,34 +5,62 @@ package helpers
 
 import (
 	"os"
-	"os/exec"
 	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestRepoRoot(t *testing.T) {
-	t.Run("returns_repo_root_from_subdirectory", func(t *testing.T) {
-		wd, err := os.Getwd()
+func TestRootModuleDir(t *testing.T) {
+	t.Run("finds_go_mod_in_parent", func(t *testing.T) {
+		tmp := t.TempDir()
+		subDir := filepath.Join(tmp, "sub")
+		require.NoError(t, os.MkdirAll(subDir, 0o700))
+
+		require.NoError(t, os.WriteFile(filepath.Join(tmp, "go.mod"), []byte("module example.com/root\n"), 0o600))
+
+		dir, err := rootModuleDir(subDir)
 		require.NoError(t, err)
+		assert.Equal(t, tmp, dir)
+	})
+
+	t.Run("finds_go_mod_in_intermediate_directory", func(t *testing.T) {
+		tmp := t.TempDir()
+		projectDir := filepath.Join(tmp, "project")
+		componentDir := filepath.Join(projectDir, "receiver", "foo")
+		require.NoError(t, os.MkdirAll(componentDir, 0o700))
 
-		root, err := repoRoot(wd)
+		// No go.mod at tmp root; go.mod is in project/ subdirectory
+		require.NoError(t, os.WriteFile(filepath.Join(projectDir, "go.mod"), []byte("module example.com/project\n"), 0o600))
+
+		dir, err := rootModuleDir(componentDir)
 		require.NoError(t, err)
-		assert.DirExists(t, root)
-		assert.FileExists(t, filepath.Join(root, "go.mod"))
+		assert.Equal(t, projectDir, dir)
 	})
 
-	t.Run("error_for_nonexistent_directory", func(t *testing.T) {
-		_, err := repoRoot("/nonexistent/path/that/does/not/exist")
-		require.Error(t, err)
+	t.Run("prefers_highest_go_mod", func(t *testing.T) {
+		tmp := t.TempDir()
+		componentDir := filepath.Join(tmp, "project", "receiver", "foo")
+		require.NoError(t, os.MkdirAll(componentDir, 0o700))
+
+		// go.mod at both levels
+		require.NoError(t, os.WriteFile(filepath.Join(tmp, "go.mod"), []byte("module example.com/root\n"), 0o600))
+		require.NoError(t, os.WriteFile(filepath.Join(tmp, "project", "go.mod"), []byte("module example.com/project\n"), 0o600))
+
+		dir, err := rootModuleDir(componentDir)
+		require.NoError(t, err)
+		assert.Equal(t, tmp, dir)
 	})
 
-	t.Run("error_outside_git_repo", func(t *testing.T) {
+	t.Run("error_when_no_go_mod_found", func(t *testing.T) {
 		tmp := t.TempDir()
-		_, err := repoRoot(tmp)
+		subDir := filepath.Join(tmp, "sub")
+		require.NoError(t, os.MkdirAll(subDir, 0o700))
+
+		_, err := rootModuleDir(subDir)
 		require.Error(t, err)
+		assert.Contains(t, err.Error(), "no go.mod found")
 	})
 }
 
@@ -51,57 +79,37 @@ func TestRootPackage(t *testing.T) {
 		require.Error(t, err)
 	})
 
-	t.Run("error_when_go_mod_missing", func(t *testing.T) {
+	t.Run("resolves_module_from_synthetic_go_mod", func(t *testing.T) {
 		tmp := t.TempDir()
-		subDir := filepath.Join(tmp, "sub")
-		require.NoError(t, os.MkdirAll(subDir, 0o700))
-
-		gitInit(t, tmp)
-
-		_, err := RootPackage(subDir)
-		require.Error(t, err)
-		assert.Contains(t, err.Error(), "go.mod")
-	})
-
-	t.Run("error_when_go_mod_has_no_module_directive", func(t *testing.T) {
-		tmp := t.TempDir()
-		subDir := filepath.Join(tmp, "sub")
+		subDir := filepath.Join(tmp, "pkg", "foo")
 		require.NoError(t, os.MkdirAll(subDir, 0o700))
 
-		gitInit(t, tmp)
 		require.NoError(t, os.WriteFile(
 			filepath.Join(tmp, "go.mod"),
-			[]byte("go 1.21\n"),
+			[]byte("module example.com/my-project\n\ngo 1.21\n"),
 			0o600,
 		))
 
-		_, err := RootPackage(subDir)
-		require.Error(t, err)
-		assert.Contains(t, err.Error(), "module directive not found")
+		pkg, err := RootPackage(subDir)
+		require.NoError(t, err)
+		assert.Equal(t, "example.com/my-project", pkg)
 	})
 
-	t.Run("parses_module_from_synthetic_go_mod", func(t *testing.T) {
+	t.Run("monorepo_go_mod_not_at_top_level", func(t *testing.T) {
 		tmp := t.TempDir()
-		subDir := filepath.Join(tmp, "pkg", "foo")
-		require.NoError(t, os.MkdirAll(subDir, 0o700))
+		projectDir := filepath.Join(tmp, "collector")
+		componentDir := filepath.Join(projectDir, "receiver", "foo")
+		require.NoError(t, os.MkdirAll(componentDir, 0o700))
 
-		gitInit(t, tmp)
+		// No go.mod at top level; only in collector/ subdirectory
 		require.NoError(t, os.WriteFile(
-			filepath.Join(tmp, "go.mod"),
-			[]byte("module example.com/my-project\n\ngo 1.21\n"),
+			filepath.Join(projectDir, "go.mod"),
+			[]byte("module go.opentelemetry.io/collector\n\ngo 1.21\n"),
 			0o600,
 		))
 
-		pkg, err := RootPackage(subDir)
+		pkg, err := RootPackage(componentDir)
 		require.NoError(t, err)
-		assert.Equal(t, "example.com/my-project", pkg)
+		assert.Equal(t, "go.opentelemetry.io/collector", pkg)
 	})
 }
-
-func gitInit(t *testing.T, dir string) {
-	t.Helper()
-	cmd := exec.Command("git", "init")
-	cmd.Dir = dir
-	out, err := cmd.CombinedOutput()
-	require.NoError(t, err, "git init failed: %s", out)
-}