Renamed BatchResponse as SendResponse

src/main/java/com/google/firebase/messaging/FirebaseMessaging.java

@@ -139,55 +139,55 @@ protected String execute() throws FirebaseMessagingException {
    * Sends all the messages in the given list as a single batch via Firebase Cloud Messaging.
    *
    * @param messages A non-null, non-empty list of messages
-   * @return A list of {@link BatchResponse} instances corresponding to the list of messages sent.
+   * @return A list of {@link SendResponse} instances corresponding to the list of messages sent.
    */
-  public List<BatchResponse> sendBatch(
+  public List<SendResponse> sendBatch(
       @NonNull List<Message> messages) throws FirebaseMessagingException {
     return sendBatch(messages, false);
   }
 
-  public List<BatchResponse> sendBatch(
+  public List<SendResponse> sendBatch(
       BatchMessage batch, boolean dryRun) throws FirebaseMessagingException {
     checkNotNull(batch, "batch message must not be null");
     return sendBatch(batch.getMessageList(), dryRun);
   }
 
-  public List<BatchResponse> sendBatch(BatchMessage batch) throws FirebaseMessagingException {
+  public List<SendResponse> sendBatch(BatchMessage batch) throws FirebaseMessagingException {
     return sendBatch(batch, false);
   }
 
-  public List<BatchResponse> sendBatch(
+  public List<SendResponse> sendBatch(
       List<Message> messages, boolean dryRun) throws FirebaseMessagingException {
     return sendBatchOp(messages, dryRun).call();
   }
 
-  public ApiFuture<List<BatchResponse>> sendBatchAsync(BatchMessage batch) {
+  public ApiFuture<List<SendResponse>> sendBatchAsync(BatchMessage batch) {
     return sendBatchAsync(batch, false);
   }
 
-  public ApiFuture<List<BatchResponse>> sendBatchAsync(BatchMessage batch, boolean dryRun) {
+  public ApiFuture<List<SendResponse>> sendBatchAsync(BatchMessage batch, boolean dryRun) {
     checkNotNull(batch, "batch message must not be null");
     return sendBatchAsync(batch.getMessageList(), dryRun);
   }
 
-  public ApiFuture<List<BatchResponse>> sendBatchAsync(List<Message> messages) {
+  public ApiFuture<List<SendResponse>> sendBatchAsync(List<Message> messages) {
     return sendBatchAsync(messages, false);
   }
 
-  public ApiFuture<List<BatchResponse>> sendBatchAsync(List<Message> messages, boolean dryRun) {
+  public ApiFuture<List<SendResponse>> sendBatchAsync(List<Message> messages, boolean dryRun) {
     return sendBatchOp(messages, dryRun).callAsync(app);
   }
 
-  private CallableOperation<List<BatchResponse>, FirebaseMessagingException> sendBatchOp(
+  private CallableOperation<List<SendResponse>, FirebaseMessagingException> sendBatchOp(
       final List<Message> messages, final boolean dryRun) {
 
     final List<Message> immutableMessages = ImmutableList.copyOf(messages);
     checkArgument(!immutableMessages.isEmpty(), "messages list must not be empty");
     checkArgument(immutableMessages.size() <= 1000,
         "messages list must not contain more than 1000 elements");
-    return new CallableOperation<List<BatchResponse>,FirebaseMessagingException>() {
+    return new CallableOperation<List<SendResponse>,FirebaseMessagingException>() {
       @Override
-      protected List<BatchResponse> execute() throws FirebaseMessagingException {
+      protected List<SendResponse> execute() throws FirebaseMessagingException {
         return messagingClient.sendBatch(messages, dryRun);
       }
     };

src/main/java/com/google/firebase/messaging/FirebaseMessagingClient.java

@@ -106,7 +106,7 @@ String send(Message message, boolean dryRun) throws FirebaseMessagingException {
     }
   }
 
-  List<BatchResponse> sendBatch(
+  List<SendResponse> sendBatch(
       List<Message> messages, boolean dryRun) throws FirebaseMessagingException {
     try {
       return sendBatchRequest(messages, dryRun);
@@ -129,13 +129,13 @@ private String sendSingleRequest(Message message, boolean dryRun) throws IOExcep
     try {
       MessagingServiceResponse parsed = new MessagingServiceResponse();
       jsonFactory.createJsonParser(response.getContent()).parseAndClose(parsed);
-      return parsed.getName();
+      return parsed.getMessageId();
     } finally {
       ApiClientUtils.disconnectQuietly(response);
     }
   }
 
-  private List<BatchResponse> sendBatchRequest(
+  private List<SendResponse> sendBatchRequest(
       List<Message> messages, boolean dryRun) throws IOException {
 
     MessagingBatchCallback callback = new MessagingBatchCallback();
@@ -223,21 +223,21 @@ private static FirebaseMessagingException newException(
   private static class MessagingBatchCallback
       implements BatchCallback<MessagingServiceResponse, MessagingServiceErrorResponse> {
 
-    private final ImmutableList.Builder<BatchResponse> responses = ImmutableList.builder();
+    private final ImmutableList.Builder<SendResponse> responses = ImmutableList.builder();
 
     @Override
     public void onSuccess(
         MessagingServiceResponse response, HttpHeaders responseHeaders) {
-      responses.add(BatchResponse.fromResponse(response));
+      responses.add(SendResponse.fromMessageId(response.getMessageId()));
     }
 
     @Override
     public void onFailure(
         MessagingServiceErrorResponse error, HttpHeaders responseHeaders) {
-      responses.add(BatchResponse.fromException(newException(error)));
+      responses.add(SendResponse.fromException(newException(error)));
     }
 
-    List<BatchResponse> getResponses() {
+    List<SendResponse> getResponses() {
       return this.responses.build();
     }
   }

src/main/java/com/google/firebase/messaging/BatchResponse.java → src/main/java/com/google/firebase/messaging/SendResponse.java

@@ -20,18 +20,13 @@
 
 import com.google.common.base.Strings;
 import com.google.common.primitives.Booleans;
-import com.google.firebase.messaging.internal.MessagingServiceErrorResponse;
-import com.google.firebase.messaging.internal.MessagingServiceResponse;
 
-/**
- * BatchResponse
- */
-public final class BatchResponse {
+public final class SendResponse {
 
   private final String messageId;
   private final FirebaseMessagingException exception;
 
-  public BatchResponse(String messageId, FirebaseMessagingException exception) {
+  private SendResponse(String messageId, FirebaseMessagingException exception) {
     int argCount = Booleans.countTrue(!Strings.isNullOrEmpty(messageId), exception != null);
     checkArgument(argCount == 1, "Exactly one of messageId or exception must be specified");
     this.messageId = messageId;
@@ -50,11 +45,11 @@ public boolean isSuccessful() {
     return !Strings.isNullOrEmpty(this.messageId);
   }
 
-  static BatchResponse fromResponse(MessagingServiceResponse response) {
-    return new BatchResponse(response.getName(), null);
+  static SendResponse fromMessageId(String messageId) {
+    return new SendResponse(messageId, null);
   }
 
-  static BatchResponse fromException(FirebaseMessagingException exception) {
-    return new BatchResponse(null, exception);
+  static SendResponse fromException(FirebaseMessagingException exception) {
+    return new SendResponse(null, exception);
   }
 }

src/main/java/com/google/firebase/messaging/internal/MessagingServiceResponse.java

@@ -8,9 +8,9 @@
 public class MessagingServiceResponse {
 
   @Key("name")
-  private String name;
+  private String messageId;
 
-  public String getName() {
-    return this.name;
+  public String getMessageId() {
+    return this.messageId;
   }
 }

src/test/java/com/google/firebase/messaging/FirebaseMessagingIT.java

@@ -85,20 +85,20 @@ public void testSendBatch() throws Exception {
           .setToken("not-a-token")
           .build());
 
-    List<BatchResponse> responses = FirebaseMessaging.getInstance().sendBatch(messages, true);
+    List<SendResponse> response = FirebaseMessaging.getInstance().sendBatch(messages, true);
 
-    assertEquals(3, responses.size());
-    assertTrue(responses.get(0).isSuccessful());
-    String id = responses.get(0).getMessageId();
+    assertEquals(3, response.size());
+    assertTrue(response.get(0).isSuccessful());
+    String id = response.get(0).getMessageId();
     assertTrue(id != null && id.matches("^projects/.*/messages/.*$"));
 
-    assertTrue(responses.get(1).isSuccessful());
-    id = responses.get(1).getMessageId();
+    assertTrue(response.get(1).isSuccessful());
+    id = response.get(1).getMessageId();
     assertTrue(id != null && id.matches("^projects/.*/messages/.*$"));
 
-    assertFalse(responses.get(2).isSuccessful());
-    assertNull(responses.get(2).getMessageId());
-    FirebaseMessagingException exception = responses.get(2).getException();
+    assertFalse(response.get(2).isSuccessful());
+    assertNull(response.get(2).getMessageId());
+    FirebaseMessagingException exception = response.get(2).getException();
     assertNotNull(exception);
     assertEquals("invalid-argument", exception.getErrorCode());
   }
@@ -109,8 +109,8 @@ public void testLargeSendBatch() throws Exception {
     for (int i = 0; i < 1000; i++) {
       messages.add(Message.builder().setTopic("foo-bar").build());
     }
-    List<BatchResponse> responses = FirebaseMessaging.getInstance().sendBatch(messages, true);
-    assertEquals(1000, responses.size());
+    List<SendResponse> response = FirebaseMessaging.getInstance().sendBatch(messages, true);
+    assertEquals(1000, response.size());
   }
 
   @Test

src/test/java/com/google/firebase/messaging/FirebaseMessagingTest.java

@@ -409,7 +409,7 @@ public void testSendBatchSuccessWithList() throws Exception {
         Message.builder().setTopic("topic2").build()
     );
 
-    List<BatchResponse> responses = messaging.sendBatch(messages);
+    List<SendResponse> responses = messaging.sendBatch(messages);
 
     assertSendBatchSuccess(responses, interceptor);
   }
@@ -424,7 +424,7 @@ public void testSendBatchSuccessWithBatchMessage() throws Exception {
         .addToken("token2")
         .build();
 
-    List<BatchResponse> responses = messaging.sendBatch(batch);
+    List<SendResponse> responses = messaging.sendBatch(batch);
 
     assertSendBatchSuccess(responses, interceptor);
   }
@@ -439,7 +439,7 @@ public void testSendBatchAsyncSuccessWithList() throws Exception {
         Message.builder().setTopic("topic2").build()
     );
 
-    List<BatchResponse> responses = messaging.sendBatchAsync(messages).get();
+    List<SendResponse> responses = messaging.sendBatchAsync(messages).get();
 
     assertSendBatchSuccess(responses, interceptor);
   }
@@ -454,7 +454,7 @@ public void testSendBatchAsyncSuccessWithBatchMessage() throws Exception {
         .addToken("token2")
         .build();
 
-    List<BatchResponse> responses = messaging.sendBatchAsync(batch).get();
+    List<SendResponse> responses = messaging.sendBatchAsync(batch).get();
 
     assertSendBatchSuccess(responses, interceptor);
   }
@@ -470,7 +470,7 @@ public void testSendBatchFailureWithList() throws Exception {
         Message.builder().setTopic("topic3").build()
     );
 
-    List<BatchResponse> responses = messaging.sendBatch(messages);
+    List<SendResponse> responses = messaging.sendBatch(messages);
 
     assertSendBatchFailure(responses, interceptor);
   }
@@ -486,7 +486,7 @@ public void testSendBatchFailureWithBatchMessage() throws Exception {
         .addToken("token3")
         .build();
 
-    List<BatchResponse> responses = messaging.sendBatch(batch);
+    List<SendResponse> responses = messaging.sendBatch(batch);
 
     assertSendBatchFailure(responses, interceptor);
   }
@@ -502,7 +502,7 @@ public void testSendBatchAsyncFailureWithList() throws Exception {
         Message.builder().setTopic("topic3").build()
     );
 
-    List<BatchResponse> responses = messaging.sendBatchAsync(messages).get();
+    List<SendResponse> responses = messaging.sendBatchAsync(messages).get();
 
     assertSendBatchFailure(responses, interceptor);
   }
@@ -518,7 +518,7 @@ public void testSendBatchAsyncFailureWithBatchMessage() throws Exception {
         .addToken("token3")
         .build();
 
-    List<BatchResponse> responses = messaging.sendBatchAsync(batch).get();
+    List<SendResponse> responses = messaging.sendBatchAsync(batch).get();
 
     assertSendBatchFailure(responses, interceptor);
   }
@@ -958,34 +958,34 @@ private FirebaseMessaging getMessagingForBatchRequest(
   }
 
   private void assertSendBatchSuccess(
-      List<BatchResponse> responses, TestResponseInterceptor interceptor) throws IOException {
+      List<SendResponse> responses, TestResponseInterceptor interceptor) throws IOException {
     assertEquals(2, responses.size());
     for (int i = 0; i < 2; i++) {
-      BatchResponse response = responses.get(i);
-      assertTrue(response.isSuccessful());
-      assertEquals("projects/test-project/messages/" + (i + 1), response.getMessageId());
-      assertNull(response.getException());
+      SendResponse sendResponse = responses.get(i);
+      assertTrue(sendResponse.isSuccessful());
+      assertEquals("projects/test-project/messages/" + (i + 1), sendResponse.getMessageId());
+      assertNull(sendResponse.getException());
     }
     checkBatchRequestHeader(interceptor.getLastRequest());
     checkBatchRequest(interceptor.getLastRequest(), 2);
   }
 
   private void assertSendBatchFailure(
-      List<BatchResponse> responses, TestResponseInterceptor interceptor) throws IOException {
+      List<SendResponse> responses, TestResponseInterceptor interceptor) throws IOException {
     assertEquals(3, responses.size());
-    BatchResponse firstResponse = responses.get(0);
+    SendResponse firstResponse = responses.get(0);
     assertTrue(firstResponse.isSuccessful());
     assertEquals("projects/test-project/messages/1", firstResponse.getMessageId());
     assertNull(firstResponse.getException());
 
-    BatchResponse secondResponse = responses.get(1);
+    SendResponse secondResponse = responses.get(1);
     assertFalse(secondResponse.isSuccessful());
     assertNull(secondResponse.getMessageId());
     FirebaseMessagingException exception = secondResponse.getException();
     assertNotNull(exception);
     assertEquals("invalid-argument", exception.getErrorCode());
 
-    BatchResponse thirdResponse = responses.get(2);
+    SendResponse thirdResponse = responses.get(2);
     assertFalse(thirdResponse.isSuccessful());
     assertNull(thirdResponse.getMessageId());
     exception = thirdResponse.getException();

src/test/java/com/google/firebase/messaging/SendResponseTest.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * 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.
+ */
+
+package com.google.firebase.messaging;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class SendResponseTest {
+
+  @Test
+  public void testSuccessfulResponse() {
+    SendResponse response = SendResponse.fromMessageId("message-id");
+
+    assertEquals("message-id", response.getMessageId());
+    assertTrue(response.isSuccessful());
+    assertNull(response.getException());
+  }
+
+  @Test
+  public void testFailureResponse() {
+    FirebaseMessagingException exception = new FirebaseMessagingException("error-code",
+        "error-message", null);
+    SendResponse response = SendResponse.fromException(exception);
+
+    assertNull(response.getMessageId());
+    assertFalse(response.isSuccessful());
+    assertSame(exception, response.getException());
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testMessageIdCannotBeNull() {
+    SendResponse.fromMessageId(null);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testMessageIdCannotBeEmpty() {
+    SendResponse.fromMessageId("");
+  }
+}