fix(auth): Integration tests and sample snippets for email action links (#166)

* Added integration tests and sample snippets

* Fixing some lint errors in the snippets

Author: hiranya911

FirebaseAdmin/FirebaseAdmin.IntegrationTests/FirebaseAuthTest.cs

@@ -18,6 +18,7 @@
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
+using System.Web;
 using FirebaseAdmin.Auth;
 using Google.Apis.Auth.OAuth2;
 using Google.Apis.Util;
@@ -27,9 +28,23 @@ namespace FirebaseAdmin.IntegrationTests
 {
     public class FirebaseAuthTest
     {
+        private const string EmailLinkSignInUrl =
+            "https://www.googleapis.com/identitytoolkit/v3/relyingparty/emailLinkSignin";
+
+        private const string ResetPasswordUrl =
+            "https://www.googleapis.com/identitytoolkit/v3/relyingparty/resetPassword";
+
         private const string VerifyCustomTokenUrl =
             "https://www.googleapis.com/identitytoolkit/v3/relyingparty/verifyCustomToken";
 
+        private const string ContinueUrl = "http://localhost/?a=1&b=2#c=3";
+
+        private static readonly ActionCodeSettings EmailLinkSettings = new ActionCodeSettings()
+        {
+            Url = ContinueUrl,
+            HandleCodeInApp = false,
+        };
+
         public FirebaseAuthTest()
         {
             IntegrationTestUtils.EnsureDefaultApp();
@@ -365,6 +380,100 @@ public async Task ListUsers()
             }
         }
 
+        [Fact]
+        public async Task EmailVerificationLink()
+        {
+            var user = await CreateUserForActionLinksAsync();
+
+            try
+            {
+                var link = await FirebaseAuth.DefaultInstance.GenerateEmailVerificationLinkAsync(
+                    user.Email, EmailLinkSettings);
+
+                var uri = new Uri(link);
+                var query = HttpUtility.ParseQueryString(uri.Query);
+                Assert.Equal(ContinueUrl, query["continueUrl"]);
+                Assert.Equal("verifyEmail", query["mode"]);
+            }
+            finally
+            {
+                await FirebaseAuth.DefaultInstance.DeleteUserAsync(user.Uid);
+            }
+        }
+
+        [Fact]
+        public async Task PasswordResetLink()
+        {
+            var user = await CreateUserForActionLinksAsync();
+
+            try
+            {
+                var link = await FirebaseAuth.DefaultInstance.GeneratePasswordResetLinkAsync(
+                    user.Email, EmailLinkSettings);
+
+                var uri = new Uri(link);
+                var query = HttpUtility.ParseQueryString(uri.Query);
+                Assert.Equal(ContinueUrl, query["continueUrl"]);
+
+                var request = new ResetPasswordRequest()
+                {
+                    Email = user.Email,
+                    OldPassword = "password",
+                    NewPassword = "NewP@$$w0rd",
+                    OobCode = query["oobCode"],
+                };
+                var resetEmail = await ResetPasswordAsync(request);
+                Assert.Equal(user.Email, resetEmail);
+
+                // Password reset also verifies the user's email
+                user = await FirebaseAuth.DefaultInstance.GetUserAsync(user.Uid);
+                Assert.True(user.EmailVerified);
+            }
+            finally
+            {
+                await FirebaseAuth.DefaultInstance.DeleteUserAsync(user.Uid);
+            }
+        }
+
+        [Fact]
+        public async Task SignInWithEmailLink()
+        {
+            var user = await CreateUserForActionLinksAsync();
+
+            try
+            {
+                var link = await FirebaseAuth.DefaultInstance.GenerateSignInWithEmailLinkAsync(
+                    user.Email, EmailLinkSettings);
+
+                var uri = new Uri(link);
+                var query = HttpUtility.ParseQueryString(uri.Query);
+                Assert.Equal(ContinueUrl, query["continueUrl"]);
+
+                var idToken = await SignInWithEmailLinkAsync(user.Email, query["oobCode"]);
+                Assert.NotEmpty(idToken);
+
+                // Sign in with link also verifies the user's email
+                user = await FirebaseAuth.DefaultInstance.GetUserAsync(user.Uid);
+                Assert.True(user.EmailVerified);
+            }
+            finally
+            {
+                await FirebaseAuth.DefaultInstance.DeleteUserAsync(user.Uid);
+            }
+        }
+
+        private static async Task<UserRecord> CreateUserForActionLinksAsync()
+        {
+            var randomUser = RandomUser.Create();
+            return await FirebaseAuth.DefaultInstance.CreateUserAsync(new UserRecordArgs()
+            {
+                Uid = randomUser.Uid,
+                Email = randomUser.Email,
+                EmailVerified = false,
+                Password = "password",
+            });
+        }
+
         private static async Task<string> SignInWithCustomTokenAsync(string customToken)
         {
             var rb = new Google.Apis.Requests.RequestBuilder()
@@ -390,6 +499,59 @@ private static async Task<string> SignInWithCustomTokenAsync(string customToken)
                 return parsed.IdToken;
             }
         }
+
+        private static async Task<string> SignInWithEmailLinkAsync(string email, string oobCode)
+        {
+            var rb = new Google.Apis.Requests.RequestBuilder()
+            {
+                Method = Google.Apis.Http.HttpConsts.Post,
+                BaseUri = new Uri(EmailLinkSignInUrl),
+            };
+            rb.AddParameter(RequestParameterType.Query, "key", IntegrationTestUtils.GetApiKey());
+
+            var data = new Dictionary<string, object>()
+            {
+                { "email", email },
+                { "oobCode", oobCode },
+            };
+            var jsonSerializer = Google.Apis.Json.NewtonsoftJsonSerializer.Instance;
+            var payload = jsonSerializer.Serialize(data);
+
+            var request = rb.CreateRequest();
+            request.Content = new StringContent(payload, Encoding.UTF8, "application/json");
+            using (var client = new HttpClient())
+            {
+                var response = await client.SendAsync(request);
+                response.EnsureSuccessStatusCode();
+                var json = await response.Content.ReadAsStringAsync();
+                var parsed = jsonSerializer.Deserialize<Dictionary<string, object>>(json);
+                return (string)parsed["idToken"];
+            }
+        }
+
+        private static async Task<string> ResetPasswordAsync(ResetPasswordRequest data)
+        {
+            var rb = new Google.Apis.Requests.RequestBuilder()
+            {
+                Method = Google.Apis.Http.HttpConsts.Post,
+                BaseUri = new Uri(ResetPasswordUrl),
+            };
+            rb.AddParameter(RequestParameterType.Query, "key", IntegrationTestUtils.GetApiKey());
+
+            var jsonSerializer = Google.Apis.Json.NewtonsoftJsonSerializer.Instance;
+            var payload = jsonSerializer.Serialize(data);
+
+            var request = rb.CreateRequest();
+            request.Content = new StringContent(payload, Encoding.UTF8, "application/json");
+            using (var client = new HttpClient())
+            {
+                var response = await client.SendAsync(request);
+                response.EnsureSuccessStatusCode();
+                var json = await response.Content.ReadAsStringAsync();
+                var parsed = jsonSerializer.Deserialize<Dictionary<string, object>>(json);
+                return (string)parsed["email"];
+            }
+        }
     }
 
     /**
@@ -406,6 +568,21 @@ internal static void NotNull(object obj, string msg)
         }
     }
 
+    internal class ResetPasswordRequest
+    {
+        [Newtonsoft.Json.JsonProperty("email")]
+        public string Email { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("oldPassword")]
+        public string OldPassword { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("newPassword")]
+        public string NewPassword { get; set; }
+
+        [Newtonsoft.Json.JsonProperty("oobCode")]
+        public string OobCode { get; set; }
+    }
+
     internal class SignInRequest
     {
         [Newtonsoft.Json.JsonProperty("token")]

FirebaseAdmin/FirebaseAdmin.Snippets/FirebaseAuthSnippets.cs

@@ -245,5 +245,68 @@ internal static async Task SetCustomUserClaimsIncrementalAsync()
 
             // [END set_custom_user_claims_incremental]
         }
+
+        internal static ActionCodeSettings InitActionCodeSettings()
+        {
+            // [START init_action_code_settings]
+            var actionCodeSettings = new ActionCodeSettings()
+            {
+                Url = "https://www.example.com/checkout?cartId=1234",
+                HandleCodeInApp = true,
+                IosBundleId = "com.example.ios",
+                AndroidPackageName = "com.example.android",
+                AndroidInstallApp = true,
+                AndroidMinimumVersion = "12",
+                DynamicLinkDomain = "coolapp.page.link",
+            };
+            // [END init_action_code_settings]
+            return actionCodeSettings;
+        }
+
+        internal static async Task GeneratePasswordResetLink()
+        {
+            var actionCodeSettings = InitActionCodeSettings();
+            var displayName = "Example User";
+            // [START password_reset_link]
+            var email = "[email protected]";
+            var link = await FirebaseAuth.DefaultInstance.GeneratePasswordResetLinkAsync(
+                email, actionCodeSettings);
+            // Construct email verification template, embed the link and send
+            // using custom SMTP server.
+            SendCustomEmail(email, displayName, link);
+            // [END password_reset_link]
+        }
+
+        internal static async Task GenerateEmailVerificationLink()
+        {
+            var actionCodeSettings = InitActionCodeSettings();
+            var displayName = "Example User";
+            // [START email_verification_link]
+            var email = "[email protected]";
+            var link = await FirebaseAuth.DefaultInstance.GenerateEmailVerificationLinkAsync(
+                email, actionCodeSettings);
+            // Construct email verification template, embed the link and send
+            // using custom SMTP server.
+            SendCustomEmail(email, displayName, link);
+            // [END email_verification_link]
+        }
+
+        internal static async Task GenerateSignInWithEmailLink()
+        {
+            var actionCodeSettings = InitActionCodeSettings();
+            var displayName = "Example User";
+            // [START sign_in_with_email_link]
+            var email = "[email protected]";
+            var link = await FirebaseAuth.DefaultInstance.GenerateSignInWithEmailLinkAsync(
+                email, actionCodeSettings);
+            // Construct email verification template, embed the link and send
+            // using custom SMTP server.
+            SendCustomEmail(email, displayName, link);
+            // [END sign_in_with_email_link]
+        }
+
+        // Place holder method to make the compiler happy. This is referenced by all email action
+        // link snippets.
+        private static void SendCustomEmail(string email, string displayName, string link) { }
     }
 }