Add missing integration test coverage

c-sharp-chat/PubnubChatApi/PubNubChatApi.Tests/ChannelTests.cs

@@ -36,7 +36,79 @@ public async Task CleanUp()
         chat.Destroy();
         await Task.Delay(3000);
     }
+
+    [Test]
+    public async Task TestUpdateChannel()
+    {
+        var channel = await chat.CreatePublicConversation();
+        channel.SetListeningForUpdates(true);
+
+        await Task.Delay(3000);
+
+        var updateReset = new ManualResetEvent(false);
+        var updatedData = new ChatChannelData()
+        {
+            ChannelDescription = "some description",
+            ChannelCustomDataJson = "{\"key\":\"value\"}",
+            ChannelName = "some name",
+            ChannelStatus = "yes",
+            ChannelType = "sometype"
+        };
+        channel.OnChannelUpdate += updatedChannel =>
+        {
+            Assert.True(updatedChannel.Description == updatedData.ChannelDescription, "updatedChannel.Description != updatedData.ChannelDescription");
+            Assert.True(updatedChannel.CustomDataJson == updatedData.ChannelCustomDataJson, "updatedChannel.CustomDataJson != updatedData.ChannelCustomDataJson");
+            Assert.True(updatedChannel.Name == updatedData.ChannelName, "updatedChannel.Name != updatedData.ChannelDescription");
+            Assert.True(updatedChannel.Status == updatedData.ChannelStatus, "updatedChannel.Status != updatedData.ChannelStatus");
+            Assert.True(updatedChannel.Type == updatedData.ChannelType, "updatedChannel.Type != updatedData.ChannelType");
+            updateReset.Set();
+        };
+        await channel.Update(updatedData);
+        var updated = updateReset.WaitOne(15000);
+        Assert.True(updated);
+    }
+
+    [Test]
+    public async Task TestDeleteChannel()
+    {
+        var channel = await chat.CreatePublicConversation();
+
+        await Task.Delay(3000);
+
+        Assert.True(chat.TryGetChannel(channel.Id, out _), "Couldn't fetch created channel from chat");
+
+        await channel.Delete();
+
+        await Task.Delay(3000);
+
+        Assert.False(chat.TryGetChannel(channel.Id, out _), "Fetched the supposedly-deleted channel from chat");
+    }
 
