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 TestWhatsAppTakesOnlyText(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 photo with a caption",
 180                         change: func(event *events.Message) {
 181                                 event.Message = &waE2E.Message{
 182                                         ImageMessage: &waE2E.ImageMessage{
 183                                                 Caption: new("look"),
 184                                         },
 185                                 }
 186                         },
 187                 },
 188                 {
 189                         name: "a text of spaces",
 190                         change: func(event *events.Message) {
 191                                 event.Message.Conversation = new("  ")
 192                         },
 193                 },
 194         }
 195
 196         for _, tc := range testCases {
 197                 t.Run(tc.name, func(t *testing.T) {
 198                         whatsapp, _ := whatsappStartTestLinked(t)
 199                         event := whatsappTestMessage(whatsappTestAna, whatsappTestAna, "m1", "hi", at)
 200                         tc.change(event)
 201                         require.True(t, whatsapp.handle(event))
 202                         require.NoError(t, whatsapp.state.CloseAll())
 203                         require.Empty(t, whatsapp.state.Closed())
 204                 })
 205         }
 206 }
 207
 208 func TestWhatsAppCatchupGivesOneTurn(t *testing.T) {
 209         whatsapp, fake := whatsappStartTestLinked(t)
 210         server := newModelFake(t)
 211         socket, memory := daemonStartTestWithWhatsApp(t, server, nil, whatsapp)
 212         client := terminalStartTestClient(t, socket)
 213         client.WaitFor(t, "[connected to OneChat]")
 214         <-fake.connects
 215
 216         require.True(t, fake.Emit(&events.Connected{}))
 217
 218         at := time.Date(2026, 1, 1, 8, 0, 0, 0, time.UTC)
 219         for index, event := range []*events.Message{
 220                 whatsappTestMessage(whatsappTestAna, whatsappTestAna, "m1", "Good morning", at),
 221                 whatsappTestMessage(whatsappTestBruno, whatsappTestBruno, "m2", "Call me", at.Add(time.Hour)),
 222                 whatsappTestMessage(whatsappTestAna, whatsappTestAna, "m3", "Are you there?", at.Add(2*time.Hour)),
 223         } {
 224                 event.Info.PushName = []string{"Ana", "Bruno", "Ana"}[index]
 225                 require.True(t, fake.Emit(event))
 226         }
 227
 228         time.Sleep(100 * time.Millisecond)
 229         require.Zero(t, memory.Len())
 230
 231         require.True(t, fake.Emit(&events.OfflineSyncCompleted{}))
 232         client.WaitFor(t, "[done]")
 233         require.Equal(t, []string{
 234                 "[WhatsApp] Ana, private chat 15550002222@s.whatsapp.net, Thursday 2026-01-01\n08:00 Ana: Good morning\n" + whatsappBatchEmptyReply,
 235                 "[WhatsApp] Bruno, private chat 15550003333@s.whatsapp.net, Thursday 2026-01-01\n09:00 Bruno: Call me\n" + whatsappBatchEmptyReply,
 236                 "[WhatsApp] Ana, private chat 15550002222@s.whatsapp.net, Thursday 2026-01-01\n10:00 Ana: Are you there?\n" + whatsappBatchEmptyReply,
 237         }, whatsappTestLogTexts(t, memory)[:3])
 238
 239         time.Sleep(100 * time.Millisecond)
 240         require.Equal(t, 1, server.Calls())
 241
 242         for _, text := range []string{"Good morning", "Call me", "Are you there?"} {
 243                 require.Contains(t, string(server.Call(0).raw), text)
 244         }
 245 }
 246
 247 func TestWhatsAppCatchupEndsAfterItsLimit(t *testing.T) {
 248         whatsapp, fake := whatsappStartTestLinked(t)
 249         whatsapp.inbox.catchupLimit = 100 * time.Millisecond
 250         socket, memory := daemonStartTestWithWhatsApp(t, newModelFake(t), nil, whatsapp)
 251         client := terminalStartTestClient(t, socket)
 252         client.WaitFor(t, "[connected to OneChat]")
 253         <-fake.connects
 254
 255         require.True(t, fake.Emit(&events.Connected{}))
 256         require.True(t, fake.Emit(whatsappTestMessage(whatsappTestAna, whatsappTestOwn, "m1", "On my way.", time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC))))
 257         client.WaitFor(t, "12:00 You: On my way.")
 258         require.Len(t, whatsappTestLogTexts(t, memory), 1)
 259 }
 260
 261 func TestWhatsAppStateOfTheStateFileWaitForTheCatchup(t *testing.T) {
 262         dir := t.TempDir()
 263         whatsappTestSession(t, dir, true)
 264
 265         before, _, _ := whatsappStartTest(t, dir, newTestClock())
 266         _, err := before.state.Add(whatsappTestChat, WhatsAppMessage{
 267                 ID:     "m1",
 268                 Sender: "Ana Souza",
 269                 Time:   time.Date(2026, 1, 1, 12, 0, 0, 0, time.UTC),
 270                 Text:   "Did you see my message?",
 271         }, time.Now().Add(-time.Hour))
 272         require.NoError(t, err)
 273
 274         whatsapp, fake, _ := whatsappStartTest(t, dir, newTestClock())
 275         socket, memory := daemonStartTestWithWhatsApp(t, newModelFake(t), nil, whatsapp)
 276         client := terminalStartTestClient(t, socket)
 277         client.WaitFor(t, "[connected to OneChat]")
 278         <-fake.connects
 279
 280         time.Sleep(100 * time.Millisecond)
 281         require.Zero(t, memory.Len())
 282
 283         require.True(t, fake.Emit(&events.Connected{}))
 284         require.True(t, fake.Emit(&events.OfflineSyncCompleted{}))
 285         client.WaitFor(t, "12:00 Ana Souza: Did you see my message?")
 286         client.WaitFor(t, "[done]")
 287 }