Implementation of InstanceIdClient to allow subscribe/unsubscribe to topic

FirebaseAdmin/FirebaseAdmin.IntegrationTests/FirebaseMessagingTest.cs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 using System;
+using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using FirebaseAdmin.Messaging;
@@ -120,5 +121,29 @@ public async Task SendMulticast()
             Assert.NotNull(response.Responses[0].Exception);
             Assert.NotNull(response.Responses[1].Exception);
         }
+
+        [Fact]
+        public async Task SubscribeToTopic()
+        {
+            var response = await FirebaseMessaging.DefaultInstance.SubscribeToTopicAsync("test-topic", new List<string> { "token1", "token2" });
+            Assert.NotNull(response);
+            Assert.Equal(2, response.FailureCount);
+            Assert.Equal("invalid-argument", response.Errors[0].Reason);
+            Assert.Equal(0, response.Errors[0].Index);
+            Assert.Equal("invalid-argument", response.Errors[1].Reason);
+            Assert.Equal(1, response.Errors[1].Index);
+        }
+
+        [Fact]
+        public async Task UnsubscribeFromTopic()
+        {
+            var response = await FirebaseMessaging.DefaultInstance.UnsubscribeFromTopicAsync("test-topic", new List<string> { "token1", "token2" });
+            Assert.NotNull(response);
+            Assert.Equal(2, response.FailureCount);
+            Assert.Equal("invalid-argument", response.Errors[0].Reason);
+            Assert.Equal(0, response.Errors[0].Index);
+            Assert.Equal("invalid-argument", response.Errors[1].Reason);
+            Assert.Equal(1, response.Errors[1].Index);
+        }
     }
 }

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/FirebaseMessagingTest.cs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using FirebaseAdmin.Tests;
@@ -118,6 +119,56 @@ await Assert.ThrowsAsync<OperationCanceledException>(
                     new Message() { Topic = "test-topic" }, canceller.Token));
         }
 