+    [Test]
+    public async Task TestLeaveChannel()
+    {
+        var currentChatUser = await chat.GetCurrentUserAsync();
+
+        Assert.IsNotNull(currentChatUser, "currentChatUser was null");
+
+        var channel = await chat.CreatePublicConversation();
+        channel.Join();
+
+        await Task.Delay(3000);
+
+        var memberships = await channel.GetMemberships();
+
+        Assert.True(memberships.Memberships.Any(x => x.UserId == currentChatUser.Id), "Join failed, current user not found in channel memberships");
+
+        channel.Leave();
+
+        await Task.Delay(3000);
+
+        memberships = await channel.GetMemberships();
+
+        Assert.False(memberships.Memberships.Any(x => x.UserId == currentChatUser.Id), "Leave failed, current user found in channel memberships");
+    }
+
     [Test]
     public async Task TestGetUserSuggestions()
     {
@@ -64,6 +136,7 @@ public async Task TestStartTyping()
     {
         var channel = (await chat.CreateDirectConversation(talkUser, "sttc")).CreatedChannel;
         channel.Join();
+        await Task.Delay(2500);
         channel.SetListeningForTyping(true);
 
         await Task.Delay(5500);
@@ -85,6 +158,7 @@ public async Task TestStopTyping()
     {
         var channel = (await chat.CreateDirectConversation(talkUser, "stop_typing_test_channel")).CreatedChannel;
         channel.Join();
+        await Task.Delay(2500);
         channel.SetListeningForTyping(true);
         await Task.Delay(2500);
 
@@ -109,6 +183,7 @@ public async Task TestStopTypingFromTimer()
     {
         var channel = (await chat.CreateDirectConversation(talkUser, "stop_typing_timeout_test_channel")).CreatedChannel;
         channel.Join();
+        await Task.Delay(2500);
         channel.SetListeningForTyping(true);
 
         await Task.Delay(4500);
@@ -202,6 +277,7 @@ public async Task TestEmitUserMention()
     {
         var channel = await chat.CreatePublicConversation("user_mention_test_channel");
         channel.Join();
+        await Task.Delay(2500);
         var receivedManualEvent = new ManualResetEvent(false);
         user.SetListeningForMentionEvents(true);
         await Task.Delay(3000);
@@ -214,4 +290,30 @@ public async Task TestEmitUserMention()
         var received = receivedManualEvent.WaitOne(7000);
         Assert.True(received);
     }
+
+    [Test]
+    public async Task TestChannelIsPresent()
+    {
+        var someChannel = await chat.CreatePublicConversation();
+        someChannel.Join();
+
+        await Task.Delay(4000);
+
+        var isPresent = await someChannel.IsUserPresent(user.Id);
+
+        Assert.True(isPresent, "someChannel.IsUserPresent() doesn't return true for most recently joined channel!");
+    }
+
+    [Test]
+    public async Task TestChannelWhoIsPresent()
+    {
+        var someChannel = await chat.CreatePublicConversation();
+        someChannel.Join();
+
+        await Task.Delay(4000);
+
+        var who = await someChannel.WhoIsPresent();
+
+        Assert.Contains(user.Id, who, "channel.WhoIsPresent() doesn't have most recently joine user!");
+    }
 }

c-sharp-chat/PubnubChatApi/PubNubChatApi.Tests/ChatTests.cs

@@ -128,9 +128,7 @@ public async Task TestForwardMessage()
         };
         forwardingChannel.Join();
         await Task.Delay(2500);
-
-        /*channel.Join();
-        await Task.Delay(3500);*/
+
         channel.OnMessageReceived += async message => { await chat.ForwardMessage(message, forwardingChannel); };
 
         await channel.SendText("message_to_forward");
@@ -199,6 +197,7 @@ public async Task TestReadReceipts()
         }
 
         otherChatChannel.Join();
+        await Task.Delay(2500);
         otherChatChannel.SetListeningForReadReceiptsEvents(true);
         await Task.Delay(2500);
 

c-sharp-chat/PubnubChatApi/PubNubChatApi.Tests/MessageDraftTests.cs

@@ -19,7 +19,10 @@ public async Task Setup()
             PubnubTestsParameters.SubscribeKey,
             "message_draft_tests_user")
         );
