]> source.dussan.org Git - gitea.git/commitdiff
Fix Benchmark tests, remove a broken one & add two new (#15250)
author6543 <6543@obermui.de>
Fri, 16 Apr 2021 18:30:16 +0000 (20:30 +0200)
committerGitHub <noreply@github.com>
Fri, 16 Apr 2021 18:30:16 +0000 (20:30 +0200)
* Benchmark Integration TESTS

* CI: add benching-arm64 pipeline

* BenchmarkRepo: name test case tests

* Fix BenchmarkRepoBranchCommit beside Create new Branch

* CI: benching use amd64

* rm total broken "BenchmarkRepo"

* dont run benchmark in CI

.gitignore
integrations/api_branch_test.go
integrations/api_repo_file_create_test.go
integrations/api_repo_file_helpers.go
integrations/benchmarks_test.go
integrations/git_helper_for_declarative_test.go

index 22f50057248406804b38d247edef56b443bc45d5..38b107a6540037ceda6e8c1e89032df248c1420b 100644 (file)
@@ -32,6 +32,7 @@ _testmain.go
 
 *coverage.out
 coverage.all
+cpu.out
 
 /modules/options/bindata.go
 /modules/options/bindata.go.hash
index 26d8fb4b451f9088227b8ec9b27f1b17816211be..d898266afee4e973ae70bda2e15c25b564f51262 100644 (file)
@@ -151,22 +151,28 @@ func testAPICreateBranches(t *testing.T, giteaURL *url.URL) {
        for _, test := range tests {
                defer resetFixtures(t)
                session := ctx.Session
-               token := getTokenForLoggedInUser(t, session)
-               req := NewRequestWithJSON(t, "POST", "/api/v1/repos/user2/my-noo-repo/branches?token="+token, &api.CreateBranchRepoOption{
-                       BranchName:    test.NewBranch,
-                       OldBranchName: test.OldBranch,
-               })
-               resp := session.MakeRequest(t, req, test.ExpectedHTTPStatus)
-
-               var branch api.Branch
-               DecodeJSON(t, resp, &branch)
-
-               if test.ExpectedHTTPStatus == http.StatusCreated {
-                       assert.EqualValues(t, test.NewBranch, branch.Name)
-               }
+               testAPICreateBranch(t, session, "user2", "my-noo-repo", test.OldBranch, test.NewBranch, test.ExpectedHTTPStatus)
        }
 }
 
+func testAPICreateBranch(t testing.TB, session *TestSession, user, repo, oldBranch, newBranch string, status int) bool {
+       token := getTokenForLoggedInUser(t, session)
+       req := NewRequestWithJSON(t, "POST", "/api/v1/repos/"+user+"/"+repo+"/branches?token="+token, &api.CreateBranchRepoOption{
+               BranchName:    newBranch,
+               OldBranchName: oldBranch,
+       })
+       resp := session.MakeRequest(t, req, status)
+
+       var branch api.Branch
+       DecodeJSON(t, resp, &branch)
+
+       if status == http.StatusCreated {
+               assert.EqualValues(t, newBranch, branch.Name)
+       }
+
+       return resp.Result().StatusCode == status
+}
+
 func TestAPIBranchProtection(t *testing.T) {
        defer prepareTestEnv(t)()
 
index 853224f09199b9c091ad8fbca8639993ea51a18d..17ed6cb7cf4a40b71c454e1a45f0e493e3fda3ec 100644 (file)
@@ -105,6 +105,36 @@ func getExpectedFileResponseForCreate(commitID, treePath string) *api.FileRespon
        }
 }
 
