git.giacomolli.uk - onechat/blob - whatsapp_fake_helper_test.go

   1 package main
   2
   3 import (
   4         "context"
   5         "io"
   6         "log"
   7         "os"
   8         "path/filepath"
   9         "sync"
  10         "testing"
  11         "time"
  12
  13         "github.com/stretchr/testify/require"
  14         "go.mau.fi/whatsmeow"
  15         waAdv "go.mau.fi/whatsmeow/proto/waAdv"
  16         "go.mau.fi/whatsmeow/proto/waE2E"
  17         "go.mau.fi/whatsmeow/store"
  18         "go.mau.fi/whatsmeow/store/sqlstore"
  19         "go.mau.fi/whatsmeow/types"
  20         "go.mau.fi/whatsmeow/types/events"
  21         waLog "go.mau.fi/whatsmeow/util/log"
  22 )
  23
  24 const (
  25         // whatsappTestNumber is the phone number of the own account in the
  26         // tests. It is a number for fiction.
  27         whatsappTestNumber = "15550001111"
  28
  29         // whatsappTestLID is the LID of the own account in the tests.
  30         whatsappTestLID = "987654321012345"
  31
  32         // whatsappTestCode is the pairing code of the fake.
  33         whatsappTestCode = "ABCD-EFGH"
  34 )
  35
  36 var (
  37         // whatsappTestOwn is the own account in the tests.
  38         whatsappTestOwn = types.NewJID(whatsappTestNumber, types.DefaultUserServer)
  39
  40         // whatsappTestAna is a contact in the tests.
  41         whatsappTestAna = types.NewJID("15550002222", types.DefaultUserServer)
  42
  43         // whatsappTestBruno is a member of the test group.
  44         whatsappTestBruno = types.NewJID("15550003333", types.DefaultUserServer)
  45
  46         // whatsappTestFamily is the test group.
  47         whatsappTestFamily = types.NewJID("120363000000000001", types.GroupServer)
  48
  49         // whatsappTestChat is the private chat with whatsappTestAna.
  50         whatsappTestChat = WhatsAppChat{
  51                 ID:   whatsappTestAna.String(),
  52                 Name: "Ana Souza",
  53         }
  54
  55         // whatsappTestGroup is the chat of whatsappTestFamily.
  56         whatsappTestGroup = WhatsAppChat{
  57                 ID:    whatsappTestFamily.String(),
  58                 Name:  "Family",
  59                 Group: true,
  60         }
  61 )
  62
  63 // WhatsAppFake is a fake WhatsApp client. It keeps the event handler that the
  64 // daemon gives it, and Emit gives events to the handler, as the library does.
  65 // Each connection sends to connects, and each pairing sends its channel to
  66 // pairings, so that the test gives the items of the pairing. A connection fails
  67 // with connectErr, and a logout with logoutErr. groups are the groups of the
  68 // account.
  69 type WhatsAppFake struct {
  70         connects chan struct{}
  71         pairings chan chan whatsmeow.QRChannelItem
  72
  73         mutex      sync.Mutex
  74         handle     func(event any) bool
  75         connectErr error
  76         logoutErr  error
  77         groups     []*types.GroupInfo
  78         phones     []string
  79         logouts    int
  80 }
  81
  82 // ConnectContext tells the test that the daemon connected.
  83 func (f *WhatsAppFake) ConnectContext(ctx context.Context) error {
  84         f.connects <- struct{}{}
  85
  86         f.mutex.Lock()
  87         defer f.mutex.Unlock()
  88
  89         return f.connectErr
  90 }
  91
  92 // Disconnect does nothing.
  93 func (f *WhatsAppFake) Disconnect() {
  94 }
  95
  96 // GetQRChannel gives a new channel of pairing items to the test.
  97 func (f *WhatsAppFake) GetQRChannel(ctx context.Context) (<-chan whatsmeow.QRChannelItem, error) {
  98         items := make(chan whatsmeow.QRChannelItem, 8)
  99         f.pairings <- items
 100
 101         return items, nil
 102 }
 103
 104 // PairPhone keeps phone and returns whatsappTestCode.
 105 func (f *WhatsAppFake) PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType whatsmeow.PairClientType, clientDisplayName string) (string, error) {
 106         f.mutex.Lock()
 107         defer f.mutex.Unlock()
 108
 109         f.phones = append(f.phones, phone)
 110
 111         return whatsappTestCode, nil
 112 }
 113
 114 // Logout counts the logouts and returns logoutErr.
 115 func (f *WhatsAppFake) Logout(ctx context.Context) error {
 116         f.mutex.Lock()
 117         defer f.mutex.Unlock()
 118
 119         f.logouts++
 120
 121         return f.logoutErr
 122 }
 123
 124 // GetJoinedGroups returns groups.
 125 func (f *WhatsAppFake) GetJoinedGroups(ctx context.Context) ([]*types.GroupInfo, error) {
 126         f.mutex.Lock()
 127         defer f.mutex.Unlock()
 128
 129         return f.groups, nil
 130 }
 131
 132 // Phones returns the phone numbers of the pairings.
 133 func (f *WhatsAppFake) Phones() []string {
 134         f.mutex.Lock()
 135         defer f.mutex.Unlock()
 136
 137         return append([]string{}, f.phones...)
 138 }
 139
 140 // Logouts returns the number of logouts.
 141 func (f *WhatsAppFake) Logouts() int {
 142         f.mutex.Lock()
 143         defer f.mutex.Unlock()
 144
 145         return f.logouts
 146 }
 147
 148 // Emit gives event to the handler of the daemon and returns its answer.
 149 func (f *WhatsAppFake) Emit(event any) bool {
 150         f.mutex.Lock()
 151         handle := f.handle
 152         f.mutex.Unlock()
 153
 154         return handle(event)
 155 }
 156
 157 // newClient keeps handle and returns the fake as the client of device.
 158 func (f *WhatsAppFake) newClient(device *store.Device, handle func(event any) bool) WhatsAppClient {
 159         f.mutex.Lock()
 160         defer f.mutex.Unlock()
 161
 162         f.handle = handle
 163
 164         return f
 165 }
 166
 167 // whatsappStartTest opens the WhatsApp of the data directory dir with a fake
 168 // client and the test clock, and closes it at the end of the test. The daemon
 169 // log goes to the returned buffer.
 170 func whatsappStartTest(t *testing.T, dir string, clock *TestClock) (*WhatsApp, *WhatsAppFake, *SyncBuffer) {
 171         t.Helper()
 172
 173         fake := &WhatsAppFake{
 174                 connects: make(chan struct{}, 16),
 175                 pairings: make(chan chan whatsmeow.QRChannelItem, 16),
 176         }
 177
 178         logs := &SyncBuffer{}
 179         whatsapp, err := openWhatsApp(t.Context(), dir, clock.Now, log.New(logs, "", 0), fake.newClient)
 180         require.NoError(t, err)
 181
 182         t.Cleanup(func() {
 183                 require.NoError(t, whatsapp.Close())
 184         })
 185
 186         return whatsapp, fake, logs
 187 }
 188
 189 // whatsappTestSession writes a session database with mode 0600 to the data
 190 // directory dir. When linked is true, it holds a device linked to
 191 // whatsappTestNumber and whatsappTestLID, and else no device.
 192 func whatsappTestSession(t *testing.T, dir string, linked bool) {
 193         t.Helper()
 194
 195         path := filepath.Join(dir, whatsappDirName, whatsappSessionFileName)
 196         require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o700))
 197         require.NoError(t, os.WriteFile(path, nil, 0o600))
 198
 199         address, err := whatsappSessionAddress(path)
 200         require.NoError(t, err)
 201
 202         container, err := sqlstore.New(t.Context(), "sqlite", address, waLog.Noop)
 203         require.NoError(t, err)
 204
 205         if linked {
 206                 device := container.NewDevice()
 207                 jid := types.NewADJID(whatsappTestNumber, 0, 1)
 208                 device.ID = &jid
 209                 device.LID = types.NewADJID(whatsappTestLID, 0, 1)
 210                 device.LID.Server = types.HiddenUserServer
 211                 device.Account = &waAdv.ADVSignedDeviceIdentity{
 212                         Details:             []byte{},
 213                         AccountSignature:    make([]byte, 64),
 214                         AccountSignatureKey: make([]byte, 32),
 215                         DeviceSignature:     make([]byte, 64),
 216                 }
 217                 require.NoError(t, device.Save(t.Context()))
 218         }
 219
 220         require.NoError(t, container.Close())
 221 }
 222
 223 // whatsappDiscardLog is a logger for a WhatsApp whose log a test does not read.
 224 func whatsappDiscardLog() *log.Logger {
 225         return log.New(io.Discard, "", 0)
 226 }
 227
 228 // whatsappTestMessage returns the event of the text message id of sender in
 229 // chat at the time at. A sender with whatsappTestNumber is the user.
 230 func whatsappTestMessage(chat, sender types.JID, id, text string, at time.Time) *events.Message {
 231         return &events.Message{
 232                 Info: types.MessageInfo{
 233                         MessageSource: types.MessageSource{
 234                                 Chat:     chat,
 235                                 Sender:   sender,
 236                                 IsFromMe: sender.User == whatsappTestNumber,
 237                                 IsGroup:  chat.Server == types.GroupServer,
 238                         },
 239                         ID:        id,
 240                         Timestamp: at,
 241                 },
 242                 Message: &waE2E.Message{
 243                         Conversation: new(text),
 244                 },
 245         }
 246 }