Moved comment http logic to Extensions

Author: hiranya911

FirebaseAdmin/FirebaseAdmin/Auth/AuthHttpUtils.cs

@@ -71,6 +71,27 @@ internal static FirebaseUserManager Create(FirebaseApp app)
             return new FirebaseUserManager(args);
         }
 
+        internal static FirebaseAuthException HandleHttpError(HttpRequestException exception)
+        {
+            var temp = exception.ToFirebaseException();
+            return new FirebaseAuthException(
+                temp.ErrorCode,
+                temp.Message,
+                inner: temp.InnerException,
+                response: temp.HttpResponse);
+        }
+
+        internal static FirebaseAuthException HandleParseError(
+            Exception e, HttpResponseMessage response)
+        {
+            throw new FirebaseAuthException(
+                ErrorCode.Unknown,
+                "Error while parsing Auth service response.",
+                AuthErrorCode.UnexpectedResponse,
+                e,
+                response);
+        }
+
         /// <summary>
         /// Gets the user data corresponding to the given user ID.
         /// </summary>
@@ -256,15 +277,15 @@ private async Task<UserRecord> GetUserAsync(
             return new UserRecord(result.Users[0]);
         }
 
-        private async Task<AuthHttpUtils.ParsedResponseInfo<TResult>> PostAndDeserializeAsync<TResult>(
+        private async Task<Extensions.ParsedResponseInfo<TResult>> PostAndDeserializeAsync<TResult>(
             string path, object body, CancellationToken cancellationToken)
         {
             var response = await this.PostAsync(path, body, cancellationToken)
                 .ConfigureAwait(false);
-            return response.SafeDeserialize<TResult>();
+            return response.SafeDeserialize<TResult>(HandleParseError);
         }
 
-        private async Task<AuthHttpUtils.ResponseInfo> PostAsync(
+        private async Task<Extensions.ResponseInfo> PostAsync(
             string path, object body, CancellationToken cancellationToken)
         {
             var request = new HttpRequestMessage()
@@ -276,25 +297,15 @@ private async Task<UserRecord> GetUserAsync(
             return await this.SendAsync(request, cancellationToken).ConfigureAwait(false);
         }
 
-        private async Task<AuthHttpUtils.ResponseInfo> SendAsync(
+        private async Task<Extensions.ResponseInfo> SendAsync(
             HttpRequestMessage request, CancellationToken cancellationToken)
         {
-            var response = await this.httpClient.SendAndReadAsync(request, cancellationToken);
+            var response = await this.httpClient.SendAndReadAsync(
+                request, cancellationToken, HandleHttpError);
             this.errorHandler.ThrowIfError(response.HttpResponse, response.Body);
             return response;
         }
 
-        private FirebaseAuthException ToFirebaseAuthException(
-            HttpRequestException exception)
-        {
-            var temp = exception.ToFirebaseException();
-            return new FirebaseAuthException(
-                temp.ErrorCode,
-                temp.Message,
-                inner: temp.InnerException,
-                response: temp.HttpResponse);
-        }
-
         /// <summary>
         /// Represents a query that can be executed against the Firebase Auth service to retrieve user records.
         /// A query mainly consists of a <see cref="UserQuery.Field"/> and a <see cref="UserQuery.Value"/> (e.g.

FirebaseAdmin/FirebaseAdmin/Auth/FirebaseUserManager.cs

@@ -70,25 +70,26 @@ public HttpRequestMessage CreateRequest(bool? overrideGZipEnabled = null)
             };
         }
 
-        public Task<Stream> ExecuteAsStreamAsync()
+        public async Task<Stream> ExecuteAsStreamAsync()
         {
-            return this.ExecuteAsStreamAsync(default);
+            return await this.ExecuteAsStreamAsync(default).ConfigureAwait(false);
         }
 
-        public Task<Stream> ExecuteAsStreamAsync(CancellationToken cancellationToken)
+        public async Task<Stream> ExecuteAsStreamAsync(CancellationToken cancellationToken)
         {
-            var response = this.SendAsync(this.CreateRequest(), cancellationToken);
-            return response.Result.HttpResponse.Content.ReadAsStreamAsync();
+            var response = await this.httpClient.SendAsync(this.CreateRequest(), cancellationToken)
+                .ConfigureAwait(false);
+            return await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
         }
 
         public Stream ExecuteAsStream()
         {
             return this.ExecuteAsStreamAsync().Result;
         }
 
-        public Task<ExportedUserRecords> ExecuteAsync()
+        public async Task<ExportedUserRecords> ExecuteAsync()
         {
-            return this.ExecuteAsync(default);
+            return await this.ExecuteAsync(default).ConfigureAwait(false);
         }
 
         public async Task<ExportedUserRecords> ExecuteAsync(CancellationToken cancellationToken)
@@ -174,13 +175,15 @@ private async Task<DownloadAccountResponse> SendAndDeserializeAsync(
         {
             var response = await this.SendAsync(request, cancellationToken)
                 .ConfigureAwait(false);
-            return response.SafeDeserialize<DownloadAccountResponse>().Result;
+            return response.SafeDeserialize<DownloadAccountResponse>(
+                FirebaseUserManager.HandleParseError).Result;
         }
 
-        private async Task<AuthHttpUtils.ResponseInfo> SendAsync(
+        private async Task<Extensions.ResponseInfo> SendAsync(
             HttpRequestMessage request, CancellationToken cancellationToken)
         {
-            var response = await this.httpClient.SendAndReadAsync(request, cancellationToken)
+            var response = await this.httpClient.SendAndReadAsync(
+                request, cancellationToken, FirebaseUserManager.HandleHttpError)
                 .ConfigureAwait(false);
             this.errorHandler.ThrowIfError(response.HttpResponse, response.Body);
             return response;

FirebaseAdmin/FirebaseAdmin/Auth/ListUsersRequest.cs

@@ -42,6 +42,11 @@ internal static class Extensions
                 SocketError.NetworkUnreachable,
             };
 
+        internal delegate FirebaseException HttpErrorHandlerFunc(HttpRequestException e);
+
+        internal delegate FirebaseException ParseErrorHandlerFunc(
+            Exception e, HttpResponseMessage response);
+
         /// <summary>
         /// Extracts and returns the underlying <see cref="ServiceAccountCredential"/> from a
         /// <see cref="GoogleCredential"/>. Returns null if the <c>GoogleCredential</c> is not
@@ -187,5 +192,64 @@ public static FirebaseException ToFirebaseException(this HttpRequestException ex
 
             return new FirebaseException(code, $"{message}: {exception.Message}", exception);
         }
+
+        internal static async Task<ResponseInfo> SendAndReadAsync(
+            this ConfigurableHttpClient httpClient,
+            HttpRequestMessage request,
+            CancellationToken cancellationToken,
+            HttpErrorHandlerFunc func = null)
+        {
+            try
+            {
+                var response = await httpClient.SendAsync(request, cancellationToken)
+                    .ConfigureAwait(false);
+                var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+
+                return new ResponseInfo()
+                {
+                    HttpResponse = response,
+                    Body = json,
+                };
+            }
+            catch (HttpRequestException e)
+            {
+                if (func == null)
+                {
+                    throw e.ToFirebaseException();
+                }
+
+                throw func(e);
+            }
+        }
+
+        internal class ResponseInfo
+        {
+            internal HttpResponseMessage HttpResponse { get; set; }
+
+            internal string Body { get; set; }
+
+            internal ParsedResponseInfo<TResult> SafeDeserialize<TResult>(ParseErrorHandlerFunc func)
+            {
+                try
+                {
+                    var parsed = NewtonsoftJsonSerializer.Instance.Deserialize<TResult>(this.Body);
+                    return new ParsedResponseInfo<TResult>()
+                    {
+                        Result = parsed,
+                        HttpResponse = this.HttpResponse,
+                        Body = this.Body,
+                    };
+                }
+                catch (Exception e)
+                {
+                    throw func(e, this.HttpResponse);
+                }
+            }
+        }
+
+        internal class ParsedResponseInfo<T> : ResponseInfo
+        {
+            internal T Result { get; set; }
+        }
     }
 }