feat(auth): Added ListTenantsAsync() and DeleteTenantAsync() APIs (#225)

* feat(auth): Added ListTenantsAsync() and DeleteTenantAsync() APIs

* fix: Added newline at eof

Author: hiranya911

FirebaseAdmin/FirebaseAdmin.Tests/Auth/Multitenancy/TenantManagerTest.cs

@@ -13,7 +13,9 @@
 // limitations under the License.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
@@ -59,6 +61,24 @@ public class TenantManagerTest
         private static readonly GoogleCredential MockCredential =
             GoogleCredential.FromAccessToken("test-token");
 
+        private static readonly IList<string> ListTenantsResponses = new List<string>()
+        {
+            $@"{{
+                ""nextPageToken"": ""token"",
+                ""tenants"": [
+                    {TenantResponse},
+                    {TenantResponse},
+                    {TenantResponse}
+                ]
+            }}",
+            $@"{{
+                ""tenants"": [
+                    {TenantResponse},
+                    {TenantResponse}
+                ]
+            }}",
+        };
+
         [Fact]
         public async Task GetTenant()
         {
@@ -318,6 +338,271 @@ public async Task UpdateTenantError()
             Assert.Null(exception.InnerException);
         }
 
+        [Fact]
+        public async Task DeleteTenant()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = TenantResponse,
+            };
+            var auth = CreateFirebaseAuth(handler);
+
+            await auth.TenantManager.DeleteTenantAsync("tenant1");
+
+            Assert.Equal(1, handler.Requests.Count);
+            var request = handler.Requests[0];
+            Assert.Equal(HttpMethod.Delete, request.Method);
+            Assert.Equal("/v2/projects/project1/tenants/tenant1", request.Url.PathAndQuery);
+            AssertClientVersionHeader(request);
+        }
+
+        [Theory]
+        [MemberData(nameof(InvalidStrings))]
+        public async Task DeleteTenantNoId(string tenantId)
+        {
+            var auth = CreateFirebaseAuth();
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                () => auth.TenantManager.DeleteTenantAsync(tenantId));
+            Assert.Equal("Tenant ID cannot be null or empty.", exception.Message);
+        }
+
+        [Fact]
+        public async Task DeleteTenantNotFoundError()
+        {
+            var handler = new MockMessageHandler()
+            {
+                StatusCode = HttpStatusCode.NotFound,
+                Response = TenantNotFoundResponse,
+            };
+            var auth = CreateFirebaseAuth(handler);
+
+            var exception = await Assert.ThrowsAsync<FirebaseAuthException>(
+                () => auth.TenantManager.DeleteTenantAsync("tenant1"));
+            Assert.Equal(ErrorCode.NotFound, exception.ErrorCode);
+            Assert.Equal(AuthErrorCode.TenantNotFound, exception.AuthErrorCode);
+            Assert.Equal(
+                "No tenant found for the given identifier (TENANT_NOT_FOUND).",
+                exception.Message);
+            Assert.NotNull(exception.HttpResponse);
+            Assert.Null(exception.InnerException);
+        }
+
+        [Fact]
+        public async Task ListTenants()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = ListTenantsResponses,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var tenants = new List<Tenant>();
+
+            var pagedEnumerable = auth.TenantManager.ListTenantsAsync(null);
+            var enumerator = pagedEnumerable.GetEnumerator();
+            while (await enumerator.MoveNext())
+            {
+                tenants.Add(enumerator.Current);
+            }
+
+            Assert.Equal(5, tenants.Count);
+            Assert.All(tenants, AssertTenant);
+
+            Assert.Equal(2, handler.Requests.Count);
+            var query = ExtractQueryParams(handler.Requests[0]);
+            Assert.Single(query);
+            Assert.Equal("100", query["pageSize"]);
+
+            query = ExtractQueryParams(handler.Requests[1]);
+            Assert.Equal(2, query.Count);
+            Assert.Equal("100", query["pageSize"]);
+            Assert.Equal("token", query["pageToken"]);
+
+            Assert.All(handler.Requests, AssertClientVersionHeader);
+        }
+
+        [Fact]
+        public void ListTenantsForEach()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = ListTenantsResponses,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var tenants = new List<Tenant>();
+
+            var pagedEnumerable = auth.TenantManager.ListTenantsAsync(null);
+            foreach (var tenant in pagedEnumerable.ToEnumerable())
+            {
+                tenants.Add(tenant);
+            }
+
+            Assert.Equal(5, tenants.Count);
+            Assert.All(tenants, AssertTenant);
+
+            Assert.Equal(2, handler.Requests.Count);
+            var query = ExtractQueryParams(handler.Requests[0]);
+            Assert.Single(query);
+            Assert.Equal("100", query["pageSize"]);
+
+            query = ExtractQueryParams(handler.Requests[1]);
+            Assert.Equal(2, query.Count);
+            Assert.Equal("100", query["pageSize"]);
+            Assert.Equal("token", query["pageToken"]);
+
+            Assert.All(handler.Requests, AssertClientVersionHeader);
+        }
+
+        [Fact]
+        public async Task ListTenantsByPages()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = ListTenantsResponses,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var tenants = new List<Tenant>();
+
+            // Read page 1.
+            var pagedEnumerable = auth.TenantManager.ListTenantsAsync(null);
+            var tenantsPage = await pagedEnumerable.ReadPageAsync(3);
+
+            Assert.Equal(3, tenantsPage.Count());
+            Assert.Equal("token", tenantsPage.NextPageToken);
+
+            Assert.Single(handler.Requests);
+            var query = ExtractQueryParams(handler.Requests[0]);
+            Assert.Single(query);
+            Assert.Equal("3", query["pageSize"]);
+            tenants.AddRange(tenantsPage);
+
+            // Read page 2.
+            pagedEnumerable = auth.TenantManager.ListTenantsAsync(new ListTenantsOptions()
+            {
+                PageToken = tenantsPage.NextPageToken,
+            });
+            tenantsPage = await pagedEnumerable.ReadPageAsync(3);
+
+            Assert.Equal(2, tenantsPage.Count());
+            Assert.Null(tenantsPage.NextPageToken);
+
+            Assert.Equal(2, handler.Requests.Count);
+            query = ExtractQueryParams(handler.Requests[1]);
+            Assert.Equal(2, query.Count);
+            Assert.Equal("3", query["pageSize"]);
+            Assert.Equal("token", query["pageToken"]);
+            tenants.AddRange(tenantsPage);
+
+            Assert.Equal(5, tenants.Count);
+            Assert.All(tenants, AssertTenant);
+        }
+
+        [Fact]
+        public async Task ListTenantsAsRawResponses()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = ListTenantsResponses,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var tenants = new List<Tenant>();
+            var tokens = new List<string>();
+
+            var pagedEnumerable = auth.TenantManager.ListTenantsAsync(null);
+            var responses = pagedEnumerable.AsRawResponses().GetEnumerator();
+            while (await responses.MoveNext())
+            {
+                tenants.AddRange(responses.Current.Tenants);
+                tokens.Add(responses.Current.NextPageToken);
+                Assert.Equal(tokens.Count, handler.Requests.Count);
+            }
+
+            Assert.Equal(new List<string>() { "token", null }, tokens);
+            Assert.Equal(5, tenants.Count);
+            Assert.All(tenants, AssertTenant);
+
+            Assert.Equal(2, handler.Requests.Count);
+            var query = ExtractQueryParams(handler.Requests[0]);
+            Assert.Single(query);
+            Assert.Equal("100", query["pageSize"]);
+
+            query = ExtractQueryParams(handler.Requests[1]);
+            Assert.Equal(2, query.Count);
+            Assert.Equal("100", query["pageSize"]);
+            Assert.Equal("token", query["pageToken"]);
+        }
+
+        [Fact]
+        public void ListTenantsOptions()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = ListTenantsResponses,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var tenants = new List<Tenant>();
+            var customOptions = new ListTenantsOptions()
+            {
+                PageSize = 3,
+                PageToken = "custom-token",
+            };
+
+            var pagedEnumerable = auth.TenantManager.ListTenantsAsync(customOptions);
+            foreach (var tenant in pagedEnumerable.ToEnumerable())
+            {
+                tenants.Add(tenant);
+            }
+
+            Assert.Equal(5, tenants.Count);
+            Assert.All(tenants, AssertTenant);
+
+            Assert.Equal(2, handler.Requests.Count);
+            var query = ExtractQueryParams(handler.Requests[0]);
+            Assert.Equal(2, query.Count);
+            Assert.Equal("3", query["pageSize"]);
+            Assert.Equal("custom-token", query["pageToken"]);
+
+            query = ExtractQueryParams(handler.Requests[1]);
+            Assert.Equal(2, query.Count);
+            Assert.Equal("3", query["pageSize"]);
+            Assert.Equal("token", query["pageToken"]);
+
+            Assert.All(handler.Requests, AssertClientVersionHeader);
+        }
+
+        [Theory]
+        [ClassData(typeof(TenantManagerTest.InvalidListOptions))]
+        public void ListInvalidOptions(ListTenantsOptions options, string expected)
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = ListTenantsResponses,
+            };
+            var auth = CreateFirebaseAuth(handler);
+
+            var exception = Assert.Throws<ArgumentException>(
+                () => auth.TenantManager.ListTenantsAsync(options));
+
+            Assert.Equal(expected, exception.Message);
+            Assert.Empty(handler.Requests);
+        }
+
+        [Fact]
+        public async Task ListReadPageSizeTooLarge()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = ListTenantsResponses,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var pagedEnumerable = auth.TenantManager.ListTenantsAsync(null);
+
+            await Assert.ThrowsAsync<ArgumentException>(
+                async () => await pagedEnumerable.ReadPageAsync(101));
+
+            Assert.Empty(handler.Requests);
+        }
+
         private static FirebaseAuth CreateFirebaseAuth(HttpMessageHandler handler = null)
         {
             var tenantManager = new TenantManager(new TenantManager.Args
@@ -344,5 +629,57 @@ private static void AssertClientVersionHeader(MockMessageHandler.IncomingRequest
         {
             Assert.Contains(ClientVersion, request.Headers.GetValues("X-Client-Version"));
         }
+
+        private static IDictionary<string, string> ExtractQueryParams(
+            MockMessageHandler.IncomingRequest req)
+        {
+            return req.Url.Query.Substring(1).Split('&').ToDictionary(
+                entry => entry.Split('=')[0], entry => entry.Split('=')[1]);
+        }
+
+        public class InvalidListOptions : IEnumerable<object[]>
+        {
+            public IEnumerator<object[]> GetEnumerator()
+            {
+                // {
+                //    1st element: InvalidInput,
+                //    2nd element: ExpectedError,
+                // }
+                yield return new object[]
+                {
+                    new ListTenantsOptions()
+                    {
+                        PageSize = 101,
+                    },
+                    "Page size must not exceed 100.",
+                };
+                yield return new object[]
+                {
+                    new ListTenantsOptions()
+                    {
+                        PageSize = 0,
+                    },
+                    "Page size must be positive.",
+                };
+                yield return new object[]
+                {
+                    new ListTenantsOptions()
+                    {
+                        PageSize = -1,
+                    },
+                    "Page size must be positive.",
+                };
+                yield return new object[]
+                {
+                    new ListTenantsOptions()
+                    {
+                        PageToken = string.Empty,
+                    },
+                    "Page token must not be empty.",
+                };
+            }
+
+            IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
+        }
     }
 }

FirebaseAdmin/FirebaseAdmin/Auth/ListUsersRequest.cs

@@ -21,7 +21,6 @@
 using System.Threading.Tasks;
 using FirebaseAdmin.Util;
 using Google.Apis.Discovery;
-using Google.Apis.Http;
 using Google.Apis.Requests;
 using Google.Apis.Services;