diff options
Diffstat (limited to 'internal/api/client/search/searchget_test.go')
| -rw-r--r-- | internal/api/client/search/searchget_test.go | 1070 |
1 files changed, 983 insertions, 87 deletions
diff --git a/internal/api/client/search/searchget_test.go b/internal/api/client/search/searchget_test.go index fe817099f..9e0a8eb67 100644 --- a/internal/api/client/search/searchget_test.go +++ b/internal/api/client/search/searchget_test.go @@ -18,55 +18,174 @@ package search_test import ( + "context" "encoding/json" "fmt" - "io/ioutil" + "io" "net/http" "net/http/httptest" + "net/url" + "strconv" + "strings" "testing" "github.com/stretchr/testify/suite" "github.com/superseriousbusiness/gotosocial/internal/api/client/search" apimodel "github.com/superseriousbusiness/gotosocial/internal/api/model" + apiutil "github.com/superseriousbusiness/gotosocial/internal/api/util" + "github.com/superseriousbusiness/gotosocial/internal/config" + "github.com/superseriousbusiness/gotosocial/internal/gtserror" + "github.com/superseriousbusiness/gotosocial/internal/gtsmodel" + "github.com/superseriousbusiness/gotosocial/internal/oauth" + "github.com/superseriousbusiness/gotosocial/testrig" ) type SearchGetTestSuite struct { SearchStandardTestSuite } -func (suite *SearchGetTestSuite) testSearch(query string, resolve bool, expectedHTTPStatus int) (*apimodel.SearchResult, error) { - requestPath := fmt.Sprintf("%s?q=%s&resolve=%t", search.BasePathV1, query, resolve) - recorder := httptest.NewRecorder() +func (suite *SearchGetTestSuite) getSearch( + requestingAccount *gtsmodel.Account, + token *gtsmodel.Token, + user *gtsmodel.User, + maxID *string, + minID *string, + limit *int, + offset *int, + query string, + queryType *string, + resolve *bool, + following *bool, + expectedHTTPStatus int, + expectedBody string, +) (*apimodel.SearchResult, error) { + var ( + recorder = httptest.NewRecorder() + ctx, _ = testrig.CreateGinTestContext(recorder, nil) + requestURL = testrig.URLMustParse("/api" + search.BasePathV1) + queryParts []string + ) + + // Put the request together. + if maxID != nil { + queryParts = append(queryParts, apiutil.MaxIDKey+"="+url.QueryEscape(*maxID)) + } + + if minID != nil { + queryParts = append(queryParts, apiutil.MinIDKey+"="+url.QueryEscape(*minID)) + } + + if limit != nil { + queryParts = append(queryParts, apiutil.LimitKey+"="+strconv.Itoa(*limit)) + } + + if offset != nil { + queryParts = append(queryParts, apiutil.SearchOffsetKey+"="+strconv.Itoa(*offset)) + } + + queryParts = append(queryParts, apiutil.SearchQueryKey+"="+url.QueryEscape(query)) - ctx := suite.newContext(recorder, requestPath) + if queryType != nil { + queryParts = append(queryParts, apiutil.SearchTypeKey+"="+url.QueryEscape(*queryType)) + } + + if resolve != nil { + queryParts = append(queryParts, apiutil.SearchResolveKey+"="+strconv.FormatBool(*resolve)) + } + + if following != nil { + queryParts = append(queryParts, apiutil.SearchFollowingKey+"="+strconv.FormatBool(*following)) + } + + requestURL.RawQuery = strings.Join(queryParts, "&") + ctx.Request = httptest.NewRequest(http.MethodGet, requestURL.String(), nil) + ctx.Set(oauth.SessionAuthorizedAccount, requestingAccount) + ctx.Set(oauth.SessionAuthorizedToken, oauth.DBTokenToToken(token)) + ctx.Set(oauth.SessionAuthorizedApplication, suite.testApplications["application_1"]) + ctx.Set(oauth.SessionAuthorizedUser, user) + // Trigger the function being tested. suite.searchModule.SearchGETHandler(ctx) + // Read the result. result := recorder.Result() defer result.Body.Close() + b, err := io.ReadAll(result.Body) + if err != nil { + suite.FailNow(err.Error()) + } + + errs := gtserror.MultiError{} + + // Check expected code + body. if resultCode := recorder.Code; expectedHTTPStatus != resultCode { - return nil, fmt.Errorf("expected %d got %d", expectedHTTPStatus, resultCode) + errs = append(errs, fmt.Sprintf("expected %d got %d", expectedHTTPStatus, resultCode)) } - b, err := ioutil.ReadAll(result.Body) - if err != nil { - return nil, err + // If we got an expected body, return early. + if expectedBody != "" && string(b) != expectedBody { + errs = append(errs, fmt.Sprintf("expected %s got %s", expectedBody, string(b))) + } + + if err := errs.Combine(); err != nil { + suite.FailNow("", "%v (body %s)", err, string(b)) } searchResult := &apimodel.SearchResult{} if err := json.Unmarshal(b, searchResult); err != nil { - return nil, err + suite.FailNow(err.Error()) } return searchResult, nil } -func (suite *SearchGetTestSuite) TestSearchRemoteAccountByURI() { - query := "https://unknown-instance.com/users/brand_new_person" - resolve := true +func (suite *SearchGetTestSuite) bodgeLocalInstance(domain string) { + // Set new host. + config.SetHost(domain) - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + // Copy instance account to not mess up other tests. + instanceAccount := >smodel.Account{} + *instanceAccount = *suite.testAccounts["instance_account"] + + // Set username of instance account to given domain. + instanceAccount.Username = domain + if err := suite.db.UpdateAccount(context.Background(), instanceAccount, "username"); err != nil { + suite.FailNow(err.Error()) + } +} + +func (suite *SearchGetTestSuite) TestSearchRemoteAccountByURI() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "https://unknown-instance.com/users/brand_new_person" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -80,10 +199,36 @@ func (suite *SearchGetTestSuite) TestSearchRemoteAccountByURI() { } func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestring() { - query := "@brand_new_person@unknown-instance.com" - resolve := true - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "@brand_new_person@unknown-instance.com" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -97,10 +242,36 @@ func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestring() { } func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringUppercase() { - query := "@Some_User@example.org" - resolve := true - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "@Some_User@example.org" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -114,10 +285,36 @@ func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringUppercase() } func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringNoLeadingAt() { - query := "brand_new_person@unknown-instance.com" - resolve := true - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "brand_new_person@unknown-instance.com" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -131,10 +328,36 @@ func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringNoLeadingAt( } func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringNoResolve() { - query := "@brand_new_person@unknown-instance.com" - resolve := false - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "@brand_new_person@unknown-instance.com" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -143,10 +366,36 @@ func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringNoResolve() } func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringSpecialChars() { - query := "@üser@ëxample.org" - resolve := false - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "@üser@ëxample.org" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -158,10 +407,36 @@ func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringSpecialChars } func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringSpecialCharsPunycode() { - query := "@üser@xn--xample-ova.org" - resolve := false - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "@üser@xn--xample-ova.org" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -173,10 +448,36 @@ func (suite *SearchGetTestSuite) TestSearchRemoteAccountByNamestringSpecialChars } func (suite *SearchGetTestSuite) TestSearchLocalAccountByNamestring() { - query := "@the_mighty_zork" - resolve := false - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "@the_mighty_zork" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -190,10 +491,36 @@ func (suite *SearchGetTestSuite) TestSearchLocalAccountByNamestring() { } func (suite *SearchGetTestSuite) TestSearchLocalAccountByNamestringWithDomain() { - query := "@the_mighty_zork@localhost:8080" - resolve := false - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "@the_mighty_zork@localhost:8080" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -207,10 +534,36 @@ func (suite *SearchGetTestSuite) TestSearchLocalAccountByNamestringWithDomain() } func (suite *SearchGetTestSuite) TestSearchNonexistingLocalAccountByNamestringResolveTrue() { - query := "@somone_made_up@localhost:8080" - resolve := true - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "@somone_made_up@localhost:8080" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -219,10 +572,36 @@ func (suite *SearchGetTestSuite) TestSearchNonexistingLocalAccountByNamestringRe } func (suite *SearchGetTestSuite) TestSearchLocalAccountByURI() { - query := "http://localhost:8080/users/the_mighty_zork" - resolve := false - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "http://localhost:8080/users/the_mighty_zork" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -235,11 +614,37 @@ func (suite *SearchGetTestSuite) TestSearchLocalAccountByURI() { suite.NotNil(gotAccount) } -func (suite *SearchGetTestSuite) TestSearchLocalInstanceAccountByURI() { - query := "http://localhost:8080/users/localhost:8080" - resolve := false - - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) +func (suite *SearchGetTestSuite) TestSearchLocalAccountByURL() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "http://localhost:8080/@the_mighty_zork" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -252,57 +657,398 @@ func (suite *SearchGetTestSuite) TestSearchLocalInstanceAccountByURI() { suite.NotNil(gotAccount) } -func (suite *SearchGetTestSuite) TestSearchLocalAccountByURL() { - query := "http://localhost:8080/@the_mighty_zork" - resolve := false +func (suite *SearchGetTestSuite) TestSearchNonexistingLocalAccountByURL() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "http://localhost:8080/@the_shmighty_shmork" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) + } - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + suite.Len(searchResult.Accounts, 0) +} + +func (suite *SearchGetTestSuite) TestSearchStatusByURL() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "https://turnip.farm/users/turniplover6969/statuses/70c53e54-3146-42d5-a630-83c8b6c7c042" + queryType *string = func() *string { i := "statuses"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } - if !suite.Len(searchResult.Accounts, 1) { - suite.FailNow("expected 1 account in search results but got 0") + if !suite.Len(searchResult.Statuses, 1) { + suite.FailNow("expected 1 status in search results but got 0") } - gotAccount := searchResult.Accounts[0] - suite.NotNil(gotAccount) + gotStatus := searchResult.Statuses[0] + suite.NotNil(gotStatus) } -func (suite *SearchGetTestSuite) TestSearchNonexistingLocalAccountByURL() { - query := "http://localhost:8080/@the_shmighty_shmork" - resolve := true +func (suite *SearchGetTestSuite) TestSearchBlockedDomainURL() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "https://replyguys.com/@someone" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) + } + + suite.Len(searchResult.Accounts, 0) + suite.Len(searchResult.Statuses, 0) + suite.Len(searchResult.Hashtags, 0) +} - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) +func (suite *SearchGetTestSuite) TestSearchBlockedDomainNamestring() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "@someone@replyguys.com" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } suite.Len(searchResult.Accounts, 0) + suite.Len(searchResult.Statuses, 0) + suite.Len(searchResult.Hashtags, 0) } -func (suite *SearchGetTestSuite) TestSearchStatusByURL() { - query := "https://turnip.farm/users/turniplover6969/statuses/70c53e54-3146-42d5-a630-83c8b6c7c042" - resolve := true +func (suite *SearchGetTestSuite) TestSearchAAny() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "a" + queryType *string = nil // Return anything. + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) + } + + suite.Len(searchResult.Accounts, 5) + suite.Len(searchResult.Statuses, 4) + suite.Len(searchResult.Hashtags, 0) +} - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) +func (suite *SearchGetTestSuite) TestSearchAAnyFollowingOnly() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "a" + queryType *string = nil // Return anything. + following *bool = func() *bool { i := true; return &i }() + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } - if !suite.Len(searchResult.Statuses, 1) { - suite.FailNow("expected 1 status in search results but got 0") + suite.Len(searchResult.Accounts, 2) + suite.Len(searchResult.Statuses, 4) + suite.Len(searchResult.Hashtags, 0) +} + +func (suite *SearchGetTestSuite) TestSearchAStatuses() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "a" + queryType *string = func() *string { i := "statuses"; return &i }() // Only statuses. + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) } - gotStatus := searchResult.Statuses[0] - suite.NotNil(gotStatus) + suite.Len(searchResult.Accounts, 0) + suite.Len(searchResult.Statuses, 4) + suite.Len(searchResult.Hashtags, 0) } -func (suite *SearchGetTestSuite) TestSearchBlockedDomainURL() { - query := "https://replyguys.com/@someone" - resolve := true +func (suite *SearchGetTestSuite) TestSearchAAccounts() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "a" + queryType *string = func() *string { i := "accounts"; return &i }() // Only accounts. + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) + } - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + suite.Len(searchResult.Accounts, 5) + suite.Len(searchResult.Statuses, 0) + suite.Len(searchResult.Hashtags, 0) +} + +func (suite *SearchGetTestSuite) TestSearchAAccountsLimit1() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = func() *int { i := 1; return &i }() + offset *int = nil + resolve *bool = func() *bool { i := true; return &i }() + query = "a" + queryType *string = func() *string { i := "accounts"; return &i }() // Only accounts. + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) + } + + suite.Len(searchResult.Accounts, 1) + suite.Len(searchResult.Statuses, 0) + suite.Len(searchResult.Hashtags, 0) +} + +func (suite *SearchGetTestSuite) TestSearchLocalInstanceAccountByURI() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "http://localhost:8080/users/localhost:8080" + queryType *string = func() *string { i := "accounts"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -312,11 +1058,89 @@ func (suite *SearchGetTestSuite) TestSearchBlockedDomainURL() { suite.Len(searchResult.Hashtags, 0) } -func (suite *SearchGetTestSuite) TestSearchBlockedDomainNamestring() { - query := "@someone@replyguys.com" - resolve := true +func (suite *SearchGetTestSuite) TestSearchInstanceAccountFull() { + // Namestring excludes ':' in usernames, so we + // need to fiddle with the instance account a + // bit to get it to look like a different domain. + newDomain := "example.org" + suite.bodgeLocalInstance(newDomain) + + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "@" + newDomain + "@" + newDomain + queryType *string = nil + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) + } - searchResult, err := suite.testSearch(query, resolve, http.StatusOK) + suite.Len(searchResult.Accounts, 0) + suite.Len(searchResult.Statuses, 0) + suite.Len(searchResult.Hashtags, 0) +} + +func (suite *SearchGetTestSuite) TestSearchInstanceAccountPartial() { + // Namestring excludes ':' in usernames, so we + // need to fiddle with the instance account a + // bit to get it to look like a different domain. + newDomain := "example.org" + suite.bodgeLocalInstance(newDomain) + + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "@" + newDomain + queryType *string = nil + following *bool = nil + expectedHTTPStatus = http.StatusOK + expectedBody = "" + ) + + searchResult, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) if err != nil { suite.FailNow(err.Error()) } @@ -326,6 +1150,78 @@ func (suite *SearchGetTestSuite) TestSearchBlockedDomainNamestring() { suite.Len(searchResult.Hashtags, 0) } +func (suite *SearchGetTestSuite) TestSearchBadQueryType() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "whatever" + queryType *string = func() *string { i := "aaaaaaaaaaa"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusBadRequest + expectedBody = `{"error":"Bad Request: search query type aaaaaaaaaaa was not recognized, valid options are ['', 'accounts', 'statuses', 'hashtags']"}` + ) + + _, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) + } +} + +func (suite *SearchGetTestSuite) TestSearchEmptyQuery() { + var ( + requestingAccount = suite.testAccounts["local_account_1"] + token = suite.testTokens["local_account_1"] + user = suite.testUsers["local_account_1"] + maxID *string = nil + minID *string = nil + limit *int = nil + offset *int = nil + resolve *bool = nil + query = "" + queryType *string = func() *string { i := "aaaaaaaaaaa"; return &i }() + following *bool = nil + expectedHTTPStatus = http.StatusBadRequest + expectedBody = `{"error":"Bad Request: required key q was not set or had empty value"}` + ) + + _, err := suite.getSearch( + requestingAccount, + token, + user, + maxID, + minID, + limit, + offset, + query, + queryType, + resolve, + following, + expectedHTTPStatus, + expectedBody) + if err != nil { + suite.FailNow(err.Error()) + } +} + func TestSearchGetTestSuite(t *testing.T) { suite.Run(t, &SearchGetTestSuite{}) } |