fix(auth): Fixing the error response parsing of ImportUsersAsync() (#224)

Author: hiranya911

FirebaseAdmin/FirebaseAdmin.Tests/Auth/FirebaseAuthTest.cs

@@ -162,25 +162,6 @@ await Assert.ThrowsAsync<ArgumentException>(
                 async () => await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync("user1", customClaims));
         }
 
-        [Fact]
-        public async Task ImportUsersPasswordNoHash()
-        {
-            var args = new ImportUserRecordArgs()
-            {
-                Uid = "123",
-                Email = "[email protected]",
-                PasswordSalt = Encoding.ASCII.GetBytes("abc"),
-                PasswordHash = Encoding.ASCII.GetBytes("def"),
-            };
-
-            var usersLst = new List<ImportUserRecordArgs>()
-            {
-                args,
-            };
-            await Assert.ThrowsAsync<NullReferenceException>(
-                async () => await FirebaseAuth.DefaultInstance.ImportUsersAsync(usersLst));
-        }
-
         public void Dispose()
         {
             FirebaseApp.DeleteAll();

FirebaseAdmin/FirebaseAdmin.Tests/Auth/FirebaseUserManagerTest.cs

@@ -18,7 +18,9 @@
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Text;
 using System.Threading.Tasks;
+using FirebaseAdmin.Auth.Hash;
 using FirebaseAdmin.Tests;
 using FirebaseAdmin.Util;
 using Google.Apis.Auth.OAuth2;
@@ -1871,6 +1873,183 @@ public async Task CreateSessionCookie()
             this.AssertClientVersion(handler.LastRequestHeaders);
         }
 
