Merge branch 'main' into lunny/fix_webhook

.gitea/workflows/test-pr.yml

@@ -39,7 +39,7 @@ jobs:
           make unit-test-coverage
     services:
       gitea:
-        image: docker.gitea.com/gitea:1.26.1
+        image: docker.gitea.com/gitea:1.26.0
         cmd:
           - bash
           - -c

cmd/attachments/delete.go

@@ -61,20 +61,12 @@ func runReleaseAttachmentDelete(_ stdctx.Context, cmd *cli.Command) error {
 		return err
 	}
 
-	var existing []*gitea.Attachment
-	for page := 1; ; {
-		page_attachments, resp, err := client.ListReleaseAttachments(ctx.Owner, ctx.Repo, release.ID, gitea.ListReleaseAttachmentsOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+	existing, _, err := client.ListReleaseAttachments(ctx.Owner, ctx.Repo, release.ID, gitea.ListReleaseAttachmentsOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
 	})
 	if err != nil {
 		return err
 	}
-		existing = append(existing, page_attachments...)
-		if resp == nil || resp.NextPage == 0 {
-			break
-		}
-		page = resp.NextPage
-	}
 
 	for _, name := range ctx.Args().Slice()[1:] {
 		var attachment *gitea.Attachment

cmd/pulls.go

@@ -109,20 +109,11 @@ func runPullDetail(_ stdctx.Context, cmd *cli.Command, index string) error {
 		return err
 	}
 
-	var reviews []*gitea.PullReview
-	for page := 1; ; {
-		page_reviews, resp, err := client.ListPullReviews(ctx.Owner, ctx.Repo, idx, gitea.ListPullReviewsOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+	reviews, _, err := client.ListPullReviews(ctx.Owner, ctx.Repo, idx, gitea.ListPullReviewsOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
 	})
 	if err != nil {
 		fmt.Printf("error while loading reviews: %v\n", err)
-			break
-		}
-		reviews = append(reviews, page_reviews...)
-		if resp == nil || resp.NextPage == 0 {
-			break
-		}
-		page = resp.NextPage
 	}
 
 	if ctx.IsSet("output") {

cmd/releases/utils.go

@@ -11,14 +11,13 @@ import (
 
 // GetReleaseByTag finds a release by its tag name.
 func GetReleaseByTag(owner, repo, tag string, client *gitea.Client) (*gitea.Release, error) {
-	for page := 1; ; {
-		rl, resp, err := client.ListReleases(owner, repo, gitea.ListReleasesOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+	rl, _, err := client.ListReleases(owner, repo, gitea.ListReleasesOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
 	})
 	if err != nil {
 		return nil, err
 	}
-		if page == 1 && len(rl) == 0 {
+	if len(rl) == 0 {
 		return nil, fmt.Errorf("repo does not have any release")
 	}
 	for _, r := range rl {
@@ -26,10 +25,5 @@ func GetReleaseByTag(owner, repo, tag string, client *gitea.Client) (*gitea.Rele
 			return r, nil
 		}
 	}
-		if resp == nil || resp.NextPage == 0 {
-			break
-		}
-		page = resp.NextPage
-	}
 	return nil, fmt.Errorf("release tag does not exist")
 }

cmd/webhooks/create.go

@@ -89,14 +89,6 @@ func runWebhooksCreate(ctx stdctx.Context, cmd *cli.Command) error {
 		config["secret"] = secret
 	}
 
-	if branchFilter != "" {
-		config["branch_filter"] = branchFilter
-	}
-
-	if authHeader != "" {
-		config["authorization_header"] = authHeader
-	}
-
 	var hook *gitea.Hook
 	if c.IsGlobal {
 		return fmt.Errorf("global webhooks not yet supported in this version")
@@ -106,6 +98,8 @@ func runWebhooksCreate(ctx stdctx.Context, cmd *cli.Command) error {
 			Config:              config,
 			Events:              events,
 			Active:              active,
+			BranchFilter:        branchFilter,
+			AuthorizationHeader: authHeader,
 		})
 	} else {
 		hook, _, err = client.CreateRepoHook(c.Owner, c.Repo, gitea.CreateHookOption{
@@ -113,6 +107,8 @@ func runWebhooksCreate(ctx stdctx.Context, cmd *cli.Command) error {
 			Config:              config,
 			Events:              events,
 			Active:              active,
+			BranchFilter:        branchFilter,
+			AuthorizationHeader: authHeader,
 		})
 	}
 	if err != nil {

cmd/webhooks/create_test.go

@@ -79,8 +79,6 @@ func TestWebhookConfigConstruction(t *testing.T) {
 		name           string
 		url            string
 		secret         string
-		branchFilter   string
-		authHeader     string
 		expectedKeys   []string
 		expectedValues map[string]string
 	}{
@@ -106,44 +104,16 @@ func TestWebhookConfigConstruction(t *testing.T) {
 				"secret":       "my-secret",
 			},
 		},
-		{
-			name:         "Config with branch filter",
-			url:          "https://example.com/webhook",
-			branchFilter: "main,develop",
-			expectedKeys: []string{"url", "http_method", "content_type", "branch_filter"},
-			expectedValues: map[string]string{
-				"url":           "https://example.com/webhook",
-				"http_method":   "post",
-				"content_type":  "json",
-				"branch_filter": "main,develop",
-			},
-		},
-		{
-			name:         "Config with auth header",
-			url:          "https://example.com/webhook",
-			authHeader:   "Bearer token123",
-			expectedKeys: []string{"url", "http_method", "content_type", "authorization_header"},
-			expectedValues: map[string]string{
-				"url":                  "https://example.com/webhook",
-				"http_method":          "post",
-				"content_type":         "json",
-				"authorization_header": "Bearer token123",
-			},
-		},
 		{
 			name:         "Complete config",
 			url:          "https://example.com/webhook",
 			secret:       "secret123",
-			branchFilter: "main",
-			authHeader:   "X-Token: abc",
-			expectedKeys: []string{"url", "http_method", "content_type", "secret", "branch_filter", "authorization_header"},
+			expectedKeys: []string{"url", "http_method", "content_type", "secret"},
 			expectedValues: map[string]string{
 				"url":          "https://example.com/webhook",
 				"http_method":  "post",
 				"content_type": "json",
 				"secret":       "secret123",
-				"branch_filter":        "main",
-				"authorization_header": "X-Token: abc",
 			},
 		},
 	}
@@ -159,12 +129,6 @@ func TestWebhookConfigConstruction(t *testing.T) {
 			if tt.secret != "" {
 				config["secret"] = tt.secret
 			}
-			if tt.branchFilter != "" {
-				config["branch_filter"] = tt.branchFilter
-			}
-			if tt.authHeader != "" {
-				config["authorization_header"] = tt.authHeader
-			}
 
 			// Check all expected keys exist
 			for _, key := range tt.expectedKeys {
@@ -189,6 +153,8 @@ func TestWebhookCreateOptions(t *testing.T) {
 		events       []string
 		active       bool
 		config       map[string]string
+		branchFilter string
+		authHeader   string
 	}{
 		{
 			name:        "Gitea webhook",
@@ -200,6 +166,8 @@ func TestWebhookCreateOptions(t *testing.T) {
 				"http_method":  "post",
 				"content_type": "json",
 			},
+			branchFilter: "main",
+			authHeader:   "X-Token: abc",
 		},
 		{
 			name:        "Slack webhook",
@@ -232,12 +200,16 @@ func TestWebhookCreateOptions(t *testing.T) {
 				Config:              tt.config,
 				Events:              tt.events,
 				Active:              tt.active,
+				BranchFilter:        tt.branchFilter,
+				AuthorizationHeader: tt.authHeader,
 			}
 
 			assert.Equal(t, gitea.HookType(tt.webhookType), option.Type)
 			assert.Equal(t, tt.events, option.Events)
 			assert.Equal(t, tt.active, option.Active)
 			assert.Equal(t, tt.config, option.Config)
+			assert.Equal(t, tt.branchFilter, option.BranchFilter)
+			assert.Equal(t, tt.authHeader, option.AuthorizationHeader)
 		})
 	}
 }

cmd/webhooks/update.go

@@ -97,11 +97,14 @@ func runWebhooksUpdate(ctx stdctx.Context, cmd *cli.Command) error {
 	if cmd.IsSet("secret") {
 		config["secret"] = cmd.String("secret")
 	}
+	branchFilter := hook.BranchFilter
 	if cmd.IsSet("branch-filter") {
-		config["branch_filter"] = cmd.String("branch-filter")
+		branchFilter = cmd.String("branch-filter")
 	}
+
+	authHeader := hook.AuthorizationHeader
 	if cmd.IsSet("authorization-header") {
-		config["authorization_header"] = cmd.String("authorization-header")
+		authHeader = cmd.String("authorization-header")
 	}
 
 	// Update events if specified
@@ -129,12 +132,16 @@ func runWebhooksUpdate(ctx stdctx.Context, cmd *cli.Command) error {
 			Config:              config,
 			Events:              events,
 			Active:              &active,
+			BranchFilter:        branchFilter,
+			AuthorizationHeader: authHeader,
 		})
 	} else {
 		_, err = client.EditRepoHook(c.Owner, c.Repo, int64(webhookID), gitea.EditHookOption{
 			Config:              config,
 			Events:              events,
 			Active:              &active,
+			BranchFilter:        branchFilter,
+			AuthorizationHeader: authHeader,
 		})
 	}
 	if err != nil {

cmd/webhooks/update_test.go

@@ -130,8 +130,6 @@ func TestUpdateConfigPreservation(t *testing.T) {
 	originalConfig := map[string]string{
 		"url":          "https://old.example.com/webhook",
 		"secret":       "old-secret",
-		"branch_filter":        "main",
-		"authorization_header": "Bearer old-token",
 		"http_method":  "post",
 		"content_type": "json",
 	}
@@ -149,37 +147,18 @@ func TestUpdateConfigPreservation(t *testing.T) {
 			expectedConfig: map[string]string{
 				"url":          "https://new.example.com/webhook",
 				"secret":       "old-secret",
-				"branch_filter":        "main",
-				"authorization_header": "Bearer old-token",
 				"http_method":  "post",
 				"content_type": "json",
 			},
 		},
 		{
-			name: "Update secret and auth header",
+			name: "Update secret",
 			updates: map[string]string{
 				"secret": "new-secret",
-				"authorization_header": "X-Token: new-token",
 			},
 			expectedConfig: map[string]string{
 				"url":          "https://old.example.com/webhook",
 				"secret":       "new-secret",
-				"branch_filter":        "main",
-				"authorization_header": "X-Token: new-token",
-				"http_method":          "post",
-				"content_type":         "json",
-			},
-		},
-		{
-			name: "Clear branch filter",
-			updates: map[string]string{
-				"branch_filter": "",
-			},
-			expectedConfig: map[string]string{
-				"url":                  "https://old.example.com/webhook",
-				"secret":               "old-secret",
-				"branch_filter":        "",
-				"authorization_header": "Bearer old-token",
 				"http_method":  "post",
 				"content_type": "json",
 			},
@@ -190,8 +169,6 @@ func TestUpdateConfigPreservation(t *testing.T) {
 			expectedConfig: map[string]string{
 				"url":          "https://old.example.com/webhook",
 				"secret":       "old-secret",
-				"branch_filter":        "main",
-				"authorization_header": "Bearer old-token",
 				"http_method":  "post",
 				"content_type": "json",
 			},
@@ -217,6 +194,61 @@ func TestUpdateConfigPreservation(t *testing.T) {
 	}
 }
 
+func TestUpdateBranchFilterAndAuthHeaderHandling(t *testing.T) {
+	tests := []struct {
+		name                   string
+		originalBranchFilter   string
+		originalAuthHeader     string
+		setBranchFilter        bool
+		newBranchFilter        string
+		setAuthorizationHeader bool
+		newAuthHeader          string
+		expectedBranchFilter   string
+		expectedAuthHeader     string
+	}{
+		{
+			name:                 "Preserve values",
+			originalBranchFilter: "main",
+			originalAuthHeader:   "Bearer old-token",
+			expectedBranchFilter: "main",
+			expectedAuthHeader:   "Bearer old-token",
+		},
+		{
+			name:                 "Update branch filter",
+			originalBranchFilter: "main",
+			setBranchFilter:      true,
+			newBranchFilter:      "develop",
+			expectedBranchFilter: "develop",
+			expectedAuthHeader:   "",
+		},
+		{
+			name:                   "Update authorization header",
+			originalAuthHeader:     "Bearer old-token",
+			setAuthorizationHeader: true,
+			newAuthHeader:          "X-Token: new-token",
+			expectedBranchFilter:   "",
+			expectedAuthHeader:     "X-Token: new-token",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			branchFilter := tt.originalBranchFilter
+			if tt.setBranchFilter {
+				branchFilter = tt.newBranchFilter
+			}
+
+			authHeader := tt.originalAuthHeader
+			if tt.setAuthorizationHeader {
+				authHeader = tt.newAuthHeader
+			}
+
+			assert.Equal(t, tt.expectedBranchFilter, branchFilter)
+			assert.Equal(t, tt.expectedAuthHeader, authHeader)
+		})
+	}
+}
+
 func TestUpdateEventsHandling(t *testing.T) {
 	tests := []struct {
 		name           string

modules/interact/issue_create.go

@@ -180,25 +180,19 @@ func fetchIssueSelectables(login *config.Login, owner, repo string, done chan is
 		r.MilestoneList[i] = m.Title
 	}
 
-	r.LabelMap = make(map[string]int64)
-	r.LabelList = make([]string, 0)
-	for page := 1; ; {
-		labels, resp, err := c.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+	labels, _, err := c.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
 	})
 	if err != nil {
 		r.Err = err
 		done <- r
 		return
 	}
-		for _, l := range labels {
+	r.LabelMap = make(map[string]int64)
+	r.LabelList = make([]string, len(labels))
+	for i, l := range labels {
 		r.LabelMap[l.Name] = l.ID
-			r.LabelList = append(r.LabelList, l.Name)
-		}
-		if resp == nil || resp.NextPage == 0 {
-			break
-		}
-		page = resp.NextPage
+		r.LabelList[i] = l.Name
 	}
 
 	done <- r

modules/print/webhook.go

@@ -67,13 +67,21 @@ func WebhookDetails(hook *gitea.Hook) {
 		if method, ok := hook.Config["http_method"]; ok {
 			fmt.Printf("- **HTTP Method**: %s\n", method)
 		}
-		if branchFilter, ok := hook.Config["branch_filter"]; ok && branchFilter != "" {
+		branchFilter := hook.BranchFilter
+		if branchFilter == "" {
+			branchFilter = hook.Config["branch_filter"]
+		}
+		if branchFilter != "" {
 			fmt.Printf("- **Branch Filter**: %s\n", branchFilter)
 		}
 		if _, hasSecret := hook.Config["secret"]; hasSecret {
 			fmt.Printf("- **Secret**: (configured)\n")
 		}
-		if _, hasAuth := hook.Config["authorization_header"]; hasAuth {
+		hasAuth := hook.AuthorizationHeader != ""
+		if !hasAuth {
+			_, hasAuth = hook.Config["authorization_header"]
+		}
+		if hasAuth {
 			fmt.Printf("- **Authorization Header**: (configured)\n")
 		}
 	}

modules/print/webhook_test.go

@@ -84,10 +84,10 @@ func TestWebhookDetails(t *testing.T) {
 					"url":          "https://example.com/webhook",
 					"content_type": "json",
 					"http_method":  "post",
-					"branch_filter":        "main,develop",
 					"secret":       "secret-value",
-					"authorization_header": "Bearer token123",
 				},
+				BranchFilter:        "main,develop",
+				AuthorizationHeader: "Bearer token123",
 				Events:              []string{"push", "pull_request", "issues"},
 				Active:              true,
 				Created:             now.Add(-24 * time.Hour),
@@ -240,14 +240,12 @@ func TestWebhookConfigHandling(t *testing.T) {
 			config: map[string]string{
 				"url":          "https://example.com/webhook",
 				"secret":       "my-secret",
-				"authorization_header": "Bearer token",
 				"content_type": "json",
 				"http_method":  "post",
-				"branch_filter":        "main",
 			},
 			expectedURL:   "https://example.com/webhook",
 			hasSecret:     true,
-			hasAuthHeader: true,
+			hasAuthHeader: false,
 		},
 		{
 			name: "Config with minimal fields",
@@ -344,10 +342,10 @@ func TestWebhookDetailsFormatting(t *testing.T) {
 			"url":          "https://example.com/webhook",
 			"content_type": "json",
 			"http_method":  "post",
-			"branch_filter":        "main,develop",
 			"secret":       "secret-value",
-			"authorization_header": "Bearer token123",
 		},
+		BranchFilter:        "main,develop",
+		AuthorizationHeader: "Bearer token123",
 		Events:              []string{"push", "pull_request", "issues"},
 		Active:              true,
 		Created:             now.Add(-24 * time.Hour),
@@ -379,8 +377,8 @@ func TestWebhookDetailsFormatting(t *testing.T) {
 	assert.Equal(t, "https://example.com/webhook", hook.Config["url"])
 	assert.Equal(t, "json", hook.Config["content_type"])
 	assert.Equal(t, "post", hook.Config["http_method"])
-	assert.Equal(t, "main,develop", hook.Config["branch_filter"])
+	assert.Equal(t, "main,develop", hook.BranchFilter)
 	assert.Contains(t, hook.Config, "secret")
-	assert.Contains(t, hook.Config, "authorization_header")
+	assert.Equal(t, "Bearer token123", hook.AuthorizationHeader)
 	assert.Equal(t, []string{"push", "pull_request", "issues"}, hook.Events)
 }

modules/task/labels.go

@@ -13,10 +13,8 @@ import (
 // ResolveLabelNames returns a list of label IDs for a given list of label names
 func ResolveLabelNames(client *gitea.Client, owner, repo string, labelNames []string) ([]int64, error) {
 	labelIDs := make([]int64, 0, len(labelNames))
-	page := 1
-	for {
-		labels, resp, err := client.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+	labels, _, err := client.ListRepoLabels(owner, repo, gitea.ListLabelsOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
 	})
 	if err != nil {
 		return nil, err
@@ -26,11 +24,6 @@ func ResolveLabelNames(client *gitea.Client, owner, repo string, labelNames []st
 			labelIDs = append(labelIDs, l.ID)
 		}
 	}
-		if resp == nil || resp.NextPage == 0 {
-			break
-		}
-		page = resp.NextPage
-	}
 	return labelIDs, nil
 }
 

modules/task/login_create.go

@@ -166,20 +166,12 @@ func generateToken(login config.Login, user, pass, otp, scopes string) (string,
 	}
 	client := login.Client(opts...)
 
-	var tl []*gitea.AccessToken
-	for page := 1; ; {
-		page_tokens, resp, err := client.ListAccessTokens(gitea.ListAccessTokensOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+	tl, _, err := client.ListAccessTokens(gitea.ListAccessTokensOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
 	})
 	if err != nil {
 		return "", err
 	}
-		tl = append(tl, page_tokens...)
-		if resp == nil || resp.NextPage == 0 {
-			break
-		}
-		page = resp.NextPage
-	}
 	host, _ := os.Hostname()
 	tokenName := host + "-tea"
 

modules/task/login_ssh.go

@@ -19,23 +19,12 @@ import (
 // a matching private key in ~/.ssh/. If no match is found, path is empty.
 func findSSHKey(client *gitea.Client) (string, error) {
 	// get keys registered on gitea instance
-	var keys []*gitea.PublicKey
-	for page := 1; ; {
-		page_keys, resp, err := client.ListMyPublicKeys(gitea.ListPublicKeysOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+	keys, _, err := client.ListMyPublicKeys(gitea.ListPublicKeysOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
 	})
-		if err != nil {
+	if err != nil || len(keys) == 0 {
 		return "", err
 	}
-		keys = append(keys, page_keys...)
-		if resp == nil || resp.NextPage == 0 {
-			break
-		}
-		page = resp.NextPage
-	}
-	if len(keys) == 0 {
-		return "", nil
-	}
 
 	// enumerate ~/.ssh/*.pub files
 	glob, err := utils.AbsPathWithExpansion("~/.ssh/*.pub")

modules/task/pull_review_comment.go

@@ -14,20 +14,12 @@ import (
 func ListPullReviewComments(ctx *context.TeaContext, idx int64) ([]*gitea.PullReviewComment, error) {
 	c := ctx.Login.Client()
 
-	var reviews []*gitea.PullReview
-	for page := 1; ; {
-		page_reviews, resp, err := c.ListPullReviews(ctx.Owner, ctx.Repo, idx, gitea.ListPullReviewsOptions{
-			ListOptions: gitea.ListOptions{Page: page, PageSize: 50},
+	reviews, _, err := c.ListPullReviews(ctx.Owner, ctx.Repo, idx, gitea.ListPullReviewsOptions{
+		ListOptions: gitea.ListOptions{Page: -1},
 	})
 	if err != nil {
 		return nil, err
 	}
-		reviews = append(reviews, page_reviews...)
-		if resp == nil || resp.NextPage == 0 {
-			break
-		}
-		page = resp.NextPage
-	}
 
 	var allComments []*gitea.PullReviewComment
 	for _, review := range reviews {