Enhance IssueProcessor and PRProcessor with additional logging and error handling

autogits.spec

@@ -22,8 +22,6 @@ Release:        0
 Summary:        GitWorkflow utilities
 License:        GPL-2.0-or-later
 URL:            https://src.opensuse.org/adamm/autogits
-#!RemoteAsset: git+https://src.suse.de/adrianSuSE/autogits#ibs_state
-Source0:        %name-%version.tar.xz
 BuildRequires:  git
 BuildRequires:  systemd-rpm-macros
 BuildRequires:  go

common/config.go

@@ -59,7 +59,6 @@ type QAConfig struct {
 	Name              string
 	Origin            string
 	Label             string   // requires this gitea lable to be set or skipped
-	Labels            []string // requires any of the lables to be set
 	BuildDisableRepos []string // which repos to build disable in the new project
 }
 
@@ -343,13 +342,6 @@ func ParseStagingConfig(data []byte) (*StagingConfig, error) {
 	if err := json.Unmarshal(data, &staging); err != nil {
 		return nil, err
 	}
-	// backward compability, transfer legacy Label to new Labels array
-	for _, setup := range staging.QA {
-                if len(setup.Labels) == 0 && len(setup.Label) > 0 {
-			setup.Labels = []string{setup.Label}
-			setup.Label = ""
-		}
-	}
 
 	return &staging, nil
 }

common/utils.go

