Exposing FirebaseMessagingException from SendResponse; Additional tests

Author: hiranya911

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/FirebaseMessagingClientTest.cs

@@ -207,12 +207,11 @@ public async Task SendAllAsyncWithError()
   ""error"": {
     ""code"": 400,
     ""message"": ""The registration token is not a valid FCM registration token"",
-    ""errors"": [
-      {
-        ""message"": ""The registration token is not a valid FCM registration token"",
-        ""domain"": ""global"",
-        ""reason"": ""badRequest""
-      }
+    ""details"": [
+        {
+            ""@type"": ""type.googleapis.com/google.firebase.fcm.v1.FcmError"",
+            ""errorCode"": ""UNREGISTERED""
+        }
     ],
     ""status"": ""INVALID_ARGUMENT""
   }
@@ -245,7 +244,87 @@ public async Task SendAllAsyncWithError()
             Assert.Equal(1, response.SuccessCount);
             Assert.Equal(1, response.FailureCount);
             Assert.Equal("projects/fir-adminintegrationtests/messages/8580920590356323124", response.Responses[0].MessageId);
-            Assert.NotNull(response.Responses[1].Exception);
+
+            var exception = response.Responses[1].Exception;
+            Assert.NotNull(exception);
+            Assert.Equal(ErrorCode.InvalidArgument, exception.ErrorCode);
+            Assert.Equal("The registration token is not a valid FCM registration token", exception.Message);
+            Assert.Equal(MessagingErrorCode.Unregistered, exception.MessagingErrorCode);
+            Assert.NotNull(exception.HttpResponse);
+
+            Assert.Equal(1, handler.Calls);
+            var versionHeader = $"X-Firebase-Client: {FirebaseMessagingClient.ClientVersion}";
+            Assert.Equal(2, this.CountLinesWithPrefix(handler.LastRequestBody, versionHeader));
+        }
+
+        [Fact]
+        public async Task SendAllAsyncWithErrorNoDetail()
+        {
+            var rawResponse = @"
+--batch_test-boundary
+Content-Type: application/http
+Content-ID: response-
+
+HTTP/1.1 200 OK
+Content-Type: application/json; charset=UTF-8
+Vary: Origin
+Vary: X-Origin
+Vary: Referer
+
+{
+  ""name"": ""projects/fir-adminintegrationtests/messages/8580920590356323124""
+}
+
+--batch_test-boundary
+Content-Type: application/http
+Content-ID: response-
+
+HTTP/1.1 400 Bad Request
+Content-Type: application/json; charset=UTF-8
+
+{
+  ""error"": {
+    ""code"": 400,
+    ""message"": ""The registration token is not a valid FCM registration token"",
+    ""status"": ""INVALID_ARGUMENT""
+  }
+}
+
+--batch_test-boundary
+";
+            var handler = new MockMessageHandler()
+            {
+                Response = rawResponse,
+                ApplyHeaders = (_, headers) =>
+                {
+                    headers.Remove("Content-Type");
+                    headers.TryAddWithoutValidation("Content-Type", "multipart/mixed; boundary=batch_test-boundary");
+                },
+            };
+            var factory = new MockHttpClientFactory(handler);
+            var client = new FirebaseMessagingClient(factory, MockCredential, "test-project");
+            var message1 = new Message()
+            {
+                Token = "test-token1",
+            };
+            var message2 = new Message()
+            {
+                Token = "test-token2",
+            };
+
+            var response = await client.SendAllAsync(new[] { message1, message2 });
+
+            Assert.Equal(1, response.SuccessCount);
+            Assert.Equal(1, response.FailureCount);
+            Assert.Equal("projects/fir-adminintegrationtests/messages/8580920590356323124", response.Responses[0].MessageId);
+
+            var exception = response.Responses[1].Exception;
+            Assert.NotNull(exception);
+            Assert.Equal(ErrorCode.InvalidArgument, exception.ErrorCode);
+            Assert.Equal("The registration token is not a valid FCM registration token", exception.Message);
+            Assert.Null(exception.MessagingErrorCode);
+            Assert.NotNull(exception.HttpResponse);
+
             Assert.Equal(1, handler.Calls);
             var versionHeader = $"X-Firebase-Client: {FirebaseMessagingClient.ClientVersion}";
             Assert.Equal(2, this.CountLinesWithPrefix(handler.LastRequestBody, versionHeader));
@@ -279,6 +358,82 @@ public async Task SendAllAsyncWithTooManyMessages()
 
         [Fact]
         public async Task HttpErrorAsync()
+        {
+            var handler = new MockMessageHandler()
+            {
+                StatusCode = HttpStatusCode.InternalServerError,
+                Response = @"{
+                    ""error"": {
+                        ""status"": ""PERMISSION_DENIED"",
+                        ""message"": ""test error"",
+                        ""details"": [
+                            {
+                                ""@type"": ""type.googleapis.com/google.firebase.fcm.v1.FcmError"",
+                                ""errorCode"": ""UNREGISTERED""
+                            }
+                        ]
+                    }
+                }",
+            };
+            var factory = new MockHttpClientFactory(handler);
+            var client = new FirebaseMessagingClient(factory, MockCredential, "test-project");
+            var message = new Message()
+            {
+                Topic = "test-topic",
+            };
+
+            var ex = await Assert.ThrowsAsync<FirebaseMessagingException>(
+                async () => await client.SendAsync(message));
+
+            Assert.Equal(ErrorCode.PermissionDenied, ex.ErrorCode);
+            Assert.Equal("test error", ex.Message);
+            Assert.Equal(MessagingErrorCode.Unregistered, ex.MessagingErrorCode);
+            Assert.NotNull(ex.HttpResponse);
+
+            var req = JsonConvert.DeserializeObject<FirebaseMessagingClient.SendRequest>(
+                handler.LastRequestBody);
+            Assert.Equal("test-topic", req.Message.Topic);
+            Assert.False(req.ValidateOnly);
+            Assert.Equal(1, handler.Calls);
+        }
+
+        [Fact]
+        public async Task HttpErrorNoDetailAsync()
+        {
+            var handler = new MockMessageHandler()
+            {
+                StatusCode = HttpStatusCode.InternalServerError,
+                Response = @"{
+                    ""error"": {
+                        ""status"": ""PERMISSION_DENIED"",
+                        ""message"": ""test error""
+                    }
+                }",
+            };
+            var factory = new MockHttpClientFactory(handler);
+            var client = new FirebaseMessagingClient(factory, MockCredential, "test-project");
+            var message = new Message()
+            {
+                Topic = "test-topic",
+            };
+
+            var ex = await Assert.ThrowsAsync<FirebaseMessagingException>(
+                async () => await client.SendAsync(message));
+
+            Assert.Equal(ErrorCode.PermissionDenied, ex.ErrorCode);
+            Assert.Equal("test error", ex.Message);
+            Assert.Null(ex.MessagingErrorCode);
+            Assert.NotNull(ex.HttpResponse);
+
+            var req = JsonConvert.DeserializeObject<FirebaseMessagingClient.SendRequest>(
+                handler.LastRequestBody);
+            Assert.Equal("test-topic", req.Message.Topic);
+            Assert.False(req.ValidateOnly);
+            Assert.Equal(1, handler.Calls);
+        }
+
+        [Fact]
+        public async Task HttpErrorNonJsonAsync()
         {
             var handler = new MockMessageHandler()
             {
@@ -297,7 +452,7 @@ public async Task HttpErrorAsync()
 
             Assert.Equal(ErrorCode.Internal, ex.ErrorCode);
             Assert.Equal(
-                $"Unexpected HTTP response with status: {500} (InternalServerError)\nnot json",
+                "Unexpected HTTP response with status: 500 (InternalServerError)\nnot json",
                 ex.Message);
             Assert.Null(ex.MessagingErrorCode);
             Assert.NotNull(ex.HttpResponse);

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/MessagingErrorHandlerTest.cs

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+using System.Collections.Generic;
 using System.Net;
 using System.Net.Http;
 using System.Text;
@@ -21,6 +22,19 @@ namespace FirebaseAdmin.Messaging.Tests
 {
     public class MessagingErrorHandlerTest
     {
+        public static readonly IEnumerable<object[]> MessagingErrorCodes =
+            new List<object[]>()
+            {
+                new object[] { "APNS_AUTH_ERROR", MessagingErrorCode.ThirdPartyAuthError },
+                new object[] { "INTERNAL", MessagingErrorCode.Internal },
+                new object[] { "INVALID_ARGUMENT", MessagingErrorCode.InvalidArgument },
+                new object[] { "QUOTA_EXCEEDED", MessagingErrorCode.QuotaExceeded },
+                new object[] { "SENDER_ID_MISMATCH", MessagingErrorCode.SenderIdMismatch },
+                new object[] { "THIRD_PARTY_AUTH_ERROR", MessagingErrorCode.ThirdPartyAuthError },
+                new object[] { "UNAVAILABLE", MessagingErrorCode.Unavailable },
+                new object[] { "UNREGISTERED", MessagingErrorCode.Unregistered },
+            };
+
         [Fact]
         public void PlatformError()
         {
@@ -46,8 +60,40 @@ public void PlatformError()
             Assert.Null(error.InnerException);
         }
 
+        [Theory]
+        [MemberData(nameof(MessagingErrorCodes))]
+        public void KnownMessagingErrorCode(string code, MessagingErrorCode expected)
+        {
+            var json = $@"{{
+                ""error"": {{
+                    ""status"": ""PERMISSION_DENIED"",
+                    ""message"": ""Test error message"",
+                    ""details"": [
+                        {{
+                            ""@type"": ""type.googleapis.com/google.firebase.fcm.v1.FcmError"",
+                            ""errorCode"": ""{code}""
+                        }}
+                    ]
+                }}
+            }}";
+            var resp = new HttpResponseMessage()
+            {
+                StatusCode = HttpStatusCode.ServiceUnavailable,
+                Content = new StringContent(json, Encoding.UTF8, "application/json"),
+            };
+
+            var handler = new MessagingErrorHandler();
+            var error = Assert.Throws<FirebaseMessagingException>(() => handler.ThrowIfError(resp, json));
+
+            Assert.Equal(ErrorCode.PermissionDenied, error.ErrorCode);
+            Assert.Equal("Test error message", error.Message);
+            Assert.Equal(expected, error.MessagingErrorCode);
+            Assert.Same(resp, error.HttpResponse);
+            Assert.Null(error.InnerException);
+        }
+
         [Fact]
-        public void PlatformErrorWithMessagingErrorCode()
+        public void UnknownMessagingErrorCode()
         {
             var json = @"{
                 ""error"": {
@@ -56,7 +102,7 @@ public void PlatformErrorWithMessagingErrorCode()
                     ""details"": [
                         {
                             ""@type"": ""type.googleapis.com/google.firebase.fcm.v1.FcmError"",
-                            ""errorCode"": ""UNREGISTERED""
+                            ""errorCode"": ""SOMETHING_UNUSUAL""
                         }
                     ]
                 }
@@ -72,13 +118,13 @@ public void PlatformErrorWithMessagingErrorCode()
 
             Assert.Equal(ErrorCode.PermissionDenied, error.ErrorCode);
             Assert.Equal("Test error message", error.Message);
-            Assert.Equal(MessagingErrorCode.Unregistered, error.MessagingErrorCode);
+            Assert.Null(error.MessagingErrorCode);
             Assert.Same(resp, error.HttpResponse);
             Assert.Null(error.InnerException);
         }
 
         [Fact]
-        public void PlatformErrorWithoutAnyDetails()
+        public void NoDetails()
         {
             var json = @"{}";
             var resp = new HttpResponseMessage()

FirebaseAdmin/FirebaseAdmin/Messaging/FirebaseMessagingClient.cs

@@ -166,20 +166,6 @@ private static void AddCommonHeaders(HttpRequestMessage request)
             request.Headers.Add("X-Firebase-Client", ClientVersion);
         }
 
-        private async Task<FirebaseMessagingException> CreateExceptionFor(HttpResponseMessage response)
-        {
-            var json = await response.Content.ReadAsStringAsync();
-            try
-            {
-                this.errorHandler.ThrowIfError(response, json);
-                return null;
-            }
-            catch (FirebaseMessagingException ex)
-            {
-                return ex;
-            }
-        }
-
         private async Task<HttpResponseMessage> SendRequestAsync(object body, CancellationToken cancellationToken)
         {
             var request = new HttpRequestMessage()
@@ -204,21 +190,24 @@ private async Task<BatchResponse> SendBatchRequestAsync(
                 dryRun,
                 async (content, error, index, message) =>
                 {
+                    SendResponse sendResponse;
                     if (error != null)
                     {
-                        responses.Add(SendResponse.FromException(await this.CreateExceptionFor(message)));
+                        sendResponse = SendResponse.FromException(await this.CreateExceptionFor(message));
                     }
                     else if (content != null)
                     {
-                        responses.Add(SendResponse.FromMessageId(content.Name));
+                        sendResponse = SendResponse.FromMessageId(content.Name);
                     }
                     else
                     {
                         var exception = new FirebaseMessagingException(
                             ErrorCode.Unknown,
                             $"Unexpected batch response. Response status code: {message.StatusCode}.");
-                        responses.Add(SendResponse.FromException(exception));
+                        sendResponse = SendResponse.FromException(exception);
                     }
+
+                    responses.Add(sendResponse);
                 });
 
             await batch.ExecuteAsync(cancellationToken).ConfigureAwait(false);
@@ -245,6 +234,20 @@ private BatchRequest CreateBatchRequest(
             return batch;
         }
 
+        private async Task<FirebaseMessagingException> CreateExceptionFor(HttpResponseMessage response)
+        {
+            var json = await response.Content.ReadAsStringAsync();
+            try
+            {
+                this.errorHandler.ThrowIfError(response, json);
+                throw new InvalidOperationException("Invalid batch response");
+            }
+            catch (FirebaseMessagingException ex)
+            {
+                return ex;
+            }
+        }
+
         /// <summary>
         /// Represents the envelope message accepted by the FCM backend service, including the message
         /// payload and other options like <c>validate_only</c>.

FirebaseAdmin/FirebaseAdmin/Messaging/SendResponse.cs

@@ -27,7 +27,7 @@ private SendResponse(string messageId)
             this.MessageId = messageId;
         }
 
-        private SendResponse(FirebaseException exception)
+        private SendResponse(FirebaseMessagingException exception)
         {
             this.Exception = exception;
         }
@@ -40,7 +40,7 @@ private SendResponse(FirebaseException exception)
         /// <summary>
         /// Gets an exception if the send operation failed. Otherwise returns null.
         /// </summary>
-        public FirebaseException Exception { get; }
+        public FirebaseMessagingException Exception { get; }
 
         /// <summary>
         /// Gets a value indicating whether the send operation was successful or not. When this property

FirebaseAdmin/FirebaseAdmin/PlatformErrorHandler.cs

@@ -64,6 +64,9 @@ private PlatformErrorResponse ParseResponseBody(string body)
             }
             catch
             {
+                // Ignore any error that may occur while parsing the error response. The server
+                // may have responded with a non-json payload. Return an empty return value, and
+                // let the base class logic come into play.
                 return new PlatformErrorResponse();
             }
         }