X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/ec230eee6b06580031637bc97c99ec6db7b41926..0b97bb2cc4bc0b8f8fe27cc7aa3f9d1d89ed28c8:/whatsapp_fake_helper_test.go diff --git a/whatsapp_fake_helper_test.go b/whatsapp_fake_helper_test.go index f7e6cad..c9bc835 100644 --- a/whatsapp_fake_helper_test.go +++ b/whatsapp_fake_helper_test.go @@ -2,44 +2,206 @@ 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" ) -// whatsappTestNumber is the phone number of the own account in the tests. It -// is a number for fiction. -const whatsappTestNumber = "15550001111" +const ( + // whatsappTestNumber is the phone number of the own account in the + // tests. It is a number for fiction. + whatsappTestNumber = "15550001111" + + // whatsappTestLID is the LID of the own account in the tests. + whatsappTestLID = "987654321012345" + + // whatsappTestCode is the pairing code of the fake. + 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 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 { - mutex sync.Mutex - handle func(event any) bool - connected chan struct{} + connects chan struct{} + pairings chan chan whatsmeow.QRChannelItem + + 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 { - close(f.connected) + f.mutex.Lock() + f.connections = append(f.connections, ctx) + f.mutex.Unlock() - return nil + f.connects <- struct{}{} + + f.mutex.Lock() + defer f.mutex.Unlock() + + 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() { } +// GetQRChannel gives a new channel of pairing items to the test. +func (f *WhatsAppFake) GetQRChannel(ctx context.Context) (<-chan whatsmeow.QRChannelItem, error) { + items := make(chan whatsmeow.QRChannelItem, 8) + f.pairings <- items + + return items, nil +} + +// PairPhone keeps phone and returns whatsappTestCode. +func (f *WhatsAppFake) PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error) { + f.mutex.Lock() + defer f.mutex.Unlock() + + f.phones = append(f.phones, phone) + + return whatsappTestCode, nil +} + +// Logout counts the logouts and returns logoutErr. +func (f *WhatsAppFake) Logout(ctx context.Context) error { + f.mutex.Lock() + defer f.mutex.Unlock() + + f.logouts++ + + 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() + defer f.mutex.Unlock() + + return append([]string{}, f.phones...) +} + +// Logouts returns the number of logouts. +func (f *WhatsAppFake) Logouts() int { + f.mutex.Lock() + defer f.mutex.Unlock() + + return f.logouts +} + // Emit gives event to the handler of the daemon and returns its answer. func (f *WhatsAppFake) Emit(event any) bool { f.mutex.Lock() @@ -59,28 +221,39 @@ 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. -func whatsappStartTest(t *testing.T, dir string) (*WhatsApp, *WhatsAppFake) { +// client and the test clock, and closes it at the end of the test. The daemon +// log goes to the returned buffer. +func whatsappStartTest(t *testing.T, dir string, clock *TestClock) (*WhatsApp, *WhatsAppFake, *SyncBuffer) { t.Helper() fake := &WhatsAppFake{ - connected: make(chan struct{}), + connects: make(chan struct{}, 16), + pairings: make(chan chan whatsmeow.QRChannelItem, 16), } - whatsapp, err := openWhatsApp(t.Context(), dir, newTestClock().Now, log.New(io.Discard, "", 0), fake.newClient) + logs := &SyncBuffer{} + whatsapp, err := openWhatsApp(t.Context(), dir, clock.Now, log.New(logs, "", 0), fake.newClient) require.NoError(t, err) t.Cleanup(func() { require.NoError(t, whatsapp.Close()) }) - return whatsapp, fake + return whatsapp, fake, logs } // whatsappTestSession writes a session database with mode 0600 to the data // directory dir. When linked is true, it holds a device linked to -// whatsappTestNumber, and else a device with no link. +// whatsappTestNumber and whatsappTestLID, and else no device. func whatsappTestSession(t *testing.T, dir string, linked bool) { t.Helper() @@ -98,6 +271,8 @@ func whatsappTestSession(t *testing.T, dir string, linked bool) { device := container.NewDevice() jid := types.NewADJID(whatsappTestNumber, 0, 1) device.ID = &jid + device.LID = types.NewADJID(whatsappTestLID, 0, 1) + device.LID.Server = types.HiddenUserServer device.Account = &waAdv.ADVSignedDeviceIdentity{ Details: []byte{}, AccountSignature: make([]byte, 64), @@ -109,3 +284,28 @@ 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. +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), + }, + } +}