575 lines
21 KiB
Go
575 lines
21 KiB
Go
package memory
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"telesrv/internal/domain"
|
|
)
|
|
|
|
func TestMessageStoreSendPrivateTextCreatesBothOwnerBoxes(t *testing.T) {
|
|
ctx := context.Background()
|
|
dialogs := NewDialogStore()
|
|
messages := NewMessageStore(dialogs)
|
|
req := domain.SendPrivateTextRequest{
|
|
SenderUserID: 1000000001,
|
|
RecipientUserID: 1000000002,
|
|
RandomID: 99,
|
|
Message: "hello",
|
|
Date: 1700000100,
|
|
}
|
|
|
|
got, err := messages.SendPrivateText(ctx, req)
|
|
if err != nil {
|
|
t.Fatalf("SendPrivateText: %v", err)
|
|
}
|
|
if got.SenderMessage.ID != 1 || got.SenderMessage.OwnerUserID != req.SenderUserID || !got.SenderMessage.Out || got.SenderMessage.Pts != 1 {
|
|
t.Fatalf("sender message = %+v, want first outgoing box with pts=1", got.SenderMessage)
|
|
}
|
|
if got.RecipientMessage.ID != 1 || got.RecipientMessage.OwnerUserID != req.RecipientUserID || got.RecipientMessage.Out || got.RecipientMessage.Pts != 1 {
|
|
t.Fatalf("recipient message = %+v, want first incoming box with pts=1", got.RecipientMessage)
|
|
}
|
|
if got.SenderMessage.UID == 0 || got.SenderMessage.UID != got.RecipientMessage.UID {
|
|
t.Fatalf("uid = sender %d recipient %d, want shared private message uid", got.SenderMessage.UID, got.RecipientMessage.UID)
|
|
}
|
|
|
|
second, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: req.SenderUserID,
|
|
RecipientUserID: req.RecipientUserID,
|
|
RandomID: 100,
|
|
Message: "again",
|
|
Date: 1700000110,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SendPrivateText second: %v", err)
|
|
}
|
|
if second.SenderMessage.ID != 2 || second.SenderMessage.Pts != 2 || second.RecipientMessage.ID != 2 || second.RecipientMessage.Pts != 2 {
|
|
t.Fatalf("second send = %+v/%+v, want per-owner box_id and pts to advance", second.SenderMessage, second.RecipientMessage)
|
|
}
|
|
|
|
dup, err := messages.SendPrivateText(ctx, req)
|
|
if err != nil {
|
|
t.Fatalf("SendPrivateText duplicate: %v", err)
|
|
}
|
|
if !dup.Duplicate || dup.SenderMessage.ID != got.SenderMessage.ID || dup.RecipientMessage.ID != got.RecipientMessage.ID {
|
|
t.Fatalf("duplicate = %+v, want original message boxes", dup)
|
|
}
|
|
|
|
senderHistory, err := messages.ListByUser(ctx, req.SenderUserID, domain.MessageFilter{HasPeer: true, Peer: got.SenderMessage.Peer, Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("sender history: %v", err)
|
|
}
|
|
recipientHistory, err := messages.ListByUser(ctx, req.RecipientUserID, domain.MessageFilter{HasPeer: true, Peer: got.RecipientMessage.Peer, Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("recipient history: %v", err)
|
|
}
|
|
if len(senderHistory.Messages) != 2 || len(recipientHistory.Messages) != 2 {
|
|
t.Fatalf("history sizes = sender %d recipient %d, want both owner partitions populated", len(senderHistory.Messages), len(recipientHistory.Messages))
|
|
}
|
|
}
|
|
|
|
func TestMessageStorePrivateMessageReactionsAreSharedAcrossOwnerBoxes(t *testing.T) {
|
|
ctx := context.Background()
|
|
messages := NewMessageStore()
|
|
aliceID := int64(1000000001)
|
|
bobID := int64(1000000002)
|
|
sent, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: aliceID,
|
|
RecipientUserID: bobID,
|
|
RandomID: 101,
|
|
Message: "react to me",
|
|
Date: 1700000100,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SendPrivateText: %v", err)
|
|
}
|
|
reaction := domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "\U0001f44d"}
|
|
res, err := messages.SetMessageReactions(ctx, domain.SetPrivateMessageReactionsRequest{
|
|
UserID: bobID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: aliceID},
|
|
MessageID: sent.RecipientMessage.ID,
|
|
Reactions: []domain.MessageReaction{
|
|
reaction,
|
|
},
|
|
Big: true,
|
|
Date: 1700000200,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SetMessageReactions: %v", err)
|
|
}
|
|
if len(res.Messages) != 2 {
|
|
t.Fatalf("reaction result messages = %d, want both owner boxes", len(res.Messages))
|
|
}
|
|
|
|
aliceReactions, err := messages.GetMessageReactions(ctx, domain.PrivateMessageReactionsRequest{
|
|
OwnerUserID: aliceID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: bobID},
|
|
IDs: []int{sent.SenderMessage.ID},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("alice GetMessageReactions: %v", err)
|
|
}
|
|
if len(aliceReactions.Messages) != 1 || aliceReactions.Messages[0].Reactions == nil {
|
|
t.Fatalf("alice reactions = %+v, want one enriched message", aliceReactions)
|
|
}
|
|
if got := aliceReactions.Messages[0].Reactions.Results; len(got) != 1 || got[0].Reaction != reaction || got[0].Count != 1 || got[0].ChosenOrder != 0 {
|
|
t.Fatalf("alice reaction counts = %+v, want one peer reaction without chosen order", got)
|
|
}
|
|
if got := aliceReactions.Messages[0].Reactions.Recent; len(got) != 1 || got[0].UserID != bobID || !got[0].Big || got[0].My {
|
|
t.Fatalf("alice recent reactions = %+v, want bob non-my big reaction", got)
|
|
}
|
|
aliceBox, err := messages.GetByIDs(ctx, aliceID, []int{sent.SenderMessage.ID})
|
|
if err != nil {
|
|
t.Fatalf("alice GetByIDs after reaction: %v", err)
|
|
}
|
|
if len(aliceBox.Messages) != 1 || !aliceBox.Messages[0].ReactionUnread {
|
|
t.Fatalf("alice box after reaction = %+v, want reaction_unread", aliceBox.Messages)
|
|
}
|
|
read, err := messages.ReadMessageContents(ctx, domain.ReadMessageContentsRequest{
|
|
OwnerUserID: aliceID,
|
|
IDs: []int{sent.SenderMessage.ID},
|
|
Date: 1700000210,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ReadMessageContents reaction: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(read.MessageIDs, []int{sent.SenderMessage.ID}) || read.Event.Type != domain.UpdateEventReadMessageContents || read.Event.Pts == 0 {
|
|
t.Fatalf("read reaction contents = %+v, want one read_message_contents event", read)
|
|
}
|
|
aliceBox, err = messages.GetByIDs(ctx, aliceID, []int{sent.SenderMessage.ID})
|
|
if err != nil {
|
|
t.Fatalf("alice GetByIDs after read reaction: %v", err)
|
|
}
|
|
if len(aliceBox.Messages) != 1 || aliceBox.Messages[0].ReactionUnread {
|
|
t.Fatalf("alice box after read reaction = %+v, want reaction_unread cleared", aliceBox.Messages)
|
|
}
|
|
|
|
bobReactions, err := messages.GetMessageReactions(ctx, domain.PrivateMessageReactionsRequest{
|
|
OwnerUserID: bobID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: aliceID},
|
|
IDs: []int{sent.RecipientMessage.ID},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("bob GetMessageReactions: %v", err)
|
|
}
|
|
if got := bobReactions.Messages[0].Reactions.Results; len(got) != 1 || got[0].ChosenOrder != 1 {
|
|
t.Fatalf("bob reaction counts = %+v, want own chosen order", got)
|
|
}
|
|
if got := bobReactions.Messages[0].Reactions.Recent; len(got) != 1 || !got[0].My {
|
|
t.Fatalf("bob recent reactions = %+v, want my reaction", got)
|
|
}
|
|
}
|
|
|
|
func TestMessageStoreSendPrivateTextReplyAndForwardMetadata(t *testing.T) {
|
|
ctx := context.Background()
|
|
messages := NewMessageStore()
|
|
aliceID := int64(1000000001)
|
|
bobID := int64(1000000002)
|
|
first, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: aliceID,
|
|
RecipientUserID: bobID,
|
|
RandomID: 501,
|
|
Message: "first",
|
|
Date: 1700000100,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("seed SendPrivateText: %v", err)
|
|
}
|
|
reply, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: aliceID,
|
|
RecipientUserID: bobID,
|
|
RandomID: 502,
|
|
Message: "reply",
|
|
Silent: true,
|
|
NoForwards: true,
|
|
ReplyTo: &domain.MessageReply{
|
|
MessageID: first.SenderMessage.ID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: bobID},
|
|
QuoteText: "fir",
|
|
QuoteOffset: 0,
|
|
},
|
|
Date: 1700000110,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("reply SendPrivateText: %v", err)
|
|
}
|
|
if reply.SenderMessage.ReplyTo == nil || reply.SenderMessage.ReplyTo.MessageID != first.SenderMessage.ID {
|
|
t.Fatalf("sender reply = %+v, want sender-side message id", reply.SenderMessage.ReplyTo)
|
|
}
|
|
if reply.RecipientMessage.ReplyTo == nil || reply.RecipientMessage.ReplyTo.MessageID != first.RecipientMessage.ID {
|
|
t.Fatalf("recipient reply = %+v, want translated recipient-side message id", reply.RecipientMessage.ReplyTo)
|
|
}
|
|
if !reply.SenderMessage.Silent || !reply.SenderMessage.NoForwards {
|
|
t.Fatalf("reply flags = silent %v noforwards %v, want true/true", reply.SenderMessage.Silent, reply.SenderMessage.NoForwards)
|
|
}
|
|
if _, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: aliceID,
|
|
RecipientUserID: bobID,
|
|
RandomID: 504,
|
|
Message: "bad quote offset",
|
|
ReplyTo: &domain.MessageReply{
|
|
MessageID: first.SenderMessage.ID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: bobID},
|
|
QuoteText: "fir",
|
|
QuoteOffset: domain.MaxMessageReplyQuoteOffset + 1,
|
|
},
|
|
Date: 1700000115,
|
|
}); !errors.Is(err, domain.ErrReplyMessageIDInvalid) {
|
|
t.Fatalf("bad quote offset err = %v, want ErrReplyMessageIDInvalid", err)
|
|
}
|
|
|
|
forwarded, err := messages.ForwardPrivateMessages(ctx, domain.ForwardPrivateMessagesRequest{
|
|
OwnerUserID: aliceID,
|
|
FromPeer: domain.Peer{Type: domain.PeerTypeUser, ID: bobID},
|
|
ToUserID: bobID,
|
|
MessageIDs: []int{first.SenderMessage.ID},
|
|
RandomIDs: []int64{503},
|
|
ReplyTo: &domain.MessageReply{
|
|
MessageID: first.SenderMessage.ID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: bobID},
|
|
},
|
|
Date: 1700000120,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ForwardPrivateMessages: %v", err)
|
|
}
|
|
if len(forwarded.SenderMessages) != 1 || forwarded.SenderMessages[0].Forward == nil || forwarded.SenderMessages[0].Forward.From.ID != aliceID {
|
|
t.Fatalf("forwarded messages = %+v, want original author header", forwarded.SenderMessages)
|
|
}
|
|
if forwarded.SenderMessages[0].ReplyTo == nil || forwarded.SenderMessages[0].ReplyTo.MessageID != first.SenderMessage.ID {
|
|
t.Fatalf("forward reply = %+v, want target dialog reply header", forwarded.SenderMessages[0].ReplyTo)
|
|
}
|
|
if _, err := messages.ForwardPrivateMessages(ctx, domain.ForwardPrivateMessagesRequest{
|
|
OwnerUserID: aliceID,
|
|
FromPeer: domain.Peer{Type: domain.PeerTypeUser, ID: bobID},
|
|
ToUserID: aliceID,
|
|
MessageIDs: []int{reply.SenderMessage.ID},
|
|
RandomIDs: []int64{504},
|
|
Date: 1700000130,
|
|
}); err != domain.ErrChatForwardsRestricted {
|
|
t.Fatalf("forward protected err=%v, want ErrChatForwardsRestricted", err)
|
|
}
|
|
}
|
|
|
|
func TestMessageStoreListByUserSupportsForwardAndAroundHistoryOffsets(t *testing.T) {
|
|
ctx := context.Background()
|
|
messages := NewMessageStore()
|
|
aliceID := int64(1000000001)
|
|
bobID := int64(1000000002)
|
|
peer := domain.Peer{Type: domain.PeerTypeUser, ID: aliceID}
|
|
|
|
for i := 1; i <= 6; i++ {
|
|
if _, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: aliceID,
|
|
RecipientUserID: bobID,
|
|
RandomID: int64(600 + i),
|
|
Message: "history",
|
|
Date: 1700000000 + i,
|
|
}); err != nil {
|
|
t.Fatalf("seed message %d: %v", i, err)
|
|
}
|
|
}
|
|
|
|
around, err := messages.ListByUser(ctx, bobID, domain.MessageFilter{
|
|
HasPeer: true,
|
|
Peer: peer,
|
|
OffsetID: 3,
|
|
AddOffset: -3,
|
|
Limit: 6,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("around history: %v", err)
|
|
}
|
|
if got := messageIDs(around.Messages); !sameInts(got, []int{6, 5, 4, 3, 2, 1}) {
|
|
t.Fatalf("around ids = %v, want unread/newer side plus older context", got)
|
|
}
|
|
|
|
forward, err := messages.ListByUser(ctx, bobID, domain.MessageFilter{
|
|
HasPeer: true,
|
|
Peer: peer,
|
|
OffsetID: 3,
|
|
AddOffset: -3,
|
|
Limit: 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("forward history: %v", err)
|
|
}
|
|
if got := messageIDs(forward.Messages); !sameInts(got, []int{6, 5, 4}) {
|
|
t.Fatalf("forward ids = %v, want messages newer than offset", got)
|
|
}
|
|
|
|
hugePositive, err := messages.ListByUser(ctx, bobID, domain.MessageFilter{
|
|
HasPeer: true,
|
|
Peer: peer,
|
|
AddOffset: 1 << 30,
|
|
Limit: 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("huge positive add_offset history: %v", err)
|
|
}
|
|
if len(hugePositive.Messages) != 0 {
|
|
t.Fatalf("huge positive add_offset ids = %v, want bounded empty page", messageIDs(hugePositive.Messages))
|
|
}
|
|
|
|
hugeNegative, err := messages.ListByUser(ctx, bobID, domain.MessageFilter{
|
|
HasPeer: true,
|
|
Peer: peer,
|
|
OffsetID: 3,
|
|
AddOffset: -1 << 30,
|
|
Limit: 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("huge negative add_offset history: %v", err)
|
|
}
|
|
if got := messageIDs(hugeNegative.Messages); !sameInts(got, []int{6, 5, 4}) {
|
|
t.Fatalf("huge negative add_offset ids = %v, want clamped forward page", got)
|
|
}
|
|
}
|
|
|
|
func TestMessageStoreReadHistoryEmitsInboxAndOutboxReceipts(t *testing.T) {
|
|
ctx := context.Background()
|
|
dialogs := NewDialogStore()
|
|
messages := NewMessageStore(dialogs)
|
|
senderID := int64(1000000001)
|
|
recipientID := int64(1000000002)
|
|
sent, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: senderID,
|
|
RecipientUserID: recipientID,
|
|
RandomID: 101,
|
|
Message: "hello",
|
|
Date: 1700000100,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SendPrivateText: %v", err)
|
|
}
|
|
|
|
read, err := messages.ReadHistory(ctx, domain.ReadHistoryRequest{
|
|
OwnerUserID: recipientID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: senderID},
|
|
Date: 1700000200,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ReadHistory: %v", err)
|
|
}
|
|
if !read.Changed || read.InboxEvent.Type != domain.UpdateEventReadHistoryInbox || read.InboxEvent.Pts != 2 || read.InboxEvent.MaxID != sent.RecipientMessage.ID {
|
|
t.Fatalf("inbox read = %+v, want recipient inbox pts=2 max recipient id", read)
|
|
}
|
|
if !read.OutboxChanged || read.OutboxUserID != senderID || read.OutboxEvent.Type != domain.UpdateEventReadHistoryOutbox || read.OutboxEvent.MaxID != sent.SenderMessage.ID {
|
|
t.Fatalf("outbox read = %+v, want sender outbox receipt with sender message id", read)
|
|
}
|
|
date, err := messages.GetOutboxReadDate(ctx, domain.OutboxReadDateRequest{
|
|
OwnerUserID: senderID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: recipientID},
|
|
ID: sent.SenderMessage.ID,
|
|
})
|
|
if err != nil || date != 1700000200 {
|
|
t.Fatalf("outbox read date = %d err=%v, want read date", date, err)
|
|
}
|
|
}
|
|
|
|
func TestMessageStoreReadMessageContentsClearsUnreadContentOnce(t *testing.T) {
|
|
ctx := context.Background()
|
|
messages := NewMessageStore()
|
|
sent, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: 1001,
|
|
RecipientUserID: 1002,
|
|
RandomID: 88,
|
|
Message: "voice placeholder",
|
|
Media: &domain.MessageMedia{Kind: domain.MessageMediaKindDocument, Voice: true},
|
|
Date: 1700000300,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SendPrivateText: %v", err)
|
|
}
|
|
if !sent.RecipientMessage.MediaUnread {
|
|
t.Fatalf("recipient MediaUnread = false, want true for incoming media")
|
|
}
|
|
got, err := messages.ReadMessageContents(ctx, domain.ReadMessageContentsRequest{
|
|
OwnerUserID: 1002,
|
|
IDs: []int{sent.RecipientMessage.ID, domain.MaxMessageBoxID},
|
|
Date: 1700000400,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ReadMessageContents: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(got.MessageIDs, []int{sent.RecipientMessage.ID}) {
|
|
t.Fatalf("MessageIDs = %v, want unread recipient id", got.MessageIDs)
|
|
}
|
|
if got.Event.Type != domain.UpdateEventReadMessageContents || got.Event.Pts == 0 || got.Event.PtsCount != 1 {
|
|
t.Fatalf("Event = %+v, want read_message_contents pts update", got.Event)
|
|
}
|
|
repeated, err := messages.ReadMessageContents(ctx, domain.ReadMessageContentsRequest{
|
|
OwnerUserID: 1002,
|
|
IDs: []int{sent.RecipientMessage.ID},
|
|
Date: 1700000500,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ReadMessageContents repeat: %v", err)
|
|
}
|
|
if len(repeated.MessageIDs) != 0 || repeated.Event.Pts != 0 {
|
|
t.Fatalf("repeat = %+v, want no affected messages and no pts", repeated)
|
|
}
|
|
if _, err := messages.ReadMessageContents(ctx, domain.ReadMessageContentsRequest{
|
|
OwnerUserID: 1002,
|
|
IDs: []int{0},
|
|
}); !errors.Is(err, domain.ErrMessageIDInvalid) {
|
|
t.Fatalf("invalid id error = %v, want ErrMessageIDInvalid", err)
|
|
}
|
|
}
|
|
|
|
func messageIDs(messages []domain.Message) []int {
|
|
out := make([]int, 0, len(messages))
|
|
for _, msg := range messages {
|
|
out = append(out, msg.ID)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func sameInts(got, want []int) bool {
|
|
if len(got) != len(want) {
|
|
return false
|
|
}
|
|
for i := range got {
|
|
if got[i] != want[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func TestMessageStoreEditMessageUpdatesBothBoxes(t *testing.T) {
|
|
ctx := context.Background()
|
|
dialogs := NewDialogStore()
|
|
messages := NewMessageStore(dialogs)
|
|
senderID := int64(1000000001)
|
|
recipientID := int64(1000000002)
|
|
sent, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: senderID,
|
|
RecipientUserID: recipientID,
|
|
RandomID: 102,
|
|
Message: "before",
|
|
Date: 1700000100,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("SendPrivateText: %v", err)
|
|
}
|
|
|
|
edited, err := messages.EditMessage(ctx, domain.EditMessageRequest{
|
|
OwnerUserID: senderID,
|
|
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: recipientID},
|
|
ID: sent.SenderMessage.ID,
|
|
Message: "after",
|
|
EditDate: 1700000200,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("EditMessage: %v", err)
|
|
}
|
|
if len(edited.Edited) != 2 || edited.Self().Message.Body != "after" || edited.Self().Event.Type != domain.UpdateEventEditMessage {
|
|
t.Fatalf("edited = %+v, want both owner boxes and self edit event", edited)
|
|
}
|
|
recipientHistory, err := messages.ListByUser(ctx, recipientID, domain.MessageFilter{HasPeer: true, Peer: domain.Peer{Type: domain.PeerTypeUser, ID: senderID}, Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("recipient history: %v", err)
|
|
}
|
|
if len(recipientHistory.Messages) != 1 || recipientHistory.Messages[0].Body != "after" || recipientHistory.Messages[0].EditDate != 1700000200 {
|
|
t.Fatalf("recipient history = %+v, want edited body/date", recipientHistory.Messages)
|
|
}
|
|
}
|
|
|
|
func TestMessageStoreDeleteHistoryDeletesOrPreservesDialogAndRebuilds(t *testing.T) {
|
|
ctx := context.Background()
|
|
dialogs := NewDialogStore()
|
|
messages := NewMessageStore(dialogs)
|
|
senderID := int64(1000000001)
|
|
recipientID := int64(1000000002)
|
|
peer := domain.Peer{Type: domain.PeerTypeUser, ID: recipientID}
|
|
|
|
for i := 0; i < 2; i++ {
|
|
if _, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: senderID,
|
|
RecipientUserID: recipientID,
|
|
RandomID: int64(100 + i),
|
|
Message: "hello",
|
|
Date: 1700000200 + i,
|
|
}); err != nil {
|
|
t.Fatalf("seed send %d: %v", i, err)
|
|
}
|
|
}
|
|
deleted, err := messages.DeleteHistory(ctx, domain.DeleteHistoryRequest{
|
|
OwnerUserID: senderID,
|
|
Peer: peer,
|
|
Date: 1700000300,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("DeleteHistory: %v", err)
|
|
}
|
|
if self := deleted.Self(); self.Event.Pts != 4 || self.Event.PtsCount != 2 || len(self.MessageIDs) != 2 {
|
|
t.Fatalf("delete result = %+v, want sender delete range pts=4 count=2", self)
|
|
}
|
|
senderHistory, err := messages.ListByUser(ctx, senderID, domain.MessageFilter{HasPeer: true, Peer: peer, Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("sender history: %v", err)
|
|
}
|
|
recipientHistory, err := messages.ListByUser(ctx, recipientID, domain.MessageFilter{HasPeer: true, Peer: domain.Peer{Type: domain.PeerTypeUser, ID: senderID}, Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("recipient history: %v", err)
|
|
}
|
|
if len(senderHistory.Messages) != 0 || len(recipientHistory.Messages) != 2 {
|
|
t.Fatalf("history sizes sender=%d recipient=%d, want sender cleared only", len(senderHistory.Messages), len(recipientHistory.Messages))
|
|
}
|
|
senderDialogs, err := dialogs.ListByUser(ctx, senderID, domain.DialogFilter{Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("sender dialogs after delete: %v", err)
|
|
}
|
|
if len(senderDialogs.Dialogs) != 0 {
|
|
t.Fatalf("sender dialogs = %+v, want dialog deleted after full history delete", senderDialogs.Dialogs)
|
|
}
|
|
|
|
rebuilt, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: senderID,
|
|
RecipientUserID: recipientID,
|
|
RandomID: 200,
|
|
Message: "rebuilt",
|
|
Date: 1700000400,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("send after delete: %v", err)
|
|
}
|
|
senderDialogs, err = dialogs.ListByUser(ctx, senderID, domain.DialogFilter{Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("sender dialogs after rebuild: %v", err)
|
|
}
|
|
if len(senderDialogs.Dialogs) != 1 || senderDialogs.Dialogs[0].Peer != peer || senderDialogs.Dialogs[0].TopMessage != rebuilt.SenderMessage.ID {
|
|
t.Fatalf("rebuilt dialogs = %+v, want one dialog with new top message %d", senderDialogs.Dialogs, rebuilt.SenderMessage.ID)
|
|
}
|
|
|
|
preservedOwner := int64(1000000003)
|
|
preservedPeerID := int64(1000000004)
|
|
preservedPeer := domain.Peer{Type: domain.PeerTypeUser, ID: preservedPeerID}
|
|
if _, err := messages.SendPrivateText(ctx, domain.SendPrivateTextRequest{
|
|
SenderUserID: preservedOwner,
|
|
RecipientUserID: preservedPeerID,
|
|
RandomID: 300,
|
|
Message: "clear but keep dialog",
|
|
Date: 1700000500,
|
|
}); err != nil {
|
|
t.Fatalf("seed preserved send: %v", err)
|
|
}
|
|
if _, err := messages.DeleteHistory(ctx, domain.DeleteHistoryRequest{
|
|
OwnerUserID: preservedOwner,
|
|
Peer: preservedPeer,
|
|
JustClear: true,
|
|
Date: 1700000600,
|
|
}); err != nil {
|
|
t.Fatalf("DeleteHistory just_clear: %v", err)
|
|
}
|
|
preservedDialogs, err := dialogs.ListByUser(ctx, preservedOwner, domain.DialogFilter{Limit: 10})
|
|
if err != nil {
|
|
t.Fatalf("preserved dialogs: %v", err)
|
|
}
|
|
if len(preservedDialogs.Dialogs) != 1 || preservedDialogs.Dialogs[0].Peer != preservedPeer || preservedDialogs.Dialogs[0].TopMessage != 0 || len(preservedDialogs.Messages) != 0 {
|
|
t.Fatalf("preserved dialogs = %+v messages=%+v, want empty dialog kept after just_clear", preservedDialogs.Dialogs, preservedDialogs.Messages)
|
|
}
|
|
}
|