Tests for UpdateUser API

Author: hiranya911

FirebaseAdmin/FirebaseAdmin.Tests/Auth/FirebaseUserManagerTest.cs

@@ -501,6 +501,19 @@ public async Task CreateUserShortPassword()
             Assert.Null(handler.Request);
         }
 
+        [Fact]
+        public async Task CreateUserIncorrectResponse()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = "{}",
+            };
+            var userManager = this.CreateFirebaseUserManager(handler);
+
+            var args = new UserRecordArgs();
+            await Assert.ThrowsAsync<FirebaseException>(async () => await userManager.CreateUserAsync(args));
+        }
+
         [Fact]
         public async Task UpdateUser()
         {
@@ -513,13 +526,114 @@ public async Task UpdateUser()
                     { "package", "gold" },
             };
 
+            await userManager.UpdateUserAsync(new UserRecordArgs()
+            {
+                CustomClaims = customClaims,
+                Disabled = true,
+                DisplayName = "Test User",
+                Email = "[email protected]",
+                EmailVerified = true,
+                Password = "secret",
+                PhoneNumber = "+1234567890",
+                PhotoUrl = "https://example.com/user.png",
+                Uid = "user1",
+            });
+
+            var request = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(handler.Request);
+            Assert.Equal("user1", request["localId"]);
+            Assert.True((bool)request["disableUser"]);
+            Assert.Equal("Test User", request["displayName"]);
+            Assert.Equal("[email protected]", request["email"]);
+            Assert.True((bool)request["emailVerified"]);
+            Assert.Equal("secret", request["password"]);
+            Assert.Equal("+1234567890", request["phoneNumber"]);
+            Assert.Equal("https://example.com/user.png", request["photoUrl"]);
+
+            var claims = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>((string)request["customAttributes"]);
+            Assert.True((bool)claims["admin"]);
+            Assert.Equal(4L, claims["level"]);
+            Assert.Equal("gold", claims["package"]);
+        }
+
+        [Fact]
+        public async Task UpdateUserPartial()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+
+            await userManager.UpdateUserAsync(new UserRecordArgs()
+            {
+                EmailVerified = true,
+                Uid = "user1",
+            });
+
+            var request = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(handler.Request);
+            Assert.Equal(2, request.Count);
+            Assert.Equal("user1", request["localId"]);
+            Assert.True((bool)request["emailVerified"]);
+        }
+
+        [Fact]
+        public async Task UpdateUserRemoveAttributes()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+
+            await userManager.UpdateUserAsync(new UserRecordArgs()
+            {
+                DisplayName = null,
+                PhotoUrl = null,
+                Uid = "user1",
+            });
+
+            var request = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(handler.Request);
+            Assert.Equal(2, request.Count);
+            Assert.Equal("user1", request["localId"]);
+            Assert.Equal(
+                new JArray() { "DISPLAY_NAME", "PHOTO_URL" },
+                request["deleteAttribute"]);
+        }
+
+        [Fact]
+        public async Task UpdateUserRemoveProviders()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+
+            await userManager.UpdateUserAsync(new UserRecordArgs()
+            {
+                PhoneNumber = null,
+                Uid = "user1",
+            });
+
+            var request = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(handler.Request);
+            Assert.Equal(2, request.Count);
+            Assert.Equal("user1", request["localId"]);
+            Assert.Equal(
+                new JArray() { "phone" },
+                request["deleteProvider"]);
+        }
+
+        [Fact]
+        public async Task UpdateUserSetCustomClaims()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+            var customClaims = new Dictionary<string, object>()
+            {
+                    { "admin", true },
+                    { "level", 4 },
+                    { "package", "gold" },
+            };
+
             await userManager.UpdateUserAsync(new UserRecordArgs()
             {
                 Uid = "user1",
                 CustomClaims = customClaims,
             });
 
             var request = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(handler.Request);