-        channel = await chat.CreatePublicConversation("message_draft_tests_channel");
+        channel = await chat.CreatePublicConversation("message_draft_tests_channel", new ChatChannelData()
+        {
+            ChannelName = "MessageDraftTestingChannel"
+        });
         if (!chat.TryGetCurrentUser(out var user))
         {
             Assert.Fail();
@@ -77,31 +80,100 @@ public async Task TestInsertSuggestedMention()
         var messageDraft = channel.CreateMessageDraft();
         messageDraft.SetSearchForSuggestions(true);
         var successReset = new ManualResetEvent(false);
-        var hadSuggestion = false;
+        var step = "user_suggestion";
         messageDraft.OnDraftUpdated += (elements, mentions) =>
         {
-            if (!hadSuggestion)
+            switch (step)
             {
-                var userSuggestion =
-                    mentions.FirstOrDefault(x => x.Target is { Target: "mock_user", Type: MentionType.User });
+                case "user_suggestion":
+                    var userSuggestion =
+                        mentions.FirstOrDefault(x => x.Target is { Target: "mock_user", Type: MentionType.User });
 
-                Assert.True(elements.Any(x => x.Text == "maybe i'll mention @Mock") && userSuggestion != null,
-                    "Received correct user suggestion");
-                hadSuggestion = true;
+                    Assert.True(elements.Any(x => x.Text == "maybe i'll mention @Mock") && userSuggestion != null,
+                        "Received incorrect user suggestion");
+                    step = "user_inserted";
 
-                messageDraft.InsertSuggestedMention(userSuggestion, userSuggestion.ReplaceTo);
-            }
-            else
-            {
-                Assert.True(elements.Any(x => x.Text.Contains("Mock Usernamiski")));
-                successReset.Set();
+                    messageDraft.InsertSuggestedMention(userSuggestion, userSuggestion.ReplaceTo);
+                    break;
+                case "user_inserted":
+                    Assert.True(elements.Any(x => x.Text.Contains("Mock Usernamiski")));
+                    successReset.Set();
+                    break;
+                //TODO: to be re-enabled after Channel and Link mentions approach unification
+                /*case "channel_suggestion":
+                    var channelSuggestion =
+                        mentions.FirstOrDefault(x => x.Target is { Target: "message_draft_tests_channel", Type: MentionType.Channel });
+
+                    Assert.True(elements.Any(x => x.Text.Contains("now mention #MessageDraft")) && channelSuggestion != null,
+                        "Received incorrect channel suggestion");
+                    step = "channel_inserted";
+
+                    messageDraft.InsertSuggestedMention(channelSuggestion, channelSuggestion.ReplaceTo);
+                    break;
+                case "channel_inserted":
+                    Assert.True(elements.Any(x => x.Text.Contains("MessageDraftTestingChannel")));
+                    successReset.Set();
+                    break;*/
+                default:
+                    Assert.Fail("Unexpected draft update callback flow in test");
+                    break;
             }
         };
         messageDraft.InsertText(0, "maybe i'll mention @Mock");
-        var gotCallback = successReset.WaitOne(5000);
-        Assert.True(gotCallback);
+        var userInserted = successReset.WaitOne(5000);
+        Assert.True(userInserted, "didn't receive user insertion callback");
+
+        //TODO: to be re-enabled after Channel and Link mentions approach unification
+        /*step = "channel_suggestion";
+        successReset = new ManualResetEvent(false);
+        messageDraft.InsertText(0, "now mention #MessageDraft ");
+        var channelInserted = successReset.WaitOne(5000);
+        Assert.True(channelInserted, "didn't receive channel insertion callback");
+
+        var messageReset = new ManualResetEvent(false);
+        channel.OnMessageReceived += message =>
+        {
+            Assert.True(message.ReferencedChannels.Any(x => x.Id == channel.Id), "received message doesn't contain expected referenced channel");
+            Assert.True(message.MentionedUsers.Any(x => x.Id == dummyUser.Id), "received message doesn't contain expected mentioned user");
+            messageReset.Set();
+        };
+        await messageDraft.Send();
+        var receivedMessage = messageReset.WaitOne(10000);
+        Assert.True(receivedMessage, "didn't receive message callback");*/
     }
 
