Skip to content

Commit 83a52f4

Browse files
sierpinskidsierpinskid
committed
Improve concurrency resilience - we wait for events related to specific channels. Otherwise it could fail if another test would trigger the same event
1 parent 077becb commit 83a52f4

2 files changed

Lines changed: 200 additions & 46 deletions

File tree

‎Assets/Plugins/StreamChat/Tests/StatefulClient/ChannelMembersTests.cs‎

Lines changed: 132 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -82,11 +82,19 @@ private async Task
8282
var memberAddedMsg = $"{otherUserId} was added to the channel";
8383

8484
var tcs = new TaskCompletionSource<bool>();
85-
channel.MessageReceived += (streamChannel, message) =>
85+
86+
void OnMessageReceived(IStreamChannel channel2, IStreamMessage message)
8687
{
88+
if (channel2.Cid != channel.Cid)
89+
{
90+
return;
91+
}
92+
8793
Assert.AreEqual(message.Text, memberAddedMsg);
8894
tcs.SetResult(true);
89-
};
95+
}
96+
97+
channel.MessageReceived += OnMessageReceived;
9098

9199
var filters = new IFieldFilterRule[]
92100
{
@@ -105,6 +113,8 @@ private async Task
105113
Assert.NotNull(channel.Members.FirstOrDefault(member => member.User == otherUser));
106114

107115
await WaitWithTimeoutAsync(tcs.Task, 5, $"Event {nameof(channel.MessageReceived)} was not received");
116+
117+
channel.MessageReceived -= OnMessageReceived;
108118
}
109119

110120
[UnityTest]
@@ -221,39 +231,56 @@ private async Task When_add_members_expect_member_added_event_fired_Async()
221231
var receivedEvent = false;
222232
IStreamChannelMember eventMember = null;
223233
IStreamChannel eventChannel = null;
224-
channel.MemberAdded += (chanel, member) =>
234+
235+
void OnMemberAdded(IStreamChannel channel2, IStreamChannelMember member)
225236
{
237+
if (channel2.Cid != channel.Cid)
238+
{
239+
return;
240+
}
241+
226242
receivedEvent = true;
227243
eventMember = member;
228-
eventChannel = chanel;
229-
};
244+
eventChannel = channel2;
245+
}
246+
247+
channel.MemberAdded += OnMemberAdded;
230248

231249
var receivedEvent2 = false;
232250
IStreamChannelMember eventMember2 = null;
233251
IStreamChannel eventChannel2 = null;
234252
OperationType? opType = default;
235-
channel.MembersChanged += (chanel, member, op) =>
253+
254+
void OnMembersChanged(IStreamChannel channel2, IStreamChannelMember member, OperationType op)
236255
{
256+
if (channel2.Cid != channel.Cid)
257+
{
258+
return;
259+
}
260+
237261
receivedEvent2 = true;
238262
eventMember2 = member;
239-
eventChannel2 = chanel;
263+
eventChannel2 = channel2;
240264
opType = op;
241-
};
265+
}
266+
267+
channel.MembersChanged += OnMembersChanged;
242268

243269
await channel.AddMembersAsync(hideHistory: default, optionalMessage: default, user);
244270

245271
await WaitWhileFalseAsync(() => receivedEvent && receivedEvent2);
246272

273+
channel.MemberAdded -= OnMemberAdded;
274+
channel.MembersChanged -= OnMembersChanged;
275+
247276
Assert.IsTrue(receivedEvent);
248277
Assert.IsNotNull(eventChannel);
249278
Assert.IsNotNull(eventMember);
250-
Assert.AreEqual(channel, eventChannel);
251279
Assert.AreEqual(user, eventMember.User);
252280

253281
Assert.IsTrue(receivedEvent2);
254282
Assert.IsNotNull(eventChannel2);
255283
Assert.IsNotNull(eventMember2);
256-
Assert.AreEqual(channel, eventChannel2);
257284
Assert.AreEqual(user, eventMember2.User);
258285
Assert.AreEqual(OperationType.Added, opType.Value);
259286
}
@@ -270,40 +297,57 @@ private async Task When_remove_members_expect_member_added_event_fired_Async()
270297
var receivedEvent = false;
271298
IStreamChannelMember eventMember = null;
272299
IStreamChannel eventChannel = null;
273-
channel.MemberRemoved += (channel2, member) =>
300+
301+
void OnMemberRemoved(IStreamChannel channel2, IStreamChannelMember member)
274302
{
303+
if (channel2.Cid != channel.Cid)
304+
{
305+
return;
306+
}
307+
275308
receivedEvent = true;
276309
eventMember = member;
277310
eventChannel = channel2;
278-
};
311+
}
312+
313+
channel.MemberRemoved += OnMemberRemoved;
279314

