diff --git a/protocol/messenger_base_test.go b/protocol/messenger_base_test.go index a1daf1422..5a8f90472 100644 --- a/protocol/messenger_base_test.go +++ b/protocol/messenger_base_test.go @@ -2,7 +2,6 @@ package protocol import ( "crypto/ecdsa" - "testing" "github.com/stretchr/testify/suite" @@ -19,10 +18,6 @@ import ( const DefaultProfileDisplayName = "" -func TestMessengerCollapsedComunityCategoriesSuite(t *testing.T) { - suite.Run(t, new(MessengerCollapsedCommunityCategoriesSuite)) -} - func (s *MessengerBaseTestSuite) SetupTest() { s.logger = tt.MustCreateTestLogger() diff --git a/protocol/messenger_builder_test.go b/protocol/messenger_builder_test.go index 7829b9134..894b70664 100644 --- a/protocol/messenger_builder_test.go +++ b/protocol/messenger_builder_test.go @@ -12,6 +12,7 @@ import ( "github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/multiaccounts" + "github.com/status-im/status-go/multiaccounts/settings" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/tt" v1protocol "github.com/status-im/status-go/protocol/v1" @@ -142,3 +143,12 @@ func (u *unhandledMessagesTracker) addMessage(msg *v1protocol.StatusMessage, err } u.messages[msgType] = append(u.messages[msgType], newMessage) } + +func newTestSettings() settings.Settings { + return settings.Settings{ + DisplayName: DefaultProfileDisplayName, + ProfilePicturesShowTo: 1, + ProfilePicturesVisibility: 1, + URLUnfurlingMode: settings.URLUnfurlingAlwaysAsk, + } +} diff --git a/protocol/messenger_collapsed_community_categories_test.go b/protocol/messenger_collapsed_community_categories_test.go index f15288fde..f45982f5b 100644 --- a/protocol/messenger_collapsed_community_categories_test.go +++ b/protocol/messenger_collapsed_community_categories_test.go @@ -1,9 +1,17 @@ package protocol import ( + "testing" + + "github.com/stretchr/testify/suite" + "github.com/status-im/status-go/protocol/requests" ) +func TestMessengerCollapsedCommunityCategoriesSuite(t *testing.T) { + suite.Run(t, new(MessengerCollapsedCommunityCategoriesSuite)) +} + type MessengerCollapsedCommunityCategoriesSuite struct { MessengerBaseTestSuite } diff --git a/protocol/messenger_identity_image_test.go b/protocol/messenger_identity_image_test.go index 196405142..dd8fc0bd2 100644 --- a/protocol/messenger_identity_image_test.go +++ b/protocol/messenger_identity_image_test.go @@ -4,10 +4,12 @@ import ( "context" "crypto/ecdsa" "errors" + "fmt" "testing" "time" "github.com/cenkalti/backoff/v3" + "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "go.uber.org/zap" @@ -17,6 +19,7 @@ import ( "github.com/status-im/status-go/images" "github.com/status-im/status-go/multiaccounts" "github.com/status-im/status-go/multiaccounts/settings" + "github.com/status-im/status-go/params" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/requests" "github.com/status-im/status-go/protocol/tt" @@ -32,9 +35,6 @@ type MessengerProfilePictureHandlerSuite struct { alice *Messenger // client instance of Messenger bob *Messenger // server instance of Messenger - aliceKey *ecdsa.PrivateKey // private key for the alice instance of Messenger - bobKey *ecdsa.PrivateKey // private key for the bob instance of Messenger - // If one wants to send messages between different instances of Messenger, // a single Waku service should be shared. shh types.Waku @@ -43,10 +43,6 @@ type MessengerProfilePictureHandlerSuite struct { func (s *MessengerProfilePictureHandlerSuite) SetupSuite() { s.logger = tt.MustCreateTestLogger() -} - -func (s *MessengerProfilePictureHandlerSuite) SetupTest() { - var err error // Setup Waku things config := waku.DefaultConfig @@ -55,29 +51,36 @@ func (s *MessengerProfilePictureHandlerSuite) SetupTest() { shh := waku.New(&config, wakuLogger) s.shh = gethbridge.NewGethWakuWrapper(shh) s.Require().NoError(shh.Start()) +} - // Generate private keys for Alice and Bob - s.aliceKey, err = crypto.GenerateKey() - s.Require().NoError(err) - s.bobKey, err = crypto.GenerateKey() +func (s *MessengerProfilePictureHandlerSuite) TearDownSuite() { + _ = gethbridge.GetGethWakuFrom(s.shh).Stop() + _ = s.logger.Sync() +} + +func (s *MessengerProfilePictureHandlerSuite) newMessenger(name string) *Messenger { + m, err := newTestMessenger(s.shh, testMessengerConfig{ + logger: s.logger.Named(fmt.Sprintf("messenger-%s", name)), + name: name, + extraOptions: []Option{ + WithAppSettings(newTestSettings(), params.NodeConfig{}), + }, + }) s.Require().NoError(err) + _, err = m.Start() + s.Require().NoError(err) + + return m +} + +func (s *MessengerProfilePictureHandlerSuite) SetupTest() { // Generate Alice Messenger - aliceLogger := s.logger.Named("Alice messenger") - s.alice, err = newMessengerWithKey(s.shh, s.aliceKey, aliceLogger, []Option{}) - s.Require().NoError(err) - s.logger.Debug("alice messenger created") - - // Generate Bob Messenger - bobLogger := s.logger.Named("Bob messenger") - s.bob, err = newMessengerWithKey(s.shh, s.bobKey, bobLogger, []Option{}) - s.Require().NoError(err) - s.logger.Debug("bob messenger created") + s.alice = s.newMessenger("Alice") + s.bob = s.newMessenger("Bobby") // Setup MultiAccount for Alice Messenger - s.logger.Debug("alice setupMultiAccount before") s.setupMultiAccount(s.alice) - s.logger.Debug("alice setupMultiAccount after") } func (s *MessengerProfilePictureHandlerSuite) TearDownTest() { @@ -89,24 +92,37 @@ func (s *MessengerProfilePictureHandlerSuite) TearDownTest() { _ = s.logger.Sync() } -func (s *MessengerProfilePictureHandlerSuite) generateKeyUID(publicKey *ecdsa.PublicKey) string { - return types.EncodeHex(crypto.FromECDSAPub(publicKey)) -} - func (s *MessengerProfilePictureHandlerSuite) setupMultiAccount(m *Messenger) { - keyUID := s.generateKeyUID(&m.identity.PublicKey) - m.account = &multiaccounts.Account{KeyUID: keyUID} + name, err := m.settings.DisplayName() + s.Require().NoError(err) - err := m.multiAccounts.SaveAccount(multiaccounts.Account{Name: "string", KeyUID: keyUID}) + keyUID := m.IdentityPublicKeyString() + m.account = &multiaccounts.Account{ + Name: name, + KeyUID: keyUID, + } + + err = m.multiAccounts.SaveAccount(*m.account) s.NoError(err) } -func (s *MessengerProfilePictureHandlerSuite) generateAndStoreIdentityImages(m *Messenger) []images.IdentityImage { - keyUID := s.generateKeyUID(&m.identity.PublicKey) +func (s *MessengerProfilePictureHandlerSuite) generateAndStoreIdentityImages(m *Messenger) map[string]images.IdentityImage { + keyUID := m.IdentityPublicKeyString() iis := images.SampleIdentityImages() - s.Require().NoError(m.multiAccounts.StoreIdentityImages(keyUID, iis, false)) - return iis + err := m.multiAccounts.StoreIdentityImages(keyUID, iis, false) + s.Require().NoError(err) + + out := make(map[string]images.IdentityImage) + + for _, ii := range iis { + out[ii.Name] = ii + } + + s.Require().Contains(out, images.SmallDimName) + s.Require().Contains(out, images.LargeDimName) + + return out } func (s *MessengerProfilePictureHandlerSuite) TestChatIdentity() { @@ -202,7 +218,7 @@ func (s *MessengerProfilePictureHandlerSuite) TestPictureInPrivateChatOneSided() err = s.alice.settings.SaveSettingField(settings.ProfilePicturesVisibility, settings.ProfilePicturesShowToEveryone) s.Require().NoError(err) - bChat := CreateOneToOneChat(s.generateKeyUID(&s.aliceKey.PublicKey), &s.aliceKey.PublicKey, s.alice.transport) + bChat := CreateOneToOneChat(s.alice.IdentityPublicKeyString(), s.alice.IdentityPublicKey(), s.alice.transport) err = s.bob.SaveChat(bChat) s.Require().NoError(err) @@ -240,16 +256,16 @@ func (s *MessengerProfilePictureHandlerSuite) TestPictureInPrivateChatOneSided() } func (s *MessengerProfilePictureHandlerSuite) TestE2eSendingReceivingProfilePicture() { - profilePicShowSettings := map[string]settings.ProfilePicturesShowToType{ - "ShowToContactsOnly": settings.ProfilePicturesShowToContactsOnly, - "ShowToEveryone": settings.ProfilePicturesShowToEveryone, - "ShowToNone": settings.ProfilePicturesShowToNone, + profilePicShowSettings := []settings.ProfilePicturesShowToType{ + settings.ProfilePicturesShowToContactsOnly, + settings.ProfilePicturesShowToEveryone, + settings.ProfilePicturesShowToNone, } - profilePicViewSettings := map[string]settings.ProfilePicturesVisibilityType{ - "ViewFromContactsOnly": settings.ProfilePicturesVisibilityContactsOnly, - "ViewFromEveryone": settings.ProfilePicturesVisibilityEveryone, - "ViewFromNone": settings.ProfilePicturesVisibilityNone, + profilePicViewSettings := []settings.ProfilePicturesVisibilityType{ + settings.ProfilePicturesVisibilityContactsOnly, + settings.ProfilePicturesVisibilityEveryone, + settings.ProfilePicturesVisibilityNone, } isContactFor := map[string][]bool{ @@ -264,243 +280,20 @@ func (s *MessengerProfilePictureHandlerSuite) TestE2eSendingReceivingProfilePict // TODO see if possible to push each test scenario into a go routine for _, cc := range chatContexts { - for sn, ss := range profilePicShowSettings { - for vn, vs := range profilePicViewSettings { + for _, ss := range profilePicShowSettings { + for _, vs := range profilePicViewSettings { for _, ac := range isContactFor["alice"] { for _, bc := range isContactFor["bob"] { - s.logger.Debug("top of the loop") - s.SetupTest() - s.logger.Info("testing with criteria:", - zap.String("chat context type", string(cc)), - zap.String("profile picture Show Settings", sn), - zap.String("profile picture View Settings", vn), - zap.Bool("bob in Alice's Contacts", ac), - zap.Bool("alice in Bob's Contacts", bc), - ) - - expectPicture, err := resultExpected(ss, vs, ac, bc) - s.logger.Debug("expect to receive a profile pic?", - zap.Bool("result", expectPicture), - zap.Error(err)) - - // Setting up Bob - s.logger.Debug("Setting up test criteria for Bob") - - s.logger.Debug("Save bob profile-pictures-visibility setting before") - err = s.bob.settings.SaveSettingField(settings.ProfilePicturesVisibility, vs) - s.Require().NoError(err) - s.logger.Debug("Save bob profile-pictures-visibility setting after") - - s.logger.Debug("bob add contact before") - if bc { - s.logger.Debug("bob has contact to add") - _, err = s.bob.AddContact(context.Background(), &requests.AddContact{ID: s.generateKeyUID(&s.alice.identity.PublicKey)}) - s.Require().NoError(err) - s.logger.Debug("bob add contact after") + args := &e2eArgs{ + chatContext: cc, + showToType: ss, + visibilityType: vs, + aliceContact: ac, + bobContact: bc, } - s.logger.Debug("bob add contact after after") - - // Create Bob's chats - switch cc { - case publicChat: - s.logger.Debug("making publicChats for bob") - - // Bob opens up the public chat and joins it - bChat := CreatePublicChat("status", s.alice.transport) - err = s.bob.SaveChat(bChat) - s.Require().NoError(err) - - _, err = s.bob.Join(bChat) - s.Require().NoError(err) - case privateChat: - s.logger.Debug("making privateChats for bob") - - s.logger.Debug("Bob making one to one chat with alice") - bChat := CreateOneToOneChat(s.generateKeyUID(&s.aliceKey.PublicKey), &s.aliceKey.PublicKey, s.alice.transport) - s.logger.Debug("Bob saving one to one chat with alice") - err = s.bob.SaveChat(bChat) - s.Require().NoError(err) - s.logger.Debug("Bob saved one to one chat with alice") - - s.logger.Debug("Bob joining one to one chat with alice") - _, err = s.bob.Join(bChat) - s.Require().NoError(err) - s.logger.Debug("Bob joined one to one chat with alice") - default: - s.Failf("unexpected chat context type", "%s", string(cc)) - } - - // Setting up Alice - s.logger.Debug("Setting up test criteria for Alice") - - s.logger.Debug("Save alice profile-pictures-show-to setting before") - err = s.alice.settings.SaveSettingField(settings.ProfilePicturesShowTo, ss) - s.Require().NoError(err) - s.logger.Debug("Save alice profile-pictures-show-to setting after") - - s.logger.Debug("alice add contact before") - if ac { - s.logger.Debug("alice has contact to add") - _, err = s.alice.AddContact(context.Background(), &requests.AddContact{ID: s.generateKeyUID(&s.bob.identity.PublicKey)}) - s.Require().NoError(err) - s.logger.Debug("alice add contact after") - } - s.logger.Debug("alice add contact after after") - - s.logger.Debug("generateAndStoreIdentityImages before") - iis := s.generateAndStoreIdentityImages(s.alice) - s.logger.Debug("generateAndStoreIdentityImages after") - - s.logger.Debug("Before making chat for alice") - // Create chats - var aChat *Chat - switch cc { - case publicChat: - s.logger.Debug("making publicChats for alice") - - // Alice opens creates a public chat - aChat = CreatePublicChat("status", s.alice.transport) - err = s.alice.SaveChat(aChat) - s.Require().NoError(err) - - case privateChat: - s.logger.Debug("making privateChats for alice") - - s.logger.Debug("Alice making one to one chat with bob") - aChat = CreateOneToOneChat(s.generateKeyUID(&s.bobKey.PublicKey), &s.bobKey.PublicKey, s.bob.transport) - s.logger.Debug("Alice saving one to one chat with bob") - err = s.alice.SaveChat(aChat) - s.Require().NoError(err) - s.logger.Debug("Alice saved one to one chat with bob") - - s.logger.Debug("Alice joining one to one chat with bob") - _, err = s.alice.Join(aChat) - s.Require().NoError(err) - s.logger.Debug("Alice joined one to one chat with bob") - - s.logger.Debug("alice before manually triggering publishContactCode") - err = s.alice.publishContactCode() - s.logger.Debug("alice after manually triggering publishContactCode", - zap.Error(err)) - s.Require().NoError(err) - default: - s.Failf("unexpected chat context type", "%s", string(cc)) - } - - s.logger.Debug("Build and send a chat from alice") - - // Alice sends a message to the public chat - message := buildTestMessage(*aChat) - response, err := s.alice.SendChatMessage(context.Background(), message) - s.Require().NoError(err) - s.Require().NotNil(response) - - // Poll bob to see if he got the chatIdentity - // Retrieve ChatIdentity - var contacts []*Contact - - s.logger.Debug("Checking Bob to see if he got the chatIdentity") - options := func(b *backoff.ExponentialBackOff) { - b.MaxElapsedTime = 2 * time.Second - } - err = tt.RetryWithBackOff(func() error { - - response, err = s.bob.RetrieveAll() - if err != nil { - return err - } - - contacts = response.Contacts - s.logger.Debug("RetryWithBackOff contact data", zap.Any("contacts", contacts)) - - if len(contacts) > 0 && len(contacts[0].Images) > 0 { - s.logger.Debug("", zap.Any("contacts", contacts)) - return nil - } - - return errors.New("no new contacts with images received") - }, options) - - s.logger.Debug("Finished RetryWithBackOff got Bob", - zap.Any("contacts", contacts), - zap.Error(err)) - - if expectPicture { - s.logger.Debug("expecting a contact with images") - s.Require().NoError(err) - s.Require().NotNil(contacts) - } else { - s.logger.Debug("expecting no contacts with images") - s.Require().EqualError(err, "no new contacts with images received") - s.logger.Info("Completed testing with criteria:", - zap.String("chat context type", string(cc)), - zap.String("profile picture Show Settings", sn), - zap.String("profile picture View Settings", vn), - zap.Bool("bob in Alice's Contacts", ac), - zap.Bool("alice in Bob's Contacts", bc), - ) - s.TearDownTest() - continue - } - - s.logger.Debug("checking alice's contact") - - // Check if alice's contact data with profile picture is there - var contact *Contact - for _, c := range contacts { - if c.ID == s.generateKeyUID(&s.alice.identity.PublicKey) { - contact = c - } - } - s.Require().NotNil(contact) - - s.logger.Debug("checked alice's contact info all good") - - // Check that Bob now has Alice's profile picture(s) - switch cc { - case publicChat: - // In public chat context we only need the images.SmallDimName, but also may have the large - s.Require().GreaterOrEqual(len(contact.Images), 1) - - // Check if the result matches expectation - smImg, ok := contact.Images[images.SmallDimName] - s.Require().True(ok, "contact images must contain the images.SmallDimName") - - for _, ii := range iis { - if ii.Name == images.SmallDimName { - s.Require().Equal(ii.Payload, smImg.Payload) - } - } - case privateChat: - s.Require().Equal(len(contact.Images), 2) - s.logger.Info("private chat chat images", zap.Any("iis", iis)) - - // Check if the result matches expectation - smImg, ok := contact.Images[images.SmallDimName] - s.Require().True(ok, "contact images must contain the images.SmallDimName") - - lgImg, ok := contact.Images[images.LargeDimName] - s.Require().True(ok, "contact images must contain the images.LargeDimName") - - for _, ii := range iis { - switch ii.Name { - case images.SmallDimName: - s.Require().Equal(ii.Payload, smImg.Payload) - case images.LargeDimName: - s.Require().Equal(ii.Payload, lgImg.Payload) - } - } - - } - - s.logger.Info("Completed testing with criteria:", - zap.String("chat context type", string(cc)), - zap.String("profile picture Show Settings", sn), - zap.String("profile picture View Settings", vn), - zap.Bool("bob in Alice's Contacts", ac), - zap.Bool("alice in Bob's Contacts", bc), - ) - s.TearDownTest() + s.Run(args.TestCaseName(s.T()), func() { + s.testE2eSendingReceivingProfilePicture(args) + }) } } } @@ -510,15 +303,201 @@ func (s *MessengerProfilePictureHandlerSuite) TestE2eSendingReceivingProfilePict s.SetupTest() } -func resultExpected(ss settings.ProfilePicturesShowToType, vs settings.ProfilePicturesVisibilityType, ac, bc bool) (bool, error) { - switch ss { +func (s *MessengerProfilePictureHandlerSuite) testE2eSendingReceivingProfilePicture(args *e2eArgs) { + // Generate Alice Messenger + alice := s.newMessenger("Alice") + bob := s.newMessenger("Bobby") + + // Setup MultiAccount for Alice Messenger + s.setupMultiAccount(alice) + + defer func() { + TearDownMessenger(&s.Suite, alice) + alice = nil + TearDownMessenger(&s.Suite, bob) + bob = nil + _ = s.logger.Sync() + }() + + s.logger.Info("testing with criteria:", zap.Any("args", args)) + defer s.logger.Info("Completed testing with criteria:", zap.Any("args", args)) + + expectPicture, err := args.resultExpected() + s.Require().NoError(err) + + s.logger.Debug("expect to receive a profile pic?", + zap.Bool("result", expectPicture), + zap.Error(err)) + + // Setting up Bob + err = bob.settings.SaveSettingField(settings.ProfilePicturesVisibility, args.visibilityType) + s.Require().NoError(err) + + if args.bobContact { + _, err = bob.AddContact(context.Background(), &requests.AddContact{ID: alice.IdentityPublicKeyString()}) + s.Require().NoError(err) + } + + // Create Bob's chats + switch args.chatContext { + case publicChat: + // Bob opens up the public chat and joins it + bChat := CreatePublicChat("status", alice.transport) + err = bob.SaveChat(bChat) + s.Require().NoError(err) + + _, err = bob.Join(bChat) + s.Require().NoError(err) + case privateChat: + bChat := CreateOneToOneChat(alice.IdentityPublicKeyString(), alice.IdentityPublicKey(), alice.transport) + err = bob.SaveChat(bChat) + s.Require().NoError(err) + + _, err = bob.Join(bChat) + s.Require().NoError(err) + default: + s.Failf("unexpected chat context type", "%s", string(args.chatContext)) + } + + // Setting up Alice + err = alice.settings.SaveSettingField(settings.ProfilePicturesShowTo, args.showToType) + s.Require().NoError(err) + + if args.aliceContact { + _, err = alice.AddContact(context.Background(), &requests.AddContact{ID: bob.IdentityPublicKeyString()}) + s.Require().NoError(err) + } + + iis := s.generateAndStoreIdentityImages(alice) + + // Create chats + var aChat *Chat + switch args.chatContext { + case publicChat: + // Alice opens creates a public chat + aChat = CreatePublicChat("status", alice.transport) + err = alice.SaveChat(aChat) + s.Require().NoError(err) + + // Alice sends a message to the public chat + message := buildTestMessage(*aChat) + response, err := alice.SendChatMessage(context.Background(), message) + s.Require().NoError(err) + s.Require().NotNil(response) + s.Require().Len(response.messages, 1) + + case privateChat: + aChat = CreateOneToOneChat(bob.IdentityPublicKeyString(), bob.IdentityPublicKey(), bob.transport) + err = alice.SaveChat(aChat) + s.Require().NoError(err) + + _, err = alice.Join(aChat) + s.Require().NoError(err) + + err = alice.publishContactCode() + s.Require().NoError(err) + + default: + s.Failf("unexpected chat context type", "%s", string(args.chatContext)) + } + + // Poll bob to see if he got the chatIdentity + // Retrieve ChatIdentity + var contacts []*Contact + + options := func(b *backoff.ExponentialBackOff) { + b.MaxElapsedTime = 2 * time.Second + } + + err = tt.RetryWithBackOff(func() error { + response, err := bob.RetrieveAll() + if err != nil { + return err + } + + contacts = response.Contacts + if len(contacts) > 0 && len(contacts[0].Images) > 0 { + return nil + } + + return errors.New("no new contacts with images received") + }, options) + + if !expectPicture { + s.Require().EqualError(err, "no new contacts with images received") + return + } + + s.Require().NoError(err) + s.Require().NotNil(contacts) + + // Check if alice's contact data with profile picture is there + var contact *Contact + for _, c := range contacts { + if c.ID == alice.IdentityPublicKeyString() { + contact = c + } + } + s.Require().NotNil(contact) + + // Check that Bob now has Alice's profile picture(s) + switch args.chatContext { + case publicChat: + // In public chat context we only need the images.SmallDimName, but also may have the large + s.Require().GreaterOrEqual(len(contact.Images), 1) + s.Require().Contains(contact.Images, images.SmallDimName) + s.Require().Equal(iis[images.SmallDimName].Payload, contact.Images[images.SmallDimName].Payload) + + case privateChat: + s.Require().Equal(len(contact.Images), 2) + s.Require().Contains(contact.Images, images.SmallDimName) + s.Require().Contains(contact.Images, images.LargeDimName) + s.Require().Equal(iis[images.SmallDimName].Payload, contact.Images[images.SmallDimName].Payload) + s.Require().Equal(iis[images.LargeDimName].Payload, contact.Images[images.LargeDimName].Payload) + } +} + +type e2eArgs struct { + chatContext ChatContext + showToType settings.ProfilePicturesShowToType + visibilityType settings.ProfilePicturesVisibilityType + aliceContact bool + bobContact bool +} + +func (args *e2eArgs) String() string { + return fmt.Sprintf("ChatContext: %s, ShowTo: %s, Visibility: %s, AliceContact: %t, BobContact: %t", + string(args.chatContext), + profilePicShowSettingsMap[args.showToType], + profilePicViewSettingsMap[args.visibilityType], + args.aliceContact, + args.bobContact, + ) +} + +func (args *e2eArgs) TestCaseName(t *testing.T) string { + expected, err := args.resultExpected() + require.NoError(t, err) + + return fmt.Sprintf("%s-%s-%s-ac.%t-bc.%t-exp.%t", + string(args.chatContext), + profilePicShowSettingsMap[args.showToType], + profilePicViewSettingsMap[args.visibilityType], + args.aliceContact, + args.bobContact, + expected, + ) +} + +func (args *e2eArgs) resultExpected() (bool, error) { + switch args.showToType { case settings.ProfilePicturesShowToContactsOnly: - if ac { - return resultExpectedVS(vs, bc) + if args.aliceContact { + return args.resultExpectedVS() } return false, nil case settings.ProfilePicturesShowToEveryone: - return resultExpectedVS(vs, bc) + return args.resultExpectedVS() case settings.ProfilePicturesShowToNone: return false, nil default: @@ -526,16 +505,28 @@ func resultExpected(ss settings.ProfilePicturesShowToType, vs settings.ProfilePi } } -func resultExpectedVS(vs settings.ProfilePicturesVisibilityType, bc bool) (bool, error) { - switch vs { +func (args *e2eArgs) resultExpectedVS() (bool, error) { + switch args.visibilityType { case settings.ProfilePicturesVisibilityContactsOnly: return true, nil case settings.ProfilePicturesVisibilityEveryone: return true, nil case settings.ProfilePicturesVisibilityNone: // If we are contacts, we save the image regardless - return bc, nil + return args.bobContact, nil default: return false, errors.New("unknown ProfilePicturesVisibilityType") } } + +var profilePicShowSettingsMap = map[settings.ProfilePicturesShowToType]string{ + settings.ProfilePicturesShowToContactsOnly: "ShowToContactsOnly", + settings.ProfilePicturesShowToEveryone: "ShowToEveryone", + settings.ProfilePicturesShowToNone: "ShowToNone", +} + +var profilePicViewSettingsMap = map[settings.ProfilePicturesVisibilityType]string{ + settings.ProfilePicturesVisibilityContactsOnly: "ViewFromContactsOnly", + settings.ProfilePicturesVisibilityEveryone: "ViewFromEveryone", + settings.ProfilePicturesVisibilityNone: "ViewFromNone", +} diff --git a/telemetry/client_test.go b/telemetry/client_test.go index cfca103d0..b836e1d43 100644 --- a/telemetry/client_test.go +++ b/telemetry/client_test.go @@ -15,6 +15,7 @@ import ( "go.uber.org/zap" "google.golang.org/protobuf/proto" + "github.com/waku-org/go-waku/waku/v2/api/publish" v2protocol "github.com/waku-org/go-waku/waku/v2/protocol" "github.com/waku-org/go-waku/waku/v2/protocol/pb" @@ -25,7 +26,6 @@ import ( "github.com/status-im/status-go/protocol/tt" v1protocol "github.com/status-im/status-go/protocol/v1" "github.com/status-im/status-go/wakuv2" - "github.com/waku-org/go-waku/waku/v2/api/publish" ) var ( diff --git a/wakuv2/common/filter_test.go b/wakuv2/common/filter_test.go index 5314ce695..38ecfdeec 100644 --- a/wakuv2/common/filter_test.go +++ b/wakuv2/common/filter_test.go @@ -11,11 +11,12 @@ import ( "golang.org/x/exp/maps" "google.golang.org/protobuf/proto" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" "github.com/waku-org/go-waku/waku/v2/payload" "github.com/waku-org/go-waku/waku/v2/protocol" "github.com/waku-org/go-waku/waku/v2/protocol/pb" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" ) const testShard = "/waku/2/rs/16/32"