97 lines
3.6 KiB
Go
97 lines
3.6 KiB
Go
package rpc
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/iamxvbaba/td/clock"
|
|
"github.com/iamxvbaba/td/tg"
|
|
"go.uber.org/zap/zaptest"
|
|
|
|
appchannels "telesrv/internal/app/channels"
|
|
appusers "telesrv/internal/app/users"
|
|
"telesrv/internal/domain"
|
|
"telesrv/internal/store/memory"
|
|
)
|
|
|
|
func TestChannelsCreateChannelResponseCarriesTdlibMessageMappingOnlyForCaller(t *testing.T) {
|
|
ctx := context.Background()
|
|
userStore := memory.NewUserStore()
|
|
owner, err := userStore.Create(ctx, domain.User{
|
|
AccessHash: 88001,
|
|
Phone: "15550088001",
|
|
FirstName: "Owner",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create owner: %v", err)
|
|
}
|
|
sessions := &captureSessions{onlineUserIDs: []int64{owner.ID}}
|
|
r := New(Config{}, Deps{
|
|
Users: appusers.NewService(userStore),
|
|
Channels: appchannels.NewService(memory.NewChannelStore()),
|
|
Sessions: sessions,
|
|
}, zaptest.NewLogger(t), clock.System)
|
|
|
|
tests := []struct {
|
|
name string
|
|
req *tg.ChannelsCreateChannelRequest
|
|
}{
|
|
{name: "broadcast", req: &tg.ChannelsCreateChannelRequest{Title: "TDLib broadcast", Broadcast: true}},
|
|
{name: "megagroup", req: &tg.ChannelsCreateChannelRequest{Title: "TDLib group", Megagroup: true}},
|
|
{name: "forum", req: &tg.ChannelsCreateChannelRequest{Title: "TDLib forum", Megagroup: true, Forum: true}},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
sessions.clearMessages()
|
|
created, err := r.onChannelsCreateChannel(WithUserID(ctx, owner.ID), test.req)
|
|
if err != nil {
|
|
t.Fatalf("create channel: %v", err)
|
|
}
|
|
updates, ok := created.(*tg.Updates)
|
|
if !ok || len(updates.Updates) != 3 {
|
|
t.Fatalf("response = %T %+v, want mapping, create message, and channel refresh", created, created)
|
|
}
|
|
mapping, ok := updates.Updates[0].(*tg.UpdateMessageID)
|
|
if !ok || mapping.ID <= 0 || mapping.RandomID == 0 {
|
|
t.Fatalf("mapping = %#v, want positive message id and non-zero random id", updates.Updates[0])
|
|
}
|
|
create, ok := updates.Updates[1].(*tg.UpdateNewChannelMessage)
|
|
if !ok || create.Pts != domain.FirstChannelEventPts || create.PtsCount != 1 {
|
|
t.Fatalf("create update = %#v, want pts=2 pts_count=1", updates.Updates[1])
|
|
}
|
|
service, ok := create.Message.(*tg.MessageService)
|
|
if !ok || service.ID != mapping.ID {
|
|
t.Fatalf("create service = %#v, want mapped id %d", create.Message, mapping.ID)
|
|
}
|
|
if _, ok := service.Action.(*tg.MessageActionChannelCreate); !ok {
|
|
t.Fatalf("create action = %T, want messageActionChannelCreate", service.Action)
|
|
}
|
|
if refresh, ok := updates.Updates[2].(*tg.UpdateChannel); !ok || refresh.ChannelID == 0 {
|
|
t.Fatalf("refresh = %#v, want updateChannel", updates.Updates[2])
|
|
}
|
|
|
|
pushed, ok := sessions.lastUserPush().(*tg.Updates)
|
|
if !ok || len(pushed.Updates) != 2 {
|
|
t.Fatalf("fan-out = %T %+v, want create message and channel refresh only", sessions.lastUserPush(), sessions.lastUserPush())
|
|
}
|
|
for _, update := range pushed.Updates {
|
|
if _, ok := update.(*tg.UpdateMessageID); ok {
|
|
t.Fatalf("response-only updateMessageID leaked into fan-out: %+v", pushed.Updates)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestChannelCreationResponseRejectsNonCreationResult(t *testing.T) {
|
|
r := New(Config{}, Deps{}, zaptest.NewLogger(t), clock.System)
|
|
for _, result := range []domain.CreateChannelResult{
|
|
{},
|
|
{Message: domain.ChannelMessage{ID: 1}},
|
|
{Message: domain.ChannelMessage{ID: 1, Action: &domain.ChannelMessageAction{Type: domain.ChannelActionChatAddUser}}},
|
|
} {
|
|
if updates, err := r.channelCreationResponseUpdates(context.Background(), 1, result); err == nil || updates != nil {
|
|
t.Fatalf("invalid creation result = %+v produced updates=%+v err=%v", result, updates, err)
|
|
}
|
|
}
|
|
}
|