+            Assert.Equal(2, request.Count);
             Assert.Equal("user1", request["localId"]);
             var claims = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>((string)request["customAttributes"]);
             Assert.True((bool)claims["admin"]);
@@ -605,34 +719,155 @@ public void UpdateUserNoUid()
         {
             var handler = new MockMessageHandler() { Response = CreateUserResponse };
             var userManager = this.CreateFirebaseUserManager(handler);
-            var customClaims = new Dictionary<string, object>()
+
+            var args = new UserRecordArgs()
             {
-                    { "key", "value" },
+                EmailVerified = true,
             };
+            Assert.ThrowsAsync<ArgumentException>(async () => await userManager.UpdateUserAsync(args));
+        }
+
+        [Fact]
+        public void UpdateUserInvalidUid()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
 
             var args = new UserRecordArgs()
             {
-                CustomClaims = customClaims,
+                EmailVerified = true,
+                Uid = new string('a', 129),
             };
             Assert.ThrowsAsync<ArgumentException>(async () => await userManager.UpdateUserAsync(args));
         }
 
         [Fact]
-        public void UpdateUserInvalidUid()
+        public async Task UpdateUserEmptyUid()
         {
             var handler = new MockMessageHandler() { Response = CreateUserResponse };
             var userManager = this.CreateFirebaseUserManager(handler);
-            var customClaims = new Dictionary<string, object>()
+            var args = new UserRecordArgs()
             {
-                    { "key", "value" },
+                Uid = string.Empty,
             };
 
+            await Assert.ThrowsAsync<ArgumentException>(async () => await userManager.UpdateUserAsync(args));
+            Assert.Null(handler.Request);
+        }
+
+        [Fact]
+        public async Task UpdateUserEmptyEmail()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
             var args = new UserRecordArgs()
             {
-                Uid = new string('a', 129),
-                CustomClaims = customClaims,
+                Email = string.Empty,
+                Uid = "user1",
             };
-            Assert.ThrowsAsync<ArgumentException>(async () => await userManager.UpdateUserAsync(args));
+
+            await Assert.ThrowsAsync<ArgumentException>(
+                async () => await userManager.UpdateUserAsync(args));
+            Assert.Null(handler.Request);
+        }
+
+        [Fact]
+        public async Task UpdateUserInvalidEmail()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+            var args = new UserRecordArgs()
+            {
+                Email = "not-an-email",
+                Uid = "user1",
+            };
+
+            await Assert.ThrowsAsync<ArgumentException>(
+                async () => await userManager.UpdateUserAsync(args));
+            Assert.Null(handler.Request);
+        }
+
+        [Fact]
+        public async Task UpdateUserEmptyPhoneNumber()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+            var args = new UserRecordArgs()
+            {
+                PhoneNumber = string.Empty,
+                Uid = "user1",
+            };
+
+            await Assert.ThrowsAsync<ArgumentException>(
+                async () => await userManager.UpdateUserAsync(args));
+            Assert.Null(handler.Request);
+        }
+
+        [Fact]
+        public async Task UpdateUserInvalidPhoneNumber()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+            var args = new UserRecordArgs()
+            {
+                PhoneNumber = "1234567890",
+                Uid = "user1",
+            };
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                async () => await userManager.UpdateUserAsync(args));
+            Assert.Equal(
+                "Phone number must be a valid, E.164 compliant identifier starting with a '+' sign.",
+                exception.Message);
+            Assert.Null(handler.Request);
+        }
+
+        [Fact]
+        public async Task UpdateUserEmptyPhotoUrl()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+            var args = new UserRecordArgs()
+            {
+                PhotoUrl = string.Empty,
+                Uid = "user1",
+            };
+
+            await Assert.ThrowsAsync<ArgumentException>(
+                async () => await userManager.UpdateUserAsync(args));
+            Assert.Null(handler.Request);
+        }
+
+        [Fact]
+        public async Task UpdateUserInvalidPhotoUrl()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+            var args = new UserRecordArgs()
+            {
+                PhotoUrl = "not a url",
+                Uid = "user1",
+            };
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                async () => await userManager.UpdateUserAsync(args));
+            Assert.Null(handler.Request);
+        }
+
+        [Fact]
+        public async Task UpdateUserShortPassword()
+        {
+            var handler = new MockMessageHandler() { Response = CreateUserResponse };
+            var userManager = this.CreateFirebaseUserManager(handler);
+            var args = new UserRecordArgs()
+            {
+                Password = "only5",
+                Uid = "user1",
+            };
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                async () => await userManager.UpdateUserAsync(args));
+            Assert.Null(handler.Request);
         }
 
         [Fact]

