Fail test if all attempts failed + output AggregateException + refactor Send_silent_message to Task/Async (#128)

* Fail test if all attempts failed + output AggregateException + refactor Send_silent_message to Task/Async

* Increate number of attempts and increase delay every failed attempt

Author: sierpinskid

Assets/Plugins/StreamChat/Tests/LowLevelClient/Integration/BaseIntegrationTests.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using NUnit.Framework;
@@ -49,10 +50,10 @@ public async void OneTimeTearDown()
 
         protected static IEnumerator ReconnectClient() => StreamTestClients.Instance.ReconnectLowLevelClientClient();
 
-        protected IEnumerator RunTest(Func<Task> task)
+        protected static IEnumerator ConnectAndExecute(Func<Task> task)
         {
             yield return LowLevelClient.WaitForClientToConnect();
-            yield return task().RunAsIEnumerator();
+            yield return ExecuteAsync(task).RunAsIEnumerator();
         }
 
         /// <summary>
@@ -252,6 +253,41 @@ await LowLevelClient.ChannelApi.DeleteChannelsAsync(new DeleteChannelsRequest
 
             _tempChannelsCidsToDelete.Clear();
         }
+        
+        private static async Task ExecuteAsync(Func<Task> test)
+        {
+            const int maxAttempts = 7;
+            var currentAttempt = 0;
+            var completed = false;
+            var exceptions = new List<Exception>();
+            while (maxAttempts > currentAttempt)
+            {
+                currentAttempt++;
+                try
+                {
+                    await test();
+                    completed = true;
+                    break;
+                }
+                catch (StreamApiException e)
+                {
+                    exceptions.Add(e);
+                    if (e.IsRateLimitExceededError())
+                    {
+                        var seconds = (int)Math.Max(1, Math.Min(60, Math.Pow(2, currentAttempt)));
+                        await Task.Delay(1000 * seconds);
+                        continue;
+                    }
+
+                    throw;
+                }
+            }
+
+            if (!completed)
+            {
+                throw new AggregateException($"Failed all attempts. Last Exception: {exceptions.Last().Message} ", exceptions);
+            }
+        }
     }
 }
 #endif

Assets/Plugins/StreamChat/Tests/LowLevelClient/Integration/ChannelApiIntegrationTests.cs

@@ -268,7 +268,7 @@ var updateChannelTask
         //[UnityTest] StreamTodo: re-enable this test once Watchers issue is resolved
         public IEnumerator When_start_watching_a_channel_expect_user_included_in_watchers()
         {
-            yield return RunTest(When_start_watching_a_channel_expect_user_included_in_watchers_Async);
+            yield return ConnectAndExecute(When_start_watching_a_channel_expect_user_included_in_watchers_Async);
         }
 
         private async Task When_start_watching_a_channel_expect_user_included_in_watchers_Async()
@@ -848,8 +848,7 @@ public IEnumerator Mark_many_read_with_specified_message_id()
         [UnityTest]
         public IEnumerator When_sending_typing_start_stop_events_expect_no_errors()
         {
-            yield return LowLevelClient.WaitForClientToConnect();
-            yield return When_sending_typing_start_stop_events_expect_no_exceptions_Async().RunAsIEnumerator();
+            yield return ConnectAndExecute(When_sending_typing_start_stop_events_expect_no_exceptions_Async);
         }
 
         private async Task When_sending_typing_start_stop_events_expect_no_exceptions_Async()

Assets/Plugins/StreamChat/Tests/LowLevelClient/Integration/MessagesApiIntegrationTests.cs

@@ -98,7 +98,7 @@ public IEnumerator Update_message()
         //[UnityTest] //StreamTodo: debug, works when triggered manually but fails in GitHub Actions
         public IEnumerator Send_message_with_url()
         {
-            yield return RunTest(Send_message_with_url_Async);
+            yield return ConnectAndExecute(Send_message_with_url_Async);
         }
 
         private async Task Send_message_with_url_Async()
@@ -137,38 +137,18 @@ private async Task Send_message_with_url_Async()
         }
 
         [UnityTest]
