feat: Add support for MemberLimit and MessageLimit when querying channels. (#156)

* feat: Add support for `MemberLimit` and `MessageLimit` when querying channels. Can be set in `QueryChannelsOptions`

* Add seperate channel for tests asserting message limits -> another test was truncating the messages

* Add async postfix to test names

Author: sierpinskid

src/Models/QueryOptions.cs

@@ -76,6 +76,8 @@ public class QueryChannelsOptions
 
         public int Offset { get; set; } = DefaultOffset;
         public int Limit { get; set; } = DefaultLimit;
+        public int MemberLimit { get; set; }
+        public int MessageLimit { get; set; }
         public bool Presence { get; set; }
         public bool State { get; set; }
         public bool Watch { get; set; }

tests/ChannelClientTests.cs

@@ -3,7 +3,6 @@
 using System.Linq;
 using System.Threading.Tasks;
 using FluentAssertions;
-using Newtonsoft.Json;
 using NUnit.Framework;
 using StreamChat.Models;
 
@@ -21,6 +20,7 @@ public class ChannelClientTests : TestBase
         private UserRequest _user2;
         private UserRequest _user3;
         private ChannelWithConfig _channel;
+        private ChannelWithConfig _channel2;
 
         [OneTimeSetUp]
         public async Task SetupAsync()
@@ -29,7 +29,13 @@ public async Task SetupAsync()
                 await UpsertNewUserAsync());
             _channel = await CreateChannelAsync(createdByUserId: _user1.Id,
                 members: new[] { _user1.Id, _user2.Id, _user3.Id });
-            await _messageClient.SendMessageAsync(_channel.Type, _channel.Id, _user1.Id, "text");
+            _channel2 = await CreateChannelAsync(createdByUserId: _user1.Id,
+                members: new[] { _user1.Id, _user2.Id, _user3.Id });
+            await _messageClient.SendMessageAsync(_channel2.Type, _channel2.Id, _user1.Id, "text");
+            await _messageClient.SendMessageAsync(_channel2.Type, _channel2.Id, _user1.Id, "text 2");
+            await _messageClient.SendMessageAsync(_channel2.Type, _channel2.Id, _user1.Id, "text 3");
+            await _messageClient.SendMessageAsync(_channel2.Type, _channel2.Id, _user1.Id, "text 4");
+            await _messageClient.SendMessageAsync(_channel2.Type, _channel2.Id, _user1.Id, "text 5");
         }
 
         [OneTimeTearDown]
@@ -812,5 +818,67 @@ public async Task TestUnarchiveChannelForMemberAsync()
 
             archivedChannels.Channels.Should().NotContain(c => c.Channel.Cid == channel.Cid);
         }
+
+        [Test]
+        public async Task TestQueryChannelsWithoutMembersLimitAsync()
+        {
+            var queryChannelResponse = await _channelClient.QueryChannelsAsync(new QueryChannelsOptions
+            {
+                Filter = new Dictionary<string, object>()
+                {
+                    { "cid", _channel2.Cid },
+                },
+                UserId = _user1.Id,
+            });
+            queryChannelResponse.Channels.Should().HaveCount(1);
+            queryChannelResponse.Channels.First().Members.Should().HaveCount(3);
+        }
+
+        [Test]
+        public async Task TestQueryChannelsWithMembersLimitAsync()
+        {
+            var queryChannelResponse = await _channelClient.QueryChannelsAsync(new QueryChannelsOptions
+            {
+                Filter = new Dictionary<string, object>()
+                {
+                    { "cid", _channel2.Cid },
+                },
+                MemberLimit = 1,
+                UserId = _user1.Id,
+            });
+            queryChannelResponse.Channels.Should().HaveCount(1);
+            queryChannelResponse.Channels.First().Members.Should().HaveCount(1);
+        }
+
+        [Test]
+        public async Task TestQueryChannelsWithoutMessageLimitAsync()
+        {
+            var queryChannelResponse = await _channelClient.QueryChannelsAsync(new QueryChannelsOptions
+            {
+                Filter = new Dictionary<string, object>()
+                {
+                    { "cid", _channel2.Cid },
+                },
+                UserId = _user1.Id,
+            });
+            queryChannelResponse.Channels.Should().HaveCount(1);
+            queryChannelResponse.Channels.First().Messages.Should().HaveCount(5);
+        }
+
+        [Test]
+        public async Task TestQueryChannelsWithMessageLimitAsync()
+        {
+            var queryChannelResponse = await _channelClient.QueryChannelsAsync(new QueryChannelsOptions
+            {
+                Filter = new Dictionary<string, object>()
+                {
+                    { "cid", _channel2.Cid },
+                },
+                MessageLimit = 2,
+                UserId = _user1.Id,
+            });
+            queryChannelResponse.Channels.Should().HaveCount(1);
+            queryChannelResponse.Channels.First().Messages.Should().HaveCount(2);
+        }
     }
 }