+        [Fact]
+        public async Task ImportUsers()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = "{}",
+            };
+            var auth = this.CreateFirebaseAuth(handler);
+            var users = new List<ImportUserRecordArgs>()
+            {
+                new ImportUserRecordArgs() { Uid = "user1" },
+                new ImportUserRecordArgs() { Uid = "user2" },
+            };
+
+            var result = await auth.ImportUsersAsync(users);
+
+            Assert.Equal(2, result.SuccessCount);
+            Assert.Equal(0, result.FailureCount);
+            Assert.Empty(result.Errors);
+
+            Assert.Equal(1, handler.Requests.Count);
+            var expected = new JObject()
+            {
+                {
+                    "users", new JArray()
+                    {
+                        new JObject() { { "localId", "user1" } },
+                        new JObject() { { "localId", "user2" } },
+                    }
+                },
+            };
+            var request = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(
+                handler.LastRequestBody);
+            Assert.True(JToken.DeepEquals(expected, request));
+            this.AssertClientVersion(handler.LastRequestHeaders);
+        }
+
+        [Fact]
+        public async Task ImportUsersError()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = @"{
+                    ""error"": [
+                        {""index"": 1, ""message"": ""test error""}
+                    ]
+                }",
+            };
+            var auth = this.CreateFirebaseAuth(handler);
+            var usersList = new List<ImportUserRecordArgs>()
+            {
+                new ImportUserRecordArgs() { Uid = "user1" },
+                new ImportUserRecordArgs() { Uid = "user2" },
+            };
+
+            var result = await auth.ImportUsersAsync(usersList);
+
+            Assert.Equal(1, result.SuccessCount);
+            Assert.Equal(1, result.FailureCount);
+            var error = Assert.Single(result.Errors);
+            Assert.Equal(1, error.Index);
+            Assert.Equal("test error", error.Reason);
+
+            Assert.Equal(1, handler.Requests.Count);
+            this.AssertClientVersion(handler.LastRequestHeaders);
+        }
+
+        [Fact]
+        public async Task ImportUsersWithPassword()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = "{}",
+            };
+            var auth = this.CreateFirebaseAuth(handler);
+            var password = Encoding.UTF8.GetBytes("password");
+            var usersList = new List<ImportUserRecordArgs>()
+            {
+                new ImportUserRecordArgs() { Uid = "user1" },
+                new ImportUserRecordArgs()
+                {
+                    Uid = "user2",
+                    PasswordHash = password,
+                },
+            };
+
+            var result = await auth.ImportUsersAsync(usersList, new UserImportOptions()
+            {
+                Hash = new Bcrypt(),
+            });
+
+            Assert.Equal(2, result.SuccessCount);
+            Assert.Equal(0, result.FailureCount);
+            Assert.Empty(result.Errors);
+
+            Assert.Equal(1, handler.Requests.Count);
+            var expected = new JObject()
+            {
+                {
+                    "users", new JArray()
+                    {
+                        new JObject() { { "localId", "user1" } },
+                        new JObject()
+                        {
+                            { "localId", "user2" },
+                            { "passwordHash", JwtUtils.UrlSafeBase64Encode(password) },
+                        },
+                    }
+                },
+                { "hashAlgorithm", "BCRYPT" },
+            };
+            var request = NewtonsoftJsonSerializer.Instance.Deserialize<JObject>(
+                handler.LastRequestBody);
+            Assert.True(JToken.DeepEquals(expected, request));
+            this.AssertClientVersion(handler.LastRequestHeaders);
+        }
+
+        [Fact]
+        public async Task ImportUsersMissingHash()
+        {
+            var auth = this.CreateFirebaseAuth(new MockMessageHandler());
+            var usersList = new List<ImportUserRecordArgs>()
+            {
+                new ImportUserRecordArgs() { Uid = "user1" },
+                new ImportUserRecordArgs()
+                {
+                    Uid = "user2",
+                    PasswordHash = Encoding.UTF8.GetBytes("password"),
+                },
+            };
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                () => auth.ImportUsersAsync(usersList));
+
+            Assert.Equal(
+                "UserImportHash option is required when at least one user has a password.",
+                exception.Message);
+        }
+
+        [Fact]
+        public async Task ImportUsersEmpty()
+        {
+            var auth = this.CreateFirebaseAuth(new MockMessageHandler());
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                () => auth.ImportUsersAsync(new List<ImportUserRecordArgs>()));
+
+            Assert.Equal("Users must not be null or empty.", exception.Message);
+        }
+
+        [Fact]
+        public async Task ImportUsersNull()
+        {
+            var auth = this.CreateFirebaseAuth(new MockMessageHandler());
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                () => auth.ImportUsersAsync(null));
+
+            Assert.Equal("Users must not be null or empty.", exception.Message);
+        }
+
+        [Fact]
+        public async Task ImportUsersExceedLimit()
+        {
+            var auth = this.CreateFirebaseAuth(new MockMessageHandler());
+            var users = new List<ImportUserRecordArgs>();
+            for (int i = 0; i < 1001; i++)
+            {
+                users.Add(new ImportUserRecordArgs() { Uid = $"user{i}" });
+            }
+
+            var exception = await Assert.ThrowsAsync<ArgumentException>(
+                () => auth.ImportUsersAsync(users));
+
+            Assert.Equal("Users list must not contain more than 1000 items.", exception.Message);
+        }
+
         [Fact]
         public async Task ServiceUnvailable()
         {

FirebaseAdmin/FirebaseAdmin/Auth/ErrorInfo.cs

@@ -13,15 +13,14 @@
 // limitations under the License.
 
 using System.Collections.Generic;
+using Newtonsoft.Json;
 
 namespace FirebaseAdmin.Auth
 {
-    // TODO(rsgowman): This class is expected to also be used for the
-    // ImportUsersAsync() method... once that exists.
-
     /// <summary>
-    /// Represents an error encountered while deleting users via the
-    /// <see cref="FirebaseAuth.DeleteUsersAsync(IReadOnlyList{string})"/> API.
+    /// Represents an error encountered while performing a batch operation such as
+    /// <see cref="FirebaseAuth.ImportUsersAsync(IEnumerable{ImportUserRecordArgs})"/> or
+    /// <see cref="FirebaseAuth.DeleteUsersAsync(IReadOnlyList{string})"/>.
     /// </summary>
     public sealed class ErrorInfo
     {
@@ -31,15 +30,18 @@ internal ErrorInfo(int index, string reason)
             this.Reason = reason;
         }
 
+        internal ErrorInfo() { }
+
         /// <summary>
-        /// Gets the index of the user that was unable to be deleted in the list passed to the
-        /// <see cref="FirebaseAuth.DeleteUsersAsync(IReadOnlyList{string})"/> method.
+        /// Gets the index of the entry that caused the error.
         /// </summary>
-        public int Index { get; }
+        [JsonProperty("index")]
+        public int Index { get; internal set; }
 
         /// <summary>
         /// Gets a string describing the error.
         /// </summary>
-        public string Reason { get; }
+        [JsonProperty("message")]
+        public string Reason { get; internal set; }
     }
 }