+    //TODO: to be re-enabled after Channel and Link mentions approach unification
+    /*[Test]
+    public async Task TestAddAndSendTextLink()
+    {
+        var messageDraft = channel.CreateMessageDraft();
+        messageDraft.InsertText(0, "some text goes here");
+        var updateReset = new ManualResetEvent(false);
+        messageDraft.OnDraftUpdated += (elements, mentions) =>
+        {
+            Assert.True(elements.Any(x => x is { Text: "some", MentionTarget: {Target: "www.pubnub.com", Type: MentionType.Url} })
+                , "updated message draft doesn't contain expected element");
+            updateReset.Set();
+        };
+        messageDraft.AddMention(0, 4, new MentionTarget()
+        {
+            Target = "www.pubnub.com",
+            Type = MentionType.Url
+        });
+        var updated = updateReset.WaitOne(3000);
+        Assert.True(updated, "didn't receive md update callback");
+
+        var messageReset = new ManualResetEvent(false);
+        channel.OnMessageReceived += message =>
+        {
+            Assert.True(message.TextLinks.Any(x => x.Link == "www.pubnub.com"), "didn't find expected link in received message");
+            messageReset.Set();
+        };
+        await messageDraft.Send();
+        var received = messageReset.WaitOne(6000);
+        Assert.True(received, "didn't receive message callback after md send");
+    }*/
+
     [Test]
     public async Task TestAddAndRemoveMention()
     {

c-sharp-chat/PubnubChatApi/PubNubChatApi.Tests/MessageTests.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics;
 using PubNubChatAPI.Entities;
 using PubnubChatApi.Entities.Data;
+using PubnubChatApi.Enums;
 
 namespace PubNubChatApi.Tests;
 
@@ -16,7 +17,7 @@ public async Task Setup()
         chat = await Chat.CreateInstance(new PubnubChatConfig(
             PubnubTestsParameters.PublishKey,
             PubnubTestsParameters.SubscribeKey,
-            "message_tests_user")
+            "message_tests_user_2")
         );
         channel = await chat.CreatePublicConversation("message_tests_channel_2");
         if (!chat.TryGetCurrentUser(out user))
@@ -44,6 +45,7 @@ public async Task TestSendAndReceive()
         channel.OnMessageReceived += message =>
         {
             Assert.True(message.MessageText == "Test message text");
+            Assert.True(message.Type == PubnubChatMessageType.Text);
             manualReceiveEvent.Set();
         };
         await channel.SendText("Test message text", new SendTextParams()
@@ -124,6 +126,32 @@ public async Task TestEditMessage()
         var receivedAndUpdated = manualUpdatedEvent.WaitOne(14000);
         Assert.IsTrue(receivedAndUpdated);
     }
+
+    [Test]
+    public async Task TestGetOriginalMessageText()
+    {
+        var manualUpdatedEvent = new ManualResetEvent(false);
+        var originalTextAfterUpdate = "";
+        channel.OnMessageReceived += async message =>
+        {
+            message.SetListeningForUpdates(true);
+            await Task.Delay(2000);
+            message.OnMessageUpdated += updatedMessage =>
+            {
+                originalTextAfterUpdate = updatedMessage.OriginalMessageText;
+                manualUpdatedEvent.Set();
+            };
+            await message.EditMessageText("new-text");
+        };
+        var originalText = "something";
+        await channel.SendText(originalText);
+
+        var receivedAndUpdated = manualUpdatedEvent.WaitOne(14000);
+
+        Assert.True(receivedAndUpdated, "didn't receive message update");
+        Assert.IsTrue(originalText == originalTextAfterUpdate, 
+            $"message.OriginalMessageText has wrong value! Expected \"{originalText}\" but got \"{originalTextAfterUpdate}\"");
+    }
 
     [Test]
     public async Task TestDeleteMessage()
@@ -172,14 +200,9 @@ public async Task TestRestoreMessage()
     [Test]
     public async Task TestPinMessage()
     {
-        if (chat.TryGetChannel("pin_test_2", out var existingChannel))
-        {
-            await chat.DeleteChannel(existingChannel.Id);
-            await Task.Delay(4000);
-        }
-
-        var pinTestChannel = await chat.CreatePublicConversation("pin_test_2");
+        var pinTestChannel = await chat.CreatePublicConversation();
         pinTestChannel.Join();
+        await Task.Delay(2500);
         pinTestChannel.SetListeningForUpdates(true);
         await Task.Delay(3000);
 

c-sharp-chat/PubnubChatApi/PubNubChatApi.Tests/ThreadsTests.cs

@@ -108,6 +108,7 @@ public async Task TestThreadChannelEmitUserMention()
         {
             var thread = await message.CreateThread();
             thread.Join();
+            await Task.Delay(2500);
             user.SetListeningForMentionEvents(true);
             await Task.Delay(2500);
             user.OnMentionEvent += mentionEvent =>