feat(auth): Added CreateTenantAsync() and UpdateTenantAsync() APIs (#223)

Author: hiranya911

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

@@ -20,6 +20,8 @@
 using FirebaseAdmin.Tests;
 using FirebaseAdmin.Util;
 using Google.Apis.Auth.OAuth2;
+using Google.Apis.Json;
+using Newtonsoft.Json.Linq;
 using Xunit;
 
 namespace FirebaseAdmin.Auth.Multitenancy.Tests
@@ -45,6 +47,12 @@ public class TenantManagerTest
             }
         }";
 
+        private const string UnknownErrorResponse = @"{
+            ""error"": {
+                ""message"": ""UNKNOWN""
+            }
+        }";
+
         private static readonly string ClientVersion =
             $"DotNet/Admin/{FirebaseApp.GetSdkVersion()}";
 
@@ -102,6 +110,214 @@ public async Task GetTenantNotFoundError()
             Assert.Null(exception.InnerException);
         }
 
+        [Fact]
+        public async Task CreateTenant()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = TenantResponse,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var args = new TenantArgs()
+            {
+                DisplayName = "Test Tenant",
+                PasswordSignUpAllowed = true,
+                EmailLinkSignInEnabled = true,
+            };
+
+            var provider = await auth.TenantManager.CreateTenantAsync(args);
+
+            AssertTenant(provider);
+            Assert.Equal(1, handler.Requests.Count);
+            var request = handler.Requests[0];
+            Assert.Equal(HttpMethod.Post, request.Method);
+            Assert.Equal("/v2/projects/project1/tenants", request.Url.PathAndQuery);
+            AssertClientVersionHeader(request);
+
+            var body = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(
+                handler.LastRequestBody);
+            Assert.Equal(3, body.Count);
+            Assert.Equal("Test Tenant", body["displayName"]);
+            Assert.True((bool)body["allowPasswordSignup"]);
+            Assert.True((bool)body["enableEmailLinkSignin"]);
+        }
+
+        [Fact]
+        public async Task CreateTenantMinimal()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = TenantResponse,
+            };
+            var auth = CreateFirebaseAuth(handler);
+
+            var provider = await auth.TenantManager.CreateTenantAsync(new TenantArgs());
+
+            AssertTenant(provider);
+            Assert.Equal(1, handler.Requests.Count);
+            var request = handler.Requests[0];
+            Assert.Equal(HttpMethod.Post, request.Method);
+            Assert.Equal("/v2/projects/project1/tenants", request.Url.PathAndQuery);
+            AssertClientVersionHeader(request);
+
+            var body = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(
+                handler.LastRequestBody);
+            Assert.Empty(body);
+        }
+
+        [Fact]
+        public async Task CreateTenantNullArgs()
+        {
+            var auth = CreateFirebaseAuth();
+
+            await Assert.ThrowsAsync<ArgumentNullException>(
+                () => auth.TenantManager.CreateTenantAsync(null));
+        }
+
+        [Fact]
+        public async Task CreateTenantError()
+        {
+            var handler = new MockMessageHandler()
+            {
+                StatusCode = HttpStatusCode.InternalServerError,
+                Response = UnknownErrorResponse,
+            };
+            var auth = CreateFirebaseAuth(handler);
+
+            var exception = await Assert.ThrowsAsync<FirebaseAuthException>(
+                () => auth.TenantManager.CreateTenantAsync(new TenantArgs()));
+            Assert.Equal(ErrorCode.Internal, exception.ErrorCode);
+            Assert.Null(exception.AuthErrorCode);
+            Assert.StartsWith(
+                "Unexpected HTTP response with status: 500 (InternalServerError)",
+                exception.Message);
+            Assert.NotNull(exception.HttpResponse);
+            Assert.Null(exception.InnerException);
+        }
+
+        [Fact]
+        public async Task UpdateTenant()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = TenantResponse,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var args = new TenantArgs()
+            {
+                DisplayName = "Test Tenant",
+                PasswordSignUpAllowed = true,
+                EmailLinkSignInEnabled = true,
+            };
+
+            var provider = await auth.TenantManager.UpdateTenantAsync("tenant1", args);
+
+            AssertTenant(provider);
+            Assert.Equal(1, handler.Requests.Count);
+            var request = handler.Requests[0];
+            Assert.Equal(HttpUtils.Patch, request.Method);
+            var mask = "allowPasswordSignup,displayName,enableEmailLinkSignin";
+            Assert.Equal(
+                $"/v2/projects/project1/tenants/tenant1?updateMask={mask}",
+                request.Url.PathAndQuery);
+            AssertClientVersionHeader(request);
+
+            var body = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(
+                handler.LastRequestBody);
+            Assert.Equal(3, body.Count);
+            Assert.Equal("Test Tenant", body["displayName"]);
+            Assert.True((bool)body["allowPasswordSignup"]);
+            Assert.True((bool)body["enableEmailLinkSignin"]);
+        }
+
+        [Fact]
+        public async Task UpdateTenantMinimal()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = TenantResponse,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var args = new TenantArgs()
+            {
+                DisplayName = "Test Tenant",
+            };
+
+            var provider = await auth.TenantManager.UpdateTenantAsync("tenant1", args);
+
+            AssertTenant(provider);
+            Assert.Equal(1, handler.Requests.Count);
+            var request = handler.Requests[0];
+            Assert.Equal(HttpUtils.Patch, request.Method);
+            Assert.Equal(
+                "/v2/projects/project1/tenants/tenant1?updateMask=displayName",
+                request.Url.PathAndQuery);
+            AssertClientVersionHeader(request);
+
+            var body = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(
+                handler.LastRequestBody);
+            Assert.Single(body);
+            Assert.Equal("Test Tenant", body["displayName"]);
+        }
+
+        [Theory]
+        [MemberData(nameof(InvalidStrings))]
+        public async Task UpdateTenantNoId(string tenantId)
+        {
+            var auth = CreateFirebaseAuth();
+            var args = new TenantArgs()
+            {
+                DisplayName = "Test Tenant",
+            };
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                () => auth.TenantManager.UpdateTenantAsync(tenantId, args));
+            Assert.Equal("Tenant ID cannot be null or empty.", exception.Message);
+        }
+
+        [Fact]
+        public async Task UpdateTenantNullArgs()
+        {
+            var auth = CreateFirebaseAuth();
+
+            await Assert.ThrowsAsync<ArgumentNullException>(
+                () => auth.TenantManager.UpdateTenantAsync("tenant1", null));
+        }
+
+        [Fact]
+        public async Task UpdateTenantEmptyArgs()
+        {
+            var auth = CreateFirebaseAuth();
+
+            await Assert.ThrowsAsync<ArgumentException>(
+                () => auth.TenantManager.UpdateTenantAsync("tenant1", new TenantArgs()));
+        }
+
+        [Fact]
+        public async Task UpdateTenantError()
+        {
+            var handler = new MockMessageHandler()
+            {
+                StatusCode = HttpStatusCode.NotFound,
+                Response = TenantNotFoundResponse,
+            };
+            var auth = CreateFirebaseAuth(handler);
+            var args = new TenantArgs()
+            {
+                DisplayName = "Test Tenant",
+            };
+
+            var exception = await Assert.ThrowsAsync<FirebaseAuthException>(
+                () => auth.TenantManager.UpdateTenantAsync("tenant1", args));
+            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);
+        }
+
         private static FirebaseAuth CreateFirebaseAuth(HttpMessageHandler handler = null)
         {
             var tenantManager = new TenantManager(new TenantManager.Args

FirebaseAdmin/FirebaseAdmin/Auth/FirebaseToken.cs

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 using System.Collections.Generic;
-using Newtonsoft.Json;
 
 namespace FirebaseAdmin.Auth
 {

FirebaseAdmin/FirebaseAdmin/Auth/Multitenancy/Tenant.cs

@@ -13,7 +13,6 @@
 // limitations under the License.
 
 using Google.Apis.Util;
-using Newtonsoft.Json;
 
 namespace FirebaseAdmin.Auth.Multitenancy
 {
@@ -39,9 +38,9 @@ namespace FirebaseAdmin.Auth.Multitenancy
     /// </summary>
     public sealed class Tenant
     {
-        private readonly Args args;
+        private readonly TenantArgs args;
 
-        internal Tenant(Args args)
+        internal Tenant(TenantArgs args)
         {
             this.args = args.ThrowIfNull(nameof(args));
         }
@@ -59,32 +58,17 @@ internal Tenant(Args args)
         /// <summary>
         /// Gets a value indicating whether the email sign-in provider is enabled.
         /// </summary>
-        public bool PasswordSignUpAllowed => args.PasswordSignUpAllowed;
+        public bool PasswordSignUpAllowed => args.PasswordSignUpAllowed ?? false;
 
         /// <summary>
         /// Gets a value indicating whether the email link sign-in is enabled.
         /// </summary>
-        public bool EmailLinkSignInEnabled => args.EmailLinkSignInEnabled;
+        public bool EmailLinkSignInEnabled => args.EmailLinkSignInEnabled ?? false;
 
         private string ExtractResourceId(string resourceName)
         {
             var segments = resourceName.Split('/');
             return segments[segments.Length - 1];
         }
-
-        internal sealed class Args
-        {
-            [JsonProperty("name")]
-            internal string Name { get; set; }
-
-            [JsonProperty("displayName")]
-            internal string DisplayName { get; set; }
-
-            [JsonProperty("allowPasswordSignup")]
-            internal bool PasswordSignUpAllowed { get; set; }
-
-            [JsonProperty("enableEmailLinkSignin")]
-            internal bool EmailLinkSignInEnabled { get; set; }
-        }
     }
 }

FirebaseAdmin/FirebaseAdmin/Auth/Multitenancy/TenantArgs.cs

@@ -0,0 +1,45 @@
+// Copyright 2020, Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Newtonsoft.Json;
+
+namespace FirebaseAdmin.Auth.Multitenancy
+{
+    /// <summary>
+    /// Arguments for creating and updating tenants.
+    /// </summary>
+    public sealed class TenantArgs
+    {
+        /// <summary>
+        /// Gets or sets the tenant display name.
+        /// </summary>
+        [JsonProperty("displayName")]
+        public string DisplayName { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the email sign-in provider is enabled.
+        /// </summary>
+        [JsonProperty("allowPasswordSignup")]
+        public bool? PasswordSignUpAllowed { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the email link sign-in is enabled.
+        /// </summary>
+        [JsonProperty("enableEmailLinkSignin")]
+        public bool? EmailLinkSignInEnabled { get; set; }
+
+        [JsonProperty("name")]
+        internal string Name { get; set; }
+    }
+}