More fix-ups

Author: kentcb

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/BatchResponseTest.cs

@@ -0,0 +1,64 @@
+// Copyright 2018, Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FirebaseAdmin.Messaging;
+using Xunit;
+
+namespace FirebaseAdmin.Tests.Messaging
+{
+    public class BatchResponseTest
+    {
+        [Fact]
+        public void EmptyResponses()
+        {
+            var responses = new List<SendResponse>();
+
+            var batchResponse = new BatchResponse(responses);
+
+            Assert.Equal(0, batchResponse.SuccessCount);
+            Assert.Equal(0, batchResponse.FailureCount);
+            Assert.Equal(0, batchResponse.Responses.Count);
+        }
+
+        [Fact]
+        public void SomeResponse()
+        {
+            var responses = new SendResponse[]
+            {
+                SendResponse.FromMessageId("message1"),
+                SendResponse.FromMessageId("message2"),
+                SendResponse.FromException(
+                    new FirebaseException(
+                        "error-message",
+                        null)),
+            };
+
+            var batchResponse = new BatchResponse(responses);
+
+            Assert.Equal(2, batchResponse.SuccessCount);
+            Assert.Equal(1, batchResponse.FailureCount);
+            Assert.Equal(3, batchResponse.Responses.Count);
+            Assert.True(responses.SequenceEqual(batchResponse.Responses));
+        }
+
+        [Fact]
+        public void ResponsesCannotBeNull()
+        {
+            Assert.Throws<ArgumentNullException>(() => new BatchResponse(null));
+        }
+    }
+}

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/MulticastMessageTest.cs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 using System;
+using System.Linq;
 using FirebaseAdmin.Messaging;
 using Xunit;
 
@@ -40,7 +41,18 @@ public void GetMessageListNoTokens()
         {
             var message = new MulticastMessage();
 
-            Assert.Throws<InvalidOperationException>(() => message.GetMessageList());
+            Assert.Throws<ArgumentException>(() => message.GetMessageList());
+        }
+
+        [Fact]
+        public void GetMessageListTooManyTokens()
+        {
+            var message = new MulticastMessage
+            {
+                Tokens = Enumerable.Range(0, 101).Select(x => x.ToString()).ToList(),
+            };
+
+            Assert.Throws<ArgumentException>(() => message.GetMessageList());
         }
     }
 }

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/SendItemResponseTest.cs

@@ -13,8 +13,6 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using FirebaseAdmin.Messaging;
 using Xunit;
 
@@ -23,42 +21,44 @@ namespace FirebaseAdmin.Tests.Messaging
     public class SendResponseTest
     {
         [Fact]
-        public void EmptyResponses()
+        public void SuccessfulResponse()
         {
-            var responses = new List<SendItemResponse>();
+            var response = SendResponse.FromMessageId("message-id");
 
-            var batchResponse = new SendResponse(responses);
-
-            Assert.Equal(0, batchResponse.SuccessCount);
-            Assert.Equal(0, batchResponse.FailureCount);
-            Assert.Equal(0, batchResponse.Responses.Count);
+            Assert.Equal("message-id", response.MessageId);
+            Assert.True(response.IsSuccess);
+            Assert.Null(response.Exception);
         }
 
         [Fact]
-        public void SomeResponse()
+        public void FailureResponse()
         {
-            var responses = new SendItemResponse[]
-            {
-                SendItemResponse.FromMessageId("message1"),
-                SendItemResponse.FromMessageId("message2"),
-                SendItemResponse.FromException(
-                    new FirebaseException(
-                        "error-message",
-                        null)),
-            };
+            var exception = new FirebaseException(
+                "error-message",
+                null);
+            var response = SendResponse.FromException(exception);
+
+            Assert.Null(response.MessageId);
+            Assert.False(response.IsSuccess);
+            Assert.Same(exception, response.Exception);
+        }
 
-            var batchResponse = new SendResponse(responses);
+        [Fact]
+        public void MessageIdCannotBeNull()
+        {
+            Assert.Throws<ArgumentException>(() => SendResponse.FromMessageId(null));
+        }
 
-            Assert.Equal(2, batchResponse.SuccessCount);
-            Assert.Equal(1, batchResponse.FailureCount);
-            Assert.Equal(3, batchResponse.Responses.Count);
-            Assert.True(responses.SequenceEqual(batchResponse.Responses));
+        [Fact]
+        public void MessageIdCannotBeEmpty()
+        {
+            Assert.Throws<ArgumentException>(() => SendResponse.FromMessageId(string.Empty));
         }
 
         [Fact]
-        public void ResponsesCannotBeNull()
+        public void ExceptionCannotBeNull()
         {
-            Assert.Throws<ArgumentNullException>(() => new SendResponse(null));
+            Assert.Throws<ArgumentNullException>(() => SendResponse.FromException(null));
         }
     }
 }

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/SendResponseTest.cs