+func BenchmarkAPICreateFileSmall(b *testing.B) {
+       onGiteaRunTB(b, func(t testing.TB, u *url.URL) {
+               b := t.(*testing.B)
+               user2 := models.AssertExistsAndLoadBean(t, &models.User{ID: 2}).(*models.User)             // owner of the repo1 & repo16
+               repo1 := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 1}).(*models.Repository) // public repo
+
+               for n := 0; n < b.N; n++ {
+                       treePath := fmt.Sprintf("update/file%d.txt", n)
+                       createFileInBranch(user2, repo1, treePath, repo1.DefaultBranch, treePath)
+               }
+       })
+}
+
+func BenchmarkAPICreateFileMedium(b *testing.B) {
+       data := make([]byte, 10*1024*1024)
+
+       onGiteaRunTB(b, func(t testing.TB, u *url.URL) {
+               b := t.(*testing.B)
+               user2 := models.AssertExistsAndLoadBean(t, &models.User{ID: 2}).(*models.User)             // owner of the repo1 & repo16
+               repo1 := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 1}).(*models.Repository) // public repo
+
+               b.ResetTimer()
+               for n := 0; n < b.N; n++ {
+                       treePath := fmt.Sprintf("update/file%d.txt", n)
+                       copy(data, treePath)
+                       createFileInBranch(user2, repo1, treePath, repo1.DefaultBranch, treePath)
+               }
+       })
+}
+
 func TestAPICreateFile(t *testing.T) {
        onGiteaRun(t, func(t *testing.T, u *url.URL) {
                user2 := models.AssertExistsAndLoadBean(t, &models.User{ID: 2}).(*models.User)               // owner of the repo1 & repo16
index 80fefe8ab3737d0edd8c23bf0ebfb119aaeb48a7..1dba136de959a81d2a2d99d0705b23326306463b 100644 (file)
@@ -10,11 +10,11 @@ import (
        api "code.gitea.io/gitea/modules/structs"
 )
 
-func createFileInBranch(user *models.User, repo *models.Repository, treePath, branchName string) (*api.FileResponse, error) {
+func createFileInBranch(user *models.User, repo *models.Repository, treePath, branchName, content string) (*api.FileResponse, error) {
        opts := &repofiles.UpdateRepoFileOptions{
                OldBranch: branchName,
                TreePath:  treePath,
-               Content:   "This is a NEW file",
+               Content:   content,
                IsNewFile: true,
                Author:    nil,
                Committer: nil,
@@ -23,5 +23,5 @@ func createFileInBranch(user *models.User, repo *models.Repository, treePath, br
 }
 
 func createFile(user *models.User, repo *models.Repository, treePath string) (*api.FileResponse, error) {
-       return createFileInBranch(user, repo, treePath, repo.DefaultBranch)
+       return createFileInBranch(user, repo, treePath, repo.DefaultBranch, "This is a NEW file")
 }
index 7c7aff994e491a348a5ba01937b583099707b358..841ecbf7eee39c9b58ecaf7e85e964b7edd68d28 100644 (file)
@@ -7,64 +7,14 @@ package integrations
 import (
        "math/rand"
        "net/http"
+       "net/url"
        "testing"
 
        "code.gitea.io/gitea/models"
        api "code.gitea.io/gitea/modules/structs"
 )
 
-func BenchmarkRepo(b *testing.B) {
-       samples := []struct {
-               url       string
-               name      string
-               skipShort bool
-       }{
-               {url: "https://github.com/go-gitea/gitea.git", name: "gitea"},
-               {url: "https://github.com/ethantkoenig/manyfiles.git", name: "manyfiles"},
-               {url: "https://github.com/moby/moby.git", name: "moby", skipShort: true},
-               {url: "https://github.com/golang/go.git", name: "go", skipShort: true},
-               {url: "https://github.com/torvalds/linux.git", name: "linux", skipShort: true},
-       }
-       defer prepareTestEnv(b)()
-       session := loginUser(b, "user2")
-       b.ResetTimer()
-
-       for _, s := range samples {
-               b.Run(s.name, func(b *testing.B) {
-                       if testing.Short() && s.skipShort {
-                               b.Skip("skipping test in short mode.")
-                       }
-                       b.Run("Migrate", func(b *testing.B) {
-                               for i := 0; i < b.N; i++ {
-                                       testRepoMigrate(b, session, s.url, s.name)
-                               }
-                       })
-                       b.Run("Access", func(b *testing.B) {
-                               var branches []*api.Branch
-                               b.Run("APIBranchList", func(b *testing.B) {
-                                       for i := 0; i < b.N; i++ {
-                                               req := NewRequestf(b, "GET", "/api/v1/repos/%s/%s/branches", "user2", s.name)
-                                               resp := session.MakeRequest(b, req, http.StatusOK)
-                                               b.StopTimer()
-                                               if len(branches) == 0 {
-                                                       DecodeJSON(b, resp, &branches) //Store for next phase
-                                               }
-                                               b.StartTimer()
-                                       }
-                               })
-                               branchCount := len(branches)
-                               b.Run("WebViewCommit", func(b *testing.B) {
-                                       for i := 0; i < b.N; i++ {
-                                               req := NewRequestf(b, "GET", "/%s/%s/commit/%s", "user2", s.name, branches[i%branchCount].Commit.ID)
-                                               session.MakeRequest(b, req, http.StatusOK)
-                                       }
-                               })
-                       })
-               })
-       }
-}
-
-//StringWithCharset random string (from https://www.calhoun.io/creating-random-strings-in-go/)
+// StringWithCharset random string (from https://www.calhoun.io/creating-random-strings-in-go/)
 func StringWithCharset(length int, charset string) string {
        b := make([]byte, length)
        for i := range b {
@@ -74,40 +24,48 @@ func StringWithCharset(length int, charset string) string {
 }
 
 func BenchmarkRepoBranchCommit(b *testing.B) {
-       samples := []int64{1, 3, 15, 16}
-       defer prepareTestEnv(b)()
-       b.ResetTimer()
+       onGiteaRunTB(b, func(t testing.TB, u *url.URL) {
+               b := t.(*testing.B)
+
+               samples := []int64{1, 2, 3}
+               b.ResetTimer()
 
-       for _, repoID := range samples {
-               b.StopTimer()
-               repo := models.AssertExistsAndLoadBean(b, &models.Repository{ID: repoID}).(*models.Repository)
-               b.StartTimer()
-               b.Run(repo.Name, func(b *testing.B) {
-                       owner := models.AssertExistsAndLoadBean(b, &models.User{ID: repo.OwnerID}).(*models.User)
-                       session := loginUser(b, owner.LoginName)
-                       b.ResetTimer()
-                       b.Run("Create", func(b *testing.B) {
-                               for i := 0; i < b.N; i++ {
+               for _, repoID := range samples {
+                       b.StopTimer()
+                       repo := models.AssertExistsAndLoadBean(b, &models.Repository{ID: repoID}).(*models.Repository)
+                       b.StartTimer()
+                       b.Run(repo.Name, func(b *testing.B) {
+                               session := loginUser(b, "user2")
+                               b.ResetTimer()
+                               b.Run("CreateBranch", func(b *testing.B) {
                                        b.StopTimer()
                                        branchName := StringWithCharset(5+rand.Intn(10), "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
                                        b.StartTimer()
-                                       testCreateBranch(b, session, owner.LoginName, repo.Name, "branch/master", branchName, http.StatusFound)
-                               }
-                       })
-                       b.Run("Access", func(b *testing.B) {
-                               var branches []*api.Branch
-                               req := NewRequestf(b, "GET", "/api/v1/%s/branches", repo.FullName())
-                               resp := session.MakeRequest(b, req, http.StatusOK)
-                               DecodeJSON(b, resp, &branches)
-                               branchCount := len(branches)
-                               b.ResetTimer() //We measure from here
-                               for i := 0; i < b.N; i++ {
-                                       req := NewRequestf(b, "GET", "/%s/%s/commits/%s", owner.Name, repo.Name, branches[i%branchCount].Name)
+                                       for i := 0; i < b.N; i++ {
+                                               b.Run("new_"+branchName, func(b *testing.B) {
+                                                       b.Skip("benchmark broken") // TODO fix
+                                                       testAPICreateBranch(b, session, repo.OwnerName, repo.Name, repo.DefaultBranch, "new_"+branchName, http.StatusCreated)
+                                               })
+                                       }
+                               })
+                               b.Run("GetBranches", func(b *testing.B) {
+                                       req := NewRequestf(b, "GET", "/api/v1/repos/%s/branches", repo.FullName())
                                        session.MakeRequest(b, req, http.StatusOK)
-                               }
+                               })
+                               b.Run("AccessCommits", func(b *testing.B) {
+                                       var branches []*api.Branch
+                                       req := NewRequestf(b, "GET", "/api/v1/repos/%s/branches", repo.FullName())
+                                       resp := session.MakeRequest(b, req, http.StatusOK)
+                                       DecodeJSON(b, resp, &branches)
+                                       b.ResetTimer() //We measure from here
+                                       if len(branches) != 0 {
+                                               for i := 0; i < b.N; i++ {
+                                                       req := NewRequestf(b, "GET", "/api/v1/repos/%s/commits?sha=%s", repo.FullName(), branches[i%len(branches)].Name)
+                                                       session.MakeRequest(b, req, http.StatusOK)
+                                               }
+                                       }
+                               })
                        })
-               })
-       }
+               }
+       })
 }
-
-//TODO list commits /repos/{owner}/{repo}/commits
index d99d80a7c706b95d2737c98ece36048d0ac1b6cb..5a5b1314c64dd01bf713196337de7814bf2e1e47 100644 (file)
@@ -76,7 +76,7 @@ func allowLFSFilters() []string {
        return filteredLFSGlobalArgs[:j]
 }
 
-func onGiteaRun(t *testing.T, callback func(*testing.T, *url.URL), prepare ...bool) {
+func onGiteaRunTB(t testing.TB, callback func(testing.TB, *url.URL), prepare ...bool) {
        if len(prepare) == 0 || prepare[0] {
                defer prepareTestEnv(t, 1)()
        }
@@ -108,6 +108,12 @@ func onGiteaRun(t *testing.T, callback func(*testing.T, *url.URL), prepare ...bo
        callback(t, u)
 }
 
+func onGiteaRun(t *testing.T, callback func(*testing.T, *url.URL), prepare ...bool) {
+       onGiteaRunTB(t, func(t testing.TB, u *url.URL) {
+               callback(t.(*testing.T), u)
+       }, prepare...)
+}
+
 func doGitClone(dstLocalPath string, u *url.URL) func(*testing.T) {
        return func(t *testing.T) {
                assert.NoError(t, git.CloneWithArgs(context.Background(), u.String(), dstLocalPath, allowLFSFilters(), git.CloneRepoOptions{}))