Merge remote-tracking branch 'upstream/master' into list-users

Author: ChristopherLenz

CHANGELOG.md

@@ -1,8 +1,18 @@
 # Unreleased
 
-- [added] Implemented the `GetUserById()` API in the `FirebaseUserManager` class.
+- [added] Implemented the `UpdateUserAsync()` API.
+- [added] Implemented the `CreateUserAsync()` and `UserRecordArgs` APIs.
 
--
+# v1.6.0
+
+- [added] `WebpushFcmOptions` added to the `WebpushConfig` class.
+- [added] Implemented the `GetUserByEmailAsync()` and `GetUserByPhoneNumberAsync()`
+  APIs in the `FirebaseAuth` class.
+
+# v1.5.0
+
+- [added] Implemented the `GetUserAsync()` API in the `FirebaseAuth` class.
+- [added] Implemented the `DeleteUserAsync()` API in the `FirebaseAuth` class.
 
 # v1.4.0
 

FirebaseAdmin/FirebaseAdmin.IntegrationTests/FirebaseAuthTest.cs

@@ -119,7 +119,169 @@ public async Task SetCustomUserClaimsWithWrongUid()
             var customClaims = new Dictionary<string, object>();
 
             await Assert.ThrowsAsync<FirebaseException>(
-                async () => await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync("mock-uid", customClaims));
+                async () => await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync("non.existing", customClaims));
+        }
+
+        [Fact]
+        public async Task CreateUserWithParams()
+        {
+            var randomUser = RandomUser.Create();
+            var args = new UserRecordArgs()
+            {
+                Uid = randomUser.Uid,
+                Email = randomUser.Email,
+                PhoneNumber = randomUser.PhoneNumber,
+                DisplayName = "Random User",
+                PhotoUrl = "https://example.com/photo.png",
+                EmailVerified = true,
+                Password = "password",
+            };
+
+            var user = await FirebaseAuth.DefaultInstance.CreateUserAsync(args);
+
+            try
+            {
+                Assert.Equal(randomUser.Uid, user.Uid);
+                Assert.Equal(randomUser.Email, user.Email);
+                Assert.Equal(randomUser.PhoneNumber, user.PhoneNumber);
+                Assert.Equal(args.DisplayName, user.DisplayName);
+                Assert.Equal(args.PhotoUrl, user.PhotoUrl);
+                Assert.True(user.EmailVerified);
+                Assert.False(user.Disabled);
+
+                // Cannot recreate the same user.
+                await Assert.ThrowsAsync<FirebaseException>(
+                    async () => await FirebaseAuth.DefaultInstance.CreateUserAsync(args));
+            }
+            finally
+            {
+                await FirebaseAuth.DefaultInstance.DeleteUserAsync(user.Uid);
+            }
+        }
+
+        [Fact]
+        public async Task UserLifecycle()
+        {
+            // Create user
+            var user = await FirebaseAuth.DefaultInstance.CreateUserAsync(new UserRecordArgs());
+            var uid = user.Uid;
+            try
+            {
+                Assert.Null(user.Email);
+                Assert.Null(user.PhoneNumber);
+                Assert.Null(user.DisplayName);
+                Assert.Null(user.PhotoUrl);
+                Assert.False(user.EmailVerified);
+                Assert.False(user.Disabled);
+                Assert.NotNull(user.UserMetaData.CreationTimestamp);
+                Assert.Null(user.UserMetaData.LastSignInTimestamp);
+                Assert.Empty(user.ProviderData);
+                Assert.Empty(user.CustomClaims);
+
+                // Get user by ID
+                user = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
+                Assert.Equal(uid, user.Uid);
+                Assert.Null(user.Email);
+                Assert.Null(user.PhoneNumber);
+                Assert.Null(user.DisplayName);
+                Assert.Null(user.PhotoUrl);
+                Assert.False(user.EmailVerified);
+                Assert.False(user.Disabled);
+                Assert.NotNull(user.UserMetaData.CreationTimestamp);
+                Assert.Null(user.UserMetaData.LastSignInTimestamp);
+                Assert.Empty(user.ProviderData);
+                Assert.Empty(user.CustomClaims);
+
+                // Update user
+                var randomUser = RandomUser.Create();
+                var updateArgs = new UserRecordArgs()
+                {
+                    Uid = uid,
+                    DisplayName = "Updated Name",
+                    Email = randomUser.Email,
+                    PhoneNumber = randomUser.PhoneNumber,
+                    PhotoUrl = "https://example.com/photo.png",
+                    EmailVerified = true,
+                    Password = "secret",
+                };
+                user = await FirebaseAuth.DefaultInstance.UpdateUserAsync(updateArgs);
+                Assert.Equal(uid, user.Uid);
+                Assert.Equal(randomUser.Email, user.Email);
+                Assert.Equal(randomUser.PhoneNumber, user.PhoneNumber);
+                Assert.Equal("Updated Name", user.DisplayName);
+                Assert.Equal("https://example.com/photo.png", user.PhotoUrl);
+                Assert.True(user.EmailVerified);
+                Assert.False(user.Disabled);
+                Assert.NotNull(user.UserMetaData.CreationTimestamp);
+                Assert.Null(user.UserMetaData.LastSignInTimestamp);
+                Assert.Equal(2, user.ProviderData.Length);
+                Assert.Empty(user.CustomClaims);
+
+                // Get user by email
+                user = await FirebaseAuth.DefaultInstance.GetUserByEmailAsync(randomUser.Email);
+                Assert.Equal(uid, user.Uid);
+
+                // Disable user and remove properties
+                var disableArgs = new UserRecordArgs()
+                {
+                    Uid = uid,
+                    Disabled = true,
+                    DisplayName = null,
+                    PhoneNumber = null,
+                    PhotoUrl = null,
+                };
+                user = await FirebaseAuth.DefaultInstance.UpdateUserAsync(disableArgs);
+                Assert.Equal(uid, user.Uid);
+                Assert.Equal(randomUser.Email, user.Email);
+                Assert.Null(user.PhoneNumber);
+                Assert.Null(user.DisplayName);
+                Assert.Null(user.PhotoUrl);
+                Assert.True(user.EmailVerified);
+                Assert.True(user.Disabled);
+                Assert.NotNull(user.UserMetaData.CreationTimestamp);
+                Assert.Null(user.UserMetaData.LastSignInTimestamp);
+                Assert.Single(user.ProviderData);
+                Assert.Empty(user.CustomClaims);
+            }
+            finally
+            {
+                // Delete user
+                await FirebaseAuth.DefaultInstance.DeleteUserAsync(uid);
+                await Assert.ThrowsAsync<FirebaseException>(
+                    async () => await FirebaseAuth.DefaultInstance.GetUserAsync(uid));
+            }
+        }
+
+        [Fact]
+        public async Task GetUserNonExistingUid()
+        {
+            await Assert.ThrowsAsync<FirebaseException>(
+                async () => await FirebaseAuth.DefaultInstance.GetUserAsync("non.existing"));
+        }
+
+        [Fact]
+        public async Task GetUserNonExistingEmail()
+        {
+            await Assert.ThrowsAsync<FirebaseException>(
+                async () => await FirebaseAuth.DefaultInstance.GetUserByEmailAsync("[email protected]"));
+        }
+
+        [Fact]
+        public async Task UpdateUserNonExistingUid()
+        {
+            var args = new UserRecordArgs()
+            {
+                Uid = "non.existing",
+            };
+            await Assert.ThrowsAsync<FirebaseException>(
+                async () => await FirebaseAuth.DefaultInstance.UpdateUserAsync(args));
+        }
+
+        [Fact]
+        public async Task DeleteUserNonExistingUid()
+        {
+            await Assert.ThrowsAsync<FirebaseException>(
+                async () => await FirebaseAuth.DefaultInstance.DeleteUserAsync("non.existing"));
         }
 
         private static async Task<string> SignInWithCustomTokenAsync(string customToken)
