package protocol import ( "context" "errors" "math/big" "github.com/stretchr/testify/suite" "go.uber.org/zap" gethcommon "github.com/ethereum/go-ethereum/common" hexutil "github.com/ethereum/go-ethereum/common/hexutil" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/protocol/common" "github.com/status-im/status-go/protocol/communities" "github.com/status-im/status-go/protocol/communities/token" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/requests" "github.com/status-im/status-go/protocol/tt" "github.com/status-im/status-go/services/wallet/bigint" ) type CommunityEventsTestsInterface interface { GetControlNode() *Messenger GetEventSender() *Messenger GetMember() *Messenger GetSuite() *suite.Suite GetCollectiblesServiceMock() *CollectiblesServiceMock SetupAdditionalMessengers([]*Messenger) GetAccountsTestData() map[string][]string GetAccountsPasswords() map[string]string } const communitiesEventsTestTokenAddress = "0x0400000000000000000000000000000000000000" const aliceAccountAddress = "0x0777100000000000000000000000000000000000" const bobAccountAddress = "0x0330000000000000000000000000000000000000" const eventsSenderAccountAddress = "0x0200000000000000000000000000000000000000" const accountPassword = "qwerty" const commonAccountAddress = "0x0890000000000000000000000000000000000000" type MessageResponseValidator func(*MessengerResponse) error func WaitMessageCondition(response *MessengerResponse) bool { return len(response.Messages()) > 0 } func waitOnMessengerResponse(s *suite.Suite, fnWait MessageResponseValidator, user *Messenger) { _, err := WaitOnMessengerResponse( user, func(r *MessengerResponse) bool { err := fnWait(r) if err != nil { user.logger.Error("response error: ", zap.Error(err)) } return err == nil }, "MessengerResponse data not received", ) s.Require().NoError(err) } func checkClientsReceivedAdminEvent(base CommunityEventsTestsInterface, fn MessageResponseValidator) { s := base.GetSuite() // Wait and verify Member received community event waitOnMessengerResponse(s, fn, base.GetMember()) // Wait and verify event sender received his own event waitOnMessengerResponse(s, fn, base.GetEventSender()) // Wait and verify ControlNode received community event // ControlNode will publish CommunityDescription update waitOnMessengerResponse(s, fn, base.GetControlNode()) // Wait and verify Member received the ControlNode CommunityDescription update waitOnMessengerResponse(s, fn, base.GetMember()) // Wait and verify event sender received the ControlNode CommunityDescription update waitOnMessengerResponse(s, fn, base.GetEventSender()) // Wait and verify ControlNode received his own CommunityDescription update waitOnMessengerResponse(s, fn, base.GetControlNode()) } func refreshMessengerResponses(base CommunityEventsTestsInterface) { _, err := WaitOnMessengerResponse(base.GetControlNode(), func(response *MessengerResponse) bool { return true }, "community description changed message not received") base.GetSuite().Require().NoError(err) _, err = WaitOnMessengerResponse(base.GetEventSender(), func(response *MessengerResponse) bool { return true }, "community description changed message not received") base.GetSuite().Require().NoError(err) _, err = WaitOnMessengerResponse(base.GetMember(), func(response *MessengerResponse) bool { return true }, "community description changed message not received") base.GetSuite().Require().NoError(err) } func createMockedWalletBalance(s *suite.Suite) map[uint64]map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big { eventSenderAddress := gethcommon.HexToAddress(eventsSenderAccountAddress) mockedBalances := make(map[uint64]map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big) mockedBalances[testChainID1] = make(map[gethcommon.Address]map[gethcommon.Address]*hexutil.Big) mockedBalances[testChainID1][eventSenderAddress] = make(map[gethcommon.Address]*hexutil.Big) // event sender will have token with `communitiesEventsTestTokenAddress`` contractAddress := gethcommon.HexToAddress(communitiesEventsTestTokenAddress) balance, ok := new(big.Int).SetString("200", 10) s.Require().True(ok) decimalsFactor := new(big.Int).Exp(big.NewInt(10), big.NewInt(int64(18)), nil) balance.Mul(balance, decimalsFactor) mockedBalances[testChainID1][eventSenderAddress][contractAddress] = (*hexutil.Big)(balance) return mockedBalances } func setUpCommunityAndRoles(base CommunityEventsTestsInterface, role protobuf.CommunityMember_Roles) *communities.Community { tcs2, err := base.GetControlNode().communitiesManager.All() suite := base.GetSuite() suite.Require().NoError(err, "eventSender.communitiesManager.All") suite.Len(tcs2, 0, "Must have 0 community") // ControlNode creates a community and chat community := createTestCommunity(base, protobuf.CommunityPermissions_AUTO_ACCEPT) refreshMessengerResponses(base) // add events sender and member to the community advertiseCommunityToUserOldWay(suite, community, base.GetControlNode(), base.GetEventSender()) advertiseCommunityToUserOldWay(suite, community, base.GetControlNode(), base.GetMember()) joinCommunity(suite, community.ID(), base.GetControlNode(), base.GetEventSender(), accountPassword, []string{eventsSenderAccountAddress}) refreshMessengerResponses(base) joinCommunity(suite, community.ID(), base.GetControlNode(), base.GetMember(), accountPassword, []string{aliceAccountAddress}) refreshMessengerResponses(base) // grant permissions to the event sender grantPermission(suite, community, base.GetControlNode(), base.GetEventSender(), role) refreshMessengerResponses(base) return community } func createTestCommunity(base CommunityEventsTestsInterface, membershipType protobuf.CommunityPermissions_Access) *communities.Community { description := &requests.CreateCommunity{ Membership: membershipType, Name: "status", Color: "#ffffff", Description: "status community description", PinMessageAllMembersEnabled: false, } response, err := base.GetControlNode().CreateCommunity(description, true) suite := base.GetSuite() suite.Require().NoError(err) suite.Require().NotNil(response) suite.Require().Len(response.Communities(), 1) suite.Require().Len(response.Chats(), 1) return response.Communities()[0] } func getModifiedCommunity(response *MessengerResponse, communityID string) (*communities.Community, error) { if len(response.Communities()) == 0 { return nil, errors.New("community not received") } var modifiedCommmunity *communities.Community = nil for _, c := range response.Communities() { if c.IDString() == communityID { modifiedCommmunity = c } } if modifiedCommmunity == nil { return nil, errors.New("couldn't find community in response") } return modifiedCommmunity, nil } func createCommunityChannel(base CommunityEventsTestsInterface, community *communities.Community, newChannel *protobuf.CommunityChat) string { checkChannelCreated := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } for _, chat := range modifiedCommmunity.Chats() { if chat.GetIdentity().GetDisplayName() == newChannel.GetIdentity().GetDisplayName() { return nil } } return errors.New("couldn't find created chat in response") } response, err := base.GetEventSender().CreateCommunityChat(community.ID(), newChannel) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkChannelCreated(response)) s.Require().Len(response.CommunityChanges, 1) s.Require().Len(response.CommunityChanges[0].ChatsAdded, 1) var addedChatID string for addedChatID = range response.CommunityChanges[0].ChatsAdded { break } checkClientsReceivedAdminEvent(base, checkChannelCreated) return addedChatID } func editCommunityChannel(base CommunityEventsTestsInterface, community *communities.Community, editChannel *protobuf.CommunityChat, channelID string) { checkChannelEdited := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } for _, chat := range modifiedCommmunity.Chats() { if chat.GetIdentity().GetDisplayName() == editChannel.GetIdentity().GetDisplayName() { return nil } } return errors.New("couldn't find modified chat in response") } response, err := base.GetEventSender().EditCommunityChat(community.ID(), channelID, editChannel) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkChannelEdited(response)) checkClientsReceivedAdminEvent(base, checkChannelEdited) } func deleteCommunityChannel(base CommunityEventsTestsInterface, community *communities.Community, channelID string) { checkChannelDeleted := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } if _, exists := modifiedCommmunity.Chats()[channelID]; exists { return errors.New("channel was not deleted") } return nil } response, err := base.GetEventSender().DeleteCommunityChat(community.ID(), channelID) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkChannelDeleted(response)) checkClientsReceivedAdminEvent(base, checkChannelDeleted) } func createTestPermissionRequest(community *communities.Community, pType protobuf.CommunityTokenPermission_Type) *requests.CreateCommunityTokenPermission { return &requests.CreateCommunityTokenPermission{ CommunityID: community.ID(), Type: pType, TokenCriteria: []*protobuf.TokenCriteria{ { Type: protobuf.CommunityTokenType_ERC20, ContractAddresses: map[uint64]string{uint64(testChainID1): communitiesEventsTestTokenAddress}, Symbol: "TEST", AmountInWei: "100000000000000000000", Decimals: uint64(18), }, }, } } func createTokenPermission(base CommunityEventsTestsInterface, community *communities.Community, request *requests.CreateCommunityTokenPermission) (string, *requests.CreateCommunityTokenPermission) { response, err := base.GetEventSender().CreateCommunityTokenPermission(request) s := base.GetSuite() s.Require().NoError(err) s.Require().Len(response.CommunityChanges, 1) s.Require().Len(response.CommunityChanges[0].TokenPermissionsAdded, 1) addedPermission := func() *communities.CommunityTokenPermission { for _, permission := range response.CommunityChanges[0].TokenPermissionsAdded { return permission } return nil }() s.Require().NotNil(addedPermission) // Permission added by event must be in pending state s.Require().Equal(communities.TokenPermissionAdditionPending, addedPermission.State) responseHasApprovedTokenPermission := func(r *MessengerResponse) bool { if len(r.Communities()) == 0 { return false } receivedPermission := r.Communities()[0].TokenPermissionByID(addedPermission.Id) return receivedPermission != nil && receivedPermission.State == communities.TokenPermissionApproved } // Control node receives community event & approves it _, err = WaitOnMessengerResponse(base.GetControlNode(), responseHasApprovedTokenPermission, "community with approved permission not found") s.Require().NoError(err) // Member receives updated community description _, err = WaitOnMessengerResponse(base.GetMember(), responseHasApprovedTokenPermission, "community with approved permission not found") s.Require().NoError(err) // EventSender receives updated community description _, err = WaitOnMessengerResponse(base.GetEventSender(), responseHasApprovedTokenPermission, "community with approved permission not found") s.Require().NoError(err) return addedPermission.Id, request } func createTestTokenPermission(base CommunityEventsTestsInterface, community *communities.Community, pType protobuf.CommunityTokenPermission_Type) (string, *requests.CreateCommunityTokenPermission) { createTokenPermissionRequest := createTestPermissionRequest(community, pType) return createTokenPermission(base, community, createTokenPermissionRequest) } func editTokenPermission(base CommunityEventsTestsInterface, community *communities.Community, request *requests.EditCommunityTokenPermission) { s := base.GetSuite() response, err := base.GetEventSender().EditCommunityTokenPermission(request) s.Require().NoError(err) s.Require().Len(response.CommunityChanges, 1) s.Require().Len(response.CommunityChanges[0].TokenPermissionsModified, 1) editedPermission := response.CommunityChanges[0].TokenPermissionsModified[request.PermissionID] s.Require().NotNil(editedPermission) // Permission edited by event must be in pending state s.Require().Equal(communities.TokenPermissionUpdatePending, editedPermission.State) permissionSatisfyRequest := func(p *communities.CommunityTokenPermission) bool { return request.Type == p.Type && request.TokenCriteria[0].Symbol == p.TokenCriteria[0].Symbol && request.TokenCriteria[0].AmountInWei == p.TokenCriteria[0].AmountInWei && request.TokenCriteria[0].Decimals == p.TokenCriteria[0].Decimals } s.Require().True(permissionSatisfyRequest(editedPermission)) responseHasApprovedEditedTokenPermission := func(r *MessengerResponse) bool { if len(r.Communities()) == 0 { return false } receivedPermission := r.Communities()[0].TokenPermissionByID(editedPermission.Id) return receivedPermission != nil && receivedPermission.State == communities.TokenPermissionApproved && permissionSatisfyRequest(receivedPermission) } // Control node receives community event & approves it _, err = WaitOnMessengerResponse(base.GetControlNode(), responseHasApprovedEditedTokenPermission, "community with approved permission not found") s.Require().NoError(err) // Member receives updated community description _, err = WaitOnMessengerResponse(base.GetMember(), responseHasApprovedEditedTokenPermission, "community with approved permission not found") s.Require().NoError(err) // EventSender receives updated community description _, err = WaitOnMessengerResponse(base.GetEventSender(), responseHasApprovedEditedTokenPermission, "community with approved permission not found") s.Require().NoError(err) } func deleteTokenPermission(base CommunityEventsTestsInterface, community *communities.Community, request *requests.DeleteCommunityTokenPermission) { response, err := base.GetEventSender().DeleteCommunityTokenPermission(request) s := base.GetSuite() s.Require().NoError(err) s.Require().Len(response.CommunityChanges, 1) s.Require().Len(response.CommunityChanges[0].TokenPermissionsModified, 1) removedPermission := response.CommunityChanges[0].TokenPermissionsModified[request.PermissionID] s.Require().NotNil(removedPermission) // Permission removed by event must be in pending state s.Require().Equal(communities.TokenPermissionRemovalPending, removedPermission.State) responseHasNoTokenPermission := func(r *MessengerResponse) bool { if len(r.Communities()) == 0 { return false } return r.Communities()[0].TokenPermissionByID(removedPermission.Id) == nil } // Control node receives community event & approves it _, err = WaitOnMessengerResponse(base.GetControlNode(), responseHasNoTokenPermission, "community with approved permission not found") s.Require().NoError(err) // Member receives updated community description _, err = WaitOnMessengerResponse(base.GetMember(), responseHasNoTokenPermission, "community with approved permission not found") s.Require().NoError(err) // EventSender receives updated community description _, err = WaitOnMessengerResponse(base.GetEventSender(), responseHasNoTokenPermission, "community with approved permission not found") s.Require().NoError(err) } func assertCheckTokenPermissionCreated(s *suite.Suite, community *communities.Community, pType protobuf.CommunityTokenPermission_Type) { permissions := community.TokenPermissionsByType(pType) s.Require().Len(permissions, 1) s.Require().Len(permissions[0].TokenCriteria, 1) s.Require().Equal(permissions[0].TokenCriteria[0].Type, protobuf.CommunityTokenType_ERC20) s.Require().Equal(permissions[0].TokenCriteria[0].Symbol, "TEST") s.Require().Equal(permissions[0].TokenCriteria[0].Amount, "100") s.Require().Equal(permissions[0].TokenCriteria[0].Decimals, uint64(18)) } func setUpOnRequestCommunityAndRoles(base CommunityEventsTestsInterface, role protobuf.CommunityMember_Roles, additionalEventSenders []*Messenger) *communities.Community { base.SetupAdditionalMessengers(additionalEventSenders) tcs2, err := base.GetControlNode().communitiesManager.All() s := base.GetSuite() s.Require().NoError(err, "eventSender.communitiesManager.All") s.Len(tcs2, 0, "Must have 0 community") // control node creates a community and chat community := createTestCommunity(base, protobuf.CommunityPermissions_MANUAL_ACCEPT) refreshMessengerResponses(base) advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), base.GetEventSender()) advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), base.GetMember()) accountsTestData := base.GetAccountsTestData() accounts := accountsTestData[base.GetEventSender().IdentityPublicKeyString()] accountsPasswords := base.GetAccountsPasswords() password := accountsPasswords[base.GetEventSender().IdentityPublicKeyString()] joinOnRequestCommunity(s, community.ID(), base.GetControlNode(), base.GetEventSender(), password, accounts) accounts = accountsTestData[base.GetEventSender().IdentityPublicKeyString()] password = accountsPasswords[base.GetEventSender().IdentityPublicKeyString()] joinOnRequestCommunity(s, community.ID(), base.GetControlNode(), base.GetMember(), password, accounts) checkMemberJoined := func(response *MessengerResponse) error { return checkMemberJoinedToTheCommunity(response, base.GetMember().IdentityPublicKey()) } waitOnMessengerResponse(s, checkMemberJoined, base.GetEventSender()) // grant permissions to event sender checkPermissionGranted := func(response *MessengerResponse) error { return checkRolePermissionInResponse(response, base.GetEventSender().IdentityPublicKey(), role) } if role != protobuf.CommunityMember_ROLE_NONE { grantPermission(s, community, base.GetControlNode(), base.GetEventSender(), role) waitOnMessengerResponse(s, checkPermissionGranted, base.GetMember()) } for _, eventSender := range additionalEventSenders { advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), eventSender) accounts = accountsTestData[base.GetEventSender().IdentityPublicKeyString()] password = accountsPasswords[base.GetEventSender().IdentityPublicKeyString()] joinOnRequestCommunity(s, community.ID(), base.GetControlNode(), eventSender, password, accounts) if role != protobuf.CommunityMember_ROLE_NONE { grantPermission(s, community, base.GetControlNode(), eventSender, role) waitOnMessengerResponse(s, checkPermissionGranted, base.GetMember()) waitOnMessengerResponse(s, checkPermissionGranted, base.GetEventSender()) } } return community } func createCommunityCategory(base CommunityEventsTestsInterface, community *communities.Community, newCategory *requests.CreateCommunityCategory) string { checkCategoryCreated := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } for _, category := range modifiedCommmunity.Categories() { if category.GetName() == newCategory.CategoryName { return nil } } return errors.New("couldn't find created Category in the response") } response, err := base.GetEventSender().CreateCommunityCategory(newCategory) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkCategoryCreated(response)) s.Require().Len(response.Communities(), 1) s.Require().Len(response.CommunityChanges[0].CategoriesAdded, 1) var categoryID string for categoryID = range response.CommunityChanges[0].CategoriesAdded { break } checkClientsReceivedAdminEvent(base, checkCategoryCreated) return categoryID } func editCommunityCategory(base CommunityEventsTestsInterface, communityID string, editCategory *requests.EditCommunityCategory) { checkCategoryEdited := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, communityID) if err != nil { return err } for _, category := range modifiedCommmunity.Categories() { if category.GetName() == editCategory.CategoryName { return nil } } return errors.New("couldn't find edited Category in the response") } response, err := base.GetEventSender().EditCommunityCategory(editCategory) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkCategoryEdited(response)) checkClientsReceivedAdminEvent(base, checkCategoryEdited) } func deleteCommunityCategory(base CommunityEventsTestsInterface, communityID string, deleteCategory *requests.DeleteCommunityCategory) { checkCategoryDeleted := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, communityID) if err != nil { return err } if _, exists := modifiedCommmunity.Chats()[deleteCategory.CategoryID]; exists { return errors.New("community was not deleted") } return nil } response, err := base.GetEventSender().DeleteCommunityCategory(deleteCategory) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkCategoryDeleted(response)) checkClientsReceivedAdminEvent(base, checkCategoryDeleted) } func reorderCategory(base CommunityEventsTestsInterface, reorderRequest *requests.ReorderCommunityCategories) { checkCategoryReorder := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(reorderRequest.CommunityID)) if err != nil { return err } category, exist := modifiedCommmunity.Categories()[reorderRequest.CategoryID] if !exist { return errors.New("couldn't find community category") } if int(category.Position) != reorderRequest.Position { return errors.New("category was not reordered") } return nil } response, err := base.GetEventSender().ReorderCommunityCategories(reorderRequest) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkCategoryReorder(response)) checkClientsReceivedAdminEvent(base, checkCategoryReorder) } func reorderChannel(base CommunityEventsTestsInterface, reorderRequest *requests.ReorderCommunityChat) { checkChannelReorder := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(reorderRequest.CommunityID)) if err != nil { return err } chat, exist := modifiedCommmunity.Chats()[reorderRequest.ChatID] if !exist { return errors.New("couldn't find community chat") } if int(chat.Position) != reorderRequest.Position { return errors.New("chat position was not reordered") } if chat.CategoryId != reorderRequest.CategoryID { return errors.New("chat category was not reordered") } return nil } response, err := base.GetEventSender().ReorderCommunityChat(reorderRequest) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkChannelReorder(response)) checkClientsReceivedAdminEvent(base, checkChannelReorder) } func kickMember(base CommunityEventsTestsInterface, communityID types.HexBytes, pubkey string) { checkKicked := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(communityID)) if err != nil { return err } if modifiedCommmunity.HasMember(&base.GetMember().identity.PublicKey) { return errors.New("alice was not kicked") } if len(modifiedCommmunity.PendingAndBannedMembers()) > 0 { return errors.New("alice was kicked and should not be presented in the pending list") } return nil } response, err := base.GetEventSender().RemoveUserFromCommunity( communityID, pubkey, ) s := base.GetSuite() s.Require().NoError(err) // 1. event sender should get pending state for kicked member modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(communityID)) s.Require().NoError(err) s.Require().True(modifiedCommmunity.HasMember(&base.GetMember().identity.PublicKey)) s.Require().Equal(communities.CommunityMemberKickPending, modifiedCommmunity.PendingAndBannedMembers()[pubkey]) // 2. wait for event as a sender waitOnMessengerResponse(s, func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(communityID)) if err != nil { return err } if !modifiedCommmunity.HasMember(&base.GetMember().identity.PublicKey) { return errors.New("alice should not be not kicked (yet)") } if modifiedCommmunity.PendingAndBannedMembers()[pubkey] != communities.CommunityMemberKickPending { return errors.New("alice should be in the pending state") } return nil }, base.GetEventSender()) // 3. wait for event as the community member and check we are still until control node gets it waitOnMessengerResponse(s, func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(communityID)) if err != nil { return err } if !modifiedCommmunity.HasMember(&base.GetMember().identity.PublicKey) { return errors.New("alice should not be not kicked (yet)") } if len(modifiedCommmunity.PendingAndBannedMembers()) == 0 { return errors.New("alice should know about banned and pending members") } return nil }, base.GetMember()) // 4. control node should handle event and actually kick member waitOnMessengerResponse(s, checkKicked, base.GetControlNode()) // 5. event sender get removed member waitOnMessengerResponse(s, checkKicked, base.GetEventSender()) // 6. member should be notified about actual removal waitOnMessengerResponse(s, checkKicked, base.GetMember()) } func banMember(base CommunityEventsTestsInterface, banRequest *requests.BanUserFromCommunity) { bannedPK := banRequest.User.String() communityStr := banRequest.CommunityID.String() checkBanned := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(banRequest.CommunityID)) if err != nil { return err } if modifiedCommmunity.HasMember(&base.GetMember().identity.PublicKey) { return errors.New("alice was not removed from the member list") } if !modifiedCommmunity.IsBanned(&base.GetMember().identity.PublicKey) { return errors.New("alice was not added to the banned list") } expectedState := communities.CommunityMemberBanned if banRequest.DeleteAllMessages { expectedState = communities.CommunityMemberBanWithAllMessagesDelete } if modifiedCommmunity.PendingAndBannedMembers()[bannedPK] != expectedState { return errors.New("alice should be in the pending state") } if banRequest.DeleteAllMessages { if len(response.DeletedMessages()) == 0 { return errors.New("alice message must be deleted") } } return nil } response, err := base.GetEventSender().BanUserFromCommunity(context.Background(), banRequest) s := base.GetSuite() s.Require().NoError(err) // 1. event sender should get pending state for ban member modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(banRequest.CommunityID)) s.Require().NoError(err) s.Require().True(modifiedCommmunity.HasMember(&base.GetMember().identity.PublicKey)) s.Require().Equal(communities.CommunityMemberBanPending, modifiedCommmunity.PendingAndBannedMembers()[bannedPK]) verifier := "event sender" verifyPendingState := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(banRequest.CommunityID)) if err != nil { return err } if !modifiedCommmunity.HasMember(&base.GetMember().identity.PublicKey) { return errors.New(verifier + ": alice should not be not banned (yet)") } state, exists := modifiedCommmunity.PendingAndBannedMembers()[bannedPK] if !exists { return errors.New(verifier + ": alice is not in the pending and banned members list") } if state != communities.CommunityMemberBanPending { return errors.New("event sender: alice has invalid state: " + string(state)) } return nil } // 2. wait for event as a sender waitOnMessengerResponse(s, verifyPendingState, base.GetEventSender()) // 3. wait for event as the community member and check we are still until control node gets it verifier = "alice" waitOnMessengerResponse(s, verifyPendingState, base.GetMember()) checkMsgDeletion := func(messenger *Messenger, expectedMsgsCount int) { msgs, err := messenger.persistence.GetCommunityMemberMessagesToDelete(bannedPK, communityStr) s.Require().NoError(err) s.Require().Len(msgs, expectedMsgsCount) } if banRequest.DeleteAllMessages { checkMsgDeletion(base.GetEventSender(), 1) checkMsgDeletion(base.GetMember(), 1) } // 4. control node should handle event and actually ban member waitOnMessengerResponse(s, checkBanned, base.GetControlNode()) // 5. event sender get banned member waitOnMessengerResponse(s, checkBanned, base.GetEventSender()) // 6. member should be notified about actual removal waitOnMessengerResponse(s, checkBanned, base.GetMember()) if banRequest.DeleteAllMessages { checkMsgDeletion(base.GetEventSender(), 0) checkMsgDeletion(base.GetMember(), 0) checkMsgDeletion(base.GetControlNode(), 0) } } func unbanMember(base CommunityEventsTestsInterface, unbanRequest *requests.UnbanUserFromCommunity) { pubkey := common.PubkeyToHex(&base.GetMember().identity.PublicKey) checkUnbanned := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(unbanRequest.CommunityID)) if err != nil { return err } if modifiedCommmunity.IsBanned(&base.GetMember().identity.PublicKey) { return errors.New("alice was not unbanned") } if modifiedCommmunity.PendingAndBannedMembers()[pubkey] != communities.CommunityMemberBanned { return errors.New("alice should be in the pending state") } return nil } response, err := base.GetEventSender().UnbanUserFromCommunity(unbanRequest) s := base.GetSuite() s.Require().NoError(err) // 1. event sender should get pending state for unban member modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(unbanRequest.CommunityID)) s.Require().NoError(err) s.Require().Equal(communities.CommunityMemberUnbanPending, modifiedCommmunity.PendingAndBannedMembers()[pubkey]) // 2. wait for event as a sender waitOnMessengerResponse(s, func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(unbanRequest.CommunityID)) if err != nil { return err } if modifiedCommmunity.PendingAndBannedMembers()[pubkey] != communities.CommunityMemberUnbanPending { return errors.New("alice should be in the pending state") } return nil }, base.GetEventSender()) // 3. wait for event as the community member and check we are still until control node gets it waitOnMessengerResponse(s, func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, types.EncodeHex(unbanRequest.CommunityID)) if err != nil { return err } if len(modifiedCommmunity.PendingAndBannedMembers()) == 0 { return errors.New("alice should know about banned and pending members") } return nil }, base.GetMember()) // 4. control node should handle event and actually unban member waitOnMessengerResponse(s, checkUnbanned, base.GetControlNode()) // 5. event sender get removed member waitOnMessengerResponse(s, checkUnbanned, base.GetEventSender()) // 6. member should be notified about actual removal waitOnMessengerResponse(s, checkUnbanned, base.GetMember()) } func controlNodeSendMessage(base CommunityEventsTestsInterface, inputMessage *common.Message) string { response, err := base.GetControlNode().SendChatMessage(context.Background(), inputMessage) s := base.GetSuite() s.Require().NoError(err) message := response.Messages()[0] s.Require().Equal(inputMessage.Text, message.Text) messageID := message.ID response, err = WaitOnMessengerResponse(base.GetEventSender(), WaitMessageCondition, "messages not received") s.Require().NoError(err) message = response.Messages()[0] s.Require().Equal(inputMessage.Text, message.Text) response, err = WaitOnMessengerResponse(base.GetMember(), WaitMessageCondition, "messages not received") s.Require().NoError(err) message = response.Messages()[0] s.Require().Equal(inputMessage.Text, message.Text) refreshMessengerResponses(base) return messageID } func deleteControlNodeMessage(base CommunityEventsTestsInterface, messageID string) { checkMessageDeleted := func(response *MessengerResponse) error { if len(response.RemovedMessages()) > 0 { return nil } return errors.New("message was not deleted") } response, err := base.GetEventSender().DeleteMessageAndSend(context.Background(), messageID) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkMessageDeleted(response)) waitOnMessengerResponse(s, checkMessageDeleted, base.GetMember()) waitOnMessengerResponse(s, checkMessageDeleted, base.GetControlNode()) } func pinControlNodeMessage(base CommunityEventsTestsInterface, pinnedMessage *common.PinMessage) { checkPinned := func(response *MessengerResponse) error { if len(response.Messages()) == 0 { return errors.New("no messages in the response") } if len(response.PinMessages()) > 0 { return nil } return errors.New("pin messages was not added") } response, err := base.GetEventSender().SendPinMessage(context.Background(), pinnedMessage) s := base.GetSuite() s.Require().NoError(err) s.Require().NoError(checkPinned(response)) waitOnMessengerResponse(s, checkPinned, base.GetMember()) waitOnMessengerResponse(s, checkPinned, base.GetControlNode()) } func editCommunityDescription(base CommunityEventsTestsInterface, community *communities.Community) { expectedName := "edited community name" expectedColor := "#000000" expectedDescr := "edited community description" response, err := base.GetEventSender().EditCommunity(&requests.EditCommunity{ CommunityID: community.ID(), CreateCommunity: requests.CreateCommunity{ Membership: protobuf.CommunityPermissions_MANUAL_ACCEPT, Name: expectedName, Color: expectedColor, Description: expectedDescr, }, }) checkCommunityEdit := func(response *MessengerResponse) error { if len(response.Communities()) == 0 { return errors.New("community not received") } rCommunities := response.Communities() if expectedName != rCommunities[0].Name() { return errors.New("incorrect community name") } if expectedColor != rCommunities[0].Color() { return errors.New("incorrect community color") } if expectedDescr != rCommunities[0].DescriptionText() { return errors.New("incorrect community description") } return nil } s := base.GetSuite() s.Require().NoError(err) s.Require().Nil(checkCommunityEdit(response)) checkClientsReceivedAdminEvent(base, checkCommunityEdit) } func controlNodeCreatesCommunityPermission(base CommunityEventsTestsInterface, community *communities.Community, permissionRequest *requests.CreateCommunityTokenPermission) string { // control node creates permission response, err := base.GetControlNode().CreateCommunityTokenPermission(permissionRequest) s := base.GetSuite() s.Require().NoError(err) var tokenPermissionID string for id := range response.CommunityChanges[0].TokenPermissionsAdded { tokenPermissionID = id } s.Require().NotEqual(tokenPermissionID, "") ownerCommunity, err := base.GetControlNode().communitiesManager.GetByID(community.ID()) s.Require().NoError(err) assertCheckTokenPermissionCreated(s, ownerCommunity, permissionRequest.Type) // then, ensure event sender receives updated community resp, err := WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && len(r.Communities()[0].TokenPermissionsByType(permissionRequest.Type)) > 0 && r.Communities()[0].HasPermissionToSendCommunityEvents() }, "event sender did not receive community token permission", ) s.Require().NoError(err) s.Require().NotNil(resp) eventSenderCommunity, err := base.GetEventSender().communitiesManager.GetByID(community.ID()) s.Require().NoError(err) assertCheckTokenPermissionCreated(s, eventSenderCommunity, permissionRequest.Type) s.Require().True(eventSenderCommunity.HasPermissionToSendCommunityEvents()) return tokenPermissionID } func testCreateEditDeleteChannels(base CommunityEventsTestsInterface, community *communities.Community) { newChat := &protobuf.CommunityChat{ Permissions: &protobuf.CommunityPermissions{ Access: protobuf.CommunityPermissions_AUTO_ACCEPT, }, Identity: &protobuf.ChatIdentity{ DisplayName: "chat from the event sender", Emoji: "", Description: "chat created by an event sender", }, } newChatID := createCommunityChannel(base, community, newChat) newChat.Identity.DisplayName = "modified chat from event sender" editCommunityChannel(base, community, newChat, newChatID) deleteCommunityChannel(base, community, newChatID) } func testCreateEditDeleteBecomeMemberPermission(base CommunityEventsTestsInterface, community *communities.Community, pType protobuf.CommunityTokenPermission_Type) { // first, create token permission tokenPermissionID, createTokenPermission := createTestTokenPermission(base, community, pType) createTokenPermission.TokenCriteria[0].Symbol = "UPDATED" createTokenPermission.TokenCriteria[0].AmountInWei = "200000000000000000000" editTokenPermissionRequest := &requests.EditCommunityTokenPermission{ PermissionID: tokenPermissionID, CreateCommunityTokenPermission: *createTokenPermission, } // then, event sender edits the permission editTokenPermission(base, community, editTokenPermissionRequest) deleteTokenPermissionRequest := &requests.DeleteCommunityTokenPermission{ CommunityID: community.ID(), PermissionID: tokenPermissionID, } // then, event sender deletes previously created token permission deleteTokenPermission(base, community, deleteTokenPermissionRequest) } // To be removed in https://github.com/status-im/status-go/issues/4437 func advertiseCommunityToUserOldWay(s *suite.Suite, community *communities.Community, owner *Messenger, user *Messenger) { chat := CreateOneToOneChat(common.PubkeyToHex(&user.identity.PublicKey), &user.identity.PublicKey, user.transport) inputMessage := common.NewMessage() inputMessage.ChatId = chat.ID inputMessage.Text = "some text" inputMessage.CommunityID = community.IDString() err := owner.SaveChat(chat) s.Require().NoError(err) _, err = owner.SendChatMessage(context.Background(), inputMessage) s.Require().NoError(err) // Ensure community is received _, err = WaitOnMessengerResponse( user, func(r *MessengerResponse) bool { if len(r.Communities()) != 1 { return false } c := r.Communities()[0] return c.IDString() == community.IDString() && c.Clock() >= community.Clock() }, "no community received", ) s.Require().NoError(err) } func testAcceptMemberRequestToJoin(base CommunityEventsTestsInterface, community *communities.Community, user *Messenger) { s := base.GetSuite() advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), user) // user sends request to join requestID := testSendRequestToJoin(base, user, community.ID()) checkRequestToJoin := func(r *MessengerResponse) bool { if len(r.RequestsToJoinCommunity()) == 0 { return false } for _, request := range r.RequestsToJoinCommunity() { if request.PublicKey == user.IdentityPublicKeyString() { return true } } return false } // event sender receives request to join response, err := WaitOnMessengerResponse( base.GetEventSender(), checkRequestToJoin, "event sender did not receive community request to join", ) s.Require().NoError(err) s.Require().Len(response.RequestsToJoinCommunity(), 1) // event sender has not accepted request yet eventSenderCommunity, err := base.GetEventSender().GetCommunityByID(community.ID()) s.Require().NoError(err) s.Require().False(eventSenderCommunity.HasMember(&user.identity.PublicKey)) acceptRequestToJoin := &requests.AcceptRequestToJoinCommunity{ID: requestID} response, err = base.GetEventSender().AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.Communities(), 1) // we don't expect `user` to be a member already, because `eventSender` merely // forwards its accept decision to the control node s.Require().False(response.Communities()[0].HasMember(&user.identity.PublicKey)) // at this point, the request to join is marked as accepted by GetEventSender node acceptedRequestsPending, err := base.GetEventSender().AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(acceptedRequestsPending, 1) s.Require().Equal(acceptedRequestsPending[0].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) // control node receives community event with accepted membership request _, err = WaitOnMessengerResponse( base.GetControlNode(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "control node did not receive community request to join response", ) s.Require().NoError(err) // at this point, the request to join is marked as accepted by control node acceptedRequests, err := base.GetControlNode().AcceptedRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) // we expect 3 here (1 event senders, 1 member + 1 from user) s.Require().Len(acceptedRequests, 3) s.Require().Equal(acceptedRequests[2].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) // user receives updated community _, err = WaitOnMessengerResponse( user, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "alice did not receive community request to join response", ) s.Require().NoError(err) // event sender receives updated community _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "event sender did not receive community with the new member", ) s.Require().NoError(err) // check control node notify event sender about accepting request to join _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { acceptedRequests, err := base.GetEventSender().AcceptedRequestsToJoinForCommunity(community.ID()) return err == nil && len(acceptedRequests) == 2 && (acceptedRequests[1].PublicKey == common.PubkeyToHex(&user.identity.PublicKey)) }, "no updates from control node", ) s.Require().NoError(err) acceptedRequestsPending, err = base.GetEventSender().AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(acceptedRequestsPending, 0) } func testAcceptMemberRequestToJoinResponseSharedWithOtherEventSenders(base CommunityEventsTestsInterface, community *communities.Community, user *Messenger, additionalEventSender *Messenger) { s := base.GetSuite() advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), user) // user sends request to join requestID := testSendRequestToJoin(base, user, community.ID()) checkRequestToJoin := func(r *MessengerResponse) bool { if len(r.RequestsToJoinCommunity()) == 0 { return false } for _, request := range r.RequestsToJoinCommunity() { if request.PublicKey == user.IdentityPublicKeyString() { return true } } return false } // event sender receives request to join _, err := WaitOnMessengerResponse( base.GetEventSender(), checkRequestToJoin, "event sender did not receive community request to join", ) s.Require().NoError(err) // event sender 2 receives request to join _, err = WaitOnMessengerResponse( additionalEventSender, checkRequestToJoin, "event sender did not receive community request to join", ) s.Require().NoError(err) // event sender 1 accepts request acceptRequestToJoin := &requests.AcceptRequestToJoinCommunity{ID: requestID} response, err := base.GetEventSender().AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.Communities(), 1) // event sender 2 receives decision of other event sender _, err = WaitOnMessengerResponse( additionalEventSender, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 }, "event sender did not receive community request to join", ) s.Require().NoError(err) // at this point, the request to join is in accepted/pending state for event sender 2 acceptedPendingRequests, err := additionalEventSender.AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(acceptedPendingRequests, 1) s.Require().Equal(acceptedPendingRequests[0].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) // event sender 1 changes its mind and rejects the request rejectRequestToJoin := &requests.DeclineRequestToJoinCommunity{ID: requestID} response, err = base.GetEventSender().DeclineRequestToJoinCommunity(rejectRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) // event sender 2 receives updated decision of other event sender _, err = WaitOnMessengerResponse( additionalEventSender, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 }, "event sender did not receive community request to join", ) s.Require().NoError(err) // at this point, the request to join is in declined/pending state for event sender 2 rejectedPendingRequests, err := additionalEventSender.DeclinedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(rejectedPendingRequests, 1) s.Require().Equal(rejectedPendingRequests[0].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) } func testRejectMemberRequestToJoinResponseSharedWithOtherEventSenders(base CommunityEventsTestsInterface, community *communities.Community, user *Messenger, additionalEventSender *Messenger) { s := base.GetSuite() advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), user) // user sends request to join requestID := testSendRequestToJoin(base, user, community.ID()) checkRequestToJoin := func(r *MessengerResponse) bool { if len(r.RequestsToJoinCommunity()) == 0 { return false } for _, request := range r.RequestsToJoinCommunity() { if request.PublicKey == user.IdentityPublicKeyString() { return true } } return false } // event sender receives request to join _, err := WaitOnMessengerResponse( base.GetEventSender(), checkRequestToJoin, "event sender did not receive community request to join", ) s.Require().NoError(err) // event sender 2 receives request to join _, err = WaitOnMessengerResponse( additionalEventSender, checkRequestToJoin, "event sender did not receive community request to join", ) s.Require().NoError(err) rejectRequestToJoin := &requests.DeclineRequestToJoinCommunity{ID: requestID} response, err := base.GetEventSender().DeclineRequestToJoinCommunity(rejectRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) // event sender 2 receives decision of other event sender _, err = WaitOnMessengerResponse( additionalEventSender, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 }, "event sender did not receive community request to join", ) s.Require().NoError(err) // at this point, the request to join is in declined/pending state for event sender 2 rejectedPendingRequests, err := additionalEventSender.DeclinedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(rejectedPendingRequests, 1) s.Require().Equal(rejectedPendingRequests[0].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) // event sender 1 changes its mind and accepts the request acceptRequestToJoin := &requests.AcceptRequestToJoinCommunity{ID: requestID} response, err = base.GetEventSender().AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.Communities(), 1) // event sender 2 receives updated decision of other event sender _, err = WaitOnMessengerResponse( additionalEventSender, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 }, "event sender did not receive community request to join", ) s.Require().NoError(err) // at this point, the request to join is in accepted/pending state for event sender 2 acceptedPendingRequests, err := additionalEventSender.AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(acceptedPendingRequests, 1) s.Require().Equal(acceptedPendingRequests[0].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) } func testRejectMemberRequestToJoin(base CommunityEventsTestsInterface, community *communities.Community, user *Messenger) { s := base.GetSuite() advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), user) // user sends request to join requestID := testSendRequestToJoin(base, user, community.ID()) // event sender receives request to join response, err := WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { return len(r.RequestsToJoinCommunity()) > 0 }, "event sender did not receive community request to join", ) s.Require().NoError(err) s.Require().Len(response.RequestsToJoinCommunity(), 1) // event sender has not accepted request yet eventSenderCommunity, err := base.GetEventSender().GetCommunityByID(community.ID()) s.Require().NoError(err) s.Require().False(eventSenderCommunity.HasMember(&user.identity.PublicKey)) // event sender rejects request to join rejectRequestToJoin := &requests.DeclineRequestToJoinCommunity{ID: requestID} _, err = base.GetEventSender().DeclineRequestToJoinCommunity(rejectRequestToJoin) s.Require().NoError(err) eventSenderCommunity, err = base.GetEventSender().GetCommunityByID(community.ID()) s.Require().NoError(err) s.Require().False(eventSenderCommunity.HasMember(&user.identity.PublicKey)) requests, err := base.GetEventSender().DeclinedPendingRequestsToJoinForCommunity(community.ID()) s.Require().Len(requests, 1) s.Require().NoError(err) // control node receives event sender event and stores rejected request to join response, err = WaitOnMessengerResponse( base.GetControlNode(), func(r *MessengerResponse) bool { requests, err := base.GetControlNode().DeclinedRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) return len(requests) == 1 && requests[0].State == communities.RequestToJoinStateDeclined }, "control node did not receive community request to join update from event sender", ) s.Require().NoError(err) s.Require().False(response.Communities()[0].HasMember(&user.identity.PublicKey)) requests, err = base.GetControlNode().DeclinedRequestsToJoinForCommunity(community.ID()) s.Require().Len(requests, 1) s.Require().NoError(err) // event sender receives updated community _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && !r.Communities()[0].HasMember(&user.identity.PublicKey) && checkRequestToJoinInResponse(r, user, communities.RequestToJoinStateDeclined, 0) }, "event sender did not receive community update", ) s.Require().NoError(err) // check control node notify event sender about declined request to join _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { declinedRequests, err := base.GetEventSender().DeclinedRequestsToJoinForCommunity(community.ID()) return err == nil && len(declinedRequests) == 1 }, "no updates from control node", ) s.Require().NoError(err) declinedRequestsPending, err := base.GetEventSender().DeclinedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(declinedRequestsPending, 0) } func testControlNodeHandlesMultipleEventSenderRequestToJoinDecisions(base CommunityEventsTestsInterface, community *communities.Community, user *Messenger, additionalEventSender *Messenger) { _, err := user.Start() s := base.GetSuite() s.Require().NoError(err) defer TearDownMessenger(s, user) advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), user) // user sends request to join requestID := testSendRequestToJoin(base, user, community.ID()) // event sender receives request to join _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { return checkRequestToJoinInResponse(r, user, communities.RequestToJoinStatePending, 0) }, "event sender did not receive community request to join", ) s.Require().NoError(err) // event sender 2 receives request to join _, err = WaitOnMessengerResponse( additionalEventSender, func(r *MessengerResponse) bool { return checkRequestToJoinInResponse(r, user, communities.RequestToJoinStatePending, 0) }, "event sender 2 did not receive community request to join", ) s.Require().NoError(err) // event sender 1 rejects request to join rejectRequestToJoin := &requests.DeclineRequestToJoinCommunity{ID: requestID} _, err = base.GetEventSender().DeclineRequestToJoinCommunity(rejectRequestToJoin) s.Require().NoError(err) // request to join is now marked as rejected pending for event sender 1 rejectedPendingRequests, err := base.GetEventSender().DeclinedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().NotNil(rejectedPendingRequests) s.Require().Len(rejectedPendingRequests, 1) // control node receives event sender 1's and 2's decision _, err = WaitOnMessengerResponse( base.GetControlNode(), func(r *MessengerResponse) bool { return checkRequestToJoinInResponse(r, user, communities.RequestToJoinStateDeclinedPending, 0) }, "control node did not receive event senders decision", ) s.Require().NoError(err) err = tt.RetryWithBackOff(func() error { // request to join is now marked as rejected rejectedRequests, err := base.GetControlNode().DeclinedRequestsToJoinForCommunity(community.ID()) if err != nil { return err } if len(rejectedRequests) != 1 { return errors.New("rejected requests should be 1") } if rejectedRequests[0].PublicKey != common.PubkeyToHex(&user.identity.PublicKey) { return errors.New("public key of rejected request not matching") } return nil }) s.Require().NoError(err) // event sender 2 accepts request to join acceptRequestToJoin := &requests.AcceptRequestToJoinCommunity{ID: requestID} _, err = additionalEventSender.AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) // request to join is now marked as accepted pending for event sender 2 acceptedPendingRequests, err := additionalEventSender.AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().NotNil(acceptedPendingRequests) s.Require().Len(acceptedPendingRequests, 1) // control node now receives event sender 2's decision _, err = WaitOnMessengerResponse( base.GetControlNode(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 }, "control node did not receive event senders decision", ) s.Require().NoError(err) err = tt.RetryWithBackOff(func() error { rejectedRequests, err := base.GetControlNode().DeclinedRequestsToJoinForCommunity(community.ID()) if err != nil { return err } if len(rejectedRequests) != 1 { return errors.New("rejected requests should be 1") } // we expect user's request to join still to be rejected if rejectedRequests[0].PublicKey != common.PubkeyToHex(&user.identity.PublicKey) { return errors.New("public key of rejected request not matching") } return nil }) s.Require().NoError(err) } func testCreateEditDeleteCategories(base CommunityEventsTestsInterface, community *communities.Community) { newCategory := &requests.CreateCommunityCategory{ CommunityID: community.ID(), CategoryName: "event-sender-category-name", } categoryID := createCommunityCategory(base, community, newCategory) editCategory := &requests.EditCommunityCategory{ CommunityID: community.ID(), CategoryID: categoryID, CategoryName: "edited-event-sender-category-name", } editCommunityCategory(base, community.IDString(), editCategory) deleteCategory := &requests.DeleteCommunityCategory{ CommunityID: community.ID(), CategoryID: categoryID, } deleteCommunityCategory(base, community.IDString(), deleteCategory) } func testReorderChannelsAndCategories(base CommunityEventsTestsInterface, community *communities.Community) { newCategory := &requests.CreateCommunityCategory{ CommunityID: community.ID(), CategoryName: "event-sender-category-name", } _ = createCommunityCategory(base, community, newCategory) newCategory.CategoryName = "event-sender-category-name2" categoryID2 := createCommunityCategory(base, community, newCategory) chat := &protobuf.CommunityChat{ Permissions: &protobuf.CommunityPermissions{ Access: protobuf.CommunityPermissions_AUTO_ACCEPT, }, Identity: &protobuf.ChatIdentity{ DisplayName: "chat from event-sender", Emoji: "", Description: "chat created by an event-sender", }, } chatID := createCommunityChannel(base, community, chat) reorderCommunityRequest := requests.ReorderCommunityCategories{ CommunityID: community.ID(), CategoryID: categoryID2, Position: 0, } reorderCategory(base, &reorderCommunityRequest) reorderChatRequest := requests.ReorderCommunityChat{ CommunityID: community.ID(), CategoryID: categoryID2, ChatID: chatID, Position: 0, } reorderChannel(base, &reorderChatRequest) } func testEventSenderKickTheSameRole(base CommunityEventsTestsInterface, community *communities.Community) { // event sender tries to kick the member with the same role _, err := base.GetEventSender().RemoveUserFromCommunity( community.ID(), common.PubkeyToHex(&base.GetEventSender().identity.PublicKey), ) s := base.GetSuite() s.Require().Error(err) s.Require().EqualError(err, "not allowed to remove admin or owner") } func testEventSenderKickControlNode(base CommunityEventsTestsInterface, community *communities.Community) { // event sender tries to kick the control node _, err := base.GetEventSender().RemoveUserFromCommunity( community.ID(), common.PubkeyToHex(&base.GetControlNode().identity.PublicKey), ) s := base.GetSuite() s.Require().Error(err) s.Require().EqualError(err, "not allowed to remove admin or owner") } func testOwnerBanTheSameRole(base CommunityEventsTestsInterface, community *communities.Community) { _, err := base.GetEventSender().BanUserFromCommunity( context.Background(), &requests.BanUserFromCommunity{ CommunityID: community.ID(), User: common.PubkeyToHexBytes(&base.GetEventSender().identity.PublicKey), }, ) s := base.GetSuite() s.Require().Error(err) s.Require().EqualError(err, "not allowed to ban admin or owner") } func testOwnerBanControlNode(base CommunityEventsTestsInterface, community *communities.Community) { _, err := base.GetEventSender().BanUserFromCommunity( context.Background(), &requests.BanUserFromCommunity{ CommunityID: community.ID(), User: common.PubkeyToHexBytes(&base.GetControlNode().identity.PublicKey), }, ) s := base.GetSuite() s.Require().Error(err) s.Require().EqualError(err, "not allowed to ban admin or owner") } func testBanUnbanMember(base CommunityEventsTestsInterface, community *communities.Community) { // verify that event sender can't ban a control node _, err := base.GetEventSender().BanUserFromCommunity( context.Background(), &requests.BanUserFromCommunity{ CommunityID: community.ID(), User: common.PubkeyToHexBytes(&base.GetControlNode().identity.PublicKey), }, ) s := base.GetSuite() s.Require().Error(err) banRequest := &requests.BanUserFromCommunity{ CommunityID: community.ID(), User: common.PubkeyToHexBytes(&base.GetMember().identity.PublicKey), } banMember(base, banRequest) unbanRequest := &requests.UnbanUserFromCommunity{ CommunityID: community.ID(), User: common.PubkeyToHexBytes(&base.GetMember().identity.PublicKey), } unbanMember(base, unbanRequest) } func testDeleteAnyMessageInTheCommunity(base CommunityEventsTestsInterface, community *communities.Community) { chatID := community.ChatIDs()[0] inputMessage := common.NewMessage() inputMessage.ChatId = chatID inputMessage.ContentType = protobuf.ChatMessage_TEXT_PLAIN inputMessage.Text = "control node text" messageID := controlNodeSendMessage(base, inputMessage) deleteControlNodeMessage(base, messageID) } func testEventSenderPinMessage(base CommunityEventsTestsInterface, community *communities.Community) { s := base.GetSuite() s.Require().False(community.AllowsAllMembersToPinMessage()) chatID := community.ChatIDs()[0] inputMessage := common.NewMessage() inputMessage.ChatId = chatID inputMessage.ContentType = protobuf.ChatMessage_TEXT_PLAIN inputMessage.Text = "control node text" messageID := controlNodeSendMessage(base, inputMessage) pinnedMessage := common.NewPinMessage() pinnedMessage.MessageId = messageID pinnedMessage.ChatId = chatID pinnedMessage.Pinned = true pinControlNodeMessage(base, pinnedMessage) } func testMemberReceiveEventsWhenControlNodeOffline(base CommunityEventsTestsInterface, community *communities.Community) { // To simulate behavior when control node is offline, we will not use control node for listening new events // In this scenario member will reveive list of events s := base.GetSuite() member := base.GetMember() eventSender := base.GetEventSender() newAdminChat := &protobuf.CommunityChat{ Permissions: &protobuf.CommunityPermissions{ Access: protobuf.CommunityPermissions_AUTO_ACCEPT, }, Identity: &protobuf.ChatIdentity{ DisplayName: "chat from event sender", Emoji: "", Description: "chat created by an event sender", }, } checkChannelCreated := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } for _, chat := range modifiedCommmunity.Chats() { if chat.GetIdentity().GetDisplayName() == newAdminChat.GetIdentity().GetDisplayName() { return nil } } return errors.New("couldn't find created chat in response") } response, err := eventSender.CreateCommunityChat(community.ID(), newAdminChat) s.Require().NoError(err) s.Require().NoError(checkChannelCreated(response)) s.Require().Len(response.CommunityChanges, 1) s.Require().Len(response.CommunityChanges[0].ChatsAdded, 1) var addedChatID string for addedChatID = range response.CommunityChanges[0].ChatsAdded { break } waitOnMessengerResponse(s, checkChannelCreated, member) waitOnMessengerResponse(s, checkChannelCreated, eventSender) newAdminChat.Identity.DisplayName = "modified chat from event sender" checkChannelEdited := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } for _, chat := range modifiedCommmunity.Chats() { if chat.GetIdentity().GetDisplayName() == newAdminChat.GetIdentity().GetDisplayName() { return nil } } return errors.New("couldn't find modified chat in response") } response, err = eventSender.EditCommunityChat(community.ID(), addedChatID, newAdminChat) s.Require().NoError(err) s.Require().NoError(checkChannelEdited(response)) waitOnMessengerResponse(s, checkChannelEdited, member) waitOnMessengerResponse(s, checkChannelEdited, eventSender) checkChannelDeleted := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } if _, exists := modifiedCommmunity.Chats()[addedChatID]; exists { return errors.New("channel was not deleted") } return nil } response, err = eventSender.DeleteCommunityChat(community.ID(), addedChatID) s.Require().NoError(err) s.Require().NoError(checkChannelDeleted(response)) waitOnMessengerResponse(s, checkChannelDeleted, member) waitOnMessengerResponse(s, checkChannelDeleted, eventSender) } func testEventSenderCannotDeletePrivilegedCommunityPermission(base CommunityEventsTestsInterface, community *communities.Community, testPermissionType protobuf.CommunityTokenPermission_Type, rolePermissionType protobuf.CommunityTokenPermission_Type) { // Community should have eventSenderRole permission or eventSender will loose his role // after control node create a new community permission if testPermissionType != rolePermissionType { rolePermission := createTestPermissionRequest(community, rolePermissionType) controlNodeCreatesCommunityPermission(base, community, rolePermission) } permissionRequest := createTestPermissionRequest(community, testPermissionType) tokenPermissionID := controlNodeCreatesCommunityPermission(base, community, permissionRequest) deleteTokenPermission := &requests.DeleteCommunityTokenPermission{ CommunityID: community.ID(), PermissionID: tokenPermissionID, } // then event sender tries to delete permission which should fail response, err := base.GetEventSender().DeleteCommunityTokenPermission(deleteTokenPermission) s := base.GetSuite() s.Require().Error(err) s.Require().Nil(response) } func testEventSenderCannotEditPrivilegedCommunityPermission(base CommunityEventsTestsInterface, community *communities.Community, testPermissionType protobuf.CommunityTokenPermission_Type, rolePermissionType protobuf.CommunityTokenPermission_Type) { // Community should have eventSenderRole permission or eventSender will loose his role // after control node create a new community permission if testPermissionType != rolePermissionType { rolePermission := createTestPermissionRequest(community, rolePermissionType) controlNodeCreatesCommunityPermission(base, community, rolePermission) } permissionRequest := createTestPermissionRequest(community, testPermissionType) tokenPermissionID := controlNodeCreatesCommunityPermission(base, community, permissionRequest) permissionRequest.TokenCriteria[0].Symbol = "UPDATED" permissionRequest.TokenCriteria[0].AmountInWei = "200000000000000000000" permissionEditRequest := &requests.EditCommunityTokenPermission{ PermissionID: tokenPermissionID, CreateCommunityTokenPermission: *permissionRequest, } // then, event sender tries to edit permission response, err := base.GetEventSender().EditCommunityTokenPermission(permissionEditRequest) s := base.GetSuite() s.Require().Error(err) s.Require().Nil(response) } func testAddAndSyncTokenFromControlNode(base CommunityEventsTestsInterface, community *communities.Community, privilegesLvl token.PrivilegesLevel) { tokenERC721 := createCommunityToken(community.IDString(), privilegesLvl) addCommunityTokenToCommunityTokensService(base, tokenERC721) s := base.GetSuite() _, err := base.GetControlNode().SaveCommunityToken(tokenERC721, nil) s.Require().NoError(err) err = base.GetControlNode().AddCommunityToken(tokenERC721.CommunityID, tokenERC721.ChainID, tokenERC721.Address) s.Require().NoError(err) tokens, err := base.GetEventSender().communitiesManager.GetAllCommunityTokens() s.Require().NoError(err) s.Require().Len(tokens, 0) checkTokenAdded := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } if privilegesLvl != token.CommunityLevel && len(modifiedCommmunity.TokenPermissions()) == 0 { return errors.New("Token permissions was not found") } for _, tokenMetadata := range modifiedCommmunity.CommunityTokensMetadata() { if tokenMetadata.Name == tokenERC721.Name { return nil } } return errors.New("Token was not found") } waitOnMessengerResponse(s, checkTokenAdded, base.GetMember()) waitOnMessengerResponse(s, checkTokenAdded, base.GetEventSender()) // check CommunityToken was added to the DB syncTokens, err := base.GetEventSender().communitiesManager.GetAllCommunityTokens() s.Require().NoError(err) s.Require().Len(syncTokens, 1) s.Require().Equal(syncTokens[0].PrivilegesLevel, privilegesLvl) // check CommunityToken was added to the DB syncTokens, err = base.GetMember().communitiesManager.GetAllCommunityTokens() s.Require().NoError(err) s.Require().Len(syncTokens, 1) } func testAddAndSyncOwnerTokenFromControlNode(base CommunityEventsTestsInterface, community *communities.Community, privilegesLvl token.PrivilegesLevel) { tokenERC721 := createCommunityToken(community.IDString(), privilegesLvl) addCommunityTokenToCommunityTokensService(base, tokenERC721) s := base.GetSuite() _, err := base.GetControlNode().SaveCommunityToken(tokenERC721, nil) s.Require().NoError(err) err = base.GetControlNode().AddCommunityToken(tokenERC721.CommunityID, tokenERC721.ChainID, tokenERC721.Address) s.Require().NoError(err) tokens, err := base.GetEventSender().communitiesManager.GetAllCommunityTokens() s.Require().NoError(err) s.Require().Len(tokens, 0) // we only check that the community has been queued for validation checkTokenAdded := func(response *MessengerResponse) error { member := base.GetMember() communitiesToValidate, err := member.communitiesManager.CommunitiesToValidate() if err != nil { return err } if len(communitiesToValidate) == 0 || communitiesToValidate[community.IDString()] == nil { return errors.New("no communities to validate") } return nil } waitOnMessengerResponse(s, checkTokenAdded, base.GetMember()) } func testEventSenderCannotCreatePrivilegedCommunityPermission(base CommunityEventsTestsInterface, community *communities.Community, pType protobuf.CommunityTokenPermission_Type) { permissionRequest := createTestPermissionRequest(community, pType) response, err := base.GetEventSender().CreateCommunityTokenPermission(permissionRequest) s := base.GetSuite() s.Require().Nil(response) s.Require().Error(err) } func createCommunityToken(communityID string, privilegesLevel token.PrivilegesLevel) *token.CommunityToken { return &token.CommunityToken{ CommunityID: communityID, TokenType: protobuf.CommunityTokenType_ERC721, Address: "0x123", Name: "StatusToken", Symbol: "STT", Description: "desc", Supply: &bigint.BigInt{Int: big.NewInt(123)}, InfiniteSupply: false, Transferable: true, RemoteSelfDestruct: true, ChainID: 1, DeployState: token.Deployed, Base64Image: "ABCD", PrivilegesLevel: privilegesLevel, } } func testAddAndSyncTokenFromEventSenderByControlNode(base CommunityEventsTestsInterface, community *communities.Community, privilegesLvl token.PrivilegesLevel) { tokenERC721 := createCommunityToken(community.IDString(), privilegesLvl) addCommunityTokenToCommunityTokensService(base, tokenERC721) s := base.GetSuite() _, err := base.GetEventSender().SaveCommunityToken(tokenERC721, nil) s.Require().NoError(err) err = base.GetEventSender().AddCommunityToken(tokenERC721.CommunityID, tokenERC721.ChainID, tokenERC721.Address) s.Require().NoError(err) tokens, err := base.GetControlNode().communitiesManager.GetAllCommunityTokens() s.Require().NoError(err) s.Require().Len(tokens, 0) checkTokenAdded := func(response *MessengerResponse) error { modifiedCommmunity, err := getModifiedCommunity(response, community.IDString()) if err != nil { return err } for _, tokenMetadata := range modifiedCommmunity.CommunityTokensMetadata() { if tokenMetadata.Name == tokenERC721.Name { return nil } } return errors.New("Token was not found") } checkClientsReceivedAdminEvent(base, checkTokenAdded) // check event sender sent sync message to the control node _, err = WaitOnMessengerResponse( base.GetControlNode(), func(r *MessengerResponse) bool { tokens, err := base.GetControlNode().communitiesManager.GetAllCommunityTokens() return err == nil && len(tokens) == 1 }, "no token sync message from event sender", ) s.Require().NoError(err) // check member received sync message with the token _, err = WaitOnMessengerResponse( base.GetMember(), func(r *MessengerResponse) bool { tokens, err := base.GetMember().communitiesManager.GetAllCommunityTokens() return err == nil && len(tokens) == 1 }, "no token sync message from event sender", ) s.Require().NoError(err) } func testEventSenderAddTokenMasterAndOwnerToken(base CommunityEventsTestsInterface, community *communities.Community) { ownerToken := createCommunityToken(community.IDString(), token.OwnerLevel) addCommunityTokenToCommunityTokensService(base, ownerToken) s := base.GetSuite() _, err := base.GetEventSender().SaveCommunityToken(ownerToken, nil) s.Require().NoError(err) err = base.GetEventSender().AddCommunityToken(ownerToken.CommunityID, ownerToken.ChainID, ownerToken.Address) s.Require().Error(err, communities.ErrInvalidManageTokensPermission) tokenMasterToken := ownerToken tokenMasterToken.PrivilegesLevel = token.MasterLevel tokenMasterToken.Address = "0x124" _, err = base.GetEventSender().SaveCommunityToken(tokenMasterToken, nil) s.Require().NoError(err) err = base.GetEventSender().AddCommunityToken(ownerToken.CommunityID, ownerToken.ChainID, ownerToken.Address) s.Require().Error(err, communities.ErrInvalidManageTokensPermission) } func addCommunityTokenToCommunityTokensService(base CommunityEventsTestsInterface, token *token.CommunityToken) { data := &communities.CollectibleContractData{ TotalSupply: token.Supply, Transferable: token.Transferable, RemoteBurnable: token.RemoteSelfDestruct, InfiniteSupply: token.InfiniteSupply, } base.GetCollectiblesServiceMock().SetMockCollectibleContractData(uint64(token.ChainID), token.Address, data) } func testJoinedPrivilegedMemberReceiveRequestsToJoin(base CommunityEventsTestsInterface, community *communities.Community, bob *Messenger, newPrivilegedUser *Messenger, tokenPermissionType protobuf.CommunityTokenPermission_Type) { s := base.GetSuite() // create community permission rolePermission := createTestPermissionRequest(community, tokenPermissionType) controlNodeCreatesCommunityPermission(base, community, rolePermission) advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), bob) advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), newPrivilegedUser) requestID := testSendRequestToJoin(base, newPrivilegedUser, community.ID()) // accept join request acceptRequestToJoin := &requests.AcceptRequestToJoinCommunity{ID: requestID} response, err := base.GetControlNode().AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) updatedCommunity := response.Communities()[0] s.Require().NotNil(updatedCommunity) s.Require().True(updatedCommunity.HasMember(&newPrivilegedUser.identity.PublicKey)) s.Require().NoError(err) _, err = WaitOnMessengerResponse( newPrivilegedUser, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasPermissionToSendCommunityEvents() }, "newPrivilegedUser did not receive privileged role", ) s.Require().NoError(err) expectedLength := 3 // newPrivilegedUser user should receive all requests to join with shared addresses from the control node waitAndCheckRequestsToJoin(s, newPrivilegedUser, expectedLength, community.ID(), tokenPermissionType == protobuf.CommunityTokenPermission_BECOME_TOKEN_MASTER) // bob joins the community requestID = testSendRequestToJoin(base, bob, community.ID()) // accept join request acceptRequestToJoin = &requests.AcceptRequestToJoinCommunity{ID: requestID} _, err = base.GetControlNode().AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) expectedLength = 4 waitAndCheckRequestsToJoin(s, newPrivilegedUser, expectedLength, community.ID(), tokenPermissionType == protobuf.CommunityTokenPermission_BECOME_TOKEN_MASTER) } func testMemberReceiveRequestsToJoinAfterGettingNewRole(base CommunityEventsTestsInterface, bob *Messenger, tokenPermissionType protobuf.CommunityTokenPermission_Type) { tcs2, err := base.GetControlNode().communitiesManager.All() s := base.GetSuite() s.Require().NoError(err, "eventSender.communitiesManager.All") s.Len(tcs2, 0, "Must have 0 community") // control node creates a community and chat community := createTestCommunity(base, protobuf.CommunityPermissions_MANUAL_ACCEPT) advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), base.GetEventSender()) advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), base.GetMember()) advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), bob) _ = testSendRequestToJoin(base, base.GetMember(), community.ID()) _ = testSendRequestToJoin(base, bob, community.ID()) accounts := base.GetAccountsTestData()[base.GetEventSender().IdentityPublicKeyString()] password := base.GetAccountsPasswords()[base.GetEventSender().IdentityPublicKeyString()] // event sender joins as simple user joinOnRequestCommunity(s, community.ID(), base.GetControlNode(), base.GetEventSender(), password, accounts) // create community permission rolePermission := createTestPermissionRequest(community, tokenPermissionType) response, err := base.GetControlNode().CreateCommunityTokenPermission(rolePermission) s.Require().NoError(err) var tokenPermissionID string for id := range response.CommunityChanges[0].TokenPermissionsAdded { tokenPermissionID = id } s.Require().NotEqual(tokenPermissionID, "") ownerCommunity, err := base.GetControlNode().communitiesManager.GetByID(community.ID()) s.Require().NoError(err) assertCheckTokenPermissionCreated(s, ownerCommunity, rolePermission.Type) _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && len(r.Communities()[0].TokenPermissionsByType(tokenPermissionType)) > 0 && r.Communities()[0].HasPermissionToSendCommunityEvents() }, "event sender did not receive privileged role", ) s.Require().NoError(err) expectedLength := 3 // if request to join state pending - privileged members should not receive revealed addresses waitAndCheckRequestsToJoin(s, base.GetEventSender(), expectedLength, community.ID(), false) } func waitAndCheckRequestsToJoin(s *suite.Suite, user *Messenger, expectedLength int, communityID types.HexBytes, checkRevealedAddresses bool) { _, err := WaitOnMessengerResponse( user, func(r *MessengerResponse) bool { requestsToJoin, err := user.communitiesManager.GetCommunityRequestsToJoinWithRevealedAddresses(communityID) if err != nil { return false } if len(requestsToJoin) != expectedLength { s.T().Log("invalid requests to join count:", len(requestsToJoin)) return false } for _, request := range requestsToJoin { if request.PublicKey == common.PubkeyToHex(&user.identity.PublicKey) { if len(request.RevealedAccounts) != 1 { s.T().Log("our own requests to join must always have accounts revealed") return false } } else if checkRevealedAddresses && request.State != communities.RequestToJoinStatePending { if len(request.RevealedAccounts) != 1 { s.T().Log("no accounts revealed") return false } } else { if len(request.RevealedAccounts) != 0 { s.T().Log("unexpected accounts revealed") return false } } } return true }, "user did not receive all requests to join from the control node", ) s.Require().NoError(err) } func testPrivilegedMemberAcceptsRequestToJoinAfterMemberLeave(base CommunityEventsTestsInterface, community *communities.Community, user *Messenger) { s := base.GetSuite() advertiseCommunityToUserOldWay(s, community, base.GetControlNode(), user) userPk := user.IdentityPublicKeyString() userPassword := base.GetAccountsPasswords()[userPk] userAccounts := base.GetAccountsTestData()[userPk] requestToJoin := createRequestToJoinCommunity(s, community.ID(), user, userPassword, userAccounts) response, err := user.RequestToJoinCommunity(requestToJoin) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.RequestsToJoinCommunity(), 1) sentRequest := response.RequestsToJoinCommunity()[0] checkRequestToJoin := func(r *MessengerResponse) bool { if len(r.RequestsToJoinCommunity()) == 0 { return false } for _, request := range r.RequestsToJoinCommunity() { if request.PublicKey == sentRequest.PublicKey { return true } } return false } // event sender receives request to join response, err = WaitOnMessengerResponse( base.GetEventSender(), checkRequestToJoin, "event sender did not receive community request to join", ) s.Require().NoError(err) s.Require().Len(response.RequestsToJoinCommunity(), 1) // control node receives request to join _, err = WaitOnMessengerResponse( base.GetControlNode(), checkRequestToJoin, "control node did not receive community request to join", ) s.Require().NoError(err) acceptRequestToJoin := &requests.AcceptRequestToJoinCommunity{ID: sentRequest.ID} response, err = base.GetEventSender().AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.Communities(), 1) // we don't expect `user` to be a member already, because `eventSender` merely // forwards its accept decision to the control node s.Require().False(response.Communities()[0].HasMember(&user.identity.PublicKey)) // at this point, the request to join is marked as accepted by GetEventSender node acceptedRequestsPending, err := base.GetEventSender().AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(acceptedRequestsPending, 1) s.Require().Equal(acceptedRequestsPending[0].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) // control node receives community event with accepted membership request _, err = WaitOnMessengerResponse( base.GetControlNode(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "control node did not receive community request to join response", ) s.Require().NoError(err) // at this point, the request to join is marked as accepted by control node acceptedRequests, err := base.GetControlNode().AcceptedRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) // we expect 3 here (1 event senders, 1 member + 1 from user) s.Require().Len(acceptedRequests, 3) s.Require().Equal(acceptedRequests[2].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) // user receives updated community _, err = WaitOnMessengerResponse( user, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "alice did not receive community request to join response", ) s.Require().NoError(err) // event sender receives updated community _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "event sender did not receive community with the new member", ) s.Require().NoError(err) // check control node notify event sender about accepting request to join _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { acceptedRequests, err := base.GetEventSender().AcceptedRequestsToJoinForCommunity(community.ID()) return err == nil && len(acceptedRequests) == 2 && (acceptedRequests[1].PublicKey == common.PubkeyToHex(&user.identity.PublicKey)) }, "no updates from control node", ) s.Require().NoError(err) acceptedRequestsPending, err = base.GetEventSender().AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(acceptedRequestsPending, 0) // user leaves the community response, err = user.LeaveCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(response.Communities(), 1) s.Require().False(response.Communities()[0].Joined()) checkMemberLeave := func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && !r.Communities()[0].HasMember(&user.identity.PublicKey) } // check control node received member leave msg _, err = WaitOnMessengerResponse( base.GetControlNode(), checkMemberLeave, "control node did not receive member leave msg", ) s.Require().NoError(err) // check event sender received member leave update from ControlNode _, err = WaitOnMessengerResponse( base.GetEventSender(), checkMemberLeave, "event sender did not receive member leave update", ) s.Require().NoError(err) // user tries to rejoin again response, err = user.RequestToJoinCommunity(requestToJoin) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.RequestsToJoinCommunity(), 1) // event sender receives request to join response, err = WaitOnMessengerResponse( base.GetEventSender(), checkRequestToJoin, "event sender did not receive community request to join", ) s.Require().NoError(err) s.Require().Len(response.RequestsToJoinCommunity(), 1) // control node receives request to join _, err = WaitOnMessengerResponse( base.GetControlNode(), checkRequestToJoin, "event sender did not receive community request to join", ) s.Require().NoError(err) response, err = base.GetEventSender().AcceptRequestToJoinCommunity(acceptRequestToJoin) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.Communities(), 1) // we don't expect `user` to be a member already, because `eventSender` merely // forwards its accept decision to the control node s.Require().False(response.Communities()[0].HasMember(&user.identity.PublicKey)) // at this point, the request to join is marked as accepted pending by GetEventSender node acceptedRequestsPending, err = base.GetEventSender().AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(acceptedRequestsPending, 1) s.Require().Equal(acceptedRequestsPending[0].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) // control node receives community event with accepted membership request _, err = WaitOnMessengerResponse( base.GetControlNode(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "control node did not receive community request to join response", ) s.Require().NoError(err) // at this point, the request to join is marked as accepted by control node acceptedRequests, err = base.GetControlNode().AcceptedRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) // we expect 3 here (1 event senders, 1 member + 1 from user) s.Require().Len(acceptedRequests, 3) s.Require().Equal(acceptedRequests[2].PublicKey, common.PubkeyToHex(&user.identity.PublicKey)) // user receives updated community _, err = WaitOnMessengerResponse( user, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "user did not receive community request to join response", ) s.Require().NoError(err) // event sender receives updated community _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && r.Communities()[0].HasMember(&user.identity.PublicKey) }, "event sender did not receive community with the new member", ) s.Require().NoError(err) // check control node notify event sender about accepting request to join _, err = WaitOnMessengerResponse( base.GetEventSender(), func(r *MessengerResponse) bool { acceptedRequests, err := base.GetEventSender().AcceptedRequestsToJoinForCommunity(community.ID()) return err == nil && len(acceptedRequests) == 2 && (acceptedRequests[1].PublicKey == common.PubkeyToHex(&user.identity.PublicKey)) }, "no updates from control node", ) s.Require().NoError(err) acceptedRequestsPending, err = base.GetEventSender().AcceptedPendingRequestsToJoinForCommunity(community.ID()) s.Require().NoError(err) s.Require().Len(acceptedRequestsPending, 0) } func testBanMemberWithDeletingAllMessages(base CommunityEventsTestsInterface, community *communities.Community) { // verify that event sender can't ban a control node and delete his messages banRequest := &requests.BanUserFromCommunity{ CommunityID: community.ID(), User: common.PubkeyToHexBytes(&base.GetControlNode().identity.PublicKey), DeleteAllMessages: true, } _, err := base.GetEventSender().BanUserFromCommunity( context.Background(), banRequest, ) s := base.GetSuite() s.Require().Error(err) chatIds := community.ChatIDs() s.Require().Len(chatIds, 1) chat := base.GetEventSender().Chat(chatIds[0]) s.Require().NotNil(chat) inputMessage := buildTestMessage(*chat) sendResponse, err := base.GetMember().SendChatMessage(context.Background(), inputMessage) s.NoError(err) s.Require().NotNil(sendResponse) s.Require().Len(sendResponse.Messages(), 1) messageID := sendResponse.Messages()[0].ID checkMsgDelivered := func(response *MessengerResponse) error { if len(response.Messages()) == 0 { return errors.New("response does not contain message") } for _, message := range response.Messages() { if message.ID == messageID { return nil } } return errors.New("messages was not found in the response") } waitOnMessengerResponse(s, checkMsgDelivered, base.GetControlNode()) waitOnMessengerResponse(s, checkMsgDelivered, base.GetEventSender()) banRequest.User = common.PubkeyToHexBytes(&base.GetMember().identity.PublicKey) banMember(base, banRequest) } func testSendRequestToJoin(base CommunityEventsTestsInterface, user *Messenger, communityID types.HexBytes) types.HexBytes { s := base.GetSuite() userPk := user.IdentityPublicKeyString() userPassword := base.GetAccountsPasswords()[userPk] userAccounts := base.GetAccountsTestData()[userPk] requestToJoin := createRequestToJoinCommunity(s, communityID, user, userPassword, userAccounts) return requestToJoinCommunity(s, base.GetControlNode(), user, requestToJoin) }