status-im/status-go

package protocol

import (
    "context"
    "encoding/json"
    "strings"
    "testing"

    "github.com/stretchr/testify/suite"

    "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/protocol/common"
    "github.com/status-im/status-go/protocol/protobuf"
)

func TestMessengerEmojiSuite(t *testing.T) {
    suite.Run(t, new(MessengerEmojiSuite))
}

type MessengerEmojiSuite struct {
    MessengerBaseTestSuite
}

func (s *MessengerEmojiSuite) TestSendEmoji() {
    alice := s.m
    alice.account = &multiaccounts.Account{KeyUID: "0xdeadbeef"}
    key, err := crypto.GenerateKey()
    s.Require().NoError(err)

    bob, err := newMessengerWithKey(s.shh, key, s.logger, nil)
    s.Require().NoError(err)
    defer TearDownMessenger(&s.Suite, bob)

    chatID := statusChatID

    chat := CreatePublicChat(chatID, alice.transport)

    err = alice.SaveChat(chat)
    s.Require().NoError(err)

    _, err = alice.Join(chat)
    s.Require().NoError(err)

    err = bob.SaveChat(chat)
    s.Require().NoError(err)

    _, err = bob.Join(chat)
    s.Require().NoError(err)

    // Send chat message from alice to bob

    message := buildTestMessage(*chat)
    _, err = alice.SendChatMessage(context.Background(), message)
    s.NoError(err)

    // Wait for message to arrive to bob
    response, err := WaitOnMessengerResponse(
        bob,
        func(r *MessengerResponse) bool { return len(r.Messages()) > 0 },
        "no messages",
    )
    s.Require().NoError(err)

    s.Require().Len(response.Messages(), 1)

    messageID := response.Messages()[0].ID

    // Respond with an emoji, donald trump style

    response, err = bob.SendEmojiReaction(context.Background(), chat.ID, messageID, protobuf.EmojiReaction_SAD)
    s.Require().NoError(err)
    s.Require().Len(response.EmojiReactions(), 1)

    emojiID := response.EmojiReactions()[0].ID()

    // Wait for the emoji to arrive to alice
    response, err = WaitOnMessengerResponse(
        alice,
        func(r *MessengerResponse) bool { return len(r.EmojiReactions()) == 1 },
        "no emoji",
    )
    s.Require().NoError(err)

    s.Require().Len(response.EmojiReactions(), 1)
    s.Require().Equal(response.EmojiReactions()[0].ID(), emojiID)
    s.Require().Equal(response.EmojiReactions()[0].Type, protobuf.EmojiReaction_SAD)

    // Retract the emoji
    response, err = bob.SendEmojiReactionRetraction(context.Background(), emojiID)
    s.Require().NoError(err)
    s.Require().Len(response.EmojiReactions(), 1)
    s.Require().True(response.EmojiReactions()[0].Retracted)

    // Wait for the emoji to arrive to alice
    response, err = WaitOnMessengerResponse(
        alice,
        func(r *MessengerResponse) bool { return len(r.EmojiReactions()) == 1 },
        "no emoji",
    )
    s.Require().NoError(err)

    s.Require().Len(response.EmojiReactions(), 1)
    s.Require().Equal(response.EmojiReactions()[0].ID(), emojiID)
    s.Require().Equal(response.EmojiReactions()[0].Type, protobuf.EmojiReaction_SAD)
    s.Require().True(response.EmojiReactions()[0].Retracted)
}

func (s *MessengerEmojiSuite) TestEmojiPrivateGroup() {
    bob := s.m
    alice := s.newMessenger()
    defer TearDownMessenger(&s.Suite, alice)
    response, err := bob.CreateGroupChatWithMembers(context.Background(), "test", []string{})
    s.NoError(err)

    s.Require().NoError(makeMutualContact(bob, &alice.identity.PublicKey))

    chat := response.Chats()[0]
    members := []string{types.EncodeHex(crypto.FromECDSAPub(&alice.identity.PublicKey))}
    _, err = bob.AddMembersToGroupChat(context.Background(), chat.ID, members)
    s.NoError(err)

    // Retrieve their messages so that the chat is created
    _, err = WaitOnMessengerResponse(
        alice,
        func(r *MessengerResponse) bool { return len(r.Chats()) > 0 },
        "chat invitation not received",
    )
    s.Require().NoError(err)

    _, err = alice.ConfirmJoiningGroup(context.Background(), chat.ID)
    s.NoError(err)

    // Wait for the message to reach its destination
    _, err = WaitOnMessengerResponse(
        bob,
        func(r *MessengerResponse) bool { return len(r.Chats()) > 0 },
        "no joining group event received",
    )
    s.Require().NoError(err)

    inputMessage := buildTestMessage(*chat)
    _, err = bob.SendChatMessage(context.Background(), inputMessage)
    s.NoError(err)

    // Wait for the message to reach its destination
    response, err = WaitOnMessengerResponse(
        alice,
        func(r *MessengerResponse) bool { return len(r.Messages()) > 0 },
        "no message received",
    )
    s.Require().NoError(err)
    messageID := response.Messages()[0].ID

    _, err = bob.SendEmojiReaction(context.Background(), chat.ID, messageID, protobuf.EmojiReaction_SAD)
    s.Require().NoError(err)

    // Wait for the message to reach its destination
    _, err = WaitOnMessengerResponse(
        alice,
        func(r *MessengerResponse) bool { return len(r.EmojiReactions()) == 1 },
        "no emoji reaction received",
    )
    s.Require().NoError(err)
}

func (s *MessengerEmojiSuite) TestCompressedKeyReturnedWithEmoji() {
    emojiReaction := NewEmojiReaction()
    id, err := crypto.GenerateKey()
    s.Require().NoError(err)

    emojiReaction.From = common.PubkeyToHex(&id.PublicKey)
    emojiReaction.LocalChatID = testPublicChatID
    encodedReaction, err := json.Marshal(emojiReaction)
    s.Require().NoError(err)

    // Check that compressedKey and emojiHash exists
    s.Require().True(strings.Contains(string(encodedReaction), "compressedKey\":\"zQ"))
    s.Require().True(strings.Contains(string(encodedReaction), "emojiHash"))
}