Improvements to thread-safety and error handling

Author: hiranya911

FirebaseAdmin/FirebaseAdmin.Tests/Auth/FirebaseAuthTest.cs

@@ -69,6 +69,8 @@ await Assert.ThrowsAsync<InvalidOperationException>(
                 async () => await auth.CreateCustomTokenAsync("user"));
             await Assert.ThrowsAsync<InvalidOperationException>(
                 async () => await auth.VerifyIdTokenAsync("user"));
+            await Assert.ThrowsAsync<InvalidOperationException>(
+                async () => await auth.SetCustomUserClaimsAsync("user", null));
         }
 
         [Fact]

FirebaseAdmin/FirebaseAdmin/Auth/FirebaseAuth.cs

@@ -39,8 +39,8 @@ private FirebaseAuth(FirebaseApp app)
                 () => FirebaseTokenFactory.Create(this.app), true);
             this.idTokenVerifier = new Lazy<FirebaseTokenVerifier>(
                 () => FirebaseTokenVerifier.CreateIDTokenVerifier(this.app), true);
-            this.userManager = new Lazy<FirebaseUserManager>(() =>
-                FirebaseUserManager.Create(this.app));
+            this.userManager = new Lazy<FirebaseUserManager>(
+                () => FirebaseUserManager.Create(this.app), true);
         }
 
         /// <summary>
@@ -211,17 +211,7 @@ public async Task<string> CreateCustomTokenAsync(
             IDictionary<string, object> developerClaims,
             CancellationToken cancellationToken)
         {
-            FirebaseTokenFactory tokenFactory;
-            lock (this.authLock)
-            {
-                if (this.deleted)
-                {
-                    throw new InvalidOperationException("Cannot invoke after deleting the app.");
-                }
-
-                tokenFactory = this.tokenFactory.Value;
-            }
-
+            var tokenFactory = this.IfNotDeleted(() => this.tokenFactory.Value);
             return await tokenFactory.CreateCustomTokenAsync(
                 uid, developerClaims, cancellationToken).ConfigureAwait(false);
         }
@@ -268,15 +258,8 @@ public async Task<FirebaseToken> VerifyIdTokenAsync(string idToken)
         public async Task<FirebaseToken> VerifyIdTokenAsync(
             string idToken, CancellationToken cancellationToken)
         {
-            lock (this.authLock)
-            {
-                if (this.deleted)
-                {
-                    throw new InvalidOperationException("Cannot invoke after deleting the app.");
-                }
-            }
-
-            return await this.idTokenVerifier.Value.VerifyTokenAsync(idToken, cancellationToken)
+            var idTokenVerifier = this.IfNotDeleted(() => this.idTokenVerifier.Value);
+            return await idTokenVerifier.VerifyTokenAsync(idToken, cancellationToken)
                 .ConfigureAwait(false);
         }
 
@@ -295,22 +278,39 @@ public async Task<FirebaseToken> VerifyIdTokenAsync(
         /// <param name="claims">The claims to be stored on the user account, and made
         /// available to Firebase security rules. These must be serializable to JSON, and after
         /// serialization it should not be larger than 1000 characters.</param>
-        public async Task SetCustomUserClaimsAsync(string uid, IReadOnlyDictionary<string, object> claims)
+        public async Task SetCustomUserClaimsAsync(
+            string uid, IReadOnlyDictionary<string, object> claims)
         {
-            lock (this.authLock)
-            {
-                if (this.deleted)
-                {
-                    throw new InvalidOperationException("Cannot invoke after deleting the app.");
-                }
-            }
+            await this.SetCustomUserClaimsAsync(uid, claims, default(CancellationToken));
+        }
 
+        /// <summary>
+        /// Sets the specified custom claims on an existing user account. A null claims value
+        /// removes any claims currently set on the user account. The claims should serialize into
+        /// a valid JSON string. The serialized claims must not be larger than 1000 characters.
+        /// </summary>
+        /// <returns>A task that completes when the claims have been set.</returns>
+        /// <exception cref="ArgumentException">If <paramref name="uid"/> is null, empty or longer
+        /// than 128 characters. Or, if the serialized <paramref name="claims"/> is larger than 1000
+        /// characters.</exception>
+        /// <param name="uid">The user ID string for the custom claims will be set. Must not be null
+        /// or longer than 128 characters.
+        /// </param>
+        /// <param name="claims">The claims to be stored on the user account, and made
+        /// available to Firebase security rules. These must be serializable to JSON, and after
+        /// serialization it should not be larger than 1000 characters.</param>
+        /// <param name="cancellationToken">A cancellation token to monitor the asynchronous
+        /// operation.</param>
+        public async Task SetCustomUserClaimsAsync(
+            string uid, IReadOnlyDictionary<string, object> claims, CancellationToken cancellationToken)
+        {
+            var userManager = this.IfNotDeleted(() => this.userManager.Value);
             var user = new UserRecord(uid)
             {
                 CustomClaims = claims,
             };
 
-            await this.userManager.Value.UpdateUserAsync(user);
+            await userManager.UpdateUserAsync(user, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -332,5 +332,18 @@ void IFirebaseService.Delete()
                 }
             }
         }