@@ -44,6 +44,42 @@ type NewRepos struct {
 const maintainership_line = "MAINTAINER"
 
 var true_lines []string = []string{"1", "TRUE", "YES", "OK", "T"}
+var InvalidUrlError error = errors.New("PrjGit or PackageGit URLs cannot be empty.")
+var AbsoluteUrlError error = errors.New("PrjGit or PackageGit URLs cannot be relative.")
+var HostsNotEqualError error = errors.New("PrjGit or PackageGit are not the same hosts.")
+var AbsoluteUrlWithQuery error = errors.New("PrjGit or PackageGit with query parameter. Unsupported.")
+var InvalidPath error = errors.New("PrjGit or PackageGit path has unsupported format.")
+
+
+func RelativeRepositoryPath(prjgit_org, packagegit string) (string, error) {
+	if len(packagegit) == 0 {
+		return "", InvalidUrlError
+	}
+
+	pkggiturl, err := url.Parse(packagegit)
+	if err != nil {
+		return "", err
+	}
+	if !pkggiturl.IsAbs() {
+		return "", AbsoluteUrlError
+	}
+	if len(pkggiturl.RawQuery) != 0 {
+		return "", AbsoluteUrlWithQuery
+	}
+
+	pkggitpath := SplitStringNoEmpty(pkggiturl.Path, "/")
+
+	if len(pkggitpath) != 2 {
+		return "", InvalidPath
+	}
+
+	pkggitpath[1] = strings.TrimSuffix(pkggitpath[1], ".git")
+	if prjgit_org == pkggitpath[0] {
+		return "../" + pkggitpath[1], nil
+	}
+
+	return "../../" + pkggitpath[0] + "/" + pkggitpath[1], nil
+}
 
 func HasSpace(s string) bool {
 	return strings.IndexFunc(s, unicode.IsSpace) >= 0

common/utils_test.go

@@ -8,6 +8,82 @@ import (
 	"src.opensuse.org/autogits/common"
 )
 
+func TestRelativeRepositoryPath(t *testing.T) {
+	tests := []struct {
+		name         string
+		prjorg, repo string
+
+		hasError bool
+		relative string
+	}{
+		{
+			name:     "Empty packagegit",
+			prjorg:   "org1",
+			repo:     "",
+			hasError: true,
+		},
+		{
+			name:     "Invalid URL",
+			prjorg:   "org1",
+			repo:     ":",
+			hasError: true,
+		},
+		{
+			name:     "Relative packagegit",
+			prjorg:   "org1",
+			repo:     "/path/to/repo",
+			hasError: true,
+		},
+		{
+			name:     "Packagegit with query",
+			prjorg:   "org1",
+			repo:     "https://host/org1/repo?query=1",
+			hasError: true,
+		},
+		{
+			name:     "Invalid path (too short)",
+			prjorg:   "org1",
+			repo:     "https://host/repo",
+			hasError: true,
+		},
+		{
+			name:     "Invalid path (too long)",
+			prjorg:   "org1",
+			repo:     "https://host/org/repo/extra",
+			hasError: true,
+		},
+		{
+			name:     "Same org",
+			prjorg:   "org1",
+			repo:     "https://host/org1/repo.git",
+			relative: "../repo",
+		},
+		{
+			name:     "Different org",
+			prjorg:   "org1",
+			repo:     "https://host/org2/repo.git",
+			relative: "../../org2/repo",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			r, err := common.RelativeRepositoryPath(test.prjorg, test.repo)
+
+			if err != nil && !test.hasError {
+				t.Error("Expected no error but have one", err)
+			}
+			if err == nil && test.hasError {
+				t.Error("Expected an error but had none. Returned:", r)
+			}
+
+			if err == nil && test.relative != r {
+				t.Error("Expected", test.relative, "but have", r)
+			}
+		})
+	}
+}
+
 func TestGitUrlParse(t *testing.T) {
 	tests := []struct {
 		name     string

obs-staging-bot/main.go

@@ -27,7 +27,6 @@ import (
 	"net/url"
 	"os"
 	"path"
-	"path/filepath"
 	"regexp"
 	"runtime/debug"
 	"slices"
@@ -734,16 +733,8 @@ func ProcessQaProjects(obs common.ObsClientInterface, stagingConfig *common.Stag
 	var qa_projects []string
 	for _, setup := range stagingConfig.QA {
 		QAproject := stagingProject + ":" + setup.Name
-		if len(setup.Labels) > 0 {
-                        matchedLabel := false
-                        for labelName := range prLabelNames {
-                                if slices.Contains(setup.Labels, labelName) {
-                                    matchedLabel = true
-                                    break
-                                }
-                        }
-
-			if matchedLabel == false {
+		if len(setup.Label) > 0 {
+			if _, ok := prLabelNames[setup.Label]; !ok {
 				if !IsDryRun {
 					// blindly remove, will fail when not existing
 					obs.DeleteProject(QAproject)
@@ -919,13 +910,10 @@ func ProcessPullRequest(obs common.ObsClientInterface, gitea common.Gitea, org,
 		if !stagingConfig.RebuildAll {
 			for pkg, headOid := range headSubmodules {
 				if baseOid, exists := baseSubmodules[pkg]; !exists || baseOid != headOid {
-					if pkg != "rpms" && pkg != "dependencies" {
-					_, spkg := filepath.Split(pkg)
 					if exists {
-						modifiedPackages = append(modifiedPackages, spkg)
+						modifiedPackages = append(modifiedPackages, pkg)
 					} else {
-						newPackages = append(newPackages, spkg)
-					}
+						newPackages = append(newPackages, pkg)
 					}
 					common.LogDebug(pkg, ":", baseOid, "->", headOid)
 				}
@@ -1035,7 +1023,6 @@ func ProcessPullRequest(obs common.ObsClientInterface, gitea common.Gitea, org,
 		done := false
 		overallBuildStatus := ProcessBuildStatus(stagingResult)
 		commentSuffix := ""
-		common.LogDebug("Number of QA Projects: ", len(qaProjects))
 		if len(qaProjects) > 0 && overallBuildStatus == BuildStatusSummarySuccess {
 			seperator := " in "
 			for _, qaProject := range qaProjects {
@@ -1184,7 +1171,6 @@ var IsDryRun bool
 var ProcessPROnly string
 var ObsClient common.ObsClientInterface
 var BotUser string
-var PollInterval = 5 * time.Minute
 
 func ObsWebHostFromApiHost(apihost string) string {
 	u, err := url.Parse(apihost)
@@ -1207,18 +1193,9 @@ func main() {
 	flag.StringVar(&ObsApiHost, "obs", "", "API for OBS instance")
 	flag.StringVar(&ObsWebHost, "obs-web", "", "Web OBS instance, if not derived from the obs config")
 	flag.BoolVar(&IsDryRun, "dry", false, "Dry-run, don't actually create any build projects or review changes")
-	pollIntervalStr := flag.String("poll-interval", common.GetEnvOverrideString(os.Getenv("AUTOGITS_STAGING_BOT_POLL_INTERVAL"), ""), "Polling interval for notifications (e.g. 5m, 10s)")
 	debug := flag.Bool("debug", false, "Turns on debug logging")
 	flag.Parse()
 
-	if len(*pollIntervalStr) > 0 {
-		if d, err := time.ParseDuration(*pollIntervalStr); err == nil {
-			PollInterval = d
-		} else {
-			common.LogError("Invalid poll interval:", err)
-		}
-	}
-
 	if *debug {
 		common.SetLoggingLevel(common.LogLevelDebug)
 	} else {
@@ -1287,6 +1264,6 @@ func main() {
 	for {
 		PollWorkNotifications(ObsClient, gitea)
 		common.LogInfo("Poll cycle finished")
-		time.Sleep(PollInterval)
+		time.Sleep(5 * time.Minute)
 	}
 }

systemd/obs-staging-bot.service

@@ -6,13 +6,9 @@ After=network-online.target
 Type=exec
 ExecStart=/usr/bin/obs-staging-bot
 EnvironmentFile=-/etc/default/obs-staging-bot.env
-User=autogits_obs_staging_bot
-Group=users
-
-# This may work when not using ssh api connections:
-#DynamicUser=yes
-#NoNewPrivileges=yes
-#ProtectSystem=strict
+DynamicUser=yes
+NoNewPrivileges=yes
+ProtectSystem=strict
 
 [Install]
 WantedBy=multi-user.target

workflow-direct/main.go

@@ -19,6 +19,7 @@ package main
  */
 
 import (
+	"bytes"
 	"flag"
 	"fmt"
 	"io/fs"
@@ -123,7 +124,9 @@ func processConfiguredRepositoryAction(action *common.RepositoryWebhookEvent, co
 			common.LogError("   - ", action.Repository.Name, "repo is not sha256. Ignoring.")
 			return
 		}
-		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", "../" + action.Repository.Name, action.Repository.Name))
+		relpath, err := common.RelativeRepositoryPath(gitOrg, action.Repository.Clone_Url)
+		common.PanicOnError(err)
+		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", relpath, action.Repository.Name))
 		defer git.GitExecQuietOrPanic(gitPrj, "submodule", "deinit", "--all", "-f")
 
 		branch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, action.Repository.Name), "branch", "--show-current"))
@@ -215,7 +218,7 @@ func processConfiguredPushAction(action *common.PushWebhookEvent, config *common
 	}
 
 	if stat, err := os.Stat(filepath.Join(git.GetPath(), gitPrj, action.Repository.Name)); err != nil {
-		git.GitExecOrPanic(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", "../" + action.Repository.Name, action.Repository.Name)
+		git.GitExecOrPanic(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", action.Repository.Clone_Url, action.Repository.Name)
 		common.LogDebug("Pushed to package that is not part of the project. Re-adding...", err)
 	} else if !stat.IsDir() {
 		common.LogError("Pushed to a package that is not a submodule but exists in the project. Ignoring.")
@@ -268,6 +271,12 @@ func verifyProjectState(git common.Git, org string, config *common.AutogitConfig
 	sub, err := git.GitSubmoduleList(gitPrj, "HEAD")
 	common.PanicOnError(err)
 
+	submodulesData, err := git.GitCatFile(gitPrj, "HEAD", ".gitmodules")
+	var submoduleEntries []common.Submodule
+	if err == nil {
+		submoduleEntries, _ = common.ParseSubmodulesFile(bytes.NewReader(submodulesData))
+	}
+
 	common.LogDebug("   * Getting package links")
 	var pkgLinks []*PackageRebaseLink
 	if f, err := fs.Stat(os.DirFS(path.Join(git.GetPath(), gitPrj)), common.PrjLinksFile); err == nil && (f.Mode()&fs.ModeType == 0) && f.Size() < 1000000 {
@@ -395,8 +404,27 @@ next_repo:
 		}
 		//		}
 
+		relpath, err := common.RelativeRepositoryPath(gitOrg, r.CloneURL)
+		common.PanicOnError(err)
+
 		for repo := range sub {
 			if repo == r.Name {
+				// verify we are using relative repository paths, and if not, adjust them
+				sidx := slices.IndexFunc(submoduleEntries, func(s common.Submodule) bool {
+					if path.Base(s.Path) == r.Name {
+						return true
+					}
+					return false
+				})
+				if sidx >= 0 && submoduleEntries[sidx].Url != relpath {
+					submoduleEntries[sidx].Url = relpath
+					f, err := os.OpenFile(path.Join(git.GetPath(), ".gitmodules"), os.O_CREATE|os.O_TRUNC, 0o6400)
+					common.PanicOnError(err)
+					defer f.Close()
+					common.PanicOnError(common.WriteSubmodules(submoduleEntries, f))
+					isGitUpdated = true
+				}
+
 				// not missing
 				continue next_repo
 			}
@@ -420,7 +448,7 @@ next_repo:
 		}
 
 		// add repository to git project
-		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", "../" + r.Name, r.Name))
+		common.PanicOnError(git.GitExec(gitPrj, "submodule", "--quiet", "add", "--force", "--depth", "1", relpath, r.Name))
 
 		curBranch := strings.TrimSpace(git.GitExecWithOutputOrPanic(path.Join(gitPrj, r.Name), "branch", "--show-current"))
 		if branch != curBranch {

workflow-pr/issue_processor.go

@@ -131,6 +131,7 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		common.LogDebug(" - Processing new repository src:", nr.Organization+"/"+nr.PackageName+"#"+nr.Branch)
 
 		targetRepo, err := Gitea.GetRepository(config.Organization, nr.PackageName)
+		common.LogDebug(" - Target repository:", config.Organization+"/"+nr.PackageName, "exists?", targetRepo != nil, "error?", err)
 		if err != nil {
 			return err
 		}
@@ -148,6 +149,7 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		// TODO, we need to filter by project config permissions of target project, not just assume bot here.
 		users := []string{CurrentUser.UserName}
 		prs := i.IssueTimeline.FindIssuePullRequestRererences(config.Organization, nr.PackageName, 0, users)
+		common.LogDebug(" - Existing PR references in timeline:", len(prs))
 		for _, t := range prs {
 			pr, err := Gitea.GetPullRequest(config.Organization, nr.PackageName, t.RefIssue.Index)
 			if err != nil {
@@ -171,7 +173,9 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		}
 
 		srcRepo, err := FindSourceRepository(nr.Organization, nr.Repository)
+		common.LogDebug(" - FindSourceRepository:", nr.Organization+"/"+nr.Repository, "err?", err)
 		if err != nil {
+			common.LogError(" - Skipping: cannot find source repository:", nr.Organization+"/"+nr.Repository, err)
 			continue
 		}
 
@@ -183,12 +187,15 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		if err != nil {
 			return err
 		}
-		remoteName, err := git.GitClone(nr.PackageName, nr.Branch, targetRepo.SSHURL)
+		// Clone the target using its default branch — the target branch may not exist yet
+		// and will be created by the push below.
+		remoteName, err := git.GitClone(nr.PackageName, targetRepo.DefaultBranch, targetRepo.SSHURL)
 		if err != nil {
 			return err
 		}
 
 		// Check that fork/parent repository relationship exists
+		common.LogDebug(" - Fork check: src.Parent=", srcRepo.Parent.Owner.UserName+"/"+srcRepo.Parent.Name, "target=", targetRepo.Owner.UserName+"/"+targetRepo.Name)
 		if srcRepo.Parent.Name != targetRepo.Name || srcRepo.Parent.Owner.UserName != targetRepo.Owner.UserName {
 			common.LogError("Source repository is not fork of the Target repository. Fork of:", srcRepo.Parent.Owner.UserName+"/"+srcRepo.Parent.Name)
 			continue
@@ -229,6 +236,7 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		if err == nil && strings.Contains(out, "refs/heads/"+srcBranch) {
 			isBranch = true
 		}
+		common.LogDebug(" - head:", head, "isBranch:", isBranch)
 
 		if !isBranch {
 			tempBranch := fmt.Sprintf("new_package_%d_%s", issue.Index, nr.PackageName)
@@ -254,6 +262,7 @@ func (i *IssueProcessor) ProcessAddIssue(config *common.AutogitConfig) error {
 		if len(br) == 0 {
 			br = targetRepo.DefaultBranch
 		}
+		common.LogDebug(" - Creating PR: head=", head, "base=", br, "title=", title)
 		pr, err, isNew := Gitea.CreatePullRequestIfNotExist(targetRepo, head, br, title, body)
 		if err != nil {
 			common.LogError(targetRepo.Name, head, i.TargetBranch, title, body)
@@ -285,6 +294,7 @@ func (i *IssueProcessor) ProcessIssue(configs common.AutogitConfigs) error {
 
 	//	out, _ := json.MarshalIndent(issue, "", "   ")
 	//	common.LogDebug(string(out))
+	common.LogInfo("Processing issue:", common.IssueToString(issue))
 
 	var err error
 	i.IssueTimeline, err = Gitea.GetTimeline(org, repo, idx)

workflow-pr/main.go

@@ -185,6 +185,7 @@ func main() {
 			common.RequestType_PRReviewAccepted: req,
 			common.RequestType_PRReviewRejected: req,
 			common.RequestType_PRComment:        req,
+			common.RequestType_Issue:            req,
 		},
 	}
 	listenDefs.Connection().RabbitURL, _ = url.Parse(*rabbitUrl)

workflow-pr/pr_processor.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"os"
 	"path"
 	"runtime/debug"
 	"slices"
@@ -144,6 +145,7 @@ func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
 		return err
 	}
 
+	PrjGitOrg, _, _ := prset.Config.GetPrjGit()
 	for _, pr := range prset.PRs {
 		if prset.IsPrjGitPR(pr.PR) {
 			continue
@@ -180,33 +182,6 @@ func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
 					}
 
 					updateSubmoduleInPR(submodulePath, prHead, git)
-					err := git.GitExec(path.Join(common.DefaultGitPrj, submodulePath), "lfs", "fetch")
-					common.LogError("lfs fetch err: ", err)
-					if err = git.GitExec(path.Join(common.DefaultGitPrj, submodulePath), "lfs", "fsck"); err != nil {
-
-						found_comment := false
-						timeline, terr := common.FetchTimelineSinceLastPush(Gitea, prHead, org, repo, idx)
-						if terr != nil {
-							common.LogError("lfs fsck error, but timeline fetch failed")
-							break
-						}
-						msgPrefix := "The LFS objects are broken!"
-						for _, t := range timeline {
-						        if t.Type == common.TimelineCommentType_Comment && strings.HasPrefix(t.Body, msgPrefix) {               
-						                found_comment = true
-								common.LogError("lfs fsck Comment already found")
-
-						                break
-						        }
-						}
-						        
-						if !found_comment && !common.IsDryRun {
-							Gitea.AddComment(pr.PR, msgPrefix + " Please verify with 'git lfs fsck'")
-						}
-						common.LogError("lfs fsck failed with: ", err.Error())
-						return err
-					}
-
 					status, err := git.GitStatus(common.DefaultGitPrj)
 					common.LogDebug("status:", status)
 					common.LogDebug("submodule", repo, " hash:", id, " -> ", prHead)
@@ -225,7 +200,26 @@ func (pr *PRProcessor) SetSubmodulesToMatchPRSet(prset *common.PRSet) error {
 			ref := fmt.Sprintf(common.PrPattern, org, repo, idx)
 			commitMsg := fmt.Sprintln("Add package", repo, "\n\nThis commit was autocreated by", GitAuthor, "\n\nreferencing PRs:\n", ref)
 
-			git.GitExecOrPanic(common.DefaultGitPrj, "submodule", "add", "-b", pr.PR.Base.Name, pr.PR.Base.Repo.SSHURL, repo)
+			relpath, err := common.RelativeRepositoryPath(PrjGitOrg, pr.PR.Base.Repo.CloneURL)
+			if err != nil {
+				common.LogError("Cannot calculate relative path for repository", pr.PR.Base.Repo.CloneURL, err)
+				return err
+			}
+			// git submodule add refuses to proceed if the repo already exists
+			// locally (left by a prior GitClone). Two locations must be cleared:
+			//   1. the working tree dir
+			//   2. .git/modules/<repo> cached by git from a previous submodule init
+			staleWorkTree := path.Join(git.GetPath(), common.DefaultGitPrj, repo)
+			staleGitModules := path.Join(git.GetPath(), common.DefaultGitPrj, ".git", "modules", repo)
+			for _, staleDir := range []string{staleWorkTree, staleGitModules} {
+				if _, err := os.Stat(staleDir); err == nil {
+					common.LogDebug("Removing stale dir before submodule add:", staleDir)
+					if err := os.RemoveAll(staleDir); err != nil {
+						return err
+					}
+				}
+			}
+			git.GitExecOrPanic(common.DefaultGitPrj, "submodule", "add", "-b", pr.PR.Base.Name, relpath, repo)
 
 			updateSubmoduleInPR(repo, prHead, git)
 			common.PanicOnError(git.GitExec(common.DefaultGitPrj, "commit", "-a", "-m", commitMsg))
@@ -341,7 +335,6 @@ func (pr *PRProcessor) UpdatePrjGitPR(prset *common.PRSet) error {
 			// well, wrong place...
 			// common.LogError("Warning: source and target branch are in different repositories. We may not have the right permissions...")
 			//		Gitea.AddComment(PrjGitPR.PR, "This PR does not allow maintainer changes, but referenced package branch has changed!")
-                	common.LogError("Warning: source and target branch are in different repositories. We may not have the right permissions...")
 			return nil
 		}
 	}
@@ -412,7 +405,7 @@ func (pr *PRProcessor) UpdatePrjGitPR(prset *common.PRSet) error {
 			}
 			return CurrentTitle == NewTitle
 		}
-		if !pr.config.NoProjectGitPR && PrjGitPR.PR.User.UserName == CurrentUser.UserName && (PrjGitPR.PR.Body != PrjGitBody || !isPrTitleSame(PrjGitPR.PR.Title, PrjGitTitle)) {
+		if PrjGitPR.PR.User.UserName == CurrentUser.UserName && (PrjGitPR.PR.Body != PrjGitBody || !isPrTitleSame(PrjGitPR.PR.Title, PrjGitTitle)) {
 			Gitea.UpdatePullRequest(PrjGit.Owner.UserName, PrjGit.Name, PrjGitPR.PR.Index, &models.EditPullRequestOption{
 				RemoveDeadline: true,
 				Title:          PrjGitTitle,
@@ -510,11 +503,11 @@ func (pr *PRProcessor) Process(req *models.PullRequest) error {
 						if _, ok := err.(*repository.RepoMergePullRequestConflict); !ok {
 							common.PanicOnError(err)
 						}
-//					} else {
-//						Gitea.AddComment(pr.PR, "Closing here because the associated Project PR has been closed.")
-//						Gitea.UpdatePullRequest(org, repo, idx, &models.EditPullRequestOption{
-//							State: "closed",
-//						})
+						//					} else {
+						//						Gitea.AddComment(pr.PR, "Closing here because the associated Project PR has been closed.")
+						//						Gitea.UpdatePullRequest(org, repo, idx, &models.EditPullRequestOption{
+						//							State: "closed",
+						//						})
 					}
 				}
 			}

workflow-pr/pr_processor_test.go

@@ -28,8 +28,10 @@ func TestPrjGitDescription(t *testing.T) {
 					Base: &models.PRBranchInfo{
 						Ref: "main",
 						Repo: &models.Repository{
-							Name:  "pkg-a",
-							Owner: &models.User{UserName: "test-org"},
+							Name:     "pkg-a",
+							Owner:    &models.User{UserName: "test-org"},
+							CloneURL: "http://example.com/test-org/pkg-a.git",
+							SSHURL:   "git@example.com:test-org/pkg-a.git",
 						},
 					},
 				},
@@ -202,8 +204,10 @@ func TestSetSubmodulesToMatchPRSet(t *testing.T) {
 					Base: &models.PRBranchInfo{
 						Ref: "main",
 						Repo: &models.Repository{
-							Name:  "pkg-a",
-							Owner: &models.User{UserName: "test-org"},
+							Name:     "pkg-a",
+							Owner:    &models.User{UserName: "test-org"},
+							CloneURL: "http://example.com/test-org/pkg-a.git",
+							SSHURL:   "git@example.com:test-org/pkg-a.git",
 						},
 					},
 					Head: &models.PRBranchInfo{
@@ -630,7 +634,12 @@ func TestCreatePRjGitPR_Integration(t *testing.T) {
 				PR: &models.PullRequest{
 					State: "open",
 					Base: &models.PRBranchInfo{
-						Repo: &models.Repository{Name: "pkg-a", Owner: &models.User{UserName: "test-org"}},
+						Repo: &models.Repository{
+							Name:     "pkg-a",
+							Owner:    &models.User{UserName: "test-org"},
+							CloneURL: "http://example.com/test-org/pkg-a.git",
+							SSHURL:   "git@example.com:test-org/pkg-a.git",
+						},
 					},
 					Head: &models.PRBranchInfo{Sha: "pkg-sha"},
 				},
@@ -653,14 +662,23 @@ func TestCreatePRjGitPR_Integration(t *testing.T) {
 			Base: &models.PRBranchInfo{
 				Name:   "main",
 				RepoID: 1,
-				Repo:   &models.Repository{Name: "test-prj", Owner: &models.User{UserName: "test-org"}},
+				Repo: &models.Repository{
+					Name:     "test-prj",
+					Owner:    &models.User{UserName: "test-org"},
+					CloneURL: "http://example.com/test-org/test-prj.git",
+					SSHURL:   "git@example.com:test-org/test-prj.git",
+				},
 			},
 			Head: &models.PRBranchInfo{
 				Sha: "prj-head-sha",
 			},
 		}
 
-		gitea.EXPECT().GetRepository(gomock.Any(), gomock.Any()).Return(&models.Repository{Owner: &models.User{UserName: "test-org"}}, nil).AnyTimes()
+		gitea.EXPECT().GetRepository(gomock.Any(), gomock.Any()).Return(&models.Repository{
+			Owner:    &models.User{UserName: "test-org"},
+			CloneURL: "http://example.com/test-org/test-prj.git",
+			SSHURL:   "git@example.com:test-org/test-prj.git",
+		}, nil).AnyTimes()
 		// CreatePullRequestIfNotExist returns isNew=true
 		gitea.EXPECT().CreatePullRequestIfNotExist(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(prjPR, nil, true).AnyTimes()
 		// Expect SetLabels to be called for new PR