FirebaseAdmin/FirebaseAdmin/Auth/FirebaseAuth.cs

@@ -812,7 +812,7 @@ public async Task<UserImportResult> ImportUsersAsync(
         {
           var request = new UserImportRequest(users, options);
           var userManager = this.IfNotDeleted(() => this.userManager.Value);
-          return await userManager.ImportUsersAsync(request, cancellationToken);
+          return await userManager.ImportUsersAsync(users, options, cancellationToken);
         }
 
         /// <summary>

FirebaseAdmin/FirebaseAdmin/Auth/FirebaseUserManager.cs

@@ -230,23 +230,14 @@ internal async Task<string> CreateUserAsync(
         }
 
         internal async Task<UserImportResult> ImportUsersAsync(
-          UserImportRequest request,
-          CancellationToken cancellationToken)
+            IEnumerable<ImportUserRecordArgs> users,
+            UserImportOptions options,
+            CancellationToken cancellationToken)
         {
-            if (request == null)
-            {
-                throw new ArgumentNullException("The UserImportRequest request should not be null");
-            }
-
+            var request = new UserImportRequest(users, options);
             var response = await this.PostAndDeserializeAsync<UploadAccountResponse>(
                 "accounts:batchCreate", request, cancellationToken).ConfigureAwait(false);
-            var uploadAccountResponse = response.Result;
-            if (uploadAccountResponse == null)
-            {
-                throw new FirebaseAuthException(ErrorCode.Internal, "Failed to import users.");
-            }
-
-            return new UserImportResult(request.GetUsersCount(), uploadAccountResponse.Errors);
+            return new UserImportResult(request.UserCount, response.Result.Errors);
         }
 
         /// <summary>
@@ -439,11 +430,8 @@ internal sealed class Args
         /// </summary>
         internal sealed class UploadAccountResponse
         {
-            /// <summary>
-            /// Gets the list of errors populated after a user import request by the identity toolkit.
-            /// </summary>
             [JsonProperty("error")]
-            public IReadOnlyList<ErrorInfo> Errors { get; }
+            internal List<ErrorInfo> Errors { get; set; }
         }
 
         /// <summary>

FirebaseAdmin/FirebaseAdmin/Auth/ImportUserRecordArgs.cs

@@ -21,8 +21,8 @@ namespace FirebaseAdmin.Auth
 {
     /// <summary>
     /// Represents a user account to be imported to Firebase Auth via the
-    /// <a cref="o:FirebaseAuth.ImportUsersAsync">FirebaseAuth.ImportUsersAsync</a> API. Must contain at least a
-    /// user ID string.
+    /// <see cref="FirebaseAuth.ImportUsersAsync(IEnumerable{ImportUserRecordArgs})"/> API. Must
+    /// contain at least a user ID string.
     /// </summary>
     public sealed class ImportUserRecordArgs
     {

FirebaseAdmin/FirebaseAdmin/Auth/UserImportHash.cs

@@ -50,13 +50,8 @@ protected UserImportHash(string hashName)
         /// Retrieves the properties of the chosen hashing algorithm.
         /// </summary>
         /// <returns>Dictionary containing the specified properties of the hashing algorithm.</returns>
-        internal IReadOnlyDictionary<string, object> GetProperties()
+        internal Dictionary<string, object> GetProperties()
         {
-            if (string.IsNullOrEmpty(this.hashName))
-            {
-                throw new ArgumentException("User import hash name must not be null or empty.");
-            }
-
             var options = this.GetHashConfiguration();
             var properties = new Dictionary<string, object>();
             foreach (var entry in options)

FirebaseAdmin/FirebaseAdmin/Auth/UserImportOptions.cs

@@ -33,7 +33,7 @@ public sealed class UserImportOptions
         /// Retrieves properties of the password hashing algorithm.
         /// </summary>
         /// <returns>Dictionary containing key/values for password hashing properties.</returns>
-        internal IReadOnlyDictionary<string, object> GetHashProperties()
+        internal Dictionary<string, object> GetHashProperties()
         {
             if (this.Hash == null)
             {