fix(fcm): Fixed error handling in the topic management APIs (#155)

Author: hiranya911

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/InstanceIdClientTest.cs

@@ -13,6 +13,16 @@ namespace FirebaseAdmin.Tests.Messaging
 {
     public class InstanceIdClientTest
     {
+        public static readonly IEnumerable<object[]> ErrorCodes =
+            new List<object[]>()
+            {
+                new object[] { HttpStatusCode.BadRequest, ErrorCode.InvalidArgument },
+                new object[] { HttpStatusCode.Unauthorized, ErrorCode.Unauthenticated },
+                new object[] { HttpStatusCode.Forbidden, ErrorCode.PermissionDenied },
+                new object[] { HttpStatusCode.NotFound, ErrorCode.NotFound },
+                new object[] { HttpStatusCode.ServiceUnavailable, ErrorCode.Unavailable },
+            };
+
         private static readonly GoogleCredential MockCredential =
             GoogleCredential.FromAccessToken("test-token");
 
@@ -64,37 +74,14 @@ public async Task UnsubscribeFromTopicAsync()
             Assert.Equal(1, result.SuccessCount);
         }
 
-        [Fact]
-        public async Task BadRequest()
-        {
-            var handler = new MockMessageHandler()
-            {
-                StatusCode = HttpStatusCode.BadRequest,
-                Response = "BadRequest",
-            };
-            var factory = new MockHttpClientFactory(handler);
-
-            var client = new InstanceIdClient(factory, MockCredential);
-
-            var exception = await Assert.ThrowsAsync<FirebaseMessagingException>(
-               () => client.SubscribeToTopicAsync(new List<string> { "abc123" }, "test-topic"));
-
-            Assert.Equal(ErrorCode.InvalidArgument, exception.ErrorCode);
-            Assert.Equal(
-                $"Unexpected HTTP response with status: 400 (BadRequest){Environment.NewLine}BadRequest",
-                exception.Message);
-            Assert.Null(exception.MessagingErrorCode);
-            Assert.NotNull(exception.HttpResponse);
-            Assert.Null(exception.InnerException);
-        }
-
-        [Fact]
-        public async Task Unauthorized()
+        [Theory]
+        [MemberData(nameof(ErrorCodes))]
+        public async Task ErrorResponse(HttpStatusCode statusCode, ErrorCode expected)
         {
             var handler = new MockMessageHandler()
             {
-                StatusCode = HttpStatusCode.Unauthorized,
-                Response = "Unauthorized",
+                StatusCode = statusCode,
+                Response = @"{""error"":""ErrorCode""}",
             };
             var factory = new MockHttpClientFactory(handler);
 
@@ -103,22 +90,23 @@ public async Task Unauthorized()
             var exception = await Assert.ThrowsAsync<FirebaseMessagingException>(
                () => client.SubscribeToTopicAsync(new List<string> { "abc123" }, "test-topic"));
 
-            Assert.Equal(ErrorCode.Unauthenticated, exception.ErrorCode);
+            Assert.Equal(expected, exception.ErrorCode);
             Assert.Equal(
-                $"Unexpected HTTP response with status: 401 (Unauthorized){Environment.NewLine}Unauthorized",
+                "Error while calling the IID service: ErrorCode",
                 exception.Message);
             Assert.Null(exception.MessagingErrorCode);
             Assert.NotNull(exception.HttpResponse);
             Assert.Null(exception.InnerException);
         }
 
-        [Fact]
-        public async Task Forbidden()
+        [Theory]
+        [MemberData(nameof(ErrorCodes))]
+        public async Task UnexpectedErrorResponse(HttpStatusCode statusCode, ErrorCode expected)
         {
             var handler = new MockMessageHandler()
             {
-                StatusCode = HttpStatusCode.Forbidden,
-                Response = "Forbidden",
+                StatusCode = statusCode,
+                Response = "NonJsonErrorResponse",
             };
             var factory = new MockHttpClientFactory(handler);
 
@@ -127,64 +115,16 @@ public async Task Forbidden()
             var exception = await Assert.ThrowsAsync<FirebaseMessagingException>(
                () => client.SubscribeToTopicAsync(new List<string> { "abc123" }, "test-topic"));
 
-            Assert.Equal(ErrorCode.PermissionDenied, exception.ErrorCode);
+            Assert.Equal(expected, exception.ErrorCode);
             Assert.Equal(
-                $"Unexpected HTTP response with status: 403 (Forbidden){Environment.NewLine}Forbidden",
+                "Unexpected HTTP response with status: "
+                + $"{(int)statusCode} ({statusCode}){Environment.NewLine}NonJsonErrorResponse",
                 exception.Message);
             Assert.Null(exception.MessagingErrorCode);
             Assert.NotNull(exception.HttpResponse);
             Assert.Null(exception.InnerException);
         }
 
-        [Fact]
-        public async Task NotFound()
-        {
-            var handler = new MockMessageHandler()
-            {
-                StatusCode = HttpStatusCode.NotFound,
-                Response = "NotFound",
-            };
-            var factory = new MockHttpClientFactory(handler);
-
-            var client = new InstanceIdClient(factory, MockCredential);
-
-            var exception = await Assert.ThrowsAsync<FirebaseMessagingException>(
-               () => client.SubscribeToTopicAsync(new List<string> { "abc123" }, "test-topic"));
-
-            Assert.Equal(ErrorCode.NotFound, exception.ErrorCode);
-            Assert.Equal(
-                $"Unexpected HTTP response with status: 404 (NotFound){Environment.NewLine}NotFound",
-                exception.Message);
-            Assert.Null(exception.MessagingErrorCode);
-            Assert.NotNull(exception.HttpResponse);
-            Assert.Null(exception.InnerException);
-        }
-
-        [Fact]
-        public async Task ServiceUnavailable()
-        {
-            var handler = new MockMessageHandler()
-            {
-                StatusCode = HttpStatusCode.ServiceUnavailable,
-                Response = "ServiceUnavailable",
-            };
-            var factory = new MockHttpClientFactory(handler);
-
-            var client = new InstanceIdClient(factory, MockCredential, RetryOptions.NoBackOff);
-
-            var exception = await Assert.ThrowsAsync<FirebaseMessagingException>(
-               () => client.SubscribeToTopicAsync(new List<string> { "abc123" }, "test-topic"));
-
-            Assert.Equal(ErrorCode.Unavailable, exception.ErrorCode);
-            Assert.Equal(
-                $"Unexpected HTTP response with status: 503 (ServiceUnavailable){Environment.NewLine}ServiceUnavailable",
-                exception.Message);
-            Assert.Null(exception.MessagingErrorCode);
-            Assert.NotNull(exception.HttpResponse);
-            Assert.Null(exception.InnerException);
-            Assert.Equal(5, handler.Calls);
-        }
-
         [Fact]
         public async Task TransportError()
         {

FirebaseAdmin/FirebaseAdmin/Messaging/InstanceIdClient.cs

@@ -54,7 +54,7 @@ internal InstanceIdClient(
                     HttpClientFactory = clientFactory.ThrowIfNull(nameof(clientFactory)),
                     Credential = credential.ThrowIfNull(nameof(credential)),
                     RequestExceptionHandler = MessagingErrorHandler.Instance,
-                    ErrorResponseHandler = MessagingErrorHandler.Instance,
+                    ErrorResponseHandler = InstanceIdErrorHandler.Instance,
                     DeserializeExceptionHandler = MessagingErrorHandler.Instance,
                     RetryOptions = retryOptions,
                 });
@@ -180,5 +180,48 @@ private class InstanceIdServiceRequest
             [JsonProperty("registration_tokens")]
             public IEnumerable<string> RegistrationTokens { get; set; }
         }
-    }
+
+        private class InstanceIdServiceError
+        {
+            [JsonProperty("error")]
+            public string ErrorCode { get; set; }
+        }
+
+        private class InstanceIdErrorHandler : HttpErrorHandler<FirebaseMessagingException>
+        {
+            internal static readonly InstanceIdErrorHandler Instance = new InstanceIdErrorHandler();
+
+            private InstanceIdErrorHandler() { }
+
+            protected override FirebaseMessagingException CreateException(FirebaseExceptionArgs args)
+            {
+                var errorCode = this.GetErrorCode(args.ResponseBody);
+                var message = args.Message;
+                if (!string.IsNullOrEmpty(errorCode))
+                {
+                    message = $"Error while calling the IID service: {errorCode}";
+                }
+
+                return new FirebaseMessagingException(
+                    args.Code,
+                    message,
+                    null,
+                    response: args.HttpResponse);
+            }
+
+            private string GetErrorCode(string response)
+            {
+                try
+                {
+                    var iidError = NewtonsoftJsonSerializer.Instance.Deserialize<InstanceIdServiceError>(
+                        response);
+                    return iidError.ErrorCode;
+                }
+                catch
+                {
+                    return null;
+                }
+            }
+        }
+  }
 }