// 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.
+// pairing. A connection takes its error from connectErrors, then connectErr. A
+// logout fails 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
- groups []*types.GroupInfo
- sendErr error
- phones []string
- logouts int
- sent []WhatsAppFakeSend
- connections []context.Context
+ mutex sync.Mutex
+ handle func(event any) bool
+ connectErr error
+ connectErrors []error
+ connectTimes []time.Time
+ logoutErr error
+ groups []*types.GroupInfo
+ sendErr error
+ phones []string
+ logouts int
+ sent []WhatsAppFakeSend
+ connections []context.Context
}
// 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.connectTimes = append(f.connectTimes, time.Now())
f.mutex.Unlock()
f.connects <- struct{}{}
f.mutex.Lock()
defer f.mutex.Unlock()
+ if len(f.connectErrors) > 0 {
+ err := f.connectErrors[0]
+ f.connectErrors = f.connectErrors[1:]
+
+ return err
+ }
+
return f.connectErr
}
return slices.Clone(f.connections)
}
+// ConnectionTimes returns the time of each connection call, in order.
+func (f *WhatsAppFake) ConnectionTimes() []time.Time {
+ f.mutex.Lock()
+ defer f.mutex.Unlock()
+
+ return slices.Clone(f.connectTimes)
+}
+
// 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) {
+func (f *WhatsAppFake) GetQRChannel(_ context.Context) (<-chan whatsmeow.QRChannelItem, error) {
items := make(chan whatsmeow.QRChannelItem, 8)
f.pairings <- items
}
// PairPhone keeps phone and returns whatsappTestCode.
-func (f *WhatsAppFake) PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error) {
+func (f *WhatsAppFake) PairPhone(_ context.Context, phone string, _ bool, _ whatsmeow.PairClientType, _ string) (string, error) {
f.mutex.Lock()
defer f.mutex.Unlock()
}
// Logout counts the logouts and returns logoutErr.
-func (f *WhatsAppFake) Logout(ctx context.Context) error {
+func (f *WhatsAppFake) Logout(_ context.Context) error {
f.mutex.Lock()
defer f.mutex.Unlock()
}
// GetJoinedGroups returns groups.
-func (f *WhatsAppFake) GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error) {
+func (f *WhatsAppFake) GetJoinedGroups(_ context.Context) ([]*types.GroupInfo, error) {
f.mutex.Lock()
defer f.mutex.Unlock()
}
// 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) {
+func (f *WhatsAppFake) SendMessage(_ context.Context, to types.JID, message *waE2E.Message, extra ...whatsmeow.SendRequestExtra) (whatsmeow.SendResponse, error) {
f.mutex.Lock()
defer f.mutex.Unlock()
}
// newClient keeps handle and returns the fake as the client of device.
-func (f *WhatsAppFake) newClient(device *store.Device, handle func(event any) bool) WhatsAppClient {
+func (f *WhatsAppFake) newClient(_ *store.Device, handle func(event any) bool) WhatsAppClient {
f.mutex.Lock()
defer f.mutex.Unlock()
},
}
}
+
+// whatsappTestLogTexts returns the texts of the messages in the log of memory,
+// after the log holds at least one message.
+func whatsappTestLogTexts(t *testing.T, memory *Memory) []string {
+ t.Helper()
+
+ require.Eventually(t, func() bool {
+ return memory.Len() > 0
+ }, 10*time.Second, time.Millisecond)
+
+ var texts []string
+ for id := range memory.Len() {
+ message, err := memory.Message(id)
+ require.NoError(t, err)
+
+ texts = append(texts, message.Text)
+ }
+
+ return texts
+}
+
+// whatsappStartTestLinked opens a WhatsApp with a linked device in a temporary
+// directory, with a quiet time of 50 ms for its batches.
+func whatsappStartTestLinked(t *testing.T) (*WhatsApp, *WhatsAppFake) {
+ t.Helper()
+
+ dir := t.TempDir()
+ whatsappTestSession(t, dir, true)
+ whatsapp, fake, _ := whatsappStartTest(t, dir, newTestClock())
+ whatsapp.state.quiet = 50 * time.Millisecond
+
+ return whatsapp, fake
+}
+
+// whatsappTestConnect waits for the connection of the daemon and gives it the
+// events of a connection with an empty catch-up.
+func whatsappTestConnect(t *testing.T, fake *WhatsAppFake) {
+ t.Helper()
+
+ <-fake.connects
+ require.True(t, fake.Emit(&events.Connected{}))
+ require.True(t, fake.Emit(&events.OfflineSyncCompleted{}))
+}
+
+// whatsappTestContacts puts the contacts of the tests into the session of
+// whatsapp: Ana Souza, Joao Silva with an accent, a business, and the user.
+func whatsappTestContacts(t *testing.T, whatsapp *WhatsApp) {
+ t.Helper()
+
+ contacts := whatsapp.device.Contacts
+ require.NoError(t, contacts.PutContactName(t.Context(), whatsappTestAna, "Ana", "Ana Souza"))
+ require.NoError(t, contacts.PutContactName(t.Context(), types.NewJID("15550004444", types.DefaultUserServer), "João", "João Silva"))
+ _, _, err := contacts.PutBusinessName(t.Context(), types.NewJID("15550005555", types.DefaultUserServer), "Corner Bakery")
+ require.NoError(t, err)
+ require.NoError(t, contacts.PutContactName(t.Context(), whatsappTestOwn, "Me", "Me Souza"))
+}
projects / onechat / blobdiff