280315
var receivedEvent2 = false;
281316
IStreamChannelMember eventMember2 = null;
282317
IStreamChannel eventChannel2 = null;
283318
OperationType? opType = default;
284-
channel.MembersChanged += (channel3, member, op) =>
319+
320+
void OnMembersChanged(IStreamChannel channel3, IStreamChannelMember member, OperationType op)
285321
{
322+
if (channel3.Cid != channel.Cid)
323+
{
324+
return;
325+
}
326+
286327
receivedEvent2 = true;
287328
eventMember2 = member;
288329
eventChannel2 = channel3;
289330
opType = op;
290-
};
331+
}
332+
333+
channel.MembersChanged += OnMembersChanged;
291334

292335
await channel.AddMembersAsync(hideHistory: default, optionalMessage: default, user);
293336
await channel.RemoveMembersAsync(user);
294337

295338
await WaitWhileFalseAsync(() => receivedEvent && receivedEvent2);
296339

340+
channel.MemberRemoved -= OnMemberRemoved;
341+
channel.MembersChanged -= OnMembersChanged;
342+
297343
Assert.IsTrue(receivedEvent);
298344
Assert.IsNotNull(eventChannel);
299345
Assert.IsNotNull(eventMember);
300-
Assert.AreEqual(channel, eventChannel);
301346
Assert.AreEqual(user, eventMember.User);
302347

303348
Assert.IsTrue(receivedEvent2);
304349
Assert.IsNotNull(eventChannel2);
305350
Assert.IsNotNull(eventMember2);
306-
Assert.AreEqual(channel, eventChannel2);
307351
Assert.AreEqual(user, eventMember2.User);
308352
Assert.AreEqual(OperationType.Removed, opType.Value);
309353
}
@@ -320,20 +364,29 @@ private async Task When_user_added_to_not_watched_channel_expect_user_receive_ad
320364
var receivedEvent = false;
321365
IStreamChannelMember eventMember = null;
322366
IStreamChannel eventChannel = null;
323-
Client.AddedToChannelAsMember += (channel2, member) =>
367+
368+
void OnAddedToChannelAsMember(IStreamChannel channel2, IStreamChannelMember member)
324369
{
370+
if (channel2.Cid != channel.Cid)
371+
{
372+
return;
373+
}
374+
325375
receivedEvent = true;
326376
eventMember = member;
327377
eventChannel = channel2;
328-
};
378+
}
379+
380+
Client.AddedToChannelAsMember += OnAddedToChannelAsMember;
329381

330382
await channel.AddMembersAsync(hideHistory: default, optionalMessage: default, Client.LocalUserData.User);
331383
await WaitWhileFalseAsync(() => receivedEvent);
332384

385+
Client.AddedToChannelAsMember -= OnAddedToChannelAsMember;
386+
333387
Assert.IsTrue(receivedEvent);
334388
Assert.IsNotNull(eventChannel);
335389
Assert.IsNotNull(eventMember);
336-
Assert.AreEqual(channel, eventChannel);
337390
Assert.AreEqual(Client.LocalUserData.User, eventMember.User);
338391
}
339392

@@ -350,23 +403,31 @@ private async Task When_user_added_to_not_watched_channel_expect_user_receive_ad
350403
IStreamChannelMember eventMember = null;
351404
IStreamChannel eventChannel = null;
352405
var receivedEventThreadId = 0;
353-
Client.AddedToChannelAsMember += (channel2, member) =>
406+
407+
void OnAddedToChannelAsMember(IStreamChannel channel2, IStreamChannelMember member)
354408
{
409+
if (channel2.Cid != channel.Cid)
410+
{
411+
return;
412+
}
413+
355414
receivedEvent = true;
356415
eventMember = member;
357416
eventChannel = channel2;
358417
receivedEventThreadId = GetCurrentThreadId();
359-
};
418+
}
419+
420+
Client.AddedToChannelAsMember += OnAddedToChannelAsMember;
360421

361422
await channel.AddMembersAsync(hideHistory: default, optionalMessage: default, Client.LocalUserData.User);
362423
await WaitWhileFalseAsync(() => receivedEvent);
363424

425+
Client.AddedToChannelAsMember -= OnAddedToChannelAsMember;
426+
364427
Assert.IsTrue(receivedEvent);
365428
Assert.IsNotNull(eventChannel);
366429
Assert.IsNotNull(eventMember);
367-
Assert.AreEqual(channel, eventChannel);
368430
Assert.AreEqual(Client.LocalUserData.User, eventMember.User);
369-
370431
Assert.AreEqual(receivedEventThreadId, MainThreadId);
371432
}
372433

