package protocol import ( "context" "encoding/hex" "testing" "time" "github.com/stretchr/testify/suite" "go.uber.org/zap" gethbridge "github.com/status-im/status-go/eth-node/bridge/geth" "github.com/status-im/status-go/eth-node/crypto" "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/peersyncing" "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/waku" ) func TestMessengerPeersyncingSuite(t *testing.T) { t.SkipNow() // FIXME suite.Run(t, new(MessengerPeersyncingSuite)) } type MessengerPeersyncingSuite struct { suite.Suite owner *Messenger bob *Messenger alice *Messenger // If one wants to send messages between different instances of Messenger, // a single Waku service should be shared. shh types.Waku logger *zap.Logger } func (s *MessengerPeersyncingSuite) SetupTest() { s.logger = tt.MustCreateTestLogger() peerSyncingLoopInterval = 500 * time.Millisecond config := waku.DefaultConfig config.MinimumAcceptedPoW = 0 shh := waku.New(&config, s.logger) s.shh = gethbridge.NewGethWakuWrapper(shh) s.Require().NoError(shh.Start()) s.owner = s.newMessenger() s.bob = s.newMessenger() s.alice = s.newMessenger() s.alice.featureFlags.ResendRawMessagesDisabled = true s.bob.featureFlags.ResendRawMessagesDisabled = true s.owner.featureFlags.ResendRawMessagesDisabled = true s.owner.communitiesManager.RekeyInterval = 50 * time.Millisecond _, err := s.owner.Start() s.Require().NoError(err) _, err = s.bob.Start() s.Require().NoError(err) _, err = s.alice.Start() s.Require().NoError(err) } func (s *MessengerPeersyncingSuite) TearDownTest() { TearDownMessenger(&s.Suite, s.owner) TearDownMessenger(&s.Suite, s.bob) TearDownMessenger(&s.Suite, s.alice) _ = s.logger.Sync() } func (s *MessengerPeersyncingSuite) newMessenger() *Messenger { return newTestCommunitiesMessenger(&s.Suite, s.shh, testCommunitiesMessengerConfig{ testMessengerConfig: testMessengerConfig{ logger: s.logger, }, }) } func (s *MessengerPeersyncingSuite) joinCommunity(community *communities.Community, owner *Messenger, user *Messenger) { request := &requests.RequestToJoinCommunity{CommunityID: community.ID()} joinCommunity(&s.Suite, community, owner, user, request, "") } func (s *MessengerPeersyncingSuite) thirdPartyTest(community *communities.Community, chat *Chat) { // We disable resending to make sure that the message is not re-transmitted s.alice.featureFlags.Peersyncing = false s.owner.featureFlags.Peersyncing = true s.bob.featureFlags.Peersyncing = true s.owner.communitiesManager.PermissionChecker = &testPermissionChecker{} advertiseCommunityTo(&s.Suite, community, s.owner, s.alice) s.joinCommunity(community, s.owner, s.alice) chatID := chat.ID inputMessage := common.NewMessage() inputMessage.ChatId = chatID inputMessage.ContentType = protobuf.ChatMessage_TEXT_PLAIN inputMessage.Text = "some text" ctx := context.Background() if community.Encrypted() { _, err := WaitOnMessengerResponse( s.alice, func(r *MessengerResponse) bool { keys, err := s.alice.encryptor.GetKeysForGroup([]byte(chat.ID)) return err == nil && len(keys) > 0 }, "keys not received", ) s.Require().NoError(err) } // Send message, it should be received response, err := s.alice.SendChatMessage(ctx, inputMessage) s.Require().NoError(err) s.Require().Len(response.Messages(), 1) messageID := response.Messages()[0].ID // Make sure the message makes it to the owner response, err = WaitOnMessengerResponse( s.owner, func(r *MessengerResponse) bool { return len(r.Communities()) > 0 && len(r.Messages()) == 1 && r.Messages()[0].ID == messageID }, "message not received", ) s.Require().NoError(err) s.Require().NotNil(response) msg, err := s.owner.peersyncing.AvailableMessages() s.Require().NoError(err) s.Require().Len(msg, 1) // Bob joins the community advertiseCommunityTo(&s.Suite, community, s.owner, s.bob) s.joinCommunity(community, s.owner, s.bob) // Bob should now send an offer _, err = WaitOnMessengerResponse( s.bob, func(r *MessengerResponse) bool { return s.bob.peersyncingOffers[messageID[2:]] != 0 }, "offer not sent", ) s.Require().NoError(err) // Owner should now reply to the offer _, err = WaitOnMessengerResponse( s.owner, func(r *MessengerResponse) bool { return s.owner.peersyncingRequests[s.bob.myHexIdentity()+messageID[2:]] != 0 }, "request not sent", ) s.Require().NoError(err) // Bob should receive the message _, err = WaitOnMessengerResponse( s.bob, func(r *MessengerResponse) bool { return len(r.Messages()) == 1 && r.Messages()[0].ID == messageID }, "message not received", ) s.Require().NoError(err) } // Owner creates a community // Owner sends a message // Alice joins // Alice receives the message func (s *MessengerPeersyncingSuite) TestSyncWithPeerCommunitySender() { s.alice.featureFlags.Peersyncing = true s.owner.featureFlags.Peersyncing = true // create community and make alice join it community, chat := createCommunity(&s.Suite, s.owner) chatID := chat.ID inputMessage := common.NewMessage() inputMessage.ChatId = chatID inputMessage.ContentType = protobuf.ChatMessage_TEXT_PLAIN inputMessage.Text = "some text" // Send message, it should be received response, err := s.owner.SendChatMessage(context.Background(), inputMessage) s.Require().NoError(err) messageID := response.Messages()[0].ID msg, err := s.owner.peersyncing.AvailableMessages() s.Require().NoError(err) s.Require().Len(msg, 1) advertiseCommunityTo(&s.Suite, community, s.owner, s.alice) s.joinCommunity(community, s.owner, s.alice) // Alice should now receive the message _, err = WaitOnMessengerResponse( s.alice, func(r *MessengerResponse) bool { _, err := s.owner.RetrieveAll() if err != nil { return false } return len(r.Messages()) == 1 && r.Messages()[0].ID == messageID }, "message not received", ) s.Require().NoError(err) } // Owner creates a community // Alice joins // Alice sends a message // Owner receives the message // Bob joins the community // They should retrieve the message from the owner func (s *MessengerPeersyncingSuite) TestSyncWithPeerCommunityThirdPartyEncrypted() { community, chat := createEncryptedCommunity(&s.Suite, s.owner) s.thirdPartyTest(community, chat) } func (s *MessengerPeersyncingSuite) TestSyncWithPeerCommunityThirdPartyNotEncrypted() { community, chat := createCommunity(&s.Suite, s.owner) s.thirdPartyTest(community, chat) } func (s *MessengerPeersyncingSuite) TestCanSyncMessageWith() { community, chat := createCommunity(&s.Suite, s.owner) advertiseCommunityTo(&s.Suite, community, s.owner, s.alice) s.joinCommunity(community, s.owner, s.alice) syncMessage := peersyncing.SyncMessage{ ID: []byte("test-id"), ChatID: []byte(chat.ID), Type: peersyncing.SyncMessageCommunityType, Payload: []byte("some-payload"), Timestamp: 1, } s.Require().NoError(s.owner.peersyncing.Add(syncMessage)) community, err := s.owner.communitiesManager.GetByID(community.ID()) s.Require().NoError(err) canSyncWithBob, err := s.owner.canSyncCommunityMessageWith(chat, community, &s.bob.identity.PublicKey) s.Require().NoError(err) s.Require().False(canSyncWithBob) canSyncWithAlice, err := s.owner.canSyncCommunityMessageWith(chat, community, &s.alice.identity.PublicKey) s.Require().NoError(err) s.Require().True(canSyncWithAlice) } func (s *MessengerPeersyncingSuite) TestSyncOneToOne() { s.alice.featureFlags.Peersyncing = true s.owner.featureFlags.Peersyncing = true pkString := hex.EncodeToString(crypto.FromECDSAPub(&s.alice.identity.PublicKey)) chat := CreateOneToOneChat(pkString, &s.alice.identity.PublicKey, s.owner.transport) chat.LastClockValue = uint64(100000000000000) err := s.owner.SaveChat(chat) s.NoError(err) _, err = s.alice.Join(chat) s.NoError(err) chatID := chat.ID inputMessage := common.NewMessage() inputMessage.ChatId = chatID inputMessage.ContentType = protobuf.ChatMessage_TEXT_PLAIN inputMessage.Text = "some text" ctx := context.Background() // Send message, it should be received response, err := s.alice.SendChatMessage(ctx, inputMessage) s.Require().NoError(err) s.Require().Len(response.Messages(), 1) messageID := response.Messages()[0].ID // Make sure the message makes it to the owner response, err = WaitOnMessengerResponse( s.owner, func(r *MessengerResponse) bool { return len(r.Messages()) == 1 && r.Messages()[0].ID == messageID }, "message not received", ) s.Require().NoError(err) s.Require().NotNil(response) msg, err := s.owner.peersyncing.AvailableMessages() s.Require().NoError(err) s.Require().Len(msg, 1) // Alice should now send an offer _, err = WaitOnMessengerResponse( s.alice, func(r *MessengerResponse) bool { return s.alice.peersyncingOffers[messageID[2:]] != 0 }, "offer not sent", ) s.Require().NoError(err) // Owner should now reply to the offer _, err = WaitOnMessengerResponse( s.owner, func(r *MessengerResponse) bool { return s.owner.peersyncingRequests[s.alice.myHexIdentity()+messageID[2:]] != 0 }, "request not sent", ) s.Require().NoError(err) } func (s *MessengerPeersyncingSuite) TestCanSyncOneToOneMessageWith() { s.alice.featureFlags.Peersyncing = true s.owner.featureFlags.Peersyncing = true pkString := hex.EncodeToString(crypto.FromECDSAPub(&s.alice.identity.PublicKey)) chat := CreateOneToOneChat(pkString, &s.alice.identity.PublicKey, s.owner.transport) chat.LastClockValue = uint64(100000000000000) err := s.owner.SaveChat(chat) s.NoError(err) _, err = s.alice.Join(chat) s.NoError(err) syncMessage := peersyncing.SyncMessage{ ID: []byte("test-id"), ChatID: []byte(chat.ID), Type: peersyncing.SyncMessageOneToOneType, Payload: []byte("some-payload"), Timestamp: chat.LastClockValue, } s.Require().NoError(s.owner.peersyncing.Add(syncMessage)) canSyncWithBob, err := s.owner.canSyncOneToOneMessageWith(chat, &s.bob.identity.PublicKey) s.Require().NoError(err) s.Require().False(canSyncWithBob) canSyncWithAlice, err := s.owner.canSyncOneToOneMessageWith(chat, &s.alice.identity.PublicKey) s.Require().NoError(err) s.Require().True(canSyncWithAlice) }