test: make three flaky tests deterministic

Fixes the failure mechanisms behind the intermittent CI failures
observed on this PR (none of which were caused by its changes):

- browser/modular 'is able to decrypt history messages': both client-
  class variants published to the same fixed channel with different
  random cipher keys, so the history wait could be satisfied by the
  other variant's message, which then failed to decrypt ('' !== 'Test
  message'). The channel name is now unique per variant.
- uts presence_lifecycle 'bulk enterClient': members are now counted
  by clientId from both 'enter' and 'present' events - a mid-test
  connection blip delivers missed members via presence re-sync as
  'present', so an enter-only count could undercount forever and burn
  the full poll timeout. Spec pseudo updated in lock-step
  (uts/realtime/integration/presence_lifecycle_test.md).
- realtime/message 'subscribes to filtered channel': the 'end'
  sentinel only orders deliveries on the raw channel, but the
  assertions count deliveries on the derived (filtered) channel - a
  separate attachment that can lag it. A setTimeout(0) cannot bridge
  that; the test now waits for the filtered deliveries (bounded at
  10s within the suite's 60s budget).

The remaining presence flakes are event-driven tests with no
identifiable race; their failures are sandbox latency and are a CI
retry-policy question, not test bugs.

Author: sacOO7

test/browser/modular.test.js

@@ -555,7 +555,11 @@ function registerAblyModularTests(Helper) {
               ? (op, realtime) => helper.monitorConnectionThenCloseAndFinishAsync(op, realtime)
               : async (op) => await op()
           )(async () => {
-            const channelName = 'encrypted_history',
+            // The channel name must be unique per client-class variant: both variants run
+            // against the same app with different random cipher keys, and a shared channel
+            // would let the history wait below be satisfied by the other variant's message,
+            // which then fails to decrypt with this variant's key.
+            const channelName = 'encrypted_history_' + clientClassConfig.clientClass.name,
               messageText = 'Test message';
 
             const key = await generateRandomKey();

test/realtime/message.test.js

@@ -1569,43 +1569,44 @@ define(['ably', 'shared_helper', 'async', 'chai'], function (Ably, Helper, async
 
               // Subscription to check all messages were received as expected
               rtUnfilteredChannel.subscribe('end', function (msg) {
-                // Ensure all pending I/O operations complete and messages are processed
-                // before running assertions to avoid race conditions
-                //
-                // Using setTimeout with 0 timeout as setImmediate is not available
-                // in browsers.
-                setTimeout(() => {
-                  try {
-                    expect(msg.data).to.equal(testData[testData.length - 1].data, 'Unexpected msg data received');
-
-                    // Check that we receive expected messages on filtered channel
-                    expect(filteredMessages.length).to.equal(2, 'Expect only two filtered message to be received');
-                    expect(filteredMessages[0].data).to.equal(testData[0].data, 'Unexpected data received');
-                    expect(filteredMessages[1].data).to.equal(testData[2].data, 'Unexpected data received');
-                    expect(filteredMessages[0].extras.headers.name).to.equal(
-                      testData[0].extras.headers.name,
-                      'Unexpected header value received',
-                    );
-                    expect(filteredMessages[1].extras.headers.name).to.equal(
-                      testData[2].extras.headers.name,
-                      'Unexpected header value received',
-                    );
-                    // Check that message with header that doesn't meet filtering condition is not received.
-                    for (const m of filteredMessages) {
-                      expect(m.extras.headers.number).to.equal(26095, 'Unexpected header filtering value received');
-                    }
+                // The 'end' sentinel only orders deliveries on the raw channel; the derived
+                // (filtered) channel is a separate attachment whose deliveries can lag it,
+                // so wait for the filtered deliveries instead of assuming one macrotask
+                // is enough.
+                helper
+                  .waitFor(() => filteredMessages.length === 2, 10000)
+                  .then(() => {
+                    try {
+                      expect(msg.data).to.equal(testData[testData.length - 1].data, 'Unexpected msg data received');
+
+                      // Check that we receive expected messages on filtered channel
+                      expect(filteredMessages.length).to.equal(2, 'Expect only two filtered message to be received');
+                      expect(filteredMessages[0].data).to.equal(testData[0].data, 'Unexpected data received');
+                      expect(filteredMessages[1].data).to.equal(testData[2].data, 'Unexpected data received');
+                      expect(filteredMessages[0].extras.headers.name).to.equal(
+                        testData[0].extras.headers.name,
+                        'Unexpected header value received',
+                      );
+                      expect(filteredMessages[1].extras.headers.name).to.equal(
+                        testData[2].extras.headers.name,
+                        'Unexpected header value received',
+                      );
+                      // Check that message with header that doesn't meet filtering condition is not received.
+                      for (const m of filteredMessages) {
+                        expect(m.extras.headers.number).to.equal(26095, 'Unexpected header filtering value received');
+                      }
 
-                    // Check that we receive expected messages on unfiltered channel, including the `end` event message
-                    expect(unFilteredMessages.length).to.equal(6, 'Expect only 6 unfiltered message to be received');
-                    for (var i = 0; i < unFilteredMessages.length; i++) {
-                      expect(unFilteredMessages[i].data).to.equal(testData[i].data, 'Unexpected data received');
+                      // Check that we receive expected messages on unfiltered channel, including the `end` event message
+                      expect(unFilteredMessages.length).to.equal(6, 'Expect only 6 unfiltered message to be received');
+                      for (var i = 0; i < unFilteredMessages.length; i++) {
+                        expect(unFilteredMessages[i].data).to.equal(testData[i].data, 'Unexpected data received');
+                      }
+                    } catch (err) {
+                      helper.closeAndFinish(done, realtime, err);
+                      return;
                     }
-                  } catch (err) {
-                    helper.closeAndFinish(done, realtime, err);
-                    return;
-                  }
-                  helper.closeAndFinish(done, realtime);
-                }, 0);
+                    helper.closeAndFinish(done, realtime);
+                  });
               });
               var restChannel = rest.channels.get('chan');
               restChannel.publish(testData);

test/uts/realtime/integration/presence/presence_lifecycle.test.ts

@@ -61,10 +61,13 @@ describeEachProtocol('uts/realtime/integration/presence/presence_lifecycle', fun
     const channelA = clientA.channels.get(channelName);
     const channelB = clientB.channels.get(channelName);
 
-    // Attach B and subscribe before A enters any members
-    const receivedEnters: any[] = [];
-    await channelB.presence.subscribe('enter', (msg: any) => {
-      receivedEnters.push(msg);
+    // Attach B and subscribe before A enters any members. Members are counted by
+    // clientId from both 'enter' and 'present' events: if B's connection blips
+    // mid-test, members it missed arrive via the presence re-sync as 'present'
+    // events rather than 'enter', and an enter-only count would undercount forever.
+    const enteredClientIds = new Set<string>();
+    await channelB.presence.subscribe(['enter', 'present'], (msg: any) => {
+      enteredClientIds.add(msg.clientId);
     });
 
     await channelA.attach();
@@ -74,12 +77,12 @@ describeEachProtocol('uts/realtime/integration/presence/presence_lifecycle', fun
       await channelA.presence.enterClient(`user-${i}`, `data-${i}`);
     }
 
-    await pollUntil(() => (receivedEnters.length >= memberCount ? true : null), {
+    await pollUntil(() => (enteredClientIds.size >= memberCount ? true : null), {
       interval: 200,
       timeout: 30000,
     });
 
-    expect(receivedEnters).to.have.length(memberCount);
+    expect(enteredClientIds.size).to.equal(memberCount);
 
     const members = await channelB.presence.get();
     expect(members).to.have.length(memberCount);