loading up the forgejo repo on tangled to test page performance
Merge pull request 'chore: improve slow tests' (#5954) from gusted/improve-slow-test into forgejo
Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/5954
Reviewed-by: Earl Warren <earl-warren@noreply.codeberg.org>
+94
-113
+3
-4
tests/integration/actions_trigger_test.go
+3
-4
tests/integration/actions_trigger_test.go
···
302
302
},
303
303
} {
304
304
t.Run(testCase.onType, func(t *testing.T) {
305
+
defer tests.PrintCurrentTest(t)()
305
306
defer func() {
306
307
// cleanup leftovers, start from scratch
307
-
_, err = db.DeleteByBean(db.DefaultContext, actions_model.ActionRun{RepoID: baseRepo.ID})
308
-
require.NoError(t, err)
309
-
_, err = db.DeleteByBean(db.DefaultContext, actions_model.ActionRunJob{RepoID: baseRepo.ID})
310
-
require.NoError(t, err)
308
+
unittest.AssertSuccessfulDelete(t, &actions_model.ActionRun{RepoID: baseRepo.ID})
309
+
unittest.AssertSuccessfulDelete(t, &actions_model.ActionRunJob{RepoID: baseRepo.ID})
311
310
}()
312
311
313
312
// trigger the onType event
+2
tests/integration/cmd_admin_test.go
+2
tests/integration/cmd_admin_test.go
···
10
10
"code.gitea.io/gitea/models/db"
11
11
"code.gitea.io/gitea/models/unittest"
12
12
user_model "code.gitea.io/gitea/models/user"
13
+
"code.gitea.io/gitea/tests"
13
14
14
15
"github.com/stretchr/testify/assert"
15
16
"github.com/stretchr/testify/require"
···
44
45
},
45
46
} {
46
47
t.Run(testCase.name, func(t *testing.T) {
48
+
defer tests.PrintCurrentTest(t)()
47
49
name := "testuser"
48
50
49
51
options := []string{"user", "create", "--username", name, "--password", "password", "--email", name + "@example.com"}
+2
tests/integration/cmd_forgejo_actions_test.go
+2
tests/integration/cmd_forgejo_actions_test.go
···
15
15
repo_model "code.gitea.io/gitea/models/repo"
16
16
"code.gitea.io/gitea/models/unittest"
17
17
user_model "code.gitea.io/gitea/models/user"
18
+
"code.gitea.io/gitea/tests"
18
19
19
20
"github.com/stretchr/testify/assert"
20
21
"github.com/stretchr/testify/require"
···
67
68
},
68
69
} {
69
70
t.Run(testCase.testName, func(t *testing.T) {
71
+
defer tests.PrintCurrentTest(t)()
70
72
output, err := runMainApp("forgejo-cli", "actions", "register", "--secret", testCase.secret, "--scope", testCase.scope)
71
73
assert.EqualValues(t, "", output)
72
74
+3
-2
tests/integration/git_helper_for_declarative_test.go
+3
-2
tests/integration/git_helper_for_declarative_test.go
···
18
18
19
19
"code.gitea.io/gitea/modules/git"
20
20
"code.gitea.io/gitea/modules/setting"
21
-
"code.gitea.io/gitea/modules/ssh"
22
21
"code.gitea.io/gitea/modules/util"
23
22
"code.gitea.io/gitea/tests"
24
23
···
33
32
require.NoError(t, err)
34
33
35
34
keyFile := filepath.Join(tmpDir, keyname)
36
-
err = ssh.GenKeyPair(keyFile)
35
+
pubkey, privkey, err := util.GenerateSSHKeypair()
37
36
require.NoError(t, err)
37
+
require.NoError(t, os.WriteFile(keyFile, privkey, 0o600))
38
+
require.NoError(t, os.WriteFile(keyFile+".pub", pubkey, 0o600))
38
39
39
40
err = os.WriteFile(path.Join(tmpDir, "ssh"), []byte("#!/bin/bash\n"+
40
41
"ssh -o \"UserKnownHostsFile=/dev/null\" -o \"StrictHostKeyChecking=no\" -o \"IdentitiesOnly=yes\" -i \""+keyFile+"\" \"$@\""), 0o700)
+5
-3
tests/integration/git_push_test.go
+5
-3
tests/integration/git_push_test.go
···
19
19
repo_module "code.gitea.io/gitea/modules/repository"
20
20
"code.gitea.io/gitea/modules/test"
21
21
repo_service "code.gitea.io/gitea/services/repository"
22
+
"code.gitea.io/gitea/tests"
22
23
23
24
"github.com/stretchr/testify/assert"
24
25
"github.com/stretchr/testify/require"
···
40
41
forEachObjectFormat(t, func(t *testing.T, objectFormat git.ObjectFormat) {
41
42
t.Run("Push branches at once", func(t *testing.T) {
42
43
runTestGitPush(t, u, objectFormat, func(t *testing.T, gitPath string) (pushed, deleted []string) {
43
-
for i := 0; i < 100; i++ {
44
+
for i := 0; i < 10; i++ {
44
45
branchName := fmt.Sprintf("branch-%d", i)
45
46
pushed = append(pushed, branchName)
46
47
doGitCreateBranch(gitPath, branchName)(t)
···
88
89
89
90
t.Run("Push branches one by one", func(t *testing.T) {
90
91
runTestGitPush(t, u, objectFormat, func(t *testing.T, gitPath string) (pushed, deleted []string) {
91
-
for i := 0; i < 100; i++ {
92
+
for i := 0; i < 10; i++ {
92
93
branchName := fmt.Sprintf("branch-%d", i)
93
94
doGitCreateBranch(gitPath, branchName)(t)
94
95
doGitPushTestRepository(gitPath, "origin", branchName)(t)
···
103
104
doGitPushTestRepository(gitPath, "origin", "master")(t) // make sure master is the default branch instead of a branch we are going to delete
104
105
pushed = append(pushed, "master")
105
106
106
-
for i := 0; i < 100; i++ {
107
+
for i := 0; i < 10; i++ {
107
108
branchName := fmt.Sprintf("branch-%d", i)
108
109
pushed = append(pushed, branchName)
109
110
doGitCreateBranch(gitPath, branchName)(t)
···
139
140
}
140
141
141
142
func runTestGitPush(t *testing.T, u *url.URL, objectFormat git.ObjectFormat, gitOperation func(t *testing.T, gitPath string) (pushed, deleted []string)) {
143
+
defer tests.PrintCurrentTest(t, 1)()
142
144
user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
143
145
repo, err := repo_service.CreateRepository(db.DefaultContext, user, user, repo_service.CreateRepoOptions{
144
146
Name: "repo-to-push",
+28
-55
tests/integration/git_test.go
+28
-55
tests/integration/git_test.go
···
8
8
"crypto/rand"
9
9
"encoding/hex"
10
10
"fmt"
11
+
"io"
11
12
"net/http"
12
13
"net/url"
13
14
"os"
···
39
40
)
40
41
41
42
const (
42
-
littleSize = 1024 // 1ko
43
-
bigSize = 128 * 1024 * 1024 // 128Mo
43
+
littleSize = 1024 // 1KiB
44
+
bigSize = 32 * 1024 * 1024 // 32MiB
44
45
)
45
46
46
47
func TestGit(t *testing.T) {
···
299
300
require.NoError(t, err)
300
301
}
301
302
302
-
func doCommitAndPush(t *testing.T, size int, repoPath, prefix string) string {
303
-
name, err := generateCommitWithNewData(size, repoPath, "user2@example.com", "User Two", prefix)
304
-
require.NoError(t, err)
305
-
_, _, err = git.NewCommand(git.DefaultContext, "push", "origin", "master").RunStdString(&git.RunOpts{Dir: repoPath}) // Push
303
+
func doCommitAndPush(t *testing.T, size int64, repoPath, prefix string) string {
304
+
name := generateCommitWithNewData(t, size, repoPath, "user2@example.com", "User Two", prefix)
305
+
_, _, err := git.NewCommand(git.DefaultContext, "push", "origin", "master").RunStdString(&git.RunOpts{Dir: repoPath}) // Push
306
306
require.NoError(t, err)
307
307
return name
308
308
}
309
309
310
-
func generateCommitWithNewData(size int, repoPath, email, fullName, prefix string) (string, error) {
311
-
// Generate random file
312
-
bufSize := 4 * 1024
313
-
if bufSize > size {
314
-
bufSize = size
315
-
}
316
-
317
-
buffer := make([]byte, bufSize)
318
-
310
+
func generateCommitWithNewData(t *testing.T, size int64, repoPath, email, fullName, prefix string) string {
311
+
t.Helper()
319
312
tmpFile, err := os.CreateTemp(repoPath, prefix)
320
-
if err != nil {
321
-
return "", err
322
-
}
313
+
require.NoError(t, err)
323
314
defer tmpFile.Close()
324
-
written := 0
325
-
for written < size {
326
-
n := size - written
327
-
if n > bufSize {
328
-
n = bufSize
329
-
}
330
-
_, err := rand.Read(buffer[:n])
331
-
if err != nil {
332
-
return "", err
333
-
}
334
-
n, err = tmpFile.Write(buffer[:n])
335
-
if err != nil {
336
-
return "", err
337
-
}
338
-
written += n
339
-
}
315
+
_, err = io.CopyN(tmpFile, rand.Reader, size)
316
+
require.NoError(t, err)
340
317
341
318
// Commit
342
319
// Now here we should explicitly allow lfs filters to run
343
320
globalArgs := git.AllowLFSFiltersArgs()
344
-
err = git.AddChangesWithArgs(repoPath, globalArgs, false, filepath.Base(tmpFile.Name()))
345
-
if err != nil {
346
-
return "", err
347
-
}
348
-
err = git.CommitChangesWithArgs(repoPath, globalArgs, git.CommitChangesOptions{
321
+
require.NoError(t, git.AddChangesWithArgs(repoPath, globalArgs, false, filepath.Base(tmpFile.Name())))
322
+
require.NoError(t, git.CommitChangesWithArgs(repoPath, globalArgs, git.CommitChangesOptions{
349
323
Committer: &git.Signature{
350
324
Email: email,
351
325
Name: fullName,
···
357
331
When: time.Now(),
358
332
},
359
333
Message: fmt.Sprintf("Testing commit @ %v", time.Now()),
360
-
})
361
-
return filepath.Base(tmpFile.Name()), err
334
+
}))
335
+
return filepath.Base(tmpFile.Name())
362
336
}
363
337
364
338
func doBranchProtect(baseCtx *APITestContext, dstPath string) func(t *testing.T) {
···
370
344
ctx := NewAPITestContext(t, baseCtx.Username, baseCtx.Reponame, auth_model.AccessTokenScopeWriteRepository)
371
345
372
346
t.Run("PushToNewProtectedBranch", func(t *testing.T) {
347
+
defer tests.PrintCurrentTest(t)()
373
348
t.Run("CreateBranchProtected", doGitCreateBranch(dstPath, "before-create-1"))
374
349
t.Run("ProtectProtectedBranch", doProtectBranch(ctx, "before-create-1", parameterProtectBranch{
375
350
"enable_push": "all",
···
378
353
t.Run("PushProtectedBranch", doGitPushTestRepository(dstPath, "origin", "before-create-1"))
379
354
380
355
t.Run("GenerateCommit", func(t *testing.T) {
381
-
_, err := generateCommitWithNewData(littleSize, dstPath, "user2@example.com", "User Two", "protected-file-data-")
382
-
require.NoError(t, err)
356
+
generateCommitWithNewData(t, littleSize, dstPath, "user2@example.com", "User Two", "protected-file-data-")
383
357
})
384
358
385
359
t.Run("ProtectProtectedBranch", doProtectBranch(ctx, "before-create-2", parameterProtectBranch{
···
392
366
})
393
367
394
368
t.Run("FailToPushToProtectedBranch", func(t *testing.T) {
369
+
defer tests.PrintCurrentTest(t)()
395
370
t.Run("ProtectProtectedBranch", doProtectBranch(ctx, "protected"))
396
371
t.Run("Create modified-protected-branch", doGitCheckoutBranch(dstPath, "-b", "modified-protected-branch", "protected"))
397
372
t.Run("GenerateCommit", func(t *testing.T) {
398
-
_, err := generateCommitWithNewData(littleSize, dstPath, "user2@example.com", "User Two", "branch-data-file-")
399
-
require.NoError(t, err)
373
+
generateCommitWithNewData(t, littleSize, dstPath, "user2@example.com", "User Two", "branch-data-file-")
400
374
})
401
375
402
376
doGitPushTestRepositoryFail(dstPath, "origin", "modified-protected-branch:protected")(t)
···
405
379
t.Run("PushToUnprotectedBranch", doGitPushTestRepository(dstPath, "origin", "modified-protected-branch:unprotected"))
406
380
407
381
t.Run("FailToPushProtectedFilesToProtectedBranch", func(t *testing.T) {
382
+
defer tests.PrintCurrentTest(t)()
408
383
t.Run("Create modified-protected-file-protected-branch", doGitCheckoutBranch(dstPath, "-b", "modified-protected-file-protected-branch", "protected"))
409
384
t.Run("GenerateCommit", func(t *testing.T) {
410
-
_, err := generateCommitWithNewData(littleSize, dstPath, "user2@example.com", "User Two", "protected-file-")
411
-
require.NoError(t, err)
385
+
generateCommitWithNewData(t, littleSize, dstPath, "user2@example.com", "User Two", "protected-file-")
412
386
})
413
387
414
388
t.Run("ProtectedFilePathsApplyToAdmins", doProtectBranch(ctx, "protected"))
···
419
393
})
420
394
421
395
t.Run("PushUnprotectedFilesToProtectedBranch", func(t *testing.T) {
396
+
defer tests.PrintCurrentTest(t)()
422
397
t.Run("Create modified-unprotected-file-protected-branch", doGitCheckoutBranch(dstPath, "-b", "modified-unprotected-file-protected-branch", "protected"))
423
398
t.Run("UnprotectedFilePaths", doProtectBranch(ctx, "protected", parameterProtectBranch{
424
399
"unprotected_file_patterns": "unprotected-file-*",
425
400
}))
426
401
t.Run("GenerateCommit", func(t *testing.T) {
427
-
_, err := generateCommitWithNewData(littleSize, dstPath, "user2@example.com", "User Two", "unprotected-file-")
428
-
require.NoError(t, err)
402
+
generateCommitWithNewData(t, littleSize, dstPath, "user2@example.com", "User Two", "unprotected-file-")
429
403
})
430
404
doGitPushTestRepository(dstPath, "origin", "modified-unprotected-file-protected-branch:protected")(t)
431
405
doGitCheckoutBranch(dstPath, "protected")(t)
···
441
415
}))
442
416
443
417
t.Run("WhitelistedUserFailToForcePushToProtectedBranch", func(t *testing.T) {
418
+
defer tests.PrintCurrentTest(t)()
444
419
t.Run("Create toforce", doGitCheckoutBranch(dstPath, "-b", "toforce", "master"))
445
420
t.Run("GenerateCommit", func(t *testing.T) {
446
-
_, err := generateCommitWithNewData(littleSize, dstPath, "user2@example.com", "User Two", "branch-data-file-")
447
-
require.NoError(t, err)
421
+
generateCommitWithNewData(t, littleSize, dstPath, "user2@example.com", "User Two", "branch-data-file-")
448
422
})
449
423
doGitPushTestRepositoryFail(dstPath, "-f", "origin", "toforce:protected")(t)
450
424
})
451
425
452
426
t.Run("WhitelistedUserPushToProtectedBranch", func(t *testing.T) {
427
+
defer tests.PrintCurrentTest(t)()
453
428
t.Run("Create topush", doGitCheckoutBranch(dstPath, "-b", "topush", "protected"))
454
429
t.Run("GenerateCommit", func(t *testing.T) {
455
-
_, err := generateCommitWithNewData(littleSize, dstPath, "user2@example.com", "User Two", "branch-data-file-")
456
-
require.NoError(t, err)
430
+
generateCommitWithNewData(t, littleSize, dstPath, "user2@example.com", "User Two", "branch-data-file-")
457
431
})
458
432
doGitPushTestRepository(dstPath, "origin", "topush:protected")(t)
459
433
})
···
693
667
t.Run("CheckoutProtected", doGitCheckoutBranch(dstPath, "protected"))
694
668
t.Run("PullProtected", doGitPull(dstPath, "origin", "protected"))
695
669
t.Run("GenerateCommit", func(t *testing.T) {
696
-
_, err := generateCommitWithNewData(littleSize, dstPath, "user2@example.com", "User Two", "branch-data-file-")
697
-
require.NoError(t, err)
670
+
generateCommitWithNewData(t, littleSize, dstPath, "user2@example.com", "User Two", "branch-data-file-")
698
671
})
699
672
t.Run("PushToUnprotectedBranch", doGitPushTestRepository(dstPath, "origin", "protected:unprotected3"))
700
673
var pr api.PullRequest
+37
-47
tests/integration/migrate_test.go
+37
-47
tests/integration/migrate_test.go
···
5
5
package integration
6
6
7
7
import (
8
-
"context"
9
8
"fmt"
10
9
"net/http"
11
10
"net/url"
···
21
20
user_model "code.gitea.io/gitea/models/user"
22
21
"code.gitea.io/gitea/modules/setting"
23
22
"code.gitea.io/gitea/modules/structs"
23
+
"code.gitea.io/gitea/modules/test"
24
24
"code.gitea.io/gitea/modules/translation"
25
25
"code.gitea.io/gitea/services/migrations"
26
-
"code.gitea.io/gitea/services/repository"
26
+
"code.gitea.io/gitea/tests"
27
27
28
28
"github.com/stretchr/testify/assert"
29
29
"github.com/stretchr/testify/require"
···
58
58
59
59
func TestMigrate(t *testing.T) {
60
60
onGiteaRun(t, func(t *testing.T, u *url.URL) {
61
-
AllowLocalNetworks := setting.Migrations.AllowLocalNetworks
62
-
setting.Migrations.AllowLocalNetworks = true
63
-
AppVer := setting.AppVer
64
-
// Gitea SDK (go-sdk) need to parse the AppVer from server response, so we must set it to a valid version string.
65
-
setting.AppVer = "1.16.0"
66
-
defer func() {
67
-
setting.Migrations.AllowLocalNetworks = AllowLocalNetworks
68
-
setting.AppVer = AppVer
69
-
migrations.Init()
70
-
}()
61
+
defer test.MockVariableValue(&setting.Migrations.AllowLocalNetworks, true)()
62
+
defer test.MockVariableValue(&setting.AppVer, "1.16.0")()
71
63
require.NoError(t, migrations.Init())
72
64
73
65
ownerName := "user2"
···
82
74
{svc: structs.GiteaService},
83
75
{svc: structs.ForgejoService},
84
76
} {
85
-
// Step 0: verify the repo is available
86
-
req := NewRequestf(t, "GET", "/%s/%s", ownerName, repoName)
87
-
_ = session.MakeRequest(t, req, http.StatusOK)
88
-
// Step 1: get the Gitea migration form
89
-
req = NewRequestf(t, "GET", "/repo/migrate/?service_type=%d", s.svc)
90
-
resp := session.MakeRequest(t, req, http.StatusOK)
91
-
// Step 2: load the form
92
-
htmlDoc := NewHTMLParser(t, resp.Body)
93
-
// Check form title
94
-
title := htmlDoc.doc.Find("title").Text()
95
-
assert.Contains(t, title, translation.NewLocale("en-US").TrString("new_migrate.title"))
96
-
// Get the link of migration button
97
-
link, exists := htmlDoc.doc.Find(`form.ui.form[action^="/repo/migrate"]`).Attr("action")
98
-
assert.True(t, exists, "The template has changed")
99
-
// Step 4: submit the migration to only migrate issues
100
-
migratedRepoName := "otherrepo"
101
-
req = NewRequestWithValues(t, "POST", link, map[string]string{
102
-
"_csrf": htmlDoc.GetCSRF(),
103
-
"service": fmt.Sprintf("%d", s.svc),
104
-
"clone_addr": fmt.Sprintf("%s%s/%s", u, ownerName, repoName),
105
-
"auth_token": token,
106
-
"issues": "on",
107
-
"repo_name": migratedRepoName,
108
-
"description": "",
109
-
"uid": fmt.Sprintf("%d", repoOwner.ID),
77
+
t.Run(s.svc.Name(), func(t *testing.T) {
78
+
defer tests.PrintCurrentTest(t)()
79
+
// Step 0: verify the repo is available
80
+
req := NewRequestf(t, "GET", "/%s/%s", ownerName, repoName)
81
+
_ = session.MakeRequest(t, req, http.StatusOK)
82
+
// Step 1: get the Gitea migration form
83
+
req = NewRequestf(t, "GET", "/repo/migrate/?service_type=%d", s.svc)
84
+
resp := session.MakeRequest(t, req, http.StatusOK)
85
+
// Step 2: load the form
86
+
htmlDoc := NewHTMLParser(t, resp.Body)
87
+
// Check form title
88
+
title := htmlDoc.doc.Find("title").Text()
89
+
assert.Contains(t, title, translation.NewLocale("en-US").TrString("new_migrate.title"))
90
+
// Get the link of migration button
91
+
link, exists := htmlDoc.doc.Find(`form.ui.form[action^="/repo/migrate"]`).Attr("action")
92
+
assert.True(t, exists, "The template has changed")
93
+
// Step 4: submit the migration to only migrate issues
94
+
migratedRepoName := "otherrepo-" + s.svc.Name()
95
+
req = NewRequestWithValues(t, "POST", link, map[string]string{
96
+
"_csrf": htmlDoc.GetCSRF(),
97
+
"service": fmt.Sprintf("%d", s.svc),
98
+
"clone_addr": fmt.Sprintf("%s%s/%s", u, ownerName, repoName),
99
+
"auth_token": token,
100
+
"issues": "on",
101
+
"repo_name": migratedRepoName,
102
+
"description": "",
103
+
"uid": fmt.Sprintf("%d", repoOwner.ID),
104
+
})
105
+
resp = session.MakeRequest(t, req, http.StatusSeeOther)
106
+
// Step 5: a redirection displays the migrated repository
107
+
assert.EqualValues(t, fmt.Sprintf("/%s/%s", ownerName, migratedRepoName), test.RedirectURL(resp))
108
+
// Step 6: check the repo was created
109
+
unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{Name: migratedRepoName})
110
110
})
111
-
resp = session.MakeRequest(t, req, http.StatusSeeOther)
112
-
// Step 5: a redirection displays the migrated repository
113
-
loc := resp.Header().Get("Location")
114
-
assert.EqualValues(t, fmt.Sprintf("/%s/%s", ownerName, migratedRepoName), loc)
115
-
// Step 6: check the repo was created
116
-
repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{Name: migratedRepoName})
117
-
118
-
// Step 7: delete the repository, so we can test with other services
119
-
err := repository.DeleteRepository(context.Background(), repoOwner, repo, false)
120
-
require.NoError(t, err)
121
111
}
122
112
})
123
113
}
+3
-2
tests/integration/pull_merge_test.go
+3
-2
tests/integration/pull_merge_test.go
···
822
822
}
823
823
for _, withAPIOrWeb := range []string{"api", "web"} {
824
824
t.Run(testCase.name+" "+withAPIOrWeb, func(t *testing.T) {
825
+
defer tests.PrintCurrentTest(t)()
825
826
branch := testCase.name + "-" + withAPIOrWeb
826
827
unprotected := branch + "-unprotected"
827
828
doGitCheckoutBranch(dstPath, "master")(t)
···
834
835
ctx = NewAPITestContext(t, testCase.doer, "not used", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
835
836
ctx.Username = owner
836
837
ctx.Reponame = repo
837
-
_, err := generateCommitWithNewData(littleSize, dstPath, "user2@example.com", "User Two", testCase.filename)
838
-
require.NoError(t, err)
838
+
generateCommitWithNewData(t, littleSize, dstPath, "user2@example.com", "User Two", testCase.filename)
839
839
doGitPushTestRepository(dstPath, "origin", branch+":"+unprotected)(t)
840
840
pr, err := doAPICreatePullRequest(ctx, owner, repo, branch, unprotected)(t)
841
841
require.NoError(t, err)
···
1015
1015
// perform all tests with API and web routes
1016
1016
for _, withAPI := range []bool{false, true} {
1017
1017
t.Run(testCase.name, func(t *testing.T) {
1018
+
defer tests.PrintCurrentTest(t)()
1018
1019
protectedBranch := parameterProtectBranch{
1019
1020
"enable_push": "true",
1020
1021
"enable_status_check": "true",
+1
tests/integration/repo_webhook_test.go
+1
tests/integration/repo_webhook_test.go
···
316
316
317
317
func testWebhookForms(name string, session *TestSession, validFields map[string]string, invalidPatches ...map[string]string) func(t *testing.T) {
318
318
return func(t *testing.T) {
319
+
defer tests.PrintCurrentTest(t)()
319
320
t.Run("repo1", func(t *testing.T) {
320
321
testWebhookFormsShared(t, "/user2/repo1/settings/hooks", name, session, validFields, invalidPatches...)
321
322
})
+1
tests/integration/user_count_test.go
+1
tests/integration/user_count_test.go
+3
tests/mysql.ini.tmpl
+3
tests/mysql.ini.tmpl
+3
tests/pgsql.ini.tmpl
+3
tests/pgsql.ini.tmpl