@@ -384,44 +445,60 @@ private async Task When_user_added_to_not_watched_channel_expect_received_channe
384445
IStreamChannelMember eventMember = null;
385446
IStreamChannel eventChannel = null;
386447
var eventThreadId = -1;
387-
Client.AddedToChannelAsMember += (channel2, member) =>
448+
449+
void OnAddedToChannelAsMember(IStreamChannel channel2, IStreamChannelMember member)
388450
{
451+
if (channel2.Cid != otherClientChannel.Cid)
452+
{
453+
return;
454+
}
455+
389456
receivedEvent = true;
390457
eventMember = member;
391458
eventChannel = channel2;
392459
eventThreadId = GetCurrentThreadId();
393-
};
460+
}
461+
462+
Client.AddedToChannelAsMember += OnAddedToChannelAsMember;
394463

395464
await otherClientChannel.AddMembersAsync(hideHistory: default, optionalMessage: default, Client.LocalUserData.User);
396465
await WaitWhileFalseAsync(() => receivedEvent);
466+
467+
Client.AddedToChannelAsMember -= OnAddedToChannelAsMember;
397468

398469
Assert.IsTrue(receivedEvent);
399470
Assert.IsNotNull(eventChannel);
400471
Assert.IsNotNull(eventMember);
401-
Assert.AreEqual(otherClientChannel.Cid, eventChannel.Cid);
402472
Assert.AreEqual(Client.LocalUserData.User, eventMember.User);
403-
404473
Assert.AreEqual(MainThreadId, eventThreadId);
405474

406475
var receivedMessageEvent = false;
407476
var receivedMessage = string.Empty;
408477
IStreamChannel receivedMessageChannel = null;
409478
var messageEventThreadId = -1;
410-
otherClientChannel.MessageReceived += (messageChannel, message) =>
479+
480+
void OnMessageReceived(IStreamChannel messageChannel, IStreamMessage message)
411481
{
482+
if (messageChannel.Cid != otherClientChannel.Cid)
483+
{
484+
return;
485+
}
486+
412487
receivedMessageEvent = true;
413488
receivedMessage = message.Text;
414489
receivedMessageChannel = messageChannel;
415490
messageEventThreadId = GetCurrentThreadId();
416-
};
491+
}
417492

493+
otherClientChannel.MessageReceived += OnMessageReceived;
494+
418495
await otherClientChannel.SendNewMessageAsync("Hello");
419-
await WaitWhileFalseAsync(() => receivedEvent);
496+
await WaitWhileFalseAsync(() => receivedMessageEvent);
420497

498+
otherClientChannel.MessageReceived -= OnMessageReceived;
499+
421500
Assert.IsTrue(receivedMessageEvent);
422-
Assert.AreEqual(otherClientChannel.Cid, receivedMessageChannel.Cid);
423501
Assert.AreEqual(receivedMessage, "Hello");
424-
425502
Assert.AreEqual(MainThreadId, messageEventThreadId);
426503
}
427504

@@ -439,25 +516,44 @@ private async Task When_user_removed_from_not_watched_channel_expect_user_remove
439516
IStreamChannelMember eventMember = null;
440517
IStreamChannel eventChannel = null;
441518

442-
Client.AddedToChannelAsMember += (channel2, member) => { receivedAddedEvent = true; };
519+
void OnAddedToChannelAsMember(IStreamChannel channel2, IStreamChannelMember member)
520+
{
521+
if (channel2.Cid != channel.Cid)
522+
{
523+
return;
524+
}
525+
526+
receivedAddedEvent = true;
527+
}
528+
529+
Client.AddedToChannelAsMember += OnAddedToChannelAsMember;
443530

444531
await channel.AddMembersAsync(hideHistory: default, optionalMessage: default, Client.LocalUserData.User);
445532
await WaitWhileFalseAsync(() => receivedAddedEvent);
446533

447-
Client.RemovedFromChannelAsMember += (channel3, member2) =>
534+
void OnRemovedFromChannelAsMember(IStreamChannel channel3, IStreamChannelMember member2)
448535
{
536+
if (channel3.Cid != channel.Cid)
537+
{
538+
return;
539+
}
540+
449541
receivedRemovedEvent = true;
450542
eventMember = member2;
451543
eventChannel = channel3;
452-
};
544+
}
545+
546+
Client.RemovedFromChannelAsMember += OnRemovedFromChannelAsMember;
453547

454548
await channel.RemoveMembersAsync(new IStreamUser[] { Client.LocalUserData.User });
455549
await WaitWhileFalseAsync(() => receivedRemovedEvent);
456550

551+
Client.AddedToChannelAsMember -= OnAddedToChannelAsMember;
552+
Client.RemovedFromChannelAsMember -= OnRemovedFromChannelAsMember;
553+
457554
Assert.IsTrue(receivedRemovedEvent);
458555
Assert.IsNotNull(eventChannel);
459556
Assert.IsNotNull(eventMember);
460-
Assert.AreEqual(channel, eventChannel);
461557
Assert.AreEqual(Client.LocalUserData.User, eventMember.User);
462558
}
463559

0 commit comments

Comments
 (0)