summaryrefslogtreecommitdiff
path: root/internal/db/bundb/relationship_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'internal/db/bundb/relationship_test.go')
-rw-r--r--internal/db/bundb/relationship_test.go249
1 files changed, 215 insertions, 34 deletions
diff --git a/internal/db/bundb/relationship_test.go b/internal/db/bundb/relationship_test.go
index 34fe85a57..3df16e2f3 100644
--- a/internal/db/bundb/relationship_test.go
+++ b/internal/db/bundb/relationship_test.go
@@ -20,7 +20,6 @@ package bundb_test
import (
"context"
- "errors"
"testing"
"github.com/stretchr/testify/suite"
@@ -48,12 +47,14 @@ func (suite *RelationshipTestSuite) TestIsBlocked() {
suite.False(blocked)
// have account1 block account2
- suite.db.Put(ctx, &gtsmodel.Block{
+ if err := suite.db.Put(ctx, &gtsmodel.Block{
ID: "01G202BCSXXJZ70BHB5KCAHH8C",
URI: "http://localhost:8080/some_block_uri_1",
AccountID: account1,
TargetAccountID: account2,
- })
+ }); err != nil {
+ suite.FailNow(err.Error())
+ }
// account 1 now blocks account 2
blocked, err = suite.db.IsBlocked(ctx, account1, account2, false)
@@ -75,62 +76,242 @@ func (suite *RelationshipTestSuite) TestIsBlocked() {
}
func (suite *RelationshipTestSuite) TestGetBlock() {
- suite.Suite.T().Skip("TODO: implement")
+ ctx := context.Background()
+
+ account1 := suite.testAccounts["local_account_1"].ID
+ account2 := suite.testAccounts["local_account_2"].ID
+
+ if err := suite.db.Put(ctx, &gtsmodel.Block{
+ ID: "01G202BCSXXJZ70BHB5KCAHH8C",
+ URI: "http://localhost:8080/some_block_uri_1",
+ AccountID: account1,
+ TargetAccountID: account2,
+ }); err != nil {
+ suite.FailNow(err.Error())
+ }
+
+ block, err := suite.db.GetBlock(ctx, account1, account2)
+ suite.NoError(err)
+ suite.NotNil(block)
+ suite.Equal("01G202BCSXXJZ70BHB5KCAHH8C", block.ID)
}
func (suite *RelationshipTestSuite) TestGetRelationship() {
- suite.Suite.T().Skip("TODO: implement")
+ requestingAccount := suite.testAccounts["local_account_1"]
+ targetAccount := suite.testAccounts["admin_account"]
+
+ relationship, err := suite.db.GetRelationship(context.Background(), requestingAccount.ID, targetAccount.ID)
+ suite.NoError(err)
+ suite.NotNil(relationship)
+
+ suite.True(relationship.Following)
+ suite.True(relationship.ShowingReblogs)
+ suite.False(relationship.Notifying)
+ suite.True(relationship.FollowedBy)
+ suite.False(relationship.Blocking)
+ suite.False(relationship.BlockedBy)
+ suite.False(relationship.Muting)
+ suite.False(relationship.MutingNotifications)
+ suite.False(relationship.Requested)
+ suite.False(relationship.DomainBlocking)
+ suite.False(relationship.Endorsed)
+ suite.Empty(relationship.Note)
+}
+
+func (suite *RelationshipTestSuite) TestIsFollowingYes() {
+ requestingAccount := suite.testAccounts["local_account_1"]
+ targetAccount := suite.testAccounts["admin_account"]
+ isFollowing, err := suite.db.IsFollowing(context.Background(), requestingAccount, targetAccount)
+ suite.NoError(err)
+ suite.True(isFollowing)
}
-func (suite *RelationshipTestSuite) TestIsFollowing() {
- suite.Suite.T().Skip("TODO: implement")
+func (suite *RelationshipTestSuite) TestIsFollowingNo() {
+ requestingAccount := suite.testAccounts["admin_account"]
+ targetAccount := suite.testAccounts["local_account_2"]
+ isFollowing, err := suite.db.IsFollowing(context.Background(), requestingAccount, targetAccount)
+ suite.NoError(err)
+ suite.False(isFollowing)
}
func (suite *RelationshipTestSuite) TestIsMutualFollowing() {
- suite.Suite.T().Skip("TODO: implement")
+ requestingAccount := suite.testAccounts["local_account_1"]
+ targetAccount := suite.testAccounts["admin_account"]
+ isMutualFollowing, err := suite.db.IsMutualFollowing(context.Background(), requestingAccount, targetAccount)
+ suite.NoError(err)
+ suite.True(isMutualFollowing)
+}
+
+func (suite *RelationshipTestSuite) TestIsMutualFollowingNo() {
+ requestingAccount := suite.testAccounts["local_account_1"]
+ targetAccount := suite.testAccounts["local_account_2"]
+ isMutualFollowing, err := suite.db.IsMutualFollowing(context.Background(), requestingAccount, targetAccount)
+ suite.NoError(err)
+ suite.True(isMutualFollowing)
}
-func (suite *RelationshipTestSuite) AcceptFollowRequest() {
- for _, account := range suite.testAccounts {
- _, err := suite.db.AcceptFollowRequest(context.Background(), account.ID, "NON-EXISTENT-ID")
- if err != nil && !errors.Is(err, db.ErrNoEntries) {
- suite.Suite.Fail("error accepting follow request: %v", err)
- }
+func (suite *RelationshipTestSuite) TestAcceptFollowRequestOK() {
+ ctx := context.Background()
+ account := suite.testAccounts["admin_account"]
+ targetAccount := suite.testAccounts["local_account_2"]
+
+ followRequest := &gtsmodel.FollowRequest{
+ ID: "01GEF753FWHCHRDWR0QEHBXM8W",
+ URI: "http://localhost:8080/weeeeeeeeeeeeeeeee",
+ AccountID: account.ID,
+ TargetAccountID: targetAccount.ID,
}
+
+ if err := suite.db.Put(ctx, followRequest); err != nil {
+ suite.FailNow(err.Error())
+ }
+
+ follow, err := suite.db.AcceptFollowRequest(ctx, account.ID, targetAccount.ID)
+ suite.NoError(err)
+ suite.NotNil(follow)
+ suite.Equal(followRequest.URI, follow.URI)
}
-func (suite *RelationshipTestSuite) GetAccountFollowRequests() {
- suite.Suite.T().Skip("TODO: implement")
+func (suite *RelationshipTestSuite) TestAcceptFollowRequestNotExisting() {
+ ctx := context.Background()
+ account := suite.testAccounts["admin_account"]
+ targetAccount := suite.testAccounts["local_account_2"]
+
+ follow, err := suite.db.AcceptFollowRequest(ctx, account.ID, targetAccount.ID)
+ suite.ErrorIs(err, db.ErrNoEntries)
+ suite.Nil(follow)
}
-func (suite *RelationshipTestSuite) GetAccountFollows() {
- suite.Suite.T().Skip("TODO: implement")
+func (suite *RelationshipTestSuite) TestAcceptFollowRequestFollowAlreadyExists() {
+ ctx := context.Background()
+ account := suite.testAccounts["local_account_1"]
+ targetAccount := suite.testAccounts["admin_account"]
+
+ // follow already exists in the db from local_account_1 -> admin_account
+ existingFollow := &gtsmodel.Follow{}
+ if err := suite.db.GetByID(ctx, suite.testFollows["local_account_1_admin_account"].ID, existingFollow); err != nil {
+ suite.FailNow(err.Error())
+ }
+
+ followRequest := &gtsmodel.FollowRequest{
+ ID: "01GEF753FWHCHRDWR0QEHBXM8W",
+ URI: "http://localhost:8080/weeeeeeeeeeeeeeeee",
+ AccountID: account.ID,
+ TargetAccountID: targetAccount.ID,
+ }
+
+ if err := suite.db.Put(ctx, followRequest); err != nil {
+ suite.FailNow(err.Error())
+ }
+
+ follow, err := suite.db.AcceptFollowRequest(ctx, account.ID, targetAccount.ID)
+ suite.NoError(err)
+ suite.NotNil(follow)
+
+ // uri should be equal to value of new/overlapping follow request
+ suite.NotEqual(followRequest.URI, existingFollow.URI)
+ suite.Equal(followRequest.URI, follow.URI)
}
-func (suite *RelationshipTestSuite) CountAccountFollows() {
- suite.Suite.T().Skip("TODO: implement")
+func (suite *RelationshipTestSuite) TestRejectFollowRequestOK() {
+ ctx := context.Background()
+ account := suite.testAccounts["admin_account"]
+ targetAccount := suite.testAccounts["local_account_2"]
+
+ followRequest := &gtsmodel.FollowRequest{
+ ID: "01GEF753FWHCHRDWR0QEHBXM8W",
+ URI: "http://localhost:8080/weeeeeeeeeeeeeeeee",
+ AccountID: account.ID,
+ TargetAccountID: targetAccount.ID,
+ }
+
+ if err := suite.db.Put(ctx, followRequest); err != nil {
+ suite.FailNow(err.Error())
+ }
+
+ rejectedFollowRequest, err := suite.db.RejectFollowRequest(ctx, account.ID, targetAccount.ID)
+ suite.NoError(err)
+ suite.NotNil(rejectedFollowRequest)
}
-func (suite *RelationshipTestSuite) GetAccountFollowedBy() {
- // TODO: more comprehensive tests here
+func (suite *RelationshipTestSuite) TestRejectFollowRequestNotExisting() {
+ ctx := context.Background()
+ account := suite.testAccounts["admin_account"]
+ targetAccount := suite.testAccounts["local_account_2"]
- for _, account := range suite.testAccounts {
- var err error
+ rejectedFollowRequest, err := suite.db.RejectFollowRequest(ctx, account.ID, targetAccount.ID)
+ suite.ErrorIs(err, db.ErrNoEntries)
+ suite.Nil(rejectedFollowRequest)
+}
- _, err = suite.db.GetAccountFollowedBy(context.Background(), account.ID, false)
- if err != nil {
- suite.Suite.Fail("error checking accounts followed by: %v", err)
- }
+func (suite *RelationshipTestSuite) TestGetAccountFollowRequests() {
+ ctx := context.Background()
+ account := suite.testAccounts["admin_account"]
+ targetAccount := suite.testAccounts["local_account_2"]
- _, err = suite.db.GetAccountFollowedBy(context.Background(), account.ID, true)
- if err != nil {
- suite.Suite.Fail("error checking localOnly accounts followed by: %v", err)
- }
+ followRequest := &gtsmodel.FollowRequest{
+ ID: "01GEF753FWHCHRDWR0QEHBXM8W",
+ URI: "http://localhost:8080/weeeeeeeeeeeeeeeee",
+ AccountID: account.ID,
+ TargetAccountID: targetAccount.ID,
}
+
+ if err := suite.db.Put(ctx, followRequest); err != nil {
+ suite.FailNow(err.Error())
+ }
+
+ followRequests, err := suite.db.GetAccountFollowRequests(ctx, targetAccount.ID)
+ suite.NoError(err)
+ suite.Len(followRequests, 1)
}
-func (suite *RelationshipTestSuite) CountAccountFollowedBy() {
- suite.Suite.T().Skip("TODO: implement")
+func (suite *RelationshipTestSuite) TestGetAccountFollows() {
+ account := suite.testAccounts["local_account_1"]
+ follows, err := suite.db.GetAccountFollows(context.Background(), account.ID)
+ suite.NoError(err)
+ suite.Len(follows, 2)
+}
+
+func (suite *RelationshipTestSuite) TestCountAccountFollowsLocalOnly() {
+ account := suite.testAccounts["local_account_1"]
+ followsCount, err := suite.db.CountAccountFollows(context.Background(), account.ID, true)
+ suite.NoError(err)
+ suite.Equal(2, followsCount)
+}
+
+func (suite *RelationshipTestSuite) TestCountAccountFollows() {
+ account := suite.testAccounts["local_account_1"]
+ followsCount, err := suite.db.CountAccountFollows(context.Background(), account.ID, false)
+ suite.NoError(err)
+ suite.Equal(2, followsCount)
+}
+
+func (suite *RelationshipTestSuite) TestGetAccountFollowedBy() {
+ account := suite.testAccounts["local_account_1"]
+ follows, err := suite.db.GetAccountFollowedBy(context.Background(), account.ID, false)
+ suite.NoError(err)
+ suite.Len(follows, 2)
+}
+
+func (suite *RelationshipTestSuite) TestGetAccountFollowedByLocalOnly() {
+ account := suite.testAccounts["local_account_1"]
+ follows, err := suite.db.GetAccountFollowedBy(context.Background(), account.ID, true)
+ suite.NoError(err)
+ suite.Len(follows, 2)
+}
+
+func (suite *RelationshipTestSuite) TestCountAccountFollowedBy() {
+ account := suite.testAccounts["local_account_1"]
+ followsCount, err := suite.db.CountAccountFollowedBy(context.Background(), account.ID, false)
+ suite.NoError(err)
+ suite.Equal(2, followsCount)
+}
+
+func (suite *RelationshipTestSuite) TestCountAccountFollowedByLocalOnly() {
+ account := suite.testAccounts["local_account_1"]
+ followsCount, err := suite.db.CountAccountFollowedBy(context.Background(), account.ID, true)
+ suite.NoError(err)
+ suite.Equal(2, followsCount)
}
func TestRelationshipTestSuite(t *testing.T) {