loading up the forgejo repo on tangled to test page performance
Resolve lint for unused parameter and unnecessary type arguments (#30750)
Resolve all cases for `unused parameter` and `unnecessary type
arguments`
Related: #30729
---------
Co-authored-by: Giteabot <teabot@gitea.io>
(cherry picked from commit e80466f7349164ce4cf3c07bdac30d736d20f035)
Conflicts:
modules/markup/markdown/transform_codespan.go
modules/setting/incoming_email.go
routers/api/v1/admin/user_badge.go
routers/private/hook_pre_receive.go
tests/integration/repo_search_test.go
resolved by discarding the change, this is linting only and
for the sake of avoiding future conflicts
authored by
Chongyi Zheng
Giteabot
and committed by
Earl Warren
c504461b
b8e7b394
+107
-129
+6
-6
models/issues/issue_xref_test.go
+6
-6
models/issues/issue_xref_test.go
···
34
34
35
35
// Comment on PR to reopen issue #1
36
36
content = fmt.Sprintf("content2, reopens #%d", itarget.Index)
37
-
c := testCreateComment(t, 1, 2, pr.ID, content)
37
+
c := testCreateComment(t, 2, pr.ID, content)
38
38
ref = unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{IssueID: itarget.ID, RefIssueID: pr.ID, RefCommentID: c.ID})
39
39
assert.Equal(t, issues_model.CommentTypeCommentRef, ref.Type)
40
40
assert.Equal(t, pr.RepoID, ref.RefRepoID)
···
104
104
pr := testCreatePR(t, 1, 2, "titlepr", fmt.Sprintf("closes #%d", i1.Index))
105
105
rp := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{IssueID: i1.ID, RefIssueID: pr.Issue.ID, RefCommentID: 0})
106
106
107
-
c1 := testCreateComment(t, 1, 2, pr.Issue.ID, fmt.Sprintf("closes #%d", i2.Index))
107
+
c1 := testCreateComment(t, 2, pr.Issue.ID, fmt.Sprintf("closes #%d", i2.Index))
108
108
r1 := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{IssueID: i2.ID, RefIssueID: pr.Issue.ID, RefCommentID: c1.ID})
109
109
110
110
// Must be ignored
111
-
c2 := testCreateComment(t, 1, 2, pr.Issue.ID, fmt.Sprintf("mentions #%d", i2.Index))
111
+
c2 := testCreateComment(t, 2, pr.Issue.ID, fmt.Sprintf("mentions #%d", i2.Index))
112
112
unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{IssueID: i2.ID, RefIssueID: pr.Issue.ID, RefCommentID: c2.ID})
113
113
114
114
// Must be superseded by c4/r4
115
-
c3 := testCreateComment(t, 1, 2, pr.Issue.ID, fmt.Sprintf("reopens #%d", i3.Index))
115
+
c3 := testCreateComment(t, 2, pr.Issue.ID, fmt.Sprintf("reopens #%d", i3.Index))
116
116
unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{IssueID: i3.ID, RefIssueID: pr.Issue.ID, RefCommentID: c3.ID})
117
117
118
-
c4 := testCreateComment(t, 1, 2, pr.Issue.ID, fmt.Sprintf("closes #%d", i3.Index))
118
+
c4 := testCreateComment(t, 2, pr.Issue.ID, fmt.Sprintf("closes #%d", i3.Index))
119
119
r4 := unittest.AssertExistsAndLoadBean(t, &issues_model.Comment{IssueID: i3.ID, RefIssueID: pr.Issue.ID, RefCommentID: c4.ID})
120
120
121
121
refs, err := pr.ResolveCrossReferences(db.DefaultContext)
···
168
168
return pr
169
169
}
170
170
171
-
func testCreateComment(t *testing.T, repo, doer, issue int64, content string) *issues_model.Comment {
171
+
func testCreateComment(t *testing.T, doer, issue int64, content string) *issues_model.Comment {
172
172
d := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: doer})
173
173
i := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: issue})
174
174
c := &issues_model.Comment{Type: issues_model.CommentTypeComment, PosterID: doer, Poster: d, IssueID: issue, Issue: i, Content: content}
+3
-3
models/organization/org_test.go
+3
-3
models/organization/org_test.go
···
291
291
func TestAccessibleReposEnv_RepoIDs(t *testing.T) {
292
292
assert.NoError(t, unittest.PrepareTestDatabase())
293
293
org := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 3})
294
-
testSuccess := func(userID, _, pageSize int64, expectedRepoIDs []int64) {
294
+
testSuccess := func(userID int64, expectedRepoIDs []int64) {
295
295
env, err := organization.AccessibleReposEnv(db.DefaultContext, org, userID)
296
296
assert.NoError(t, err)
297
297
repoIDs, err := env.RepoIDs(1, 100)
298
298
assert.NoError(t, err)
299
299
assert.Equal(t, expectedRepoIDs, repoIDs)
300
300
}
301
-
testSuccess(2, 1, 100, []int64{3, 5, 32})
302
-
testSuccess(4, 0, 100, []int64{3, 32})
301
+
testSuccess(2, []int64{3, 5, 32})
302
+
testSuccess(4, []int64{3, 32})
303
303
}
304
304
305
305
func TestAccessibleReposEnv_Repos(t *testing.T) {
+12
-12
modules/actions/workflows.go
+12
-12
modules/actions/workflows.go
···
211
211
webhook_module.HookEventIssueAssign,
212
212
webhook_module.HookEventIssueLabel,
213
213
webhook_module.HookEventIssueMilestone:
214
-
return matchIssuesEvent(commit, payload.(*api.IssuePayload), evt)
214
+
return matchIssuesEvent(payload.(*api.IssuePayload), evt)
215
215
216
216
case // issue_comment
217
217
webhook_module.HookEventIssueComment,
218
218
// `pull_request_comment` is same as `issue_comment`
219
219
// See https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_comment-use-issue_comment
220
220
webhook_module.HookEventPullRequestComment:
221
-
return matchIssueCommentEvent(commit, payload.(*api.IssueCommentPayload), evt)
221
+
return matchIssueCommentEvent(payload.(*api.IssueCommentPayload), evt)
222
222
223
223
case // pull_request
224
224
webhook_module.HookEventPullRequest,
···
232
232
case // pull_request_review
233
233
webhook_module.HookEventPullRequestReviewApproved,
234
234
webhook_module.HookEventPullRequestReviewRejected:
235
-
return matchPullRequestReviewEvent(commit, payload.(*api.PullRequestPayload), evt)
235
+
return matchPullRequestReviewEvent(payload.(*api.PullRequestPayload), evt)
236
236
237
237
case // pull_request_review_comment
238
238
webhook_module.HookEventPullRequestReviewComment:
239
-
return matchPullRequestReviewCommentEvent(commit, payload.(*api.PullRequestPayload), evt)
239
+
return matchPullRequestReviewCommentEvent(payload.(*api.PullRequestPayload), evt)
240
240
241
241
case // release
242
242
webhook_module.HookEventRelease:
243
-
return matchReleaseEvent(commit, payload.(*api.ReleasePayload), evt)
243
+
return matchReleaseEvent(payload.(*api.ReleasePayload), evt)
244
244
245
245
case // registry_package
246
246
webhook_module.HookEventPackage:
247
-
return matchPackageEvent(commit, payload.(*api.PackagePayload), evt)
247
+
return matchPackageEvent(payload.(*api.PackagePayload), evt)
248
248
249
249
default:
250
250
log.Warn("unsupported event %q", triggedEvent)
···
350
350
return matchTimes == len(evt.Acts())
351
351
}
352
352
353
-
func matchIssuesEvent(commit *git.Commit, issuePayload *api.IssuePayload, evt *jobparser.Event) bool {
353
+
func matchIssuesEvent(issuePayload *api.IssuePayload, evt *jobparser.Event) bool {
354
354
// with no special filter parameters
355
355
if len(evt.Acts()) == 0 {
356
356
return true
···
498
498
return activityTypeMatched && matchTimes == len(evt.Acts())
499
499
}
500
500
501
-
func matchIssueCommentEvent(commit *git.Commit, issueCommentPayload *api.IssueCommentPayload, evt *jobparser.Event) bool {
501
+
func matchIssueCommentEvent(issueCommentPayload *api.IssueCommentPayload, evt *jobparser.Event) bool {
502
502
// with no special filter parameters
503
503
if len(evt.Acts()) == 0 {
504
504
return true
···
530
530
return matchTimes == len(evt.Acts())
531
531
}
532
532
533
-
func matchPullRequestReviewEvent(commit *git.Commit, prPayload *api.PullRequestPayload, evt *jobparser.Event) bool {
533
+
func matchPullRequestReviewEvent(prPayload *api.PullRequestPayload, evt *jobparser.Event) bool {
534
534
// with no special filter parameters
535
535
if len(evt.Acts()) == 0 {
536
536
return true
···
579
579
return matchTimes == len(evt.Acts())
580
580
}
581
581
582
-
func matchPullRequestReviewCommentEvent(commit *git.Commit, prPayload *api.PullRequestPayload, evt *jobparser.Event) bool {
582
+
func matchPullRequestReviewCommentEvent(prPayload *api.PullRequestPayload, evt *jobparser.Event) bool {
583
583
// with no special filter parameters
584
584
if len(evt.Acts()) == 0 {
585
585
return true
···
628
628
return matchTimes == len(evt.Acts())
629
629
}
630
630
631
-
func matchReleaseEvent(commit *git.Commit, payload *api.ReleasePayload, evt *jobparser.Event) bool {
631
+
func matchReleaseEvent(payload *api.ReleasePayload, evt *jobparser.Event) bool {
632
632
// with no special filter parameters
633
633
if len(evt.Acts()) == 0 {
634
634
return true
···
665
665
return matchTimes == len(evt.Acts())
666
666
}
667
667
668
-
func matchPackageEvent(commit *git.Commit, payload *api.PackagePayload, evt *jobparser.Event) bool {
668
+
func matchPackageEvent(payload *api.PackagePayload, evt *jobparser.Event) bool {
669
669
// with no special filter parameters
670
670
if len(evt.Acts()) == 0 {
671
671
return true
+2
-2
modules/git/commit_info_nogogit.go
+2
-2
modules/git/commit_info_nogogit.go
···
29
29
var revs map[string]*Commit
30
30
if commit.repo.LastCommitCache != nil {
31
31
var unHitPaths []string
32
-
revs, unHitPaths, err = getLastCommitForPathsByCache(ctx, commit.ID.String(), treePath, entryPaths, commit.repo.LastCommitCache)
32
+
revs, unHitPaths, err = getLastCommitForPathsByCache(commit.ID.String(), treePath, entryPaths, commit.repo.LastCommitCache)
33
33
if err != nil {
34
34
return nil, nil, err
35
35
}
···
97
97
return commitsInfo, treeCommit, nil
98
98
}
99
99
100
-
func getLastCommitForPathsByCache(ctx context.Context, commitID, treePath string, paths []string, cache *LastCommitCache) (map[string]*Commit, []string, error) {
100
+
func getLastCommitForPathsByCache(commitID, treePath string, paths []string, cache *LastCommitCache) (map[string]*Commit, []string, error) {
101
101
var unHitEntryPaths []string
102
102
results := make(map[string]*Commit)
103
103
for _, p := range paths {
+1
-1
modules/git/parse_gogit.go
+1
-1
modules/git/parse_gogit.go
+1
-1
modules/git/parse_gogit_test.go
+1
-1
modules/git/parse_gogit_test.go
···
67
67
}
68
68
69
69
for _, testCase := range testCases {
70
-
entries, err := ParseTreeEntries(Sha1ObjectFormat, []byte(testCase.Input))
70
+
entries, err := ParseTreeEntries([]byte(testCase.Input))
71
71
assert.NoError(t, err)
72
72
if len(entries) > 1 {
73
73
fmt.Println(testCase.Expected[0].ID)
+3
-3
modules/git/parse_nogogit.go
+3
-3
modules/git/parse_nogogit.go
···
17
17
)
18
18
19
19
// ParseTreeEntries parses the output of a `git ls-tree -l` command.
20
-
func ParseTreeEntries(objectFormat ObjectFormat, data []byte) ([]*TreeEntry, error) {
21
-
return parseTreeEntries(objectFormat, data, nil)
20
+
func ParseTreeEntries(data []byte) ([]*TreeEntry, error) {
21
+
return parseTreeEntries(data, nil)
22
22
}
23
23
24
24
var sepSpace = []byte{' '}
25
25
26
-
func parseTreeEntries(objectFormat ObjectFormat, data []byte, ptree *Tree) ([]*TreeEntry, error) {
26
+
func parseTreeEntries(data []byte, ptree *Tree) ([]*TreeEntry, error) {
27
27
var err error
28
28
entries := make([]*TreeEntry, 0, bytes.Count(data, []byte{'\n'})+1)
29
29
for pos := 0; pos < len(data); {
+3
-7
modules/git/parse_nogogit_test.go
+3
-7
modules/git/parse_nogogit_test.go
···
12
12
)
13
13
14
14
func TestParseTreeEntriesLong(t *testing.T) {
15
-
objectFormat := Sha1ObjectFormat
16
-
17
15
testCases := []struct {
18
16
Input string
19
17
Expected []*TreeEntry
···
56
54
},
57
55
}
58
56
for _, testCase := range testCases {
59
-
entries, err := ParseTreeEntries(objectFormat, []byte(testCase.Input))
57
+
entries, err := ParseTreeEntries([]byte(testCase.Input))
60
58
assert.NoError(t, err)
61
59
assert.Len(t, entries, len(testCase.Expected))
62
60
for i, entry := range entries {
···
66
64
}
67
65
68
66
func TestParseTreeEntriesShort(t *testing.T) {
69
-
objectFormat := Sha1ObjectFormat
70
-
71
67
testCases := []struct {
72
68
Input string
73
69
Expected []*TreeEntry
···
91
87
},
92
88
}
93
89
for _, testCase := range testCases {
94
-
entries, err := ParseTreeEntries(objectFormat, []byte(testCase.Input))
90
+
entries, err := ParseTreeEntries([]byte(testCase.Input))
95
91
assert.NoError(t, err)
96
92
assert.Len(t, entries, len(testCase.Expected))
97
93
for i, entry := range entries {
···
102
98
103
99
func TestParseTreeEntriesInvalid(t *testing.T) {
104
100
// there was a panic: "runtime error: slice bounds out of range" when the input was invalid: #20315
105
-
entries, err := ParseTreeEntries(Sha1ObjectFormat, []byte("100644 blob ea0d83c9081af9500ac9f804101b3fd0a5c293af"))
101
+
entries, err := ParseTreeEntries([]byte("100644 blob ea0d83c9081af9500ac9f804101b3fd0a5c293af"))
106
102
assert.Error(t, err)
107
103
assert.Len(t, entries, 0)
108
104
}
+4
-10
modules/git/tree_nogogit.go
+4
-10
modules/git/tree_nogogit.go
···
77
77
return nil, runErr
78
78
}
79
79
80
-
objectFormat, err := t.repo.GetObjectFormat()
81
-
if err != nil {
82
-
return nil, err
83
-
}
84
-
t.entries, err = parseTreeEntries(objectFormat, stdout, t)
80
+
var err error
81
+
t.entries, err = parseTreeEntries(stdout, t)
85
82
if err == nil {
86
83
t.entriesParsed = true
87
84
}
···
104
101
return nil, runErr
105
102
}
106
103
107
-
objectFormat, err := t.repo.GetObjectFormat()
108
-
if err != nil {
109
-
return nil, err
110
-
}
111
-
t.entriesRecursive, err = parseTreeEntries(objectFormat, stdout, t)
104
+
var err error
105
+
t.entriesRecursive, err = parseTreeEntries(stdout, t)
112
106
if err == nil {
113
107
t.entriesRecursiveParsed = true
114
108
}
+4
-8
modules/indexer/code/git.go
+4
-8
modules/indexer/code/git.go
···
62
62
}
63
63
64
64
// parseGitLsTreeOutput parses the output of a `git ls-tree -r --full-name` command
65
-
func parseGitLsTreeOutput(objectFormat git.ObjectFormat, stdout []byte) ([]internal.FileUpdate, error) {
66
-
entries, err := git.ParseTreeEntries(objectFormat, stdout)
65
+
func parseGitLsTreeOutput(stdout []byte) ([]internal.FileUpdate, error) {
66
+
entries, err := git.ParseTreeEntries(stdout)
67
67
if err != nil {
68
68
return nil, err
69
69
}
···
91
91
return nil, runErr
92
92
}
93
93
94
-
objectFormat := git.ObjectFormatFromName(repo.ObjectFormatName)
95
-
96
94
var err error
97
-
changes.Updates, err = parseGitLsTreeOutput(objectFormat, stdout)
95
+
changes.Updates, err = parseGitLsTreeOutput(stdout)
98
96
return &changes, err
99
97
}
100
98
···
172
170
return nil, err
173
171
}
174
172
175
-
objectFormat := git.ObjectFormatFromName(repo.ObjectFormatName)
176
-
177
-
changes.Updates, err = parseGitLsTreeOutput(objectFormat, lsTreeStdout)
173
+
changes.Updates, err = parseGitLsTreeOutput(lsTreeStdout)
178
174
return &changes, err
179
175
}
+3
-3
modules/markup/markdown/goldmark.go
+3
-3
modules/markup/markdown/goldmark.go
···
58
58
case *ast.Paragraph:
59
59
g.applyElementDir(v)
60
60
case *ast.Image:
61
-
g.transformImage(ctx, v, reader)
61
+
g.transformImage(ctx, v)
62
62
case *ast.Link:
63
-
g.transformLink(ctx, v, reader)
63
+
g.transformLink(ctx, v)
64
64
case *ast.List:
65
-
g.transformList(ctx, v, reader, rc)
65
+
g.transformList(ctx, v, rc)
66
66
case *ast.Text:
67
67
if v.SoftLineBreak() && !v.HardLineBreak() {
68
68
if ctx.Metas["mode"] != "document" {
+1
-1
modules/markup/markdown/transform_heading.go
+1
-1
modules/markup/markdown/transform_heading.go
···
13
13
"github.com/yuin/goldmark/util"
14
14
)
15
15
16
-
func (g *ASTTransformer) transformHeading(ctx *markup.RenderContext, v *ast.Heading, reader text.Reader, tocList *[]markup.Header) {
16
+
func (g *ASTTransformer) transformHeading(_ *markup.RenderContext, v *ast.Heading, reader text.Reader, tocList *[]markup.Header) {
17
17
for _, attr := range v.Attributes() {
18
18
if _, ok := attr.Value.([]byte); !ok {
19
19
v.SetAttribute(attr.Name, []byte(fmt.Sprintf("%v", attr.Value)))
+1
-2
modules/markup/markdown/transform_image.go
+1
-2
modules/markup/markdown/transform_image.go
···
10
10
giteautil "code.gitea.io/gitea/modules/util"
11
11
12
12
"github.com/yuin/goldmark/ast"
13
-
"github.com/yuin/goldmark/text"
14
13
)
15
14
16
-
func (g *ASTTransformer) transformImage(ctx *markup.RenderContext, v *ast.Image, reader text.Reader) {
15
+
func (g *ASTTransformer) transformImage(ctx *markup.RenderContext, v *ast.Image) {
17
16
// Images need two things:
18
17
//
19
18
// 1. Their src needs to munged to be a real value
+1
-2
modules/markup/markdown/transform_link.go
+1
-2
modules/markup/markdown/transform_link.go
···
12
12
giteautil "code.gitea.io/gitea/modules/util"
13
13
14
14
"github.com/yuin/goldmark/ast"
15
-
"github.com/yuin/goldmark/text"
16
15
)
17
16
18
-
func (g *ASTTransformer) transformLink(ctx *markup.RenderContext, v *ast.Link, reader text.Reader) {
17
+
func (g *ASTTransformer) transformLink(ctx *markup.RenderContext, v *ast.Link) {
19
18
// Links need their href to munged to be a real value
20
19
link := v.Destination
21
20
+1
-2
modules/markup/markdown/transform_list.go
+1
-2
modules/markup/markdown/transform_list.go
···
11
11
"github.com/yuin/goldmark/ast"
12
12
east "github.com/yuin/goldmark/extension/ast"
13
13
"github.com/yuin/goldmark/renderer/html"
14
-
"github.com/yuin/goldmark/text"
15
14
"github.com/yuin/goldmark/util"
16
15
)
17
16
···
50
49
return ast.WalkContinue, nil
51
50
}
52
51
53
-
func (g *ASTTransformer) transformList(ctx *markup.RenderContext, v *ast.List, reader text.Reader, rc *RenderConfig) {
52
+
func (g *ASTTransformer) transformList(_ *markup.RenderContext, v *ast.List, rc *RenderConfig) {
54
53
if v.HasChildren() {
55
54
children := make([]ast.Node, 0, v.ChildCount())
56
55
child := v.FirstChild()
+2
-2
modules/markup/mdstripper/mdstripper.go
+2
-2
modules/markup/mdstripper/mdstripper.go
···
54
54
}
55
55
return ast.WalkContinue, nil
56
56
case *ast.Link:
57
-
r.processLink(w, v.Destination)
57
+
r.processLink(v.Destination)
58
58
return ast.WalkSkipChildren, nil
59
59
case *ast.AutoLink:
60
60
// This could be a reference to an issue or pull - if so convert it
···
124
124
_, _ = w.Write([]byte(parts[4]))
125
125
}
126
126
127
-
func (r *stripRenderer) processLink(w io.Writer, link []byte) {
127
+
func (r *stripRenderer) processLink(link []byte) {
128
128
// Links are processed out of band
129
129
r.links = append(r.links, string(link))
130
130
}
+1
-1
modules/optional/option_test.go
+1
-1
modules/optional/option_test.go
···
22
22
assert.Equal(t, int(0), none.Value())
23
23
assert.Equal(t, int(1), none.ValueOrDefault(1))
24
24
25
-
some := optional.Some[int](1)
25
+
some := optional.Some(1)
26
26
assert.True(t, some.Has())
27
27
assert.Equal(t, int(1), some.Value())
28
28
assert.Equal(t, int(1), some.ValueOrDefault(2))
+2
-2
modules/setting/incoming_email.go
+2
-2
modules/setting/incoming_email.go
···
56
56
}
57
57
}
58
58
59
-
if err := checkReplyToAddress(IncomingEmail.ReplyToAddress); err != nil {
59
+
if err := checkReplyToAddress(); err != nil {
60
60
log.Fatal("Invalid incoming_mail.REPLY_TO_ADDRESS (%s): %v", IncomingEmail.ReplyToAddress, err)
61
61
}
62
62
}
63
63
64
-
func checkReplyToAddress(address string) error {
64
+
func checkReplyToAddress() error {
65
65
parsed, err := mail.ParseAddress(IncomingEmail.ReplyToAddress)
66
66
if err != nil {
67
67
return err
+2
-2
modules/setting/storage.go
+2
-2
modules/setting/storage.go
···
99
99
return nil, err
100
100
}
101
101
102
-
overrideSec := getStorageOverrideSection(rootCfg, targetSec, sec, tp, name)
102
+
overrideSec := getStorageOverrideSection(rootCfg, sec, tp, name)
103
103
104
104
targetType := targetSec.Key("STORAGE_TYPE").String()
105
105
switch targetType {
···
191
191
}
192
192
193
193
// getStorageOverrideSection override section will be read SERVE_DIRECT, PATH, MINIO_BASE_PATH, MINIO_BUCKET to override the targetsec when possible
194
-
func getStorageOverrideSection(rootConfig ConfigProvider, targetSec, sec ConfigSection, targetSecType targetSecType, name string) ConfigSection {
194
+
func getStorageOverrideSection(rootConfig ConfigProvider, sec ConfigSection, targetSecType targetSecType, name string) ConfigSection {
195
195
if targetSecType == targetSecIsSec {
196
196
return nil
197
197
}
+3
-3
routers/api/v1/repo/migrate.go
+3
-3
routers/api/v1/repo/migrate.go
···
180
180
Status: repo_model.RepositoryBeingMigrated,
181
181
})
182
182
if err != nil {
183
-
handleMigrateError(ctx, repoOwner, remoteAddr, err)
183
+
handleMigrateError(ctx, repoOwner, err)
184
184
return
185
185
}
186
186
···
207
207
}()
208
208
209
209
if repo, err = migrations.MigrateRepository(graceful.GetManager().HammerContext(), ctx.Doer, repoOwner.Name, opts, nil); err != nil {
210
-
handleMigrateError(ctx, repoOwner, remoteAddr, err)
210
+
handleMigrateError(ctx, repoOwner, err)
211
211
return
212
212
}
213
213
···
215
215
ctx.JSON(http.StatusCreated, convert.ToRepo(ctx, repo, access_model.Permission{AccessMode: perm.AccessModeAdmin}))
216
216
}
217
217
218
-
func handleMigrateError(ctx *context.APIContext, repoOwner *user_model.User, remoteAddr string, err error) {
218
+
func handleMigrateError(ctx *context.APIContext, repoOwner *user_model.User, err error) {
219
219
switch {
220
220
case repo_model.IsErrRepoAlreadyExist(err):
221
221
ctx.Error(http.StatusConflict, "", "The repository with the same name already exists.")
+1
-1
routers/web/admin/admin.go
+1
-1
routers/web/admin/admin.go
···
158
158
switch form.Op {
159
159
case "sync_repo_branches":
160
160
go func() {
161
-
if err := repo_service.AddAllRepoBranchesToSyncQueue(graceful.GetManager().ShutdownContext(), ctx.Doer.ID); err != nil {
161
+
if err := repo_service.AddAllRepoBranchesToSyncQueue(graceful.GetManager().ShutdownContext()); err != nil {
162
162
log.Error("AddAllRepoBranchesToSyncQueue: %v: %v", ctx.Doer.ID, err)
163
163
}
164
164
}()
+1
-1
routers/web/feed/convert.go
+1
-1
routers/web/feed/convert.go
···
287
287
}
288
288
289
289
// feedActionsToFeedItems convert gitea's Repo's Releases to feeds Item
290
-
func releasesToFeedItems(ctx *context.Context, releases []*repo_model.Release, isReleasesOnly bool) (items []*feeds.Item, err error) {
290
+
func releasesToFeedItems(ctx *context.Context, releases []*repo_model.Release) (items []*feeds.Item, err error) {
291
291
for _, rel := range releases {
292
292
err := rel.LoadAttributes(ctx)
293
293
if err != nil {
+1
-1
routers/web/feed/release.go
+1
-1
routers/web/feed/release.go
+4
-4
services/context/repo.go
+4
-4
services/context/repo.go
···
810
810
return false
811
811
}
812
812
813
-
func getRefNameFromPath(ctx *Base, repo *Repository, path string, isExist func(string) bool) string {
813
+
func getRefNameFromPath(repo *Repository, path string, isExist func(string) bool) string {
814
814
refName := ""
815
815
parts := strings.Split(path, "/")
816
816
for i, part := range parts {
···
846
846
repo.TreePath = path
847
847
return repo.Repository.DefaultBranch
848
848
case RepoRefBranch:
849
-
ref := getRefNameFromPath(ctx, repo, path, repo.GitRepo.IsBranchExist)
849
+
ref := getRefNameFromPath(repo, path, repo.GitRepo.IsBranchExist)
850
850
if len(ref) == 0 {
851
851
// check if ref is HEAD
852
852
parts := strings.Split(path, "/")
···
856
856
}
857
857
858
858
// maybe it's a renamed branch
859
-
return getRefNameFromPath(ctx, repo, path, func(s string) bool {
859
+
return getRefNameFromPath(repo, path, func(s string) bool {
860
860
b, exist, err := git_model.FindRenamedBranch(ctx, repo.Repository.ID, s)
861
861
if err != nil {
862
862
log.Error("FindRenamedBranch: %v", err)
···
876
876
877
877
return ref
878
878
case RepoRefTag:
879
-
return getRefNameFromPath(ctx, repo, path, repo.GitRepo.IsTagExist)
879
+
return getRefNameFromPath(repo, path, repo.GitRepo.IsTagExist)
880
880
case RepoRefCommit:
881
881
parts := strings.Split(path, "/")
882
882
+7
-7
services/doctor/storage.go
+7
-7
services/doctor/storage.go
···
27
27
name string
28
28
}
29
29
30
-
func commonCheckStorage(ctx context.Context, logger log.Logger, autofix bool, opts *commonStorageCheckOptions) error {
30
+
func commonCheckStorage(logger log.Logger, autofix bool, opts *commonStorageCheckOptions) error {
31
31
totalCount, orphanedCount := 0, 0
32
32
totalSize, orphanedSize := int64(0), int64(0)
33
33
···
98
98
}
99
99
100
100
if opts.Attachments || opts.All {
101
-
if err := commonCheckStorage(ctx, logger, autofix,
101
+
if err := commonCheckStorage(logger, autofix,
102
102
&commonStorageCheckOptions{
103
103
storer: storage.Attachments,
104
104
isOrphaned: func(path string, obj storage.Object, stat fs.FileInfo) (bool, error) {
···
116
116
logger.Info("LFS isn't enabled (skipped)")
117
117
return nil
118
118
}
119
-
if err := commonCheckStorage(ctx, logger, autofix,
119
+
if err := commonCheckStorage(logger, autofix,
120
120
&commonStorageCheckOptions{
121
121
storer: storage.LFS,
122
122
isOrphaned: func(path string, obj storage.Object, stat fs.FileInfo) (bool, error) {
···
132
132
}
133
133
134
134
if opts.Avatars || opts.All {
135
-
if err := commonCheckStorage(ctx, logger, autofix,
135
+
if err := commonCheckStorage(logger, autofix,
136
136
&commonStorageCheckOptions{
137
137
storer: storage.Avatars,
138
138
isOrphaned: func(path string, obj storage.Object, stat fs.FileInfo) (bool, error) {
···
146
146
}
147
147
148
148
if opts.RepoAvatars || opts.All {
149
-
if err := commonCheckStorage(ctx, logger, autofix,
149
+
if err := commonCheckStorage(logger, autofix,
150
150
&commonStorageCheckOptions{
151
151
storer: storage.RepoAvatars,
152
152
isOrphaned: func(path string, obj storage.Object, stat fs.FileInfo) (bool, error) {
···
160
160
}
161
161
162
162
if opts.RepoArchives || opts.All {
163
-
if err := commonCheckStorage(ctx, logger, autofix,
163
+
if err := commonCheckStorage(logger, autofix,
164
164
&commonStorageCheckOptions{
165
165
storer: storage.RepoArchives,
166
166
isOrphaned: func(path string, obj storage.Object, stat fs.FileInfo) (bool, error) {
···
182
182
logger.Info("Packages isn't enabled (skipped)")
183
183
return nil
184
184
}
185
-
if err := commonCheckStorage(ctx, logger, autofix,
185
+
if err := commonCheckStorage(logger, autofix,
186
186
&commonStorageCheckOptions{
187
187
storer: storage.Packages,
188
188
isOrphaned: func(path string, obj storage.Object, stat fs.FileInfo) (bool, error) {
+7
-8
services/migrations/gitea_uploader.go
+7
-8
services/migrations/gitea_uploader.go
···
982
982
}
983
983
984
984
func (g *GiteaLocalUploader) remapUser(source user_model.ExternalUserMigrated, target user_model.ExternalUserRemappable) error {
985
-
var userid int64
985
+
var userID int64
986
986
var err error
987
987
if g.sameApp {
988
-
userid, err = g.remapLocalUser(source, target)
988
+
userID, err = g.remapLocalUser(source)
989
989
} else {
990
-
userid, err = g.remapExternalUser(source, target)
990
+
userID, err = g.remapExternalUser(source)
991
991
}
992
-
993
992
if err != nil {
994
993
return err
995
994
}
996
995
997
-
if userid > 0 {
998
-
return target.RemapExternalUser("", 0, userid)
996
+
if userID > 0 {
997
+
return target.RemapExternalUser("", 0, userID)
999
998
}
1000
999
return target.RemapExternalUser(source.GetExternalName(), source.GetExternalID(), g.doer.ID)
1001
1000
}
1002
1001
1003
-
func (g *GiteaLocalUploader) remapLocalUser(source user_model.ExternalUserMigrated, target user_model.ExternalUserRemappable) (int64, error) {
1002
+
func (g *GiteaLocalUploader) remapLocalUser(source user_model.ExternalUserMigrated) (int64, error) {
1004
1003
userid, ok := g.userMap[source.GetExternalID()]
1005
1004
if !ok {
1006
1005
name, err := user_model.GetUserNameByID(g.ctx, source.GetExternalID())
···
1018
1017
return userid, nil
1019
1018
}
1020
1019
1021
-
func (g *GiteaLocalUploader) remapExternalUser(source user_model.ExternalUserMigrated, target user_model.ExternalUserRemappable) (userid int64, err error) {
1020
+
func (g *GiteaLocalUploader) remapExternalUser(source user_model.ExternalUserMigrated) (userid int64, err error) {
1022
1021
userid, ok := g.userMap[source.GetExternalID()]
1023
1022
if !ok {
1024
1023
userid, err = user_model.GetUserIDByExternalUserID(g.ctx, g.gitServiceType.Name(), fmt.Sprintf("%d", source.GetExternalID()))
+1
-1
services/mirror/mirror.go
+1
-1
services/mirror/mirror.go
···
90
90
91
91
pullMirrorsRequested := 0
92
92
if pullLimit != 0 {
93
-
if err := repo_model.MirrorsIterate(ctx, pullLimit, func(idx int, bean any) error {
93
+
if err := repo_model.MirrorsIterate(ctx, pullLimit, func(_ int, bean any) error {
94
94
if err := handler(bean); err != nil {
95
95
return err
96
96
}
+2
-2
services/pull/review.go
+2
-2
services/pull/review.go
···
49
49
50
50
// checkInvalidation checks if the line of code comment got changed by another commit.
51
51
// If the line got changed the comment is going to be invalidated.
52
-
func checkInvalidation(ctx context.Context, c *issues_model.Comment, doer *user_model.User, repo *git.Repository, branch string) error {
52
+
func checkInvalidation(ctx context.Context, c *issues_model.Comment, repo *git.Repository, branch string) error {
53
53
// FIXME differentiate between previous and proposed line
54
54
commit, err := repo.LineBlame(branch, repo.Path, c.TreePath, uint(c.UnsignedLine()))
55
55
if err != nil && (strings.Contains(err.Error(), "fatal: no such path") || notEnoughLines.MatchString(err.Error())) {
···
83
83
return fmt.Errorf("find code comments: %v", err)
84
84
}
85
85
for _, comment := range codeComments {
86
-
if err := checkInvalidation(ctx, comment, doer, repo, branch); err != nil {
86
+
if err := checkInvalidation(ctx, comment, repo, branch); err != nil {
87
87
return err
88
88
}
89
89
}
+1
-1
services/pull/update.go
+1
-1
services/pull/update.go
+1
-1
services/pull/update_rebase.go
+1
-1
services/pull/update_rebase.go
···
18
18
)
19
19
20
20
// updateHeadByRebaseOnToBase handles updating a PR's head branch by rebasing it on the PR current base branch
21
-
func updateHeadByRebaseOnToBase(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.User, message string) error {
21
+
func updateHeadByRebaseOnToBase(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.User) error {
22
22
// "Clone" base repo and add the cache headers for the head repo and branch
23
23
mergeCtx, cancel, err := createTemporaryRepoForMerge(ctx, pr, doer, "")
24
24
if err != nil {
+2
-2
services/repository/adopt.go
+2
-2
services/repository/adopt.go
···
80
80
return fmt.Errorf("getRepositoryByID: %w", err)
81
81
}
82
82
83
-
if err := adoptRepository(ctx, repoPath, doer, repo, opts.DefaultBranch); err != nil {
83
+
if err := adoptRepository(ctx, repoPath, repo, opts.DefaultBranch); err != nil {
84
84
return fmt.Errorf("createDelegateHooks: %w", err)
85
85
}
86
86
···
111
111
return repo, nil
112
112
}
113
113
114
-
func adoptRepository(ctx context.Context, repoPath string, u *user_model.User, repo *repo_model.Repository, defaultBranch string) (err error) {
114
+
func adoptRepository(ctx context.Context, repoPath string, repo *repo_model.Repository, defaultBranch string) (err error) {
115
115
isExist, err := util.IsExist(repoPath)
116
116
if err != nil {
117
117
log.Error("Unable to check if %s exists. Error: %v", repoPath, err)
+3
-3
services/repository/branch.go
+3
-3
services/repository/branch.go
···
491
491
return nil
492
492
}
493
493
494
-
func addRepoToBranchSyncQueue(repoID, doerID int64) error {
494
+
func addRepoToBranchSyncQueue(repoID int64) error {
495
495
return branchSyncQueue.Push(&BranchSyncOptions{
496
496
RepoID: repoID,
497
497
})
···
507
507
return nil
508
508
}
509
509
510
-
func AddAllRepoBranchesToSyncQueue(ctx context.Context, doerID int64) error {
510
+
func AddAllRepoBranchesToSyncQueue(ctx context.Context) error {
511
511
if err := db.Iterate(ctx, builder.Eq{"is_empty": false}, func(ctx context.Context, repo *repo_model.Repository) error {
512
-
return addRepoToBranchSyncQueue(repo.ID, doerID)
512
+
return addRepoToBranchSyncQueue(repo.ID)
513
513
}); err != nil {
514
514
return fmt.Errorf("run sync all branches failed: %v", err)
515
515
}
+2
-2
services/repository/files/update.go
+2
-2
services/repository/files/update.go
···
211
211
}
212
212
213
213
for _, file := range opts.Files {
214
-
if err := handleCheckErrors(file, commit, opts, repo); err != nil {
214
+
if err := handleCheckErrors(file, commit, opts); err != nil {
215
215
return nil, err
216
216
}
217
217
}
···
277
277
}
278
278
279
279
// handles the check for various issues for ChangeRepoFiles
280
-
func handleCheckErrors(file *ChangeRepoFile, commit *git.Commit, opts *ChangeRepoFilesOptions, repo *repo_model.Repository) error {
280
+
func handleCheckErrors(file *ChangeRepoFile, commit *git.Commit, opts *ChangeRepoFilesOptions) error {
281
281
if file.Operation == "update" || file.Operation == "delete" {
282
282
fromEntry, err := commit.GetTreeEntryByPath(file.Options.fromTreePath)
283
283
if err != nil {
+1
-1
services/user/update_test.go
+1
-1
services/user/update_test.go
···
35
35
Description: optional.Some("description"),
36
36
AllowGitHook: optional.Some(true),
37
37
AllowImportLocal: optional.Some(true),
38
-
MaxRepoCreation: optional.Some[int](10),
38
+
MaxRepoCreation: optional.Some(10),
39
39
IsRestricted: optional.Some(true),
40
40
IsActive: optional.Some(false),
41
41
IsAdmin: optional.Some(true),
+2
-2
tests/integration/api_packages_chef_test.go
+2
-2
tests/integration/api_packages_chef_test.go
···
169
169
assert.Nil(t, u)
170
170
assert.Error(t, err)
171
171
172
-
signRequest := func(t *testing.T, rw *RequestWrapper, version string) {
172
+
signRequest := func(rw *RequestWrapper, version string) {
173
173
req := rw.Request
174
174
username := req.Header.Get("X-Ops-Userid")
175
175
if version != "1.0" && version != "1.3" {
···
255
255
t.Run(v, func(t *testing.T) {
256
256
defer tests.PrintCurrentTest(t)()
257
257
258
-
signRequest(t, req, v)
258
+
signRequest(req, v)
259
259
u, err = auth.Verify(req.Request, nil, nil, nil)
260
260
assert.NotNil(t, u)
261
261
assert.NoError(t, err)
+7
-7
tests/integration/api_releases_test.go
+7
-7
tests/integration/api_releases_test.go
···
77
77
testFilterByLen(true, url.Values{"draft": {"true"}, "pre-release": {"true"}}, 0, "there is no pre-release draft")
78
78
}
79
79
80
-
func createNewReleaseUsingAPI(t *testing.T, session *TestSession, token string, owner *user_model.User, repo *repo_model.Repository, name, target, title, desc string) *api.Release {
80
+
func createNewReleaseUsingAPI(t *testing.T, token string, owner *user_model.User, repo *repo_model.Repository, name, target, title, desc string) *api.Release {
81
81
urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/releases", owner.Name, repo.Name)
82
82
req := NewRequestWithJSON(t, "POST", urlStr, &api.CreateReleaseOption{
83
83
TagName: name,
···
120
120
target, err := gitRepo.GetTagCommitID("v0.0.1")
121
121
assert.NoError(t, err)
122
122
123
-
newRelease := createNewReleaseUsingAPI(t, session, token, owner, repo, "v0.0.1", target, "v0.0.1", "test")
123
+
newRelease := createNewReleaseUsingAPI(t, token, owner, repo, "v0.0.1", target, "v0.0.1", "test")
124
124
125
125
urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/releases/%d", owner.Name, repo.Name, newRelease.ID)
126
126
req := NewRequest(t, "GET", urlStr).
···
167
167
session := loginUser(t, owner.LowerName)
168
168
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
169
169
170
-
createNewReleaseUsingAPI(t, session, token, owner, repo, "v0.0.1", "", "v0.0.1", "test")
170
+
createNewReleaseUsingAPI(t, token, owner, repo, "v0.0.1", "", "v0.0.1", "test")
171
171
}
172
172
173
173
func TestAPICreateReleaseToDefaultBranchOnExistingTag(t *testing.T) {
···
185
185
err = gitRepo.CreateTag("v0.0.1", "master")
186
186
assert.NoError(t, err)
187
187
188
-
createNewReleaseUsingAPI(t, session, token, owner, repo, "v0.0.1", "", "v0.0.1", "test")
188
+
createNewReleaseUsingAPI(t, token, owner, repo, "v0.0.1", "", "v0.0.1", "test")
189
189
}
190
190
191
191
func TestAPIGetLatestRelease(t *testing.T) {
···
237
237
session := loginUser(t, owner.LowerName)
238
238
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
239
239
240
-
createNewReleaseUsingAPI(t, session, token, owner, repo, "release-tag", "", "Release Tag", "test")
240
+
createNewReleaseUsingAPI(t, token, owner, repo, "release-tag", "", "Release Tag", "test")
241
241
242
242
// delete release
243
243
req := NewRequestf(t, http.MethodDelete, fmt.Sprintf("/api/v1/repos/%s/%s/releases/tags/release-tag", owner.Name, repo.Name)).
···
263
263
session := loginUser(t, owner.LowerName)
264
264
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
265
265
266
-
r := createNewReleaseUsingAPI(t, session, token, owner, repo, "release-tag", "", "Release Tag", "test")
266
+
r := createNewReleaseUsingAPI(t, token, owner, repo, "release-tag", "", "Release Tag", "test")
267
267
268
268
filename := "image.png"
269
269
buff := generateImg()
···
335
335
336
336
name := "ReleaseDownloadCount"
337
337
338
-
createNewReleaseUsingAPI(t, session, token, owner, repo, name, "", name, "test")
338
+
createNewReleaseUsingAPI(t, token, owner, repo, name, "", name, "test")
339
339
340
340
urlStr := fmt.Sprintf("/api/v1/repos/%s/%s/releases/tags/%s", owner.Name, repo.Name, name)
341
341
+1
-3
tests/integration/pull_create_test.go
+1
-3
tests/integration/pull_create_test.go
···
455
455
t.Run("unrelated branches are not shown", func(t *testing.T) {
456
456
defer tests.PrintCurrentTest(t)()
457
457
458
-
adminUser := unittest.AssertExistsAndLoadBean(t, &user_model.User{IsAdmin: true})
459
-
460
458
// Create a new branch with no relation to the default branch.
461
459
// 1. Create a new Tree object
462
460
cmd := git.NewCommand(db.DefaultContext, "write-tree")
···
473
471
_, _, gitErr = cmd.RunStdString(&git.RunOpts{Dir: repo.RepoPath()})
474
472
assert.NoError(t, gitErr)
475
473
// 4. Sync the git repo to the database
476
-
syncErr := repo_service.AddAllRepoBranchesToSyncQueue(graceful.GetManager().ShutdownContext(), adminUser.ID)
474
+
syncErr := repo_service.AddAllRepoBranchesToSyncQueue(graceful.GetManager().ShutdownContext())
477
475
assert.NoError(t, syncErr)
478
476
// 5. Add a fresh commit, so that FindRecentlyPushedBranches has
479
477
// something to find.
+1
-1
tests/integration/repo_badges_test.go
+1
-1
tests/integration/repo_badges_test.go
···
215
215
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
216
216
err := release.CreateNewTag(git.DefaultContext, repo.Owner, repo, "main", "repo-name-2.0", "dash in the tag name")
217
217
assert.NoError(t, err)
218
-
createNewReleaseUsingAPI(t, session, token, repo.Owner, repo, "repo-name-2.0", "main", "dashed release", "dashed release")
218
+
createNewReleaseUsingAPI(t, token, repo.Owner, repo, "repo-name-2.0", "main", "dashed release", "dashed release")
219
219
220
220
req := NewRequestf(t, "GET", "/user2/%s/badges/release.svg", repo.Name)
221
221
resp := MakeRequest(t, req, http.StatusSeeOther)
+2
-4
tests/integration/repo_branch_test.go
+2
-4
tests/integration/repo_branch_test.go
···
16
16
git_model "code.gitea.io/gitea/models/git"
17
17
repo_model "code.gitea.io/gitea/models/repo"
18
18
"code.gitea.io/gitea/models/unittest"
19
-
user_model "code.gitea.io/gitea/models/user"
20
19
"code.gitea.io/gitea/modules/git"
21
20
"code.gitea.io/gitea/modules/graceful"
22
21
"code.gitea.io/gitea/modules/setting"
···
170
169
171
170
func TestDatabaseMissingABranch(t *testing.T) {
172
171
onGiteaRun(t, func(t *testing.T, URL *url.URL) {
173
-
adminUser := unittest.AssertExistsAndLoadBean(t, &user_model.User{IsAdmin: true})
174
172
session := loginUser(t, "user2")
175
173
176
174
// Create two branches
···
178
176
testCreateBranch(t, session, "user2", "repo1", "branch/master", "will-be-missing", http.StatusSeeOther)
179
177
180
178
// Run the repo branch sync, to ensure the db and git agree.
181
-
err2 := repo_service.AddAllRepoBranchesToSyncQueue(graceful.GetManager().ShutdownContext(), adminUser.ID)
179
+
err2 := repo_service.AddAllRepoBranchesToSyncQueue(graceful.GetManager().ShutdownContext())
182
180
assert.NoError(t, err2)
183
181
184
182
// Delete one branch from git only, leaving it in the database
···
197
195
assert.GreaterOrEqual(t, firstBranchCount, 3)
198
196
199
197
// Run the repo branch sync again
200
-
err2 = repo_service.AddAllRepoBranchesToSyncQueue(graceful.GetManager().ShutdownContext(), adminUser.ID)
198
+
err2 = repo_service.AddAllRepoBranchesToSyncQueue(graceful.GetManager().ShutdownContext())
201
199
assert.NoError(t, err2)
202
200
203
201
// Verify that loading the repo's branches page works still, and that it
+3
-3
tests/integration/repofiles_change_test.go
+3
-3
tests/integration/repofiles_change_test.go
···
78
78
}
79
79
}
80
80
81
-
func getExpectedFileResponseForRepofilesDelete(u *url.URL) *api.FileResponse {
81
+
func getExpectedFileResponseForRepofilesDelete() *api.FileResponse {
82
82
// Just returns fields that don't change, i.e. fields with commit SHAs and dates can't be determined
83
83
return &api.FileResponse{
84
84
Content: nil,
···
418
418
t.Run("Delete README.md file", func(t *testing.T) {
419
419
filesResponse, err := files_service.ChangeRepoFiles(git.DefaultContext, repo, doer, opts)
420
420
assert.NoError(t, err)
421
-
expectedFileResponse := getExpectedFileResponseForRepofilesDelete(u)
421
+
expectedFileResponse := getExpectedFileResponseForRepofilesDelete()
422
422
assert.NotNil(t, filesResponse)
423
423
assert.Nil(t, filesResponse.Files[0])
424
424
assert.EqualValues(t, expectedFileResponse.Commit.Message, filesResponse.Commit.Message)
···
460
460
t.Run("Delete README.md without Branch Name", func(t *testing.T) {
461
461
filesResponse, err := files_service.ChangeRepoFiles(git.DefaultContext, repo, doer, opts)
462
462
assert.NoError(t, err)
463
-
expectedFileResponse := getExpectedFileResponseForRepofilesDelete(u)
463
+
expectedFileResponse := getExpectedFileResponseForRepofilesDelete()
464
464
assert.NotNil(t, filesResponse)
465
465
assert.Nil(t, filesResponse.Files[0])
466
466
assert.EqualValues(t, expectedFileResponse.Commit.Message, filesResponse.Commit.Message)