FirebaseAdmin/FirebaseAdmin/Auth/FirebaseAuth.cs

@@ -403,6 +403,44 @@ public async Task<UserRecord> GetUserByPhoneNumberAsync(
                 .ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Updates an existing user account with the attributes contained in the specified <see cref="UserRecordArgs"/>.
+        /// The <see cref="UserRecordArgs.Uid"/> property must be specified.
+        /// </summary>
+        /// <param name="args">Attributes that will be updated.</param>
+        /// <returns>A task that completes with a <see cref="UserRecord"/> representing
+        /// the updated user account.</returns>
+        /// <exception cref="ArgumentNullException">If <paramref name="args"/> is null.</exception>
+        /// <exception cref="ArgumentException">If any of the values in <paramref name="args"/> are invalid.</exception>
+        /// <exception cref="FirebaseException">If an error occurs while updating the user account.</exception>
+        public async Task<UserRecord> UpdateUserAsync(UserRecordArgs args)
+        {
+            return await this.UpdateUserAsync(args, default(CancellationToken))
+                .ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Updates an existing user account with the attributes contained in the specified <see cref="UserRecordArgs"/>.
+        /// The <see cref="UserRecordArgs.Uid"/> property must be specified.
+        /// </summary>
+        /// <param name="args">Attributes that will be updated.</param>
+        /// <param name="cancellationToken">A cancellation token to monitor the asynchronous
+        /// operation.</param>
+        /// <returns>A task that completes with a <see cref="UserRecord"/> representing
+        /// the updated user account.</returns>
+        /// <exception cref="ArgumentNullException">If <paramref name="args"/> is null.</exception>
+        /// <exception cref="ArgumentException">If any of the values in <paramref name="args"/> are invalid.</exception>
+        /// <exception cref="FirebaseException">If an error occurs while updating the user account.</exception>
+        public async Task<UserRecord> UpdateUserAsync(
+            UserRecordArgs args, CancellationToken cancellationToken)
+        {
+            var userManager = this.IfNotDeleted(() => this.userManager.Value);
+            var uid = await userManager.UpdateUserAsync(args, cancellationToken)
+                .ConfigureAwait(false);
+            return await userManager.GetUserByIdAsync(uid, cancellationToken)
+                .ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Deletes the user identified by the specified <paramref name="uid"/>.
         /// </summary>

FirebaseAdmin/FirebaseAdmin/Auth/FirebaseUserManager.cs

@@ -168,7 +168,7 @@ internal async Task<string> CreateUserAsync(
         /// <param name="args">The user account data to be updated.</param>
         /// <param name="cancellationToken">A cancellation token to monitor the asynchronous
         /// operation.</param>
-        internal async Task UpdateUserAsync(
+        internal async Task<string> UpdateUserAsync(
             UserRecordArgs args, CancellationToken cancellationToken = default(CancellationToken))
         {
             var payload = args.ToUpdateUserRequest();
@@ -178,6 +178,8 @@ internal async Task UpdateUserAsync(
             {
                 throw new FirebaseException($"Failed to update user: {payload.Uid}");
             }
+
+            return payload.Uid;
         }
 
         /// <summary>