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