Feat: Add command line app to validate go.mod (#67796)

* chore: start modowners

* read go.mod, parse modfile, iterate through requires; add dummy go.mod

* make BEP owners of all grafana dependencies 😱

* push attempt at logging the require comments

* shrink dummy modfile

* revert changes in go.mod

* access comments suffix

* add Module struct; attempt to separate ParseGoMod functionality into its own func; add owner (third) for loop when interating modfile

* feat: print all owners in modfile

* add additional question in comment

* feat: add subcommands: check, owners, modules; chunk out some functions

* chunk out subcommand functions

* add flags

* start tests for common element

* refactor: test for common element

* attempt #1 to refactor modules to accept multiple args

* refactor: refactor modfule func to take 1+ owner arguments (0 arguments not working atm)

* chore: remove debug logging

* refine existing comments

* comment out indirect flag stuff, add example cli command for modules

* unsuccessful attempt #2 to refactor modules to accept -o and -i flags

* refactor funcs to take filesystem and logger

* test: add test for check when all modules have owners

* fail attempt 1 to get TestModules to work

* assert expected log result in TestModules; unsure if properly reading logs

* test: add TestModules to test modules func without any flags returns direct dependencies

* test: add TestInvalidCheck for scenario when some dependencies are missing an owner

* attempt 1 at refactoring TestCheck into a table

* chore: clean TestCheck

* chore: clean up comments for func check

* move files under scripts/modowners

* revert go.mod and go.sum

scripts/modowners/modowners_test.go

@@ -0,0 +1,102 @@
+package main
+
+import (
+	"bytes"
+	"log"
+	"strings"
+	"testing"
+	"testing/fstest"
+)
+
+func TestCommonElement(t *testing.T) {
+	for _, test := range []struct {
+		A      []string
+		B      []string
+		Result bool
+	}{
+		{nil, nil, false},
+		{[]string{"a"}, []string{"a"}, true},
+		{[]string{"a", "b"}, []string{"a"}, true},
+		{[]string{"a"}, []string{"b"}, false},
+	} {
+		if hasCommonElement(test.A, test.B) != test.Result {
+			t.Error(test)
+		}
+	}
+}
+
+func TestCheck(t *testing.T) {
+	for _, test := range []struct {
+		description    string
+		fileName       string
+		contents       string
+		args           []string
+		valid          bool
+		expectedOutput string
+	}{
+		{"Test valid modfile", "go.mod", `
+		require (
+			cloud.google.com/go/storage v1.28.1 // @delivery
+			cuelang.org/go v0.5.0 // @as-code @backend-platform
+			github.com/Azure/azure-sdk-for-go v65.0.0+incompatible // indirect, @delivery
+			github.com/Masterminds/semver v1.5.0 // @delivery @backend-platform
+		)
+		`, []string{"go.mod"}, true, ""},
+		{"Test invalid modfile", "go.mod", `
+		require (
+			cloud.google.com/go/storage v1.28.1
+			cuelang.org/go v0.5.0 // @as-code @backend-platform
+			github.com/Azure/azure-sdk-for-go v65.0.0+incompatible // indirect, @delivery
+			github.com/Masterminds/semver v1.5.0 // @delivery @backend-platform
+		)
+		`, []string{"go.mod"}, false, "cloud.google.com/go/storage@v1.28.1\n"},
+	} {
+		buf := &bytes.Buffer{}
+		logger := log.New(buf, "", 0)
+		filesystem := fstest.MapFS{test.fileName: &fstest.MapFile{Data: []byte(test.contents)}}
+		err := check(filesystem, logger, test.args)
+		if test.valid && err != nil {
+			t.Error(test.description, err)
+		} else if !test.valid && err == nil {
+			t.Error(test.description, "error expected")
+		}
+		if buf.String() != test.expectedOutput {
+			t.Error(test.description, buf.String())
+		}
+	}
+}
+
+func TestModules(t *testing.T) {
+	buf := &bytes.Buffer{}
+	logger := log.New(buf, "", 0)
+	filesystem := fstest.MapFS{"go.txd": &fstest.MapFile{Data: []byte(`
+	require (
+		cloud.google.com/go/storage v1.28.1
+		cuelang.org/go v0.5.0 // @as-code @backend-platform
+		github.com/Azure/azure-sdk-for-go v65.0.0+incompatible // indirect, @delivery
+		github.com/Masterminds/semver v1.5.0 // @delivery @backend-platform
+	)
+	`)}}
+
+	err := modules(filesystem, logger, []string{"-m", "go.txd"}) // NOTE: pass various flags, these are cmd line arguments
+	if err != nil {
+		t.Error(err, buf.String())
+	}
+
+	logs := buf.String()
+
+	// Expected results
+	expectedModules := []string{
+		"cloud.google.com/go/storage v1.28.1",
+		"cuelang.org/go v0.5.0",
+		"github.com/Azure/azure-sdk-for-go v65.0.0+incompatible",
+		"github.com/Masterminds/semver v1.5.0",
+	}
+
+	expectedResults := strings.Join(expectedModules, "\n")
+
+	// Compare logs to expected results
+	if logs != expectedResults {
+		t.Error(err)
+	}
+}