status-go/protocol/messenger_identity_image_te...

542 lines
18 KiB
Go

package protocol
import (
"context"
"crypto/ecdsa"
"errors"
"testing"
"time"
"github.com/cenkalti/backoff/v3"
"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/images"
"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/requests"
"github.com/status-im/status-go/protocol/tt"
"github.com/status-im/status-go/waku"
)
func TestMessengerProfilePictureHandlerSuite(t *testing.T) {
suite.Run(t, new(MessengerProfilePictureHandlerSuite))
}
type MessengerProfilePictureHandlerSuite struct {
suite.Suite
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
logger *zap.Logger
}
func (s *MessengerProfilePictureHandlerSuite) SetupSuite() {
s.logger = tt.MustCreateTestLogger()
}
func (s *MessengerProfilePictureHandlerSuite) SetupTest() {
var err error
// Setup Waku things
config := waku.DefaultConfig
config.MinimumAcceptedPoW = 0
wakuLogger := s.logger.Named("Waku")
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()
s.Require().NoError(err)
// 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")
// 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() {
// Shutdown messengers
TearDownMessenger(&s.Suite, s.alice)
s.alice = nil
TearDownMessenger(&s.Suite, s.bob)
s.bob = nil
_ = 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}
err := m.multiAccounts.SaveAccount(multiaccounts.Account{Name: "string", KeyUID: keyUID})
s.NoError(err)
}
func (s *MessengerProfilePictureHandlerSuite) generateAndStoreIdentityImages(m *Messenger) []images.IdentityImage {
keyUID := s.generateKeyUID(&m.identity.PublicKey)
iis := images.SampleIdentityImages()
s.Require().NoError(m.multiAccounts.StoreIdentityImages(keyUID, iis, false))
return iis
}
func (s *MessengerProfilePictureHandlerSuite) TestChatIdentity() {
iis := s.generateAndStoreIdentityImages(s.alice)
ci, err := s.alice.createChatIdentity(privateChat)
s.Require().NoError(err)
s.Require().Exactly(len(iis), len(ci.Images))
}
func (s *MessengerProfilePictureHandlerSuite) TestEncryptDecryptIdentityImagesWithContactPubKeys() {
smPayload := "hello small image"
lgPayload := "hello large image"
ci := protobuf.ChatIdentity{
Clock: uint64(time.Now().Unix()),
Images: map[string]*protobuf.IdentityImage{
"small": {
Payload: []byte(smPayload),
},
"large": {
Payload: []byte(lgPayload),
},
},
}
// Make contact keys and Contacts, set the Contacts to added
contactKeys := make([]*ecdsa.PrivateKey, 10)
for i := range contactKeys {
contactKey, err := crypto.GenerateKey()
s.Require().NoError(err)
contactKeys[i] = contactKey
contact, err := BuildContactFromPublicKey(&contactKey.PublicKey)
s.Require().NoError(err)
contact.ContactRequestLocalState = ContactRequestStateSent
s.alice.allContacts.Store(contact.ID, contact)
}
// Test EncryptIdentityImagesWithContactPubKeys
err := EncryptIdentityImagesWithContactPubKeys(ci.Images, s.alice)
s.Require().NoError(err)
for _, ii := range ci.Images {
s.Require().Equal(s.alice.allContacts.Len(), len(ii.EncryptionKeys))
}
s.Require().NotEqual([]byte(smPayload), ci.Images["small"].Payload)
s.Require().NotEqual([]byte(lgPayload), ci.Images["large"].Payload)
s.Require().True(ci.Images["small"].Encrypted)
s.Require().True(ci.Images["large"].Encrypted)
// Test DecryptIdentityImagesWithIdentityPrivateKey
err = DecryptIdentityImagesWithIdentityPrivateKey(ci.Images, contactKeys[2], &s.alice.identity.PublicKey)
s.Require().NoError(err)
s.Require().Equal(smPayload, string(ci.Images["small"].Payload))
s.Require().Equal(lgPayload, string(ci.Images["large"].Payload))
s.Require().False(ci.Images["small"].Encrypted)
s.Require().False(ci.Images["large"].Encrypted)
// RESET Messenger identity, Contacts and IdentityImage.EncryptionKeys
s.alice.allContacts = new(contactMap)
ci.Images["small"].EncryptionKeys = nil
ci.Images["large"].EncryptionKeys = nil
// Test EncryptIdentityImagesWithContactPubKeys with no contacts
err = EncryptIdentityImagesWithContactPubKeys(ci.Images, s.alice)
s.Require().NoError(err)
for _, ii := range ci.Images {
s.Require().Equal(0, len(ii.EncryptionKeys))
}
s.Require().NotEqual([]byte(smPayload), ci.Images["small"].Payload)
s.Require().NotEqual([]byte(lgPayload), ci.Images["large"].Payload)
s.Require().True(ci.Images["small"].Encrypted)
s.Require().True(ci.Images["large"].Encrypted)
// Test DecryptIdentityImagesWithIdentityPrivateKey with no valid identity
err = DecryptIdentityImagesWithIdentityPrivateKey(ci.Images, contactKeys[2], &s.alice.identity.PublicKey)
s.Require().NoError(err)
s.Require().NotEqual([]byte(smPayload), ci.Images["small"].Payload)
s.Require().NotEqual([]byte(lgPayload), ci.Images["large"].Payload)
s.Require().True(ci.Images["small"].Encrypted)
s.Require().True(ci.Images["large"].Encrypted)
}
func (s *MessengerProfilePictureHandlerSuite) TestPictureInPrivateChatOneSided() {
err := s.bob.settings.SaveSettingField(settings.ProfilePicturesVisibility, settings.ProfilePicturesShowToEveryone)
s.Require().NoError(err)
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)
err = s.bob.SaveChat(bChat)
s.Require().NoError(err)
_, err = s.bob.Join(bChat)
s.Require().NoError(err)
// Alice sends a message to the public chat
message := buildTestMessage(*bChat)
response, err := s.bob.SendChatMessage(context.Background(), message)
s.Require().NoError(err)
s.Require().NotNil(response)
options := func(b *backoff.ExponentialBackOff) {
b.MaxElapsedTime = 2 * time.Second
}
err = tt.RetryWithBackOff(func() error {
response, err = s.alice.RetrieveAll()
if err != nil {
return err
}
s.Require().NotNil(response)
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)
}
func (s *MessengerProfilePictureHandlerSuite) TestE2eSendingReceivingProfilePicture() {
profilePicShowSettings := map[string]settings.ProfilePicturesShowToType{
"ShowToContactsOnly": settings.ProfilePicturesShowToContactsOnly,
"ShowToEveryone": settings.ProfilePicturesShowToEveryone,
"ShowToNone": settings.ProfilePicturesShowToNone,
}
profilePicViewSettings := map[string]settings.ProfilePicturesVisibilityType{
"ViewFromContactsOnly": settings.ProfilePicturesVisibilityContactsOnly,
"ViewFromEveryone": settings.ProfilePicturesVisibilityEveryone,
"ViewFromNone": settings.ProfilePicturesVisibilityNone,
}
isContactFor := map[string][]bool{
"alice": {true, false},
"bob": {true, false},
}
chatContexts := []ChatContext{
publicChat,
privateChat,
}
// 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 _, 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")
}
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.SetupTest()
}
func resultExpected(ss settings.ProfilePicturesShowToType, vs settings.ProfilePicturesVisibilityType, ac, bc bool) (bool, error) {
switch ss {
case settings.ProfilePicturesShowToContactsOnly:
if ac {
return resultExpectedVS(vs, bc)
}
return false, nil
case settings.ProfilePicturesShowToEveryone:
return resultExpectedVS(vs, bc)
case settings.ProfilePicturesShowToNone:
return false, nil
default:
return false, errors.New("unknown ProfilePicturesShowToType")
}
}
func resultExpectedVS(vs settings.ProfilePicturesVisibilityType, bc bool) (bool, error) {
switch vs {
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
default:
return false, errors.New("unknown ProfilePicturesVisibilityType")
}
}