merged from gramsrv upstream

internal/rpc/update_peer_refs_test.go

@@ -1,8 +1,12 @@
 package rpc
 
 import (
+	"context"
 	"testing"
 
+	"github.com/iamxvbaba/td/clock"
+	"go.uber.org/zap/zaptest"
+
 	"telesrv/internal/domain"
 )
 
@@ -28,3 +32,138 @@ func TestRemoveKnownChannelRefs(t *testing.T) {
 		}
 	}
 }
+func TestCollectChannelMessagePeerRefsIncludesNestedWireUsers(t *testing.T) {
+	const currentChannelID = int64(3001)
+	users := map[int64]struct{}{}
+	channels := map[int64]struct{}{}
+	collectChannelMessagePeerRefs(domain.ChannelMessage{
+		SavedPeer: domain.Peer{Type: domain.PeerTypeUser, ID: 1005},
+		Forward: &domain.MessageForward{
+			From:      domain.Peer{Type: domain.PeerTypeUser, ID: 1001},
+			SavedFrom: domain.Peer{Type: domain.PeerTypeUser, ID: 1002},
+		},
+		Replies: &domain.ChannelMessageReplies{RecentRepliers: []domain.Peer{
+			{Type: domain.PeerTypeUser, ID: 1003},
+			{Type: domain.PeerTypeChannel, ID: 4001},
+			{Type: domain.PeerTypeChannel, ID: currentChannelID},
+		}},
+		Action: &domain.ChannelMessageAction{InviterUserID: 1004},
+	}, currentChannelID, users, channels)
+
+	for _, id := range []int64{1001, 1002, 1003, 1004, 1005} {
+		if _, ok := users[id]; !ok {
+			t.Fatalf("channel message user refs=%v, missing %d", users, id)
+		}
+	}
+	if _, ok := channels[4001]; !ok {
+		t.Fatalf("channel message channel refs=%v, missing recent replier channel", channels)
+	}
+	if _, ok := channels[currentChannelID]; ok {
+		t.Fatalf("current channel leaked into external refs=%v", channels)
+	}
+}
+
+func TestMessageMentionNameUsersAreProjectedInStrictAndNonStrictEnvelopes(t *testing.T) {
+	const (
+		viewerID   = int64(1001)
+		entityUser = int64(2001)
+		quoteUser  = int64(2002)
+		channelID  = int64(3001)
+	)
+	entities := []domain.MessageEntity{{
+		Type:   domain.MessageEntityMentionName,
+		UserID: entityUser,
+	}}
+	reply := &domain.MessageReply{
+		MessageID: 1,
+		QuoteEntities: []domain.MessageEntity{{
+			Type:   domain.MessageEntityMentionName,
+			UserID: quoteUser,
+		}},
+	}
+	users := mapUsersService{users: map[int64]domain.User{
+		entityUser: {ID: entityUser, FirstName: "Projected entity mention"},
+		quoteUser:  {ID: quoteUser, FirstName: "Projected quote mention"},
+	}}
+	r := New(Config{}, Deps{Users: users}, zaptest.NewLogger(t), clock.System)
+	ctx := context.Background()
+
+	tests := []struct {
+		name   string
+		enrich func() ([]domain.User, error)
+	}{
+		{
+			name: "private non-strict",
+			enrich: func() ([]domain.User, error) {
+				list := r.enrichMessageList(ctx, viewerID, domain.MessageList{Messages: []domain.Message{{
+					Entities: entities,
+					ReplyTo:  reply,
+				}}})
+				return list.Users, nil
+			},
+		},
+		{
+			name: "private strict",
+			enrich: func() ([]domain.User, error) {
+				events, err := r.enrichUpdateEventsWithPeerCacheStrict(ctx, viewerID, []domain.UpdateEvent{{
+					Type: domain.UpdateEventNewMessage,
+					Message: domain.Message{
+						Entities: entities,
+						ReplyTo:  reply,
+					},
+				}}, nil)
+				if err != nil {
+					return nil, err
+				}
+				return events[0].Users, nil
+			},
+		},
+		{
+			name: "channel non-strict",
+			enrich: func() ([]domain.User, error) {
+				history := r.enrichChannelHistory(ctx, viewerID, domain.ChannelHistory{
+					Channel: domain.Channel{ID: channelID},
+					Messages: []domain.ChannelMessage{{
+						ChannelID: channelID,
+						Entities:  entities,
+						ReplyTo:   reply,
+					}},
+				})
+				return history.Users, nil
+			},
+		},
+		{
+			name: "channel strict",
+			enrich: func() ([]domain.User, error) {
+				diff, err := r.enrichChannelDifferenceStrict(ctx, viewerID, domain.ChannelDifference{
+					Channel: domain.Channel{ID: channelID},
+					NewMessages: []domain.ChannelMessage{{
+						ChannelID: channelID,
+						Entities:  entities,
+						ReplyTo:   reply,
+					}},
+				})
+				return diff.Users, err
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := tt.enrich()
+			if err != nil {
+				t.Fatalf("enrich: %v", err)
+			}
+			byID := make(map[int64]domain.User, len(got))
+			for _, user := range got {
+				byID[user.ID] = user
+			}
+			if user := byID[entityUser]; user.FirstName != "Projected entity mention" {
+				t.Fatalf("entity mention user = %+v, want viewer projection", user)
+			}
+			if user := byID[quoteUser]; user.FirstName != "Projected quote mention" {
+				t.Fatalf("quote mention user = %+v, want viewer projection", user)
+			}
+		})
+	}
+}