@@ -0,0 +1,57 @@
+// Copyright 2018, Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Google.Apis.Util;
+
+namespace FirebaseAdmin.Messaging
+{
+    /// <summary>
+    /// Response from an operation that sends FCM messages to multiple recipients.
+    /// See <see cref="FirebaseMessaging.SendMulticastAsync(MulticastMessage)"/>.
+    /// </summary>
+    public sealed class BatchResponse
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BatchResponse"/> class.
+        /// </summary>
+        /// <param name="responses">The responses.</param>
+        internal BatchResponse(IEnumerable<SendResponse> responses)
+        {
+            responses.ThrowIfNull(nameof(responses));
+
+            this.Responses = new List<SendResponse>(responses);
+            this.SuccessCount = responses.Where(response => response.IsSuccess).Count();
+        }
+
+        /// <summary>
+        /// Gets information about all responses for the batch.
+        /// </summary>
+        public IReadOnlyList<SendResponse> Responses { get; }
+
+        /// <summary>
+        /// Gets a count of how many of the responses in <see cref="Responses"/> were
+        /// successful.
+        /// </summary>
+        public int SuccessCount { get; }
+
+        /// <summary>
+        /// Gets a count of how many of the responses in <see cref="Responses"/> were
+        /// unsuccessful.
+        /// </summary>
+        public int FailureCount => this.Responses.Count - this.SuccessCount;
+    }
+}

FirebaseAdmin/FirebaseAdmin/Messaging/BatchResponse.cs

