Update IGroupsClient to support paging of groups and projects (#642)

* Add Page support to IGroupsClient

* Add unit tests for mock GroupClient

* Add integration tests

* Fix integration test failures

* Replace WebHeaderCollection with NameValueCollection

Do not use System.Net types in public APIs.

* Revert all possible breaking changes

* Update docs to use the 3rd person descriptive form

* Replace `ToList` with `ToArray`

* Keep static fields together

* Dispose `StreamReader`

* Return early in some cases to reduce indentation

* Use `PagedResponse<T>` for all paged responses

* Replace NameValueCollection with a IReadOnlyDictionary

* Add unit tests for WebHeadersDictionaryAdaptor

* Replace the custom IEnumerator impl with the IEnumerable's enumerator

* Use custom error message

Author: belcher-rok

NGitLab.Mock.Tests/GroupsMockTests.cs

@@ -7,6 +7,27 @@ namespace NGitLab.Mock.Tests;
 
 public class GroupsMockTests
 {
+    private static GitLabServer CreateGroupHierarchy() =>
+        new GitLabConfig()
+            .WithUser("user1", isDefault: true)
+            .WithGroup("tlg", 1)
+                .WithGroup("sg1", 2, @namespace: "tlg")
+                    .WithGroup("sg1_1", 3, @namespace: "tlg/sg1")
+                .WithGroup("sg2", 4, @namespace: "tlg")
+                    .WithGroup("sg2_1", 5, @namespace: "tlg/sg2")
+            .BuildServer();
+
+    private static GitLabServer CreateProjectHierarchy() =>
+        new GitLabConfig()
+            .WithUser("user1", isDefault: true)
+            .WithGroup("tlg", 1)
+                .WithProject("p1", 2, @namespace: "tlg")
+                .WithGroup("sg1", 3, @namespace: "tlg")
+                    .WithProject("p2", 4, @namespace: "tlg/sg1")
+                    .WithProject("p3", 5, @namespace: "tlg/sg1")
+                .WithGroup("sg2", 6, @namespace: "tlg")
+            .BuildServer();
+
     [Test]
     public async Task Test_group_get_by_id()
     {
@@ -41,6 +62,69 @@ public async Task Test_group_get_by_fullpath()
         Assert.That(group.FullPath, Is.EqualTo("name3"), "Subgroups found are invalid");
     }
 
+    [Test]
+    public void Test_get_groups_with_top_level_only_ignores_subgroups()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        var groups = client.Groups.GetAsync(new Models.GroupQuery { TopLevelOnly = true });
+
+        var expected = new string[] { "user1", "tlg" };
+        Assert.That(groups.Select(g => g.FullPath), Is.EquivalentTo(expected));
+    }
+
+    [Test]
+    public async Task Test_page_groups_first_page()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageAsync(new(page: 1, perPage: 3));
+
+        var expected = new string[] { "user1", "tlg", "tlg/sg1" };
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(g => g.FullPath), Is.EquivalentTo(expected));
+            Assert.That(total, Is.EqualTo(6));
+        });
+    }
+
+    [Test]
+    public async Task Test_page_groups_last_page()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageAsync(new(page: 2, perPage: 4));
+
+        var expected = new string[] { "tlg/sg2", "tlg/sg2/sg2_1" };
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(g => g.FullPath), Is.EquivalentTo(expected));
+            Assert.That(total, Is.EqualTo(6));
+        });
+    }
+
+    [Test]
+    public async Task Test_page_groups_with_page_0_returns_page_1()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageAsync(new(page: 0));
+
+        Assert.That(total, Is.EqualTo(6));
+    }
+
+    [Test]
+    public void Test_page_groups_with_invalid_perpage_throws()
+    {
+        using var server = CreateGroupHierarchy();
+        var client = server.CreateClient("user1");
+        Assert.ThrowsAsync<Clients.GitLabBadRequestException>(() => client.Groups.PageAsync(new(perPage: 0)));
+    }
+
     [Test]
     public void Test_get_subgroups_by_id()
     {
@@ -78,4 +162,181 @@ public void Test_get_subgroups_by_fullpath()
 
         Assert.That(group.Count(), Is.EqualTo(2), "Subgroups found are invalid");
     }
+
+    [Test]
+    public void Test_get_subgroups_descendants_by_fullpath()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        var group = client.Groups.GetSubgroupsByFullPathAsync("tlg", new Models.SubgroupQuery { IncludeDescendants = true });
+
+        var expected = new string[] { "tlg/sg1", "tlg/sg1/sg1_1", "tlg/sg2", "tlg/sg2/sg2_1" };
+        Assert.That(group.Select(g => g.FullPath), Is.EquivalentTo(expected));
+    }
+
+    [Test]
+    public void Test_get_subgroups_descendants_by_id()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        var group = client.Groups.GetSubgroupsByIdAsync(1, new Models.SubgroupQuery { IncludeDescendants = true });
+
+        var expected = new string[] { "tlg/sg1", "tlg/sg1/sg1_1", "tlg/sg2", "tlg/sg2/sg2_1" };
+        Assert.That(group.Select(g => g.FullPath), Is.EquivalentTo(expected));
+    }
+
+    [Test]
+    public void Test_get_subgroups_descendants_of_subgroup_by_fullpath()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        var group = client.Groups.GetSubgroupsAsync("tlg/sg2", new Models.SubgroupQuery { IncludeDescendants = true });
+
+        var expected = new string[] { "tlg/sg2/sg2_1" };
+        Assert.That(group.Select(g => g.FullPath), Is.EquivalentTo(expected));
+    }
+
+    [Test]
+    public void Test_get_subgroups_descendants_of_subgroup_by_id()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        var group = client.Groups.GetSubgroupsAsync(2, new Models.SubgroupQuery { IncludeDescendants = true });
+
+        var expected = new string[] { "tlg/sg1/sg1_1" };
+        Assert.That(group.Select(g => g.FullPath), Is.EquivalentTo(expected));
+    }
+
+    [Test]
+    public async Task Test_page_subgroups_with_descendants_first_page()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageSubgroupsAsync("tlg", new(page: 1, perPage: 3, new Models.SubgroupQuery { IncludeDescendants = true }));
+
+        var expected = new string[] { "tlg/sg1", "tlg/sg1/sg1_1", "tlg/sg2" };
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(g => g.FullPath), Is.EquivalentTo(expected));
+            Assert.That(total, Is.EqualTo(4));
+        });
+    }
+
+    [Test]
+    public async Task Test_page_subgroups_with_descendants_last_page()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageSubgroupsAsync(1, new(page: 2, perPage: 3, new Models.SubgroupQuery { IncludeDescendants = true }));
+
+        var expected = new string[] { "tlg/sg2/sg2_1" };
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(g => g.FullPath), Is.EquivalentTo(expected));
+            Assert.That(total, Is.EqualTo(4));
+        });
+    }
+
+    [Test]
+    public async Task Test_page_subgroups_with_descendants_after_last_page()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageSubgroupsAsync(1, new(page: 100, perPage: 3, new Models.SubgroupQuery { IncludeDescendants = true }));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(g => g.FullPath), Is.Empty);
+            Assert.That(total, Is.EqualTo(4));
+        });
+    }
+
+    [Test]
+    public async Task Test_page_subgroups_with_page_0_returns_page_1()
+    {
+        using var server = CreateGroupHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageSubgroupsAsync("tlg", new(page: 0));
+
+        Assert.That(total, Is.EqualTo(2));
+    }
+
+    [Test]
+    public void Test_page_subgroups_with_invalid_perpage_throws()
+    {
+        using var server = CreateGroupHierarchy();
+        var client = server.CreateClient("user1");
+        Assert.ThrowsAsync<Clients.GitLabBadRequestException>(() => client.Groups.PageSubgroupsAsync(1, new(page: 1, perPage: 0)));
+    }
+
+    [Test]
+    public async Task Test_page_projects_first_page()
+    {
+        using var server = CreateProjectHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageProjectsAsync("tlg", new(page: 1, perPage: 1000));
+
+        var expected = new string[] { "tlg/p1" };
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(p => p.PathWithNamespace), Is.EquivalentTo(expected));
+            Assert.That(total, Is.EqualTo(1));
+        });
+    }
+
+    [Test]
+    public async Task Test_page_projects_in_subgroup()
+    {
+        using var server = CreateProjectHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageProjectsAsync("tlg/sg1", new(page: 2, perPage: 1));
+
+        var expected = new string[] { "tlg/sg1/p3" };
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(p => p.PathWithNamespace), Is.EquivalentTo(expected));
+            Assert.That(total, Is.EqualTo(2));
+        });
+    }
+
+    [Test]
+    public async Task Test_page_projects_in_subgroup_with_no_projects()
+    {
+        using var server = CreateProjectHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageProjectsAsync("tlg/sg2", new());
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(p => p.PathWithNamespace), Is.Empty);
+            Assert.That(total, Is.EqualTo(0));
+        });
+    }
+
+    [Test]
+    public async Task Test_page_projects_in_subgroup_with_descendants()
+    {
+        using var server = CreateProjectHierarchy();
+
+        var client = server.CreateClient("user1");
+        (var page, var total) = await client.Groups.PageProjectsAsync("tlg", new(query: new() { IncludeSubGroups = true }));
+
+        var expected = new string[] { "p1", "p2", "p3" };
+        Assert.Multiple(() =>
+        {
+            Assert.That(page.Select(p => p.Name), Is.EquivalentTo(expected));
+            Assert.That(total, Is.EqualTo(3));
+        });
+    }
 }