+
+        private TResult IfNotDeleted<TResult>(Func<TResult> func)
+        {
+            lock (this.authLock)
+            {
+                if (this.deleted)
+                {
+                    throw new InvalidOperationException("Cannot invoke after deleting the app.");
+                }
+
+                return func();
+            }
+        }
     }
 }

FirebaseAdmin/FirebaseAdmin/Auth/FirebaseUserManager.cs

@@ -14,9 +14,11 @@
 
 using System;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using Google.Apis.Auth.OAuth2;
 using Google.Apis.Http;
+using Google.Apis.Json;
 using Newtonsoft.Json.Linq;
 
 namespace FirebaseAdmin.Auth
@@ -64,22 +66,17 @@ public static FirebaseUserManager Create(FirebaseApp app)
         /// </summary>
         /// <exception cref="FirebaseException">If the server responds that cannot update the user.</exception>
         /// <param name="user">The user which we want to update.</param>
-        public async Task UpdateUserAsync(UserRecord user)
+        /// <param name="cancellationToken">A cancellation token to monitor the asynchronous
+        /// operation.</param>
+        public async Task UpdateUserAsync(
+            UserRecord user, CancellationToken cancellationToken = default(CancellationToken))
         {
-            var updatePath = "/accounts:update";
-            var resopnse = await this.PostAsync(updatePath, user);
-
-            try
-            {
-                var userResponse = resopnse.ToObject<UserRecord>();
-                if (userResponse.Uid != user.Uid)
-                {
-                    throw new FirebaseException($"Failed to update user: {user.Uid}");
-                }
-            }
-            catch (Exception e)
+            const string updatePath = "accounts:update";
+            var response = await this.PostAndDeserializeAsync<JObject>(
+                updatePath, user, cancellationToken).ConfigureAwait(false);
+            if (response["localId"]?.Value<string>() != user.Uid)
             {
-                throw new FirebaseException("Error while calling Firebase Auth service", e);
+                throw new FirebaseException($"Failed to update user: {user.Uid}");
             }
         }
 
@@ -88,31 +85,42 @@ public void Dispose()
             this.httpClient.Dispose();
         }
 
-        private async Task<JObject> PostAsync(string path, UserRecord user)
+        private async Task<TResult> PostAndDeserializeAsync<TResult>(
+            string path, object body, CancellationToken cancellationToken)
         {
-            var requestUri = $"{this.baseUrl}{path}";
-            HttpResponseMessage response = null;
             try
             {
-                response = await this.httpClient.PostJsonAsync(requestUri, user, default);
-                var json = await response.Content.ReadAsStringAsync();
-
-                if (response.IsSuccessStatusCode)
-                {
-                    return JObject.Parse(json);
-                }
-                else
-                {
-                    var error = "Response status code does not indicate success: "
-                            + $"{(int)response.StatusCode} ({response.StatusCode})"
-                            + $"{Environment.NewLine}{json}";
-                    throw new FirebaseException(error);
-                }
+                var json = await this.PostAsync(path, body, cancellationToken)
+                    .ConfigureAwait(false);
+                return NewtonsoftJsonSerializer.Instance.Deserialize<TResult>(json);
+            }
+            catch (FirebaseException)
+            {
+                throw;
             }
-            catch (HttpRequestException e)
+            catch (Exception e)
             {
                 throw new FirebaseException("Error while calling Firebase Auth service", e);
             }
         }
+
+        private async Task<string> PostAsync(
+            string path, object body, CancellationToken cancellationToken)
+        {
+            var requestUri = $"{this.baseUrl}/{path}";
+            var response = await this.httpClient
+                .PostJsonAsync(requestUri, body, cancellationToken)
+                .ConfigureAwait(false);
+            var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+            if (!response.IsSuccessStatusCode)
+            {
+                var error = "Response status code does not indicate success: "
+                        + $"{(int)response.StatusCode} ({response.StatusCode})"
+                        + $"{Environment.NewLine}{json}";
+                throw new FirebaseException(error);
+            }
+
+            return json;
+        }
     }
 }