X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/0018014ab36f3de61a4b8a5515009dab803d6c38..0b97bb2cc4bc0b8f8fe27cc7aa3f9d1d89ed28c8:/whatsapp_fake_helper_test.go diff --git a/whatsapp_fake_helper_test.go b/whatsapp_fake_helper_test.go index 1a7130c..c9bc835 100644 --- a/whatsapp_fake_helper_test.go +++ b/whatsapp_fake_helper_test.go @@ -2,19 +2,24 @@ package main import ( "context" + "fmt" "io" "log" "os" "path/filepath" + "slices" "sync" "testing" + "time" "github.com/stretchr/testify/require" "go.mau.fi/whatsmeow" waAdv "go.mau.fi/whatsmeow/proto/waAdv" + "go.mau.fi/whatsmeow/proto/waE2E" "go.mau.fi/whatsmeow/store" "go.mau.fi/whatsmeow/store/sqlstore" "go.mau.fi/whatsmeow/types" + "go.mau.fi/whatsmeow/types/events" waLog "go.mau.fi/whatsmeow/util/log" ) @@ -30,25 +35,65 @@ const ( whatsappTestCode = "ABCD-EFGH" ) +var ( + // whatsappTestOwn is the own account in the tests. + whatsappTestOwn = types.NewJID(whatsappTestNumber, types.DefaultUserServer) + + // whatsappTestAna is a contact in the tests. + whatsappTestAna = types.NewJID("15550002222", types.DefaultUserServer) + + // whatsappTestBruno is a member of the test group. + whatsappTestBruno = types.NewJID("15550003333", types.DefaultUserServer) + + // whatsappTestFamily is the test group. + whatsappTestFamily = types.NewJID("120363000000000001", types.GroupServer) + + // whatsappTestChat is the private chat with whatsappTestAna. + whatsappTestChat = WhatsAppChat{ + ID: whatsappTestAna.String(), + Name: "Ana Souza", + } + + // whatsappTestSendTime is the time of the sends of the fake. + whatsappTestSendTime = time.Date(2026, 1, 1, 12, 5, 0, 0, time.UTC) + + // whatsappTestGroup is the chat of whatsappTestFamily. + whatsappTestGroup = WhatsAppChat{ + ID: whatsappTestFamily.String(), + Name: "Family", + Group: true, + } +) + // WhatsAppFake is a fake WhatsApp client. It keeps the event handler that the // daemon gives it, and Emit gives events to the handler, as the library does. -// Each connection sends to connects, and each pairing sends its channel to -// pairings, so that the test gives the items of the pairing. A connection -// fails with connectErr, and a logout with logoutErr. +// Each connection keeps its context and sends to connects, and each pairing +// sends its channel to pairings, so that the test gives the items of the +// pairing. A connection fails with connectErr, a logout with logoutErr, and a +// send with sendErr. groups are the groups of the account. A send that does not +// fail gets the time whatsappTestSendTime. type WhatsAppFake struct { connects chan struct{} pairings chan chan whatsmeow.QRChannelItem - mutex sync.Mutex - handle func(event any) bool - connectErr error - logoutErr error - phones []string - logouts int + mutex sync.Mutex + handle func(event any) bool + connectErr error + logoutErr error + groups []*types.GroupInfo + sendErr error + phones []string + logouts int + sent []WhatsAppFakeSend + connections []context.Context } -// ConnectContext tells the test that the daemon connected. +// ConnectContext keeps ctx and tells the test that the daemon connected. func (f *WhatsAppFake) ConnectContext(ctx context.Context) error { + f.mutex.Lock() + f.connections = append(f.connections, ctx) + f.mutex.Unlock() + f.connects <- struct{}{} f.mutex.Lock() @@ -57,6 +102,14 @@ func (f *WhatsAppFake) ConnectContext(ctx context.Context) error { return f.connectErr } +// Connections returns the contexts of the connections, in order. +func (f *WhatsAppFake) Connections() []context.Context { + f.mutex.Lock() + defer f.mutex.Unlock() + + return slices.Clone(f.connections) +} + // Disconnect does nothing. func (f *WhatsAppFake) Disconnect() { } @@ -89,6 +142,50 @@ func (f *WhatsAppFake) Logout(ctx context.Context) error { return f.logoutErr } +// GetJoinedGroups returns groups. +func (f *WhatsAppFake) GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error) { + f.mutex.Lock() + defer f.mutex.Unlock() + + return f.groups, nil +} + +// GenerateMessageID returns a new message ID. +func (f *WhatsAppFake) GenerateMessageID() types.MessageID { + f.mutex.Lock() + defer f.mutex.Unlock() + + return fmt.Sprintf("MSG%d", len(f.sent)+1) +} + +// SendMessage keeps the send and returns sendErr. +func (f *WhatsAppFake) SendMessage(ctx context.Context, to types.JID, message *waE2E.Message, extra ...whatsmeow.SendRequestExtra) (whatsmeow.SendResponse, error) { + f.mutex.Lock() + defer f.mutex.Unlock() + + f.sent = append(f.sent, WhatsAppFakeSend{ + to: to.String(), + text: message.GetConversation(), + id: extra[0].ID, + }) + + if f.sendErr != nil { + return whatsmeow.SendResponse{}, f.sendErr + } + + return whatsmeow.SendResponse{ + Timestamp: whatsappTestSendTime, + }, nil +} + +// Sent returns the sends. +func (f *WhatsAppFake) Sent() []WhatsAppFakeSend { + f.mutex.Lock() + defer f.mutex.Unlock() + + return slices.Clone(f.sent) +} + // Phones returns the phone numbers of the pairings. func (f *WhatsAppFake) Phones() []string { f.mutex.Lock() @@ -124,6 +221,14 @@ func (f *WhatsAppFake) newClient(device *store.Device, handle func(event any) bo return f } +// WhatsAppFakeSend is one send of the fake: the chat, the text, and the message +// ID. +type WhatsAppFakeSend struct { + to string + text string + id string +} + // whatsappStartTest opens the WhatsApp of the data directory dir with a fake // client and the test clock, and closes it at the end of the test. The daemon // log goes to the returned buffer. @@ -180,8 +285,27 @@ func whatsappTestSession(t *testing.T, dir string, linked bool) { require.NoError(t, container.Close()) } -// whatsappDiscardLog is a logger for a WhatsApp whose log a test does not -// read. +// whatsappDiscardLog is a logger for a WhatsApp whose log a test does not read. func whatsappDiscardLog() *log.Logger { return log.New(io.Discard, "", 0) } + +// whatsappTestMessage returns the event of the text message id of sender in +// chat at the time at. A sender with whatsappTestNumber is the user. +func whatsappTestMessage(chat, sender types.JID, id, text string, at time.Time) *events.Message { + return &events.Message{ + Info: types.MessageInfo{ + MessageSource: types.MessageSource{ + Chat: chat, + Sender: sender, + IsFromMe: sender.User == whatsappTestNumber, + IsGroup: chat.Server == types.GroupServer, + }, + ID: id, + Timestamp: at, + }, + Message: &waE2E.Message{ + Conversation: new(text), + }, + } +}