-        public IEnumerator Send_silent_message()
+        public IEnumerator When_sending_silent_message_expect_message_received_in_channel()
+        {
+            yield return ConnectAndExecute(When_sending_silent_message_expect_message_received_in_channel_Async);
+        }
+        
+        private async Task When_sending_silent_message_expect_message_received_in_channel_Async()
         {
-            yield return LowLevelClient.WaitForClientToConnect();
-
             const string channelType = "messaging";
 
-            ChannelState channelState = null;
-            yield return CreateTempUniqueChannel(channelType, new ChannelGetOrCreateRequest(),
-                state => channelState = state);
+            var channelState = await CreateTempUniqueChannelAsync(channelType, new ChannelGetOrCreateRequest());
             var channelId = channelState.Channel.Id;
 
-            var sendMessageRequest = new SendMessageRequest
-            {
-                Message = new MessageRequest
-                {
-                    Text = "Regular message"
-                }
-            };
-
-            var messageResponseTask = LowLevelClient.MessageApi.SendNewMessageAsync(channelType, channelId, sendMessageRequest);
-
-            yield return messageResponseTask.RunAsIEnumerator();
-
-            var createChannelTask2 = LowLevelClient.ChannelApi.GetOrCreateChannelAsync(channelType, channelId,
-                new ChannelGetOrCreateRequest
-                {
-                    Watch = true,
-                    State = true,
-                });
-
-            yield return createChannelTask2.RunAsIEnumerator();
-
             var sendSilentMessageRequest = new SendMessageRequest
             {
                 Message = new MessageRequest
@@ -178,21 +158,15 @@ public IEnumerator Send_silent_message()
                 }
             };
 
-            var silentMessageResponseTask =
-                LowLevelClient.MessageApi.SendNewMessageAsync(channelType, channelId, sendSilentMessageRequest);
+            await LowLevelClient.MessageApi.SendNewMessageAsync(channelType, channelId, sendSilentMessageRequest);
 
-            yield return silentMessageResponseTask.RunAsIEnumerator();
-
-            var createChannelTask3 = LowLevelClient.ChannelApi.GetOrCreateChannelAsync(channelType, channelId,
+            var channelState2 = await LowLevelClient.ChannelApi.GetOrCreateChannelAsync(channelType, channelId,
                 new ChannelGetOrCreateRequest
                 {
                     State = true,
                 });
 
-            yield return createChannelTask3.RunAsIEnumerator(response =>
-            {
-                Assert.AreEqual(response.Messages.Last().Silent, true);
-            });
+            Assert.AreEqual(channelState2.Messages.Last().Silent, true);
         }
 
         [UnityTest]

Assets/Plugins/StreamChat/Tests/StatefulClient/BaseStateIntegrationTests.cs

@@ -159,27 +159,37 @@ protected static async Task<T> TryAsync<T>(Func<Task<T>> task, Predicate<T> succ
         private static async Task ConnectAndExecuteAsync(Func<Task> test)
         {
             await StreamTestClients.Instance.ConnectStateClientAsync();
-            const int maxAttempts = 3;
-            int currentAttempt = 0;
+            const int maxAttempts = 7;
+            var currentAttempt = 0;
+            var completed = false;
+            var exceptions = new List<Exception>();
             while (maxAttempts > currentAttempt)
             {
                 currentAttempt++;
                 try
                 {
                     await test();
+                    completed = true;
                     break;
                 }
                 catch (StreamApiException e)
                 {
+                    exceptions.Add(e);
                     if (e.IsRateLimitExceededError())
                     {
-                        await Task.Delay(1000);
+                        var seconds = (int)Math.Max(1, Math.Min(60, Math.Pow(2, currentAttempt)));
+                        await Task.Delay(1000 * seconds);
                         continue;
                     }
 
                     throw;
                 }
             }
+
+            if (!completed)
+            {
+                throw new AggregateException($"Failed all attempts. Last Exception: {exceptions.Last().Message} ", exceptions);
+            }
         }
 
         private async Task DeleteTempChannelsAsync()