test: fix user.messages.deleted event tests

Refactors the tests for the `user.messages.deleted` WebSocket event to improve reliability and correctness.

- Connects the client and waits for a connected status in `setUp`, ensuring a realistic test environment.
- Simplifies event dispatching by sending a single global event instead of one per channel.
- Removes an unnecessary test for channel-specific `user.messages.deleted` events, as these are handled by the channel itself.
- Adds tests to verify that messages are correctly deleted from the persistence client when `hardDelete` is true.

Author: xsahil03x

packages/stream_chat/test/src/client/channel_test.dart

@@ -5200,8 +5200,18 @@ void main() {
       const channelId = 'test-channel-id';
       const channelType = 'test-channel-type';
       late Channel channel;
+      late MockPersistenceClient persistenceClient;
 
       setUp(() {
+        persistenceClient = MockPersistenceClient();
+        when(() => client.chatPersistenceClient).thenReturn(persistenceClient);
+        when(() => persistenceClient.deleteMessageByIds(any()))
+            .thenAnswer((_) async {});
+        when(() => persistenceClient.deletePinnedMessageByIds(any()))
+            .thenAnswer((_) async {});
+        when(() => persistenceClient.getChannelThreads(any()))
+            .thenAnswer((_) async => <String, List<Message>>{});
+
         final channelState = _generateChannelState(channelId, channelType);
         channel = Channel.fromState(client, channelState);
       });
@@ -5468,6 +5478,106 @@ void main() {
           expect(channel.state?.messages.length, equals(0));
         },
       );
+
+      test(
+        'should delete messages from persistence when hardDelete is true',
+        () async {
+          // Setup: Add messages from different users
+          final user1 = User(id: 'user-1', name: 'User 1');
+          final user2 = User(id: 'user-2', name: 'User 2');
+
+          final message1 = Message(
+            id: 'msg-1',
+            text: 'Message from user 1',
+            user: user1,
+          );
+          final message2 = Message(
+            id: 'msg-2',
+            text: 'Another message from user 1',
+            user: user1,
+          );
+          final message3 = Message(
+            id: 'msg-3',
+            text: 'Message from user 2',
+            user: user2,
+          );
+
+          channel.state?.updateMessage(message1);
+          channel.state?.updateMessage(message2);
+          channel.state?.updateMessage(message3);
+
+          // Verify initial state
+          expect(channel.state?.messages.length, equals(3));
+
+          // Create user.messages.deleted event (hard delete)
+          final userMessagesDeletedEvent = Event(
+            cid: channel.cid,
+            type: EventType.userMessagesDeleted,
+            user: user1,
+            hardDelete: true,
+          );
+
+          // Dispatch event
+          client.addEvent(userMessagesDeletedEvent);
+
+          // Wait for the event to be processed
+          await Future.delayed(Duration.zero);
+
+          // Verify messages are removed from persistence
+          verify(
+            () => persistenceClient.deleteMessageByIds(['msg-1', 'msg-2']),
+          ).called(1);
+          verify(
+            () =>
+                persistenceClient.deletePinnedMessageByIds(['msg-1', 'msg-2']),
+          ).called(1);
+
+          // Verify user1's messages are removed from state
+          expect(channel.state?.messages.length, equals(1));
+          expect(
+            channel.state?.messages.any((m) => m.user?.id == 'user-1'),
+            isFalse,
+          );
+        },
+      );
+
+      test(
+        'should not delete from persistence when hardDelete is false',
+        () async {
+          // Setup: Add messages
+          final user1 = User(id: 'user-1', name: 'User 1');
+          final message1 = Message(
+            id: 'msg-1',
+            text: 'Message from user 1',
+            user: user1,
+          );
+
+          channel.state?.updateMessage(message1);
+
+          // Create user.messages.deleted event (soft delete)
+          final userMessagesDeletedEvent = Event(
+            cid: channel.cid,
+            type: EventType.userMessagesDeleted,
+            user: user1,
+            hardDelete: false,
+          );
+
+          // Dispatch event
+          client.addEvent(userMessagesDeletedEvent);
+
+          // Wait for the event to be processed
+          await Future.delayed(Duration.zero);
+
+          // Verify persistence deletion methods were NOT called
+          verifyNever(() => persistenceClient.deleteMessageByIds(any()));
+          verifyNever(() => persistenceClient.deletePinnedMessageByIds(any()));
+
+          // Verify message is soft deleted (still in state)
+          expect(channel.state?.messages.length, equals(1));
+          expect(
+              channel.state?.messages.first.type, equals(MessageType.deleted));
+        },
+      );
     });
   });
 

packages/stream_chat/test/src/client/client_test.dart

@@ -3734,22 +3734,28 @@ void main() {
         verify(() => api.general.sync(cids, lastSyncAt)).called(1);
       });
     });
+  });
 
