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

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