+        [Fact]
+        public async Task SubscribeWithClientFactory()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = @"{""results"":[{}]}",
+            };
+            var factory = new MockHttpClientFactory(handler);
+
+            var app = FirebaseApp.Create(new AppOptions()
+            {
+                Credential = GoogleCredential.FromAccessToken("test-token"),
+                HttpClientFactory = factory,
+                ProjectId = "test-project",
+            });
+            FirebaseMessaging messaging = FirebaseMessaging.GetMessaging(app);
+            Assert.NotNull(messaging);
+            Assert.Same(messaging, FirebaseMessaging.GetMessaging(app));
+
+            var response = await messaging.SubscribeToTopicAsync("test-topic", new List<string> { "test-token" });
+            Assert.Equal(0, response.FailureCount);
+            Assert.Equal(1, response.SuccessCount);
+            app.Delete();
+        }
+
+        [Fact]
+        public async Task UnsubscribeWithClientFactory()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = @"{""results"":[{}]}",
+            };
+            var factory = new MockHttpClientFactory(handler);
+
+            var app = FirebaseApp.Create(new AppOptions()
+            {
+                Credential = GoogleCredential.FromAccessToken("test-token"),
+                HttpClientFactory = factory,
+                ProjectId = "test-project",
+            });
+            FirebaseMessaging messaging = FirebaseMessaging.GetMessaging(app);
+            Assert.NotNull(messaging);
+            Assert.Same(messaging, FirebaseMessaging.GetMessaging(app));
+
+            var response = await messaging.UnsubscribeFromTopicAsync("test-topic", new List<string> { "test-token" });
+            Assert.Equal(0, response.FailureCount);
+            Assert.Equal(1, response.SuccessCount);
+            app.Delete();
+        }
+
         public void Dispose()
         {
             FirebaseApp.DeleteAll();

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/InstanceIdClientTest.cs

@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Threading.Tasks;
+using FirebaseAdmin.Messaging;
+using Google.Apis.Auth.OAuth2;
+using Google.Apis.Http;
+using Xunit;
+
+namespace FirebaseAdmin.Tests.Messaging
+{
+    public class InstanceIdClientTest
+    {
+        private static readonly GoogleCredential MockCredential =
+            GoogleCredential.FromAccessToken("test-token");
+
+        [Fact]
+        public void NoCredential()
+        {
+            var clientFactory = new HttpClientFactory();
+            Assert.Throws<ArgumentNullException>(
+                () => new InstanceIdClient(clientFactory, null));
+        }
+
+        [Fact]
+        public void NoClientFactory()
+        {
+            var clientFactory = new HttpClientFactory();
+            Assert.Throws<ArgumentNullException>(
+                () => new InstanceIdClient(null, MockCredential));
+        }
+
+        [Fact]
+        public async Task SubscribeToTopicAsync()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = @"{""results"":[{}]}",
+            };
+            var factory = new MockHttpClientFactory(handler);
+
+            var client = new InstanceIdClient(factory, MockCredential);
+
+            var result = await client.SubscribeToTopicAsync("test-topic", new List<string> { "abc123" });
+
+            Assert.Equal(1, result.SuccessCount);
+        }
+
+        [Fact]
+        public async Task UnsubscribeFromTopicAsync()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = @"{""results"":[{}]}",
+            };
+            var factory = new MockHttpClientFactory(handler);
+
+            var client = new InstanceIdClient(factory, MockCredential);
+
+            var result = await client.UnsubscribeFromTopicAsync("test-topic", new List<string> { "abc123" });
+
+            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("test-topic", new List<string> { "abc123" }));
+
+            Assert.Equal(ErrorCode.InvalidArgument, exception.ErrorCode);
+            Assert.Equal("Unexpected HTTP response with status: 400 (BadRequest)\nBadRequest", exception.Message);
+            Assert.Null(exception.MessagingErrorCode);
+            Assert.NotNull(exception.HttpResponse);
+            Assert.Null(exception.InnerException);
+        }
+
+        [Fact]
+        public async Task Unauthorized()
+        {
+            var handler = new MockMessageHandler()
+            {
+                StatusCode = HttpStatusCode.Unauthorized,
+                Response = "Unauthorized",
+            };
+            var factory = new MockHttpClientFactory(handler);
+
+            var client = new InstanceIdClient(factory, MockCredential);
+
+            var exception = await Assert.ThrowsAsync<FirebaseMessagingException>(
+               () => client.SubscribeToTopicAsync("test-topic", new List<string> { "abc123" }));
+
+            Assert.Equal(ErrorCode.Unauthenticated, exception.ErrorCode);
+            Assert.Equal("Unexpected HTTP response with status: 401 (Unauthorized)\nUnauthorized", exception.Message);
+            Assert.Null(exception.MessagingErrorCode);
+            Assert.NotNull(exception.HttpResponse);
+            Assert.Null(exception.InnerException);
+        }
+
+        [Fact]
+        public async Task Forbidden()
+        {
+            var handler = new MockMessageHandler()
+            {
+                StatusCode = HttpStatusCode.Forbidden,
+                Response = "Forbidden",
+            };
+            var factory = new MockHttpClientFactory(handler);
+
+            var client = new InstanceIdClient(factory, MockCredential);
+
+            var exception = await Assert.ThrowsAsync<FirebaseMessagingException>(
+               () => client.SubscribeToTopicAsync("test-topic", new List<string> { "abc123" }));
+
+            Assert.Equal(ErrorCode.PermissionDenied, exception.ErrorCode);
+            Assert.Equal("Unexpected HTTP response with status: 403 (Forbidden)\nForbidden", 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("test-topic", new List<string> { "abc123" }));
+
+            Assert.Equal(ErrorCode.NotFound, exception.ErrorCode);
+            Assert.Equal("Unexpected HTTP response with status: 404 (NotFound)\nNotFound", 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);
+
+            var exception = await Assert.ThrowsAsync<FirebaseMessagingException>(
+               () => client.SubscribeToTopicAsync("test-topic", new List<string> { "abc123" }));
+
+            Assert.Equal(ErrorCode.Unavailable, exception.ErrorCode);
+            Assert.Equal("Unexpected HTTP response with status: 503 (ServiceUnavailable)\nServiceUnavailable", exception.Message);
+            Assert.Null(exception.MessagingErrorCode);
+            Assert.NotNull(exception.HttpResponse);
+            Assert.Null(exception.InnerException);
+        }
+    }
+}

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/TopicManagementResponseTest.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using FirebaseAdmin.Messaging;
+using Newtonsoft.Json;
+using Xunit;
+
+namespace FirebaseAdmin.Tests.Messaging
+{
+    public class TopicManagementResponseTest
+    {
+        [Fact]
+        public void SuccessfulReponse()
+        {
+            var json = @"{""results"": [{}, {}]}";
+            var instanceIdServiceResponse = JsonConvert.DeserializeObject<InstanceIdServiceResponse>(json);
+            var response = new TopicManagementResponse(instanceIdServiceResponse);
+
+            Assert.Equal(0, response.FailureCount);
+            Assert.Equal(2, response.SuccessCount);
+        }
+
+        [Fact]
+        public void UnsuccessfulResponse()
+        {
+            var json = @"{""results"": [{}, {""error"":""NOT_FOUND""}]}";
+            var instanceIdServiceResponse = JsonConvert.DeserializeObject<InstanceIdServiceResponse>(json);
+            var response = new TopicManagementResponse(instanceIdServiceResponse);
+
+            Assert.Equal(1, response.FailureCount);
+            Assert.Equal(1, response.SuccessCount);
+            Assert.NotEmpty(response.Errors);
+            Assert.Equal("registration-token-not-registered", response.Errors[0].Reason);
+            Assert.Equal(1, response.Errors[0].Index);
+        }
+
+        [Fact]
+        public void NullResponse()
+        {
+            Assert.Throws<ArgumentNullException>(() =>
+            {
+                new TopicManagementResponse(null);
+            });
+        }
+
+        [Fact]
+        public void EmptyResponse()
+        {
+            Assert.Throws<ArgumentNullException>(() =>
+            {
+                var instanceIdServiceResponse = new InstanceIdServiceResponse();
+                new TopicManagementResponse(instanceIdServiceResponse);
+            });
+        }
+
+        [Fact]
+        public void UnregisteredToken()
+        {
+            var json = @"{""results"": [{}, {""error"":""NOT_FOUND""}]}";
+            var instanceIdServiceResponse = JsonConvert.DeserializeObject<InstanceIdServiceResponse>(json);
+            var response = new TopicManagementResponse(instanceIdServiceResponse);
+
+            Assert.Single(response.Errors);
+            Assert.Equal("registration-token-not-registered", response.Errors[0].Reason);
+            Assert.Equal(1, response.Errors[0].Index);
+        }
+
+        [Fact]
+        public void CountsSuccessAndErrors()
+        {
+            var json = @"{""results"": [{""error"": ""NOT_FOUND""}, {}, {""error"": ""INVALID_ARGUMENT""}, {}, {}]}";
+            var instanceIdServiceResponse = JsonConvert.DeserializeObject<InstanceIdServiceResponse>(json);
+            var response = new TopicManagementResponse(instanceIdServiceResponse);
+
+            Assert.Equal(2, response.FailureCount);
+            Assert.Equal(3, response.SuccessCount);
+            Assert.Equal("registration-token-not-registered", response.Errors[0].Reason);
+            Assert.NotEmpty(response.Errors);
+            Assert.Equal(0, response.Errors[0].Index);
+            Assert.Equal("invalid-argument", response.Errors[1].Reason);
+            Assert.Equal(2, response.Errors[1].Index);
+        }
+    }
+}