diff --git a/integrations/api_repo_test.go b/integrations/api_repo_test.go
index 8e383dbda..c536b8d32 100644
--- a/integrations/api_repo_test.go
+++ b/integrations/api_repo_test.go
@@ -5,6 +5,7 @@
package integrations
import (
+ "fmt"
"net/http"
"testing"
@@ -32,7 +33,7 @@ func TestAPIUserReposNotLogin(t *testing.T) {
}
}
-func TestAPISearchRepoNotLogin(t *testing.T) {
+func TestAPISearchRepo(t *testing.T) {
prepareTestEnv(t)
const keyword = "test"
@@ -46,6 +47,102 @@ func TestAPISearchRepoNotLogin(t *testing.T) {
assert.Contains(t, repo.Name, keyword)
assert.False(t, repo.Private)
}
+
+ user := models.AssertExistsAndLoadBean(t, &models.User{ID: 15}).(*models.User)
+ user2 := models.AssertExistsAndLoadBean(t, &models.User{ID: 16}).(*models.User)
+ orgUser := models.AssertExistsAndLoadBean(t, &models.User{ID: 17}).(*models.User)
+
+ // Map of expected results, where key is user for login
+ type expectedResults map[*models.User]struct {
+ count int
+ repoOwnerID int64
+ repoName string
+ includesPrivate bool
+ }
+
+ testCases := []struct {
+ name, requestURL string
+ expectedResults
+ }{
+ {name: "RepositoriesMax50", requestURL: "/api/v1/repos/search?limit=50", expectedResults: expectedResults{
+ nil: {count: 12},
+ user: {count: 12},
+ user2: {count: 12}},
+ },
+ {name: "RepositoriesMax10", requestURL: "/api/v1/repos/search?limit=10", expectedResults: expectedResults{
+ nil: {count: 10},
+ user: {count: 10},
+ user2: {count: 10}},
+ },
+ {name: "RepositoriesDefaultMax10", requestURL: "/api/v1/repos/search", expectedResults: expectedResults{
+ nil: {count: 10},
+ user: {count: 10},
+ user2: {count: 10}},
+ },
+ {name: "RepositoriesByName", requestURL: fmt.Sprintf("/api/v1/repos/search?q=%s", "big_test_"), expectedResults: expectedResults{
+ nil: {count: 4, repoName: "big_test_"},
+ user: {count: 4, repoName: "big_test_"},
+ user2: {count: 4, repoName: "big_test_"}},
+ },
+ {name: "RepositoriesAccessibleAndRelatedToUser", requestURL: fmt.Sprintf("/api/v1/repos/search?uid=%d", user.ID), expectedResults: expectedResults{
+ // FIXME: Should return 4 (all public repositories related to "another" user = owned + collaborative), now returns only public repositories directly owned by user
+ nil: {count: 2},
+ user: {count: 8, includesPrivate: true},
+ // FIXME: Should return 4 (all public repositories related to "another" user = owned + collaborative), now returns only public repositories directly owned by user
+ user2: {count: 2}},
+ },
+ {name: "RepositoriesAccessibleAndRelatedToUser2", requestURL: fmt.Sprintf("/api/v1/repos/search?uid=%d", user2.ID), expectedResults: expectedResults{
+ nil: {count: 1},
+ user: {count: 1},
+ user2: {count: 2, includesPrivate: true}},
+ },
+ {name: "RepositoriesOwnedByOrganization", requestURL: fmt.Sprintf("/api/v1/repos/search?uid=%d", orgUser.ID), expectedResults: expectedResults{
+ nil: {count: 1, repoOwnerID: orgUser.ID},
+ user: {count: 2, repoOwnerID: orgUser.ID, includesPrivate: true},
+ user2: {count: 1, repoOwnerID: orgUser.ID}},
+ },
+ }
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ for userToLogin, expected := range testCase.expectedResults {
+ var session *TestSession
+ var testName string
+ if userToLogin != nil && userToLogin.ID > 0 {
+ testName = fmt.Sprintf("LoggedUser%d", userToLogin.ID)
+ session = loginUser(t, userToLogin.Name)
+ } else {
+ testName = "AnonymousUser"
+ session = emptyTestSession(t)
+ }
+
+ t.Run(testName, func(t *testing.T) {
+ request := NewRequest(t, "GET", testCase.requestURL)
+ response := session.MakeRequest(t, request, http.StatusOK)
+
+ var body api.SearchResults
+ DecodeJSON(t, response, &body)
+
+ assert.Len(t, body.Data, expected.count)
+ for _, repo := range body.Data {
+ assert.NotEmpty(t, repo.Name)
+
+ if len(expected.repoName) > 0 {
+ assert.Contains(t, repo.Name, expected.repoName)
+ }
+
+ if expected.repoOwnerID > 0 {
+ assert.Equal(t, expected.repoOwnerID, repo.Owner.ID)
+ }
+
+ if !expected.includesPrivate {
+ assert.False(t, repo.Private)
+ }
+ }
+ })
+ }
+ })
+ }
}
func TestAPIViewRepo(t *testing.T) {
diff --git a/models/repo_list_test.go b/models/repo_list_test.go
index 8ac0d8048..6f829f279 100644
--- a/models/repo_list_test.go
+++ b/models/repo_list_test.go
@@ -18,10 +18,8 @@ func TestSearchRepositoryByName(t *testing.T) {
Keyword: "repo_12",
Page: 1,
PageSize: 10,
- Searcher: nil,
})
- assert.NotNil(t, repos)
assert.NoError(t, err)
if assert.Len(t, repos, 1) {
assert.Equal(t, "test_repo_12", repos[0].Name)
@@ -32,12 +30,11 @@ func TestSearchRepositoryByName(t *testing.T) {
Keyword: "test_repo",
Page: 1,
PageSize: 10,
- Searcher: nil,
})
- assert.NotNil(t, repos)
assert.NoError(t, err)
assert.Equal(t, int64(2), count)
+ assert.Len(t, repos, 2)
// test search private repository on explore page
repos, count, err = SearchRepositoryByName(&SearchRepoOptions{
@@ -48,7 +45,6 @@ func TestSearchRepositoryByName(t *testing.T) {
Searcher: &User{ID: 14},
})
- assert.NotNil(t, repos)
assert.NoError(t, err)
if assert.Len(t, repos, 1) {
assert.Equal(t, "test_repo_13", repos[0].Name)
@@ -63,7 +59,81 @@ func TestSearchRepositoryByName(t *testing.T) {
Searcher: &User{ID: 14},
})
- assert.NotNil(t, repos)
assert.NoError(t, err)
assert.Equal(t, int64(3), count)
+ assert.Len(t, repos, 3)
+
+ testCases := []struct {
+ name string
+ opts *SearchRepoOptions
+ count int
+ }{
+ {name: "PublicRepositoriesByName",
+ opts: &SearchRepoOptions{Keyword: "big_test_", PageSize: 10},
+ count: 4},
+ {name: "PublicAndPrivateRepositoriesByName",
+ opts: &SearchRepoOptions{Keyword: "big_test_", Page: 1, PageSize: 10, Private: true},
+ count: 8},
+ {name: "PublicAndPrivateRepositoriesByNameWithPagesizeLimitFirstPage",
+ opts: &SearchRepoOptions{Keyword: "big_test_", Page: 1, PageSize: 5, Private: true},
+ count: 8},
+ {name: "PublicAndPrivateRepositoriesByNameWithPagesizeLimitSecondPage",
+ opts: &SearchRepoOptions{Keyword: "big_test_", Page: 2, PageSize: 5, Private: true},
+ count: 8},
+ {name: "PublicRepositoriesOfUser",
+ opts: &SearchRepoOptions{Page: 1, PageSize: 10, OwnerID: 15},
+ count: 3}, // FIXME: Should return 2 (only directly owned repositories), now includes 1 public repository from owned organization
+ {name: "PublicAndPrivateRepositoriesOfUser",
+ opts: &SearchRepoOptions{Page: 1, PageSize: 10, OwnerID: 15, Private: true},
+ count: 6}, // FIXME: Should return 4 (only directly owned repositories), now includes 2 repositories from owned organization
+ {name: "PublicRepositoriesOfUserIncludingCollaborative",
+ opts: &SearchRepoOptions{Page: 1, PageSize: 10, OwnerID: 15, Collaborate: true},
+ count: 4},
+ {name: "PublicAndPrivateRepositoriesOfUserIncludingCollaborative",
+ opts: &SearchRepoOptions{Page: 1, PageSize: 10, OwnerID: 15, Private: true, Collaborate: true},
+ count: 8},
+ {name: "PublicRepositoriesOfOrganization",
+ opts: &SearchRepoOptions{Page: 1, PageSize: 10, OwnerID: 17},
+ count: 1},
+ {name: "PublicAndPrivateRepositoriesOfOrganization",
+ opts: &SearchRepoOptions{Page: 1, PageSize: 10, OwnerID: 17, Private: true},
+ count: 2},
+ }
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ if testCase.opts.OwnerID > 0 {
+ testCase.opts.Searcher = &User{ID: testCase.opts.OwnerID}
+ }
+ repos, count, err := SearchRepositoryByName(testCase.opts)
+
+ assert.NoError(t, err)
+ assert.Equal(t, int64(testCase.count), count)
+
+ var expectedLen int
+ if testCase.opts.PageSize*testCase.opts.Page > testCase.count {
+ expectedLen = testCase.count % testCase.opts.PageSize
+ } else {
+ expectedLen = testCase.opts.PageSize
+ }
+ assert.Len(t, repos, expectedLen)
+
+ for _, repo := range repos {
+ assert.NotEmpty(t, repo.Name)
+
+ if len(testCase.opts.Keyword) > 0 {
+ assert.Contains(t, repo.Name, testCase.opts.Keyword)
+ }
+
+ // FIXME: Can't check, need to fix current behaviour (see previous FIXME comments in test cases)
+ /*if testCase.opts.OwnerID > 0 && !testCase.opts.Collaborate {
+ assert.Equal(t, testCase.opts.OwnerID, repo.Owner.ID)
+ }*/
+
+ if !testCase.opts.Private {
+ assert.False(t, repo.IsPrivate)
+ }
+ }
+ })
+ }
}