-    group('User messages deleted event', () {
-      const apiKey = 'test-api-key';
-      late StreamChatClient client;
-
-      setUp(() {
-        final ws = FakeWebSocket();
-        final api = FakeChatApi();
-        client = StreamChatClient(apiKey, ws: ws, chatApi: api);
-        client.state.currentUser = OwnUser(id: 'test-user');
-      });
+  group('WS events', () {
+    late StreamChatClient client;
 
-      tearDown(() {
-        client.dispose();
-      });
+    setUp(() async {
+      final ws = FakeWebSocket();
+      client = StreamChatClient('test-api-key', ws: ws);
+
+      final user = User(id: 'test-user-id');
+      final token = Token.development(user.id).rawValue;
+
+      await client.connectUser(user, token);
+      await delay(300);
+      expect(client.wsConnectionStatus, ConnectionStatus.connected);
+    });
 
+    tearDown(() async {
+      await client.dispose();
+    });
+
+    group('User messages deleted event', () {
       test(
         'should broadcast global user.messages.deleted event to all channels',
         () async {
@@ -3780,32 +3786,24 @@ void main() {
           final channel2 = Channel.fromState(client, channelState2);
 
           // Register channels in client state
-          client.state.channels['messaging:channel-1'] = channel1;
-          client.state.channels['messaging:channel-2'] = channel2;
+          client.state.addChannels({
+            'messaging:channel-1': channel1,
+            'messaging:channel-2': channel2,
+          });
 
           // Verify initial state
           expect(channel1.state?.messages.length, equals(1));
           expect(channel2.state?.messages.length, equals(1));
 
           // Simulate global user.messages.deleted event being broadcast to channels
           // (In production, ClientState._listenUserMessagesDeleted does this)
-          final event1 = Event(
-            cid: channel1.cid,
-            type: EventType.userMessagesDeleted,
-            user: bannedUser,
-            hardDelete: false,
-          );
-
-          client.handleEvent(event1);
-
-          final event2 = Event(
-            cid: channel2.cid,
+          final event = Event(
             type: EventType.userMessagesDeleted,
             user: bannedUser,
             hardDelete: false,
           );
 
-          client.handleEvent(event2);
+          client.handleEvent(event);
 
           // Wait for the events to be processed
           await Future.delayed(Duration.zero);
@@ -3818,10 +3816,6 @@ void main() {
           final channel2Message = channel2.state?.messages.first;
           expect(channel2Message?.type, equals(MessageType.deleted));
           expect(channel2Message?.state.isDeleted, isTrue);
-
-          // Cleanup
-          channel1.dispose();
-          channel2.dispose();
         },
       );
 
@@ -3862,32 +3856,24 @@ void main() {
           final channel2 = Channel.fromState(client, channelState2);
 
           // Register channels in client state
-          client.state.channels['messaging:channel-1'] = channel1;
-          client.state.channels['messaging:channel-2'] = channel2;
+          client.state.addChannels({
+            'messaging:channel-1': channel1,
+            'messaging:channel-2': channel2,
+          });
 
           // Verify initial state
           expect(channel1.state?.messages.length, equals(2));
           expect(channel2.state?.messages.length, equals(1));
 
           // Simulate global user.messages.deleted event being broadcast to channels
           // (In production, ClientState._listenUserMessagesDeleted does this)
-          final event1 = Event(
-            cid: channel1.cid,
-            type: EventType.userMessagesDeleted,
-            user: bannedUser,
-            hardDelete: true,
-          );
-
-          client.handleEvent(event1);
-
-          final event2 = Event(
-            cid: channel2.cid,
+          final event = Event(
             type: EventType.userMessagesDeleted,
             user: bannedUser,
             hardDelete: true,
           );
 
-          client.handleEvent(event2);
+          client.handleEvent(event);
 
           // Wait for the events to be processed
           await Future.delayed(Duration.zero);
@@ -3904,80 +3890,6 @@ void main() {
           final safeMessage =
               channel1.state?.messages.firstWhere((m) => m.id == 'msg-3');
           expect(safeMessage?.user?.id, equals('other-user'));
-
-          // Cleanup
-          channel1.dispose();
-          channel2.dispose();
-        },
-      );
-
-      test(
-        'should not handle channel-specific user.messages.deleted events',
-        () async {
-          // Add messages
-          final bannedUser = User(id: 'banned-user', name: 'Banned User');
-          final message1 = Message(
-            id: 'msg-1',
-            text: 'Message in channel 1',
-            user: bannedUser,
-          );
-          final message2 = Message(
-            id: 'msg-2',
-            text: 'Message in channel 2',
-            user: bannedUser,
-          );
-
-          // Setup: Create channels with state
-          final channelState1 = ChannelState(
-            channel: ChannelModel(id: 'channel-1', type: 'messaging'),
-            messages: [message1],
-          );
-          final channelState2 = ChannelState(
-            channel: ChannelModel(id: 'channel-2', type: 'messaging'),
-            messages: [message2],
-          );
-
-          final channel1 = Channel.fromState(client, channelState1);
-          final channel2 = Channel.fromState(client, channelState2);
-
-          // Register channels in client state
-          client.state.channels['messaging:channel-1'] = channel1;
-          client.state.channels['messaging:channel-2'] = channel2;
-
-          // Verify initial state
-          expect(channel1.state?.messages.length, equals(1));
-          expect(channel2.state?.messages.length, equals(1));
-
-          // Create channel-specific event (has cid)
-          final channelSpecificEvent = Event(
-            cid: channel1.cid,
-            type: EventType.userMessagesDeleted,
-            user: bannedUser,
-            hardDelete: true,
-          );
-
-          // Dispatch event - this should be handled by channel, not client state
-          client.handleEvent(channelSpecificEvent);
-
-          // Wait for the event to be processed
-          await Future.delayed(Duration.zero);
-
-          // Verify only channel1 is affected (by channel's own handler)
-          expect(
-            channel1.state?.messages.any((m) => m.user?.id == 'banned-user'),
-            isFalse,
-          );
-
-          // Verify channel2 is unaffected (client state didn't broadcast it)
-          expect(channel2.state?.messages.length, equals(1));
-          expect(
-            channel2.state?.messages.any((m) => m.user?.id == 'banned-user'),
-            isTrue,
-          );
-
-          // Cleanup
-          channel1.dispose();
-          channel2.dispose();
         },
       );
     });