@@ -163,4 +325,33 @@ internal class SignInResponse
         [Newtonsoft.Json.JsonProperty("idToken")]
         public string IdToken { get; set; }
     }
+
+    internal class RandomUser
+    {
+        internal string Uid { get; private set; }
+
+        internal string Email { get; private set; }
+
+        internal string PhoneNumber { get; private set; }
+
+        internal static RandomUser Create()
+        {
+            var uid = Guid.NewGuid().ToString().Replace("-", string.Empty);
+            var email = $"test{uid.Substring(0, 12)}@example.{uid.Substring(12)}.com";
+
+            var phone = "+1";
+            var rand = new Random();
+            for (int i = 0; i < 10; i++)
+            {
+                phone += rand.Next(10);
+            }
+
+            return new RandomUser()
+            {
+                Uid = uid,
+                Email = email,
+                PhoneNumber = phone,
+            };
+        }
+    }
 }

FirebaseAdmin/FirebaseAdmin.Snippets/FirebaseAuthSnippets.cs

@@ -57,5 +57,75 @@ internal static async Task VeridyIdTokenAsync(string idToken)
             // [END verify_id_token]
             Console.WriteLine("Decoded ID token from user: {0}", uid);
         }
+
+        internal static async Task GetUserAsync(string uid)
+        {
+            // [START get_user_by_id]
+            UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
+            // See the UserRecord reference doc for the contents of userRecord.
+            Console.WriteLine("Successfully fetched user data: {0}", userRecord.Uid);
+            // [END get_user_by_id]
+        }
+
+        internal static async Task GetUserByEmailAsync(string email)
+        {
+            // [START get_user_by_email]
+            UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByEmailAsync(email);
+            // See the UserRecord reference doc for the contents of userRecord.
+            Console.WriteLine("Successfully fetched user data: {0}", userRecord.Uid);
+            // [END get_user_by_email]
+        }
+
+        internal static async Task GetUserByPhoneNumberAsync(string phoneNumber)
+        {
+            // [START get_user_by_phone]
+            UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByPhoneNumberAsync(phoneNumber);
+            // See the UserRecord reference doc for the contents of userRecord.
+            Console.WriteLine("Successfully fetched user data: {0}", userRecord.Uid);
+            // [END get_user_by_phone]
+        }
+
+        internal static async Task DeleteUserAsync(string uid)
+        {
+            // [START delete_user]
+            await FirebaseAuth.DefaultInstance.DeleteUserAsync(uid);
+            Console.WriteLine("Successfully deleted user.");
+            // [END delete_user]
+        }
+
+        internal static async Task SetCustomUserClaimsAsync(string uid)
+        {
+            // [START set_custom_user_claims]
+            // Set admin privileges on the user corresponding to uid.
+            var claims = new Dictionary<string, object>()
+            {
+                { "admin", true },
+            };
+            await FirebaseAuth.DefaultInstance.SetCustomUserClaimsAsync(uid, claims);
+            // The new custom claims will propagate to the user's ID token the
+            // next time a new one is issued.
+            // [END set_custom_user_claims]
+
+            var idToken = "id_token";
+            // [START verify_custom_claims]
+            // Verify the ID token first.
+            FirebaseToken decoded = await FirebaseAuth.DefaultInstance.VerifyIdTokenAsync(idToken);
+            object isAdmin;
+            if (decoded.Claims.TryGetValue("admin", out isAdmin))
+            {
+                if ((bool)isAdmin)
+                {
+                    // Allow access to requested admin resource.
+                }
+            }
+
+            // [END verify_custom_claims]
+
+            // [START read_custom_user_claims]
+            // Lookup the user associated with the specified uid.
+            UserRecord user = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
+            Console.WriteLine(user.CustomClaims["admin"]);
+            // [END read_custom_user_claims]
+        }
     }
 }