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

   1 package main
   2
   3 import (
   4         "net/http"
   5         "testing"
   6         "testing/synctest"
   7         "time"
   8
   9         "github.com/stretchr/testify/require"
  10         "go.mau.fi/whatsmeow/proto/waE2E"
  11         "go.mau.fi/whatsmeow/proto/waWeb"
  12         "go.mau.fi/whatsmeow/types"
  13         "go.mau.fi/whatsmeow/types/events"
  14 )
  15
  16 func TestWhatsAppPrivateBatchStartsATurnWithAnEmptyReply(t *testing.T) {
  17         whatsapp, fake := whatsappStartTestLinked(t)
  18         require.NoError(t, whatsapp.device.Contacts.PutContactName(t.Context(), whatsappTestAna, "Ana", "Ana Souza"))
  19
  20         server := newModelFake(t)
  21         server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {
  22                 modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("")}, 100, 0, 5))
  23         }
  24
  25         telegram := newTelegramFake(t)
  26         bot, _ := telegramStartTestBot(t, telegram)
  27         socket, memory := daemonStartTestWithWhatsApp(t, server, bot, whatsapp)
  28         client := terminalStartTestClient(t, socket)
  29         client.WaitFor(t, "[connected to OneChat]")
  30         <-fake.connects
  31
  32         // The catch-up holds the batch open until its end, so the two messages
  33         // form one batch also on a slow machine.
  34         require.True(t, fake.Emit(&events.Connected{}))
  35
  36         at := time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC)
  37         require.True(t, fake.Emit(whatsappTestMessage(whatsappTestAna, whatsappTestAna, "m1", "Are you at home?", at)))
  38         require.True(t, fake.Emit(whatsappTestMessage(whatsappTestAna, whatsappTestOwn, "m2", "Yes", at)))
  39         require.True(t, fake.Emit(&events.OfflineSyncCompleted{}))
  40
  41         text := "[WhatsApp] Ana Souza, private chat 15550002222@s.whatsapp.net, Thursday 2026-01-01\n12:00 Ana Souza: Are you at home?\n12:00 You: Yes\n" + whatsappBatchEmptyReply
  42         client.WaitFor(t, text+"\n[working]\n[done]\n")
  43         require.Equal(t, 1, server.Calls())
  44         require.Contains(t, string(server.Call(0).raw), "Are you at home?")
  45         require.Equal(t, []string{text}, whatsappTestLogTexts(t, memory))
  46         require.Empty(t, telegram.Sent())
  47         require.Eventually(t, func() bool {
  48                 return len(whatsapp.state.Closed()) == 0
  49         }, 10*time.Second, time.Millisecond)
  50 }
  51
  52 func TestWhatsAppGroupTurns(t *testing.T) {
  53         testCases := []struct {
  54                 name    string
  55                 message func(event *events.Message)
  56                 line    string
  57                 turn    bool
  58         }{
  59                 {
  60                         name: "plain",
  61                         message: func(_ *events.Message) {
  62                         },
  63                         line: "12:00 Bruno Lima: Who brings the cake?",
  64                 },
  65                 {
  66                         name: "mention",
  67                         message: func(event *events.Message) {
  68                                 event.Message = &waE2E.Message{
  69                                         ExtendedTextMessage: &waE2E.ExtendedTextMessage{
  70                                                 Text: new("@" + whatsappTestLID + " can you bring the cake? Call " + whatsappTestNumber + "."),
  71                                                 ContextInfo: &waE2E.ContextInfo{
  72                                                         MentionedJID: []string{whatsappTestLID + "@lid"},
  73                                                 },
  74                                         },
  75                                 }
  76                         },
  77                         line: "12:00 Bruno Lima (mentions you): @you can you bring the cake? Call OWN.",
  78                         turn: true,
  79                 },
  80                 {
  81                         name: "reply",
  82                         message: func(event *events.Message) {
  83                                 event.Message = &waE2E.Message{
  84                                         ExtendedTextMessage: &waE2E.ExtendedTextMessage{
  85                                                 Text: new("Who brings the cake?"),
  86                                                 ContextInfo: &waE2E.ContextInfo{
  87                                                         Participant: new(whatsappTestOwn.String()),
  88                                                 },
  89                                         },
  90                                 }
  91                         },
  92                         line: "12:00 Bruno Lima (replies to you): Who brings the cake?",
  93                         turn: true,
  94                 },
  95         }
  96
  97         for _, tc := range testCases {
  98                 t.Run(tc.name, func(t *testing.T) {
  99                         whatsapp, fake := whatsappStartTestLinked(t)
 100                         fake.groups = []*types.GroupInfo{
 101                                 {
 102                                         JID: whatsappTestFamily,
 103                                         GroupName: types.GroupName{
 104                                                 Name: "Family",
 105                                         },
 106                                 },
 107                         }
 108
 109                         server := newModelFake(t)
 110                         socket, memory := daemonStartTestWithWhatsApp(t, server, nil, whatsapp)
 111                         client := terminalStartTestClient(t, socket)
 112                         client.WaitFor(t, "[connected to OneChat]")
 113                         whatsappTestConnect(t, fake)
 114
 115                         event := whatsappTestMessage(whatsappTestFamily, whatsappTestBruno, "m1", "Who brings the cake?", time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC))
 116                         event.Info.PushName = "Bruno Lima"
 117                         tc.message(event)
 118                         require.True(t, fake.Emit(event))
 119                         require.NoError(t, whatsapp.state.CloseAll())
 120
 121                         whatsapp.inbox.wake <- struct{}{}
 122
 123                         text := "[WhatsApp] Family, group 120363000000000001@g.us, Thursday 2026-01-01\n" + tc.line
 124                         if tc.turn {
 125                                 text += "\n" + whatsappBatchEmptyReply
 126
 127                                 client.WaitFor(t, "[done]")
 128                                 require.Equal(t, 1, server.Calls())
 129                         } else {
 130                                 client.WaitFor(t, text)
 131                                 time.Sleep(100 * time.Millisecond)
 132                                 require.Zero(t, server.Calls())
 133                         }
 134
 135                         require.Equal(t, text, whatsappTestLogTexts(t, memory)[0])
 136                 })
 137         }
 138 }
 139
 140 func TestWhatsAppRunClosesABatchAfterQuietTime(t *testing.T) {
 141         synctest.Test(t, func(t *testing.T) {
 142                 test := whatsappRetryTest(t)
 143                 test.start(t)
 144                 synctest.Wait()
 145                 require.True(t, test.fake.Emit(&events.Connected{}))
 146                 require.True(t, test.fake.Emit(&events.OfflineSyncCompleted{}))
 147                 synctest.Wait()
 148                 require.True(t, test.fake.Emit(whatsappTestMessage(whatsappTestAna, whatsappTestOwn, "m1", "On my way.", time.Now())))
 149                 synctest.Wait()
 150                 time.Sleep(whatsappBatchIdleTimeout - time.Nanosecond)
 151                 synctest.Wait()
 152                 require.Zero(t, test.loop.memory.Len())
 153
 154                 time.Sleep(time.Nanosecond)
 155                 synctest.Wait()
 156                 require.Equal(t, 1, test.loop.memory.Len())
 157                 require.Contains(t, test.events.Last("work"), "You: On my way.")
 158         })
 159 }
 160
 161 func TestWhatsAppSkipsExcludedMessages(t *testing.T) {
 162         at := time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC)
 163         testCases := []struct {
 164                 name   string
 165                 change func(event *events.Message)
 166         }{
 167                 {
 168                         name: "an edit",
 169                         change: func(event *events.Message) {
 170                                 event.IsEdit = true
 171                         },
 172                 },
 173                 {
 174                         name: "old history",
 175                         change: func(event *events.Message) {
 176                                 event.SourceWebMsg = &waWeb.WebMessageInfo{}
 177                         },
 178                 },
 179                 {
 180                         name: "a view-once message",
 181                         change: func(event *events.Message) {
 182                                 event.IsViewOnce = true
 183                         },
 184                 },
 185                 {
 186                         name: "a disappearing message",
 187                         change: func(event *events.Message) {
 188                                 event.IsEphemeral = true
 189                         },
 190                 },
 191                 {
 192                         name: "the chat of the user with itself",
 193                         change: func(event *events.Message) {
 194                                 event.Info.Chat = whatsappTestOwn
 195                         },
 196                 },
 197                 {
 198                         name: "a status broadcast",
 199                         change: func(event *events.Message) {
 200                                 event.Info.Chat = types.StatusBroadcastJID
 201                         },
 202                 },
 203                 {
 204                         name: "a text of spaces",
 205                         change: func(event *events.Message) {
 206                                 event.Message.Conversation = new("  ")
 207                         },
 208                 },
 209         }
 210
 211         for _, tc := range testCases {
 212                 t.Run(tc.name, func(t *testing.T) {
 213                         whatsapp, _ := whatsappStartTestLinked(t)
 214                         event := whatsappTestMessage(whatsappTestAna, whatsappTestAna, "m1", "hi", at)
 215                         tc.change(event)
 216                         require.True(t, whatsapp.handle(event))
 217                         require.NoError(t, whatsapp.state.CloseAll())
 218                         require.Empty(t, whatsapp.state.Closed())
 219                 })
 220         }
 221 }
 222
 223 func TestWhatsAppCatchupGivesOneTurn(t *testing.T) {
 224         whatsapp, fake := whatsappStartTestLinked(t)
 225         server := newModelFake(t)
 226         socket, memory := daemonStartTestWithWhatsApp(t, server, nil, whatsapp)
 227         client := terminalStartTestClient(t, socket)
 228         client.WaitFor(t, "[connected to OneChat]")
 229         <-fake.connects
 230
 231         require.True(t, fake.Emit(&events.Connected{}))
 232
 233         at := time.Date(2026, 1, 1, 8, 0, 0, 0, time.UTC)
 234         for index, event := range []*events.Message{
 235                 whatsappTestMessage(whatsappTestAna, whatsappTestAna, "m1", "Good morning", at),
 236                 whatsappTestMessage(whatsappTestBruno, whatsappTestBruno, "m2", "Call me", at.Add(time.Hour)),
 237                 whatsappTestMessage(whatsappTestAna, whatsappTestAna, "m3", "Are you there?", at.Add(2*time.Hour)),
 238         } {
 239                 event.Info.PushName = []string{"Ana", "Bruno", "Ana"}[index]
 240                 require.True(t, fake.Emit(event))
 241         }
 242
 243         time.Sleep(100 * time.Millisecond)
 244         require.Zero(t, memory.Len())
 245
 246         require.True(t, fake.Emit(&events.OfflineSyncCompleted{}))
 247         client.WaitFor(t, "[done]")
 248         require.Equal(t, []string{
 249                 "[WhatsApp] Ana, private chat 15550002222@s.whatsapp.net, Thursday 2026-01-01\n08:00 Ana: Good morning\n" + whatsappBatchEmptyReply,
 250                 "[WhatsApp] Bruno, private chat 15550003333@s.whatsapp.net, Thursday 2026-01-01\n09:00 Bruno: Call me\n" + whatsappBatchEmptyReply,
 251                 "[WhatsApp] Ana, private chat 15550002222@s.whatsapp.net, Thursday 2026-01-01\n10:00 Ana: Are you there?\n" + whatsappBatchEmptyReply,
 252         }, whatsappTestLogTexts(t, memory)[:3])
 253
 254         time.Sleep(100 * time.Millisecond)
 255         require.Equal(t, 1, server.Calls())
 256
 257         for _, text := range []string{"Good morning", "Call me", "Are you there?"} {
 258                 require.Contains(t, string(server.Call(0).raw), text)
 259         }
 260 }
 261
 262 func TestWhatsAppCatchupEndsAfterItsLimit(t *testing.T) {
 263         synctest.Test(t, func(t *testing.T) {
 264                 test := whatsappRetryTest(t)
 265                 test.whatsapp.client = test.fake
 266                 require.True(t, test.whatsapp.handle(&events.Connected{}))
 267                 require.True(t, test.whatsapp.handle(whatsappTestMessage(whatsappTestAna, whatsappTestOwn, "m1", "On my way.", time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC))))
 268                 require.NoError(t, test.whatsapp.inbox.deliver(t.Context(), test.loop, test.whatsapp.link(), false))
 269                 require.Zero(t, test.loop.memory.Len())
 270
 271                 time.Sleep(whatsappCatchupTimeout)
 272                 synctest.Wait()
 273                 require.NoError(t, test.whatsapp.inbox.deliver(t.Context(), test.loop, test.whatsapp.link(), false))
 274                 require.Equal(t, 1, test.loop.memory.Len())
 275                 require.Contains(t, test.events.Last("work"), "12:00 You: On my way.")
 276         })
 277 }
 278
 279 func TestWhatsAppStateOfTheStateFileWaitForTheCatchup(t *testing.T) {
 280         dir := t.TempDir()
 281         whatsappTestSession(t, dir, true)
 282
 283         before, _, _ := whatsappStartTest(t, dir, newTestClock())
 284         _, err := before.state.Add(whatsappTestChat, WhatsAppMessage{
 285                 ID:     "m1",
 286                 Sender: "Ana Souza",
 287                 Time:   time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC),
 288                 Text:   "Did you see my message?",
 289         }, time.Now().Add(-time.Hour))
 290         require.NoError(t, err)
 291
 292         whatsapp, fake, _ := whatsappStartTest(t, dir, newTestClock())
 293         socket, memory := daemonStartTestWithWhatsApp(t, newModelFake(t), nil, whatsapp)
 294         client := terminalStartTestClient(t, socket)
 295         client.WaitFor(t, "[connected to OneChat]")
 296         <-fake.connects
 297
 298         time.Sleep(100 * time.Millisecond)
 299         require.Zero(t, memory.Len())
 300
 301         require.True(t, fake.Emit(&events.Connected{}))
 302         require.True(t, fake.Emit(&events.OfflineSyncCompleted{}))
 303         client.WaitFor(t, "12:00 Ana Souza: Did you see my message?")
 304         client.WaitFor(t, "[done]")
 305 }