make pinning works with local flag, enable auto update on fork and non-fork repo

Author: antoooks

cmd/gorepomod/gorepomod_test.go

@@ -1,37 +1,75 @@
 package main
 
 import (
-	"bytes"
-	"log"
 	"os/exec"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-func TestLoadRepoManager(t *testing.T) {
+func TestListCommand(t *testing.T) {
 	// Assuming gorepomod is installed
-	path, err := exec.LookPath("gorepomod")
-	if err != nil {
-		log.Fatal(err)
-	}
 	var testCases = map[string]struct {
-		cmd *exec.Cmd
+		isFork   bool
+		cmd      string
+		expected string
 	}{
-		"withLocalFlag": {
-			cmd: exec.Command(path, "list --local"),
+		"upstreamWithLocalFlag": {
+			isFork: false,
+			cmd:    "cd ../.. && gorepomod list --local",
+		},
+		"upstreamWithNoLocalFlag": {
+			isFork: false,
+			cmd:    "cd ../.. && gorepomod list",
 		},
-		"noLocalFlag": {
-			cmd: exec.Command(path, "list"),
+		"forkWithLocalFlag": {
+			isFork: true,
+			cmd:    "cd ../.. && gorepomod list --local",
+		},
+		"forkWithNoLocalFlag": {
+			isFork: true,
+			cmd:    "cd ../.. && gorepomod list",
 		},
 	}
 
 	for _, tc := range testCases {
-		err := tc.cmd.Run()
+		out, err := exec.Command("bash", "-c", tc.cmd).Output()
+		if err != nil {
+			assert.Error(t, err, "exit status 1")
+		}
+		assert.Greater(t, len(string(out)), 1)
+	}
+}
 
-		var out bytes.Buffer
-		tc.cmd.Stdout = &out
+func TestPinCommand(t *testing.T) {
+	// Assuming gorepomod is installed
+	var testCases = map[string]struct {
+		isFork bool
+		cmd    string
+	}{
+		"upstreamWithLocalFlag": {
+			isFork: false,
+			cmd:    "cd ../.. && gorepomod pin kyaml --local",
+		},
+		"upstreamWithNoLocalFlag": {
+			isFork: false,
+			cmd:    "cd ../.. && gorepomod pin kyaml",
+		},
+		"forkWithLocalFlag": {
+			isFork: true,
+			cmd:    "cd ../.. && gorepomod pin kyaml --local",
+		},
+		"forkWithNoLocalFlag": {
+			isFork: true,
+			cmd:    "cd ../.. && gorepomod pin kyaml",
+		},
+	}
 
+	for _, tc := range testCases {
+		out, err := exec.Command("bash", "-c", tc.cmd).Output()
 		if err != nil {
-			log.Fatal(err)
+			assert.Error(t, err, "exit status 1")
 		}
+		assert.Greater(t, len(string(out)), 1)
 	}
 }

cmd/gorepomod/internal/edit/editor.go

@@ -57,9 +57,9 @@ func (e *Editor) Tidy() error {
 func (e *Editor) Pin(target misc.LaModule, oldV, newV semver.SemVer) error {
 	err := e.run(
 		"edit",
-		"-dropreplace="+target.ImportPath(),
-		"-dropreplace="+target.ImportPath()+"@"+oldV.String(),
-		"-require="+target.ImportPath()+"@"+newV.String(),
+		"-dropreplace=sigs.k8s.io/kustomize/"+string(target.ShortName()),
+		"-dropreplace=sigs.k8s.io/kustomize/"+string(target.ShortName())+"@"+oldV.String(),
+		"-require=sigs.k8s.io/kustomize/"+string(target.ShortName())+"@"+newV.String(),
 	)
 	if err != nil {
 		return err

cmd/gorepomod/internal/git/runner.go

@@ -261,7 +261,12 @@ func (gr *Runner) CheckoutMainBranch() error {
 // FetchRemote does that.
 func (gr *Runner) FetchRemote(remote misc.TrackedRepo) error {
 	gr.comment("fetching remote")
-	return gr.runNoOut(noHarmDone, "fetch", string(remote))
+	err := gr.runNoOut(noHarmDone, "fetch", string(remote))
+	if err != nil {
+		// If current repo is fork
+		return gr.runNoOut(noHarmDone, "fetch", string(remoteUpstream))
+	}
+	return err
 }
 
 // MergeFromRemoteMain does a fast forward only merge with main branch.
@@ -357,15 +362,19 @@ func (gr *Runner) DeleteTagFromRemote(
 func (gr *Runner) GetLatestTag(releaseBranch string) (string, error) {
 	var latestTag string
 	// Assuming release branch has this format: release-path/to/module-vX.Y.Z
-	// and each release branch maintains tags, get latest tag from `releaseBranch`
-	gr.comment("getting latest tags from release branch")
-	latestTag, err := gr.run(noHarmDone, "describe", "--tags", "--abbrev=0")
-	if err != nil {
-		fmt.Errorf("error getting latest tag for %s: %q", releaseBranch, err.Error())
-	}
-	if len(latestTag) < 1 {
+	// and each release branch maintains tags, extract version from latest `releaseBranch`
+	gr.comment("extract version from latest release branch")
+	filteredBranchList, err := gr.run(noHarmDone, "branch", "-a", "--list", "*"+string(releaseBranch)+"*", "--sort=-committerdate")
+	if len(filteredBranchList) < 1 {
 		fmt.Errorf("latest tag not found for %s", releaseBranch)
 		return "", err
 	}
+	newestBranch := strings.Split(strings.ReplaceAll(filteredBranchList, "\r\n", "\n"), "\n")
+	split := strings.Split(newestBranch[0], "-")
+	latestTag = split[len(split)-1]
+	if err != nil {
+		fmt.Errorf("error getting latest tag for %s: %q", releaseBranch, err.Error())
+	}
+
 	return latestTag, nil
 }

cmd/gorepomod/internal/repo/manager.go

@@ -51,19 +51,6 @@ func (mgr *Manager) Tidy(doIt bool) error {
 
 func (mgr *Manager) Pin(
 	doIt bool, target misc.LaModule, newV semver.SemVer) error {
-	// Always use latest tag while does not removing manual usage capability
-	if newV == semver.Zero() {
-		releaseBranch := fmt.Sprintf("release-%s", target.ShortName())
-		gr := git.NewLoud(mgr.AbsPath(), doIt, false)
-		latest, err := gr.GetLatestTag(string(releaseBranch))
-		if err != nil {
-			fmt.Errorf("cannot get latest tag for %s", target)
-		}
-		newV, err = semver.Parse(latest)
-		if err != nil {
-			fmt.Errorf("failed to parse value for %s", latest)
-		}
-	}
 	return mgr.modules.Apply(func(m misc.LaModule) error {
 		if yes, oldVersion := m.DependsOn(target); yes {
 			return edit.New(m, doIt).Pin(target, oldVersion, newV)

cmd/gorepomod/main.go

@@ -8,8 +8,10 @@ import (
 	"os"
 
 	"sigs.k8s.io/kustomize/cmd/gorepomod/internal/arguments"
+	"sigs.k8s.io/kustomize/cmd/gorepomod/internal/git"
 	"sigs.k8s.io/kustomize/cmd/gorepomod/internal/misc"
 	"sigs.k8s.io/kustomize/cmd/gorepomod/internal/repo"
+	"sigs.k8s.io/kustomize/cmd/gorepomod/internal/semver"
 )
 
 //go:generate go run internal/gen/main.go
@@ -72,10 +74,37 @@ func actualMain() error {
 		return mgr.Tidy(args.DoIt())
 	case arguments.Pin:
 		v := args.Version()
+		// Update branch history
+		gr := git.NewQuiet(mgr.AbsPath(), args.DoIt(), false)
+		gr.FetchRemote("master")
+
 		if v.IsZero() {
+			// Always use latest tag while does not removing manual usage capability
+			releaseBranch := fmt.Sprintf("release-%s", targetModule.ShortName())
+			fmt.Printf("new version not specified, fall back to latest version according to release branch: %s-*\n", releaseBranch)
+			latest, err := gr.GetLatestTag(string(releaseBranch))
+			if err != nil {
+				fmt.Errorf("cannot get latest tag for %s, falling back to local version %s", targetModule.ShortName(), targetModule.VersionLocal())
+				v = targetModule.VersionLocal()
+				return mgr.Pin(args.DoIt(), targetModule, v)
+
+			}
+			v, err = semver.Parse(latest)
+			if err != nil {
+				fmt.Errorf("failed to parse value for %s, falling back to local version %s", latest, targetModule.VersionLocal())
+				v = targetModule.VersionLocal()
+				return mgr.Pin(args.DoIt(), targetModule, v)
+			}
+		}
+
+		// If we can't find revision extracted from latest version specified on release branch
+		err = mgr.Pin(args.DoIt(), targetModule, v)
+		if err != nil {
+			fmt.Errorf("cannot determine latest version existence, retrying with local version %s", targetModule.VersionLocal())
 			v = targetModule.VersionLocal()
+			err = mgr.Pin(args.DoIt(), targetModule, v)
 		}
-		return mgr.Pin(args.DoIt(), targetModule, v)
+		return err
 	case arguments.UnPin:
 		return mgr.UnPin(args.DoIt(), targetModule, conditionalModule)
 	case arguments.Release: