mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-11 09:30:59 +01:00
705 lines
15 KiB
Go
705 lines
15 KiB
Go
// GoToSocial
|
|
// Copyright (C) GoToSocial Authors admin@gotosocial.org
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package timeline_test
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/suite"
|
|
"github.com/superseriousbusiness/gotosocial/internal/gtscontext"
|
|
"github.com/superseriousbusiness/gotosocial/internal/id"
|
|
"github.com/superseriousbusiness/gotosocial/internal/timeline"
|
|
)
|
|
|
|
type GetTestSuite struct {
|
|
TimelineStandardTestSuite
|
|
}
|
|
|
|
func (suite *GetTestSuite) checkStatuses(statuses []timeline.Preparable, maxID string, minID string, expectedLength int) {
|
|
if l := len(statuses); l != expectedLength {
|
|
suite.FailNow("", "expected %d statuses in slice, got %d", expectedLength, l)
|
|
} else if l == 0 {
|
|
// Can't test empty slice.
|
|
return
|
|
}
|
|
|
|
// Check ordering + bounds of statuses.
|
|
highest := statuses[0].GetID()
|
|
for _, status := range statuses {
|
|
id := status.GetID()
|
|
|
|
if id >= maxID {
|
|
suite.FailNow("", "%s greater than maxID %s", id, maxID)
|
|
}
|
|
|
|
if id <= minID {
|
|
suite.FailNow("", "%s smaller than minID %s", id, minID)
|
|
}
|
|
|
|
if id > highest {
|
|
suite.FailNow("", "statuses in slice were not ordered highest -> lowest ID")
|
|
}
|
|
|
|
highest = id
|
|
}
|
|
}
|
|
|
|
func (suite *GetTestSuite) emptyAccountFollows(ctx context.Context, accountID string) {
|
|
// Get all of account's follows.
|
|
follows, err := suite.state.DB.GetAccountFollows(
|
|
gtscontext.SetBarebones(ctx),
|
|
accountID,
|
|
nil, // select all
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
// Remove each follow.
|
|
for _, follow := range follows {
|
|
if err := suite.state.DB.DeleteFollowByID(ctx, follow.ID); err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
}
|
|
|
|
// Ensure no follows left.
|
|
follows, err = suite.state.DB.GetAccountFollows(
|
|
gtscontext.SetBarebones(ctx),
|
|
accountID,
|
|
nil, // select all
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
if len(follows) != 0 {
|
|
suite.FailNow("follows should be empty")
|
|
}
|
|
}
|
|
|
|
func (suite *GetTestSuite) emptyAccountStatuses(ctx context.Context, accountID string) {
|
|
// Get all of account's statuses.
|
|
statuses, err := suite.state.DB.GetAccountStatuses(
|
|
ctx,
|
|
accountID,
|
|
9999,
|
|
false,
|
|
false,
|
|
id.Highest,
|
|
id.Lowest,
|
|
false,
|
|
false,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
// Remove each status.
|
|
for _, status := range statuses {
|
|
if err := suite.state.DB.DeleteStatusByID(ctx, status.ID); err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
}
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetNewTimelinePageDown() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = ""
|
|
limit = 5
|
|
local = false
|
|
)
|
|
|
|
// Get 5 from the top.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
suite.checkStatuses(statuses, id.Highest, id.Lowest, 5)
|
|
|
|
// Get 5 from next maxID.
|
|
maxID = statuses[len(statuses)-1].GetID()
|
|
statuses, err = suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
suite.checkStatuses(statuses, maxID, id.Lowest, 5)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetNewTimelinePageUp() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = id.Lowest
|
|
limit = 5
|
|
local = false
|
|
)
|
|
|
|
// Get 5 from the back.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
suite.checkStatuses(statuses, id.Highest, minID, 5)
|
|
|
|
// Page up from next minID.
|
|
minID = statuses[0].GetID()
|
|
statuses, err = suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
suite.checkStatuses(statuses, id.Highest, minID, 5)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetNewTimelineMoreThanPossible() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = ""
|
|
limit = 100
|
|
local = false
|
|
)
|
|
|
|
// Get 100 from the top.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
suite.checkStatuses(statuses, id.Highest, id.Lowest, 19)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetNewTimelineMoreThanPossiblePageUp() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = id.Lowest
|
|
limit = 100
|
|
local = false
|
|
)
|
|
|
|
// Get 100 from the back.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
suite.checkStatuses(statuses, id.Highest, id.Lowest, 19)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetNewTimelineNoFollowing() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = ""
|
|
limit = 10
|
|
local = false
|
|
)
|
|
|
|
suite.emptyAccountFollows(ctx, testAccount.ID)
|
|
|
|
// Try to get 10 from the top of the timeline.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
suite.checkStatuses(statuses, id.Highest, id.Lowest, 7)
|
|
|
|
for _, s := range statuses {
|
|
if s.GetAccountID() != testAccount.ID {
|
|
suite.FailNow("timeline with no follows should only contain posts by timeline owner account")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetNewTimelineNoFollowingNoStatuses() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = ""
|
|
limit = 5
|
|
local = false
|
|
)
|
|
|
|
suite.emptyAccountFollows(ctx, testAccount.ID)
|
|
suite.emptyAccountStatuses(ctx, testAccount.ID)
|
|
|
|
// Try to get 5 from the top of the timeline.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
suite.checkStatuses(statuses, id.Highest, id.Lowest, 0)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetNoParams() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = ""
|
|
limit = 10
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Get 10 statuses from the top (no params).
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
suite.checkStatuses(statuses, id.Highest, id.Lowest, 10)
|
|
|
|
// First status should have the highest ID in the testrig.
|
|
suite.Equal(suite.highestStatusID, statuses[0].GetID())
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetMaxID() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = "01F8MHBQCBTDKN6X5VHGMMN4MA"
|
|
sinceID = ""
|
|
minID = ""
|
|
limit = 10
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 10 with a max ID somewhere in the middle of the stack.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
// We'll only get 6 statuses back.
|
|
suite.checkStatuses(statuses, maxID, id.Lowest, 6)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetSinceID() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = "01F8MHBQCBTDKN6X5VHGMMN4MA"
|
|
minID = ""
|
|
limit = 10
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 10 with a since ID somewhere in the middle of the stack.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
suite.checkStatuses(statuses, id.Highest, sinceID, 10)
|
|
|
|
// The first status in the stack should have the highest ID of all
|
|
// in the testrig, because we're paging down.
|
|
suite.Equal(suite.highestStatusID, statuses[0].GetID())
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetSinceIDOneOnly() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = "01F8MHBQCBTDKN6X5VHGMMN4MA"
|
|
minID = ""
|
|
limit = 1
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 1 with a since ID somewhere in the middle of the stack.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
suite.checkStatuses(statuses, id.Highest, sinceID, 1)
|
|
|
|
// The one status we got back should have the highest ID of all in
|
|
// the testrig, because using sinceID means we're paging down.
|
|
suite.Equal(suite.highestStatusID, statuses[0].GetID())
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetMinID() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = "01F8MHBQCBTDKN6X5VHGMMN4MA"
|
|
limit = 5
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 5 with a min ID somewhere in the middle of the stack.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
suite.checkStatuses(statuses, id.Highest, minID, 5)
|
|
|
|
// We're paging up so even the highest status ID in the pile
|
|
// shouldn't be the highest ID we have.
|
|
suite.NotEqual(suite.highestStatusID, statuses[0])
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetMinIDOneOnly() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = "01F8MHBQCBTDKN6X5VHGMMN4MA"
|
|
limit = 1
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 1 with a min ID somewhere in the middle of the stack.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
suite.checkStatuses(statuses, id.Highest, minID, 1)
|
|
|
|
// The one status we got back should have the an ID equal to the
|
|
// one ID immediately newer than it.
|
|
suite.Equal("01F8MHC0H0A7XHTVH5F596ZKBM", statuses[0].GetID())
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetMinIDFromLowestInTestrig() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = suite.lowestStatusID
|
|
limit = 1
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 1 with minID equal to the lowest status in the testrig.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
suite.checkStatuses(statuses, id.Highest, minID, 1)
|
|
|
|
// The one status we got back should have an id higher than
|
|
// the lowest status in the testrig, since minID is not inclusive.
|
|
suite.Greater(statuses[0].GetID(), suite.lowestStatusID)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetMinIDFromLowestPossible() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = id.Lowest
|
|
limit = 1
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 1 with the lowest possible min ID.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
suite.checkStatuses(statuses, id.Highest, minID, 1)
|
|
|
|
// The one status we got back should have the an ID equal to the
|
|
// lowest ID status in the test rig.
|
|
suite.Equal(suite.lowestStatusID, statuses[0].GetID())
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetBetweenID() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = "01F8MHCP5P2NWYQ416SBA0XSEV"
|
|
sinceID = ""
|
|
minID = "01F8MHBQCBTDKN6X5VHGMMN4MA"
|
|
limit = 10
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 10 between these two IDs
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
// There's only two statuses between these two IDs.
|
|
suite.checkStatuses(statuses, maxID, minID, 2)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetBetweenIDImpossible() {
|
|
var (
|
|
ctx = context.Background()
|
|
testAccount = suite.testAccounts["local_account_1"]
|
|
maxID = id.Lowest
|
|
sinceID = ""
|
|
minID = id.Highest
|
|
limit = 10
|
|
local = false
|
|
)
|
|
|
|
suite.fillTimeline(testAccount.ID)
|
|
|
|
// Ask for 10 between these two IDs which present
|
|
// an impossible query.
|
|
statuses, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
)
|
|
if err != nil {
|
|
suite.FailNow(err.Error())
|
|
}
|
|
|
|
// We should have nothing back.
|
|
suite.checkStatuses(statuses, maxID, minID, 0)
|
|
}
|
|
|
|
func (suite *GetTestSuite) TestGetTimelinesAsync() {
|
|
var (
|
|
ctx = context.Background()
|
|
accountToNuke = suite.testAccounts["local_account_1"]
|
|
maxID = ""
|
|
sinceID = ""
|
|
minID = ""
|
|
limit = 5
|
|
local = false
|
|
multiplier = 5
|
|
)
|
|
|
|
// Nuke one account's statuses and follows,
|
|
// as though the account had just been created.
|
|
suite.emptyAccountFollows(ctx, accountToNuke.ID)
|
|
suite.emptyAccountStatuses(ctx, accountToNuke.ID)
|
|
|
|
// Get 5 statuses from each timeline in
|
|
// our testrig at the same time, five times.
|
|
wg := new(sync.WaitGroup)
|
|
wg.Add(len(suite.testAccounts) * multiplier)
|
|
|
|
for i := 0; i < multiplier; i++ {
|
|
go func() {
|
|
for _, testAccount := range suite.testAccounts {
|
|
if _, err := suite.state.Timelines.Home.GetTimeline(
|
|
ctx,
|
|
testAccount.ID,
|
|
maxID,
|
|
sinceID,
|
|
minID,
|
|
limit,
|
|
local,
|
|
); err != nil {
|
|
suite.Fail(err.Error())
|
|
}
|
|
|
|
wg.Done()
|
|
}
|
|
}()
|
|
}
|
|
|
|
wg.Wait() // Wait until all get calls have returned.
|
|
}
|
|
|
|
func TestGetTestSuite(t *testing.T) {
|
|
suite.Run(t, new(GetTestSuite))
|
|
}
|