@@ -174,9 +174,9 @@ public async Task<string> SendAsync(
         /// method, this is a significantly more efficient way to send multiple messages.
         /// </summary>
         /// <param name="messages">Up to 100 messages to send in the batch. Cannot be null.</param>
-        /// <returns>A <see cref="SendResponse"/> containing details of the batch operation's
+        /// <returns>A <see cref="BatchResponse"/> containing details of the batch operation's
         /// outcome.</returns>
-        public async Task<SendResponse> SendAllAsync(IEnumerable<Message> messages)
+        public async Task<BatchResponse> SendAllAsync(IEnumerable<Message> messages)
         {
             return await this.SendAllAsync(messages, false);
         }
@@ -189,9 +189,9 @@ public async Task<SendResponse> SendAllAsync(IEnumerable<Message> messages)
         /// <param name="messages">Up to 100 messages to send in the batch. Cannot be null.</param>
         /// <param name="cancellationToken">A cancellation token to monitor the asynchronous
         /// operation.</param>
-        /// <returns>A <see cref="SendResponse"/> containing details of the batch operation's
+        /// <returns>A <see cref="BatchResponse"/> containing details of the batch operation's
         /// outcome.</returns>
-        public async Task<SendResponse> SendAllAsync(IEnumerable<Message> messages, CancellationToken cancellationToken)
+        public async Task<BatchResponse> SendAllAsync(IEnumerable<Message> messages, CancellationToken cancellationToken)
         {
             return await this.SendAllAsync(messages, false, cancellationToken);
         }
@@ -205,9 +205,9 @@ public async Task<SendResponse> SendAllAsync(IEnumerable<Message> messages, Canc
         /// <param name="dryRun">A boolean indicating whether to perform a dry run (validation
         /// only) of the send. If set to true, the message will be sent to the FCM backend service,
         /// but it will not be delivered to any actual recipients.</param>
-        /// <returns>A <see cref="SendResponse"/> containing details of the batch operation's
+        /// <returns>A <see cref="BatchResponse"/> containing details of the batch operation's
         /// outcome.</returns>
-        public async Task<SendResponse> SendAllAsync(IEnumerable<Message> messages, bool dryRun)
+        public async Task<BatchResponse> SendAllAsync(IEnumerable<Message> messages, bool dryRun)
         {
             return await this.SendAllAsync(messages, dryRun, default);
         }
@@ -223,9 +223,9 @@ public async Task<SendResponse> SendAllAsync(IEnumerable<Message> messages, bool
         /// but it will not be delivered to any actual recipients.</param>
         /// <param name="cancellationToken">A cancellation token to monitor the asynchronous
         /// operation.</param>
-        /// <returns>A <see cref="SendResponse"/> containing details of the batch operation's
+        /// <returns>A <see cref="BatchResponse"/> containing details of the batch operation's
         /// outcome.</returns>
-        public async Task<SendResponse> SendAllAsync(IEnumerable<Message> messages, bool dryRun, CancellationToken cancellationToken)
+        public async Task<BatchResponse> SendAllAsync(IEnumerable<Message> messages, bool dryRun, CancellationToken cancellationToken)
         {
             return await this.messagingClient.SendAllAsync(messages, dryRun, cancellationToken);
         }
@@ -234,8 +234,9 @@ public async Task<SendResponse> SendAllAsync(IEnumerable<Message> messages, bool
         /// Sends the given multicast message to all the FCM registration tokens specified in it.
         /// </summary>
         /// <param name="message">The message to be sent. Must not be null.</param>
-        /// <returns>A task that completes with message ID strings.</returns>
-        public async Task<SendResponse> SendMulticastAsync(MulticastMessage message)
+        /// <returns>A <see cref="BatchResponse"/> containing details of the batch operation's
+        /// outcome.</returns>
+        public async Task<BatchResponse> SendMulticastAsync(MulticastMessage message)
         {
             return await this.SendMulticastAsync(message, false);
         }
@@ -246,8 +247,9 @@ public async Task<SendResponse> SendMulticastAsync(MulticastMessage message)
         /// <param name="message">The message to be sent. Must not be null.</param>
         /// <param name="cancellationToken">A cancellation token to monitor the asynchronous
         /// operation.</param>
-        /// <returns>A task that completes with message ID strings.</returns>
-        public async Task<SendResponse> SendMulticastAsync(MulticastMessage message, CancellationToken cancellationToken)
+        /// <returns>A <see cref="BatchResponse"/> containing details of the batch operation's
+        /// outcome.</returns>
+        public async Task<BatchResponse> SendMulticastAsync(MulticastMessage message, CancellationToken cancellationToken)
         {
             return await this.SendMulticastAsync(message, false, cancellationToken);
         }
@@ -263,8 +265,9 @@ public async Task<SendResponse> SendMulticastAsync(MulticastMessage message, Can
         /// <param name="dryRun">A boolean indicating whether to perform a dry run (validation
         /// only) of the send. If set to true, the message will be sent to the FCM backend service,
         /// but it will not be delivered to any actual recipients.</param>
-        /// <returns>A task that completes with message ID strings.</returns>
-        public async Task<SendResponse> SendMulticastAsync(MulticastMessage message, bool dryRun)
+        /// <returns>A <see cref="BatchResponse"/> containing details of the batch operation's
+        /// outcome.</returns>
+        public async Task<BatchResponse> SendMulticastAsync(MulticastMessage message, bool dryRun)
         {
             return await this.SendMulticastAsync(message, dryRun, default);
         }
@@ -282,8 +285,9 @@ public async Task<SendResponse> SendMulticastAsync(MulticastMessage message, boo
         /// but it will not be delivered to any actual recipients.</param>
         /// <param name="cancellationToken">A cancellation token to monitor the asynchronous
         /// operation.</param>
-        /// <returns>A task that completes with message ID strings.</returns>
-        public async Task<SendResponse> SendMulticastAsync(
+        /// <returns>A <see cref="BatchResponse"/> containing details of the batch operation's
+        /// outcome.</returns>
+        public async Task<BatchResponse> SendMulticastAsync(
             MulticastMessage message, bool dryRun, CancellationToken cancellationToken)
         {
             return await this.SendAllAsync(