[GCM] API update to allow only a single sender in registration

google_apis/gcm/engine/registration_request_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 82 matching lines @@
 RegistrationRequestTest::~RegistrationRequestTest() {}
 
 void RegistrationRequestTest::RegistrationCallback(
     RegistrationRequest::Status status,
     const std::string& registration_id) {
   status_ = status;
   registration_id_ = registration_id;
   callback_called_ = true;
 }
 
-void RegistrationRequestTest::CreateRequest(const std::string& sender_ids) {
-  std::vector<std::string> senders;
-  base::StringTokenizer tokenizer(sender_ids, ",");
-  while (tokenizer.GetNext())
-    senders.push_back(tokenizer.token());
-
+void RegistrationRequestTest::CreateRequest(const std::string& sender_id) {
   request_.reset(new RegistrationRequest(
       RegistrationRequest::RequestInfo(kAndroidId,
                                        kSecurityToken,
                                        kAppId,
                                        kCert,
-                                       senders),
+                                       sender_id),
       kDefaultBackoffPolicy,
       base::Bind(&RegistrationRequestTest::RegistrationCallback,
                  base::Unretained(this)),
       max_retry_count_,
       url_request_context_getter_.get()));
 }
 
 void RegistrationRequestTest::SetResponseStatusAndString(
     net::HttpStatusCode status_code,
     const std::string& response_body) {
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   fetcher->set_response_code(status_code);
   fetcher->SetResponseString(response_body);
 }
 
 void RegistrationRequestTest::CompleteFetch() {
   registration_id_.clear();
   status_ = RegistrationRequest::SUCCESS;
   callback_called_ = false;
 
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_F(RegistrationRequestTest, RequestSuccessful) {
   set_max_retry_count(0);
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
@@ skipping 33 matching lines @@
     ASSERT_TRUE(iter != expected_pairs.end());
     ASSERT_TRUE(data_tokenizer.GetNext());
     EXPECT_EQ(iter->second, data_tokenizer.token());
     // Ensure that none of the keys appears twice.
     expected_pairs.erase(iter);
   }
 
   EXPECT_EQ(0UL, expected_pairs.size());
 }
 
-TEST_F(RegistrationRequestTest, RequestRegistrationWithMultipleSenderIds) {
-  CreateRequest("sender1,sender2@gmail.com");
-  request_->Start();
-
-  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
-  ASSERT_TRUE(fetcher);
-
-  // Verify data was formatted properly.
-  std::string upload_data = fetcher->upload_data();
-  base::StringTokenizer data_tokenizer(upload_data, "&=");
-
-  // Skip all tokens until you hit entry for senders.
-  while (data_tokenizer.GetNext() && data_tokenizer.token() != "sender")
-    continue;
-
-  ASSERT_TRUE(data_tokenizer.GetNext());
-  std::string senders(net::UnescapeURLComponent(data_tokenizer.token(),
-      net::UnescapeRule::URL_SPECIAL_CHARS));
-  base::StringTokenizer sender_tokenizer(senders, ",");
-  ASSERT_TRUE(sender_tokenizer.GetNext());
-  EXPECT_EQ("sender1", sender_tokenizer.token());
-  ASSERT_TRUE(sender_tokenizer.GetNext());
-  EXPECT_EQ("sender2@gmail.com", sender_tokenizer.token());
-}
-
 TEST_F(RegistrationRequestTest, ResponseParsing) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, ResponseHttpStatusNotOK) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_UNAUTHORIZED, "token=2501");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, ResponseMissingRegistrationId) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_OK, "some error in response");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   // Ensuring a retry happened and succeeds.
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, ResponseDeviceRegistrationError) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "Error=PHONE_REGISTRATION_ERROR");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   // Ensuring a retry happened and succeeds.
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, ResponseAuthenticationError) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_UNAUTHORIZED,
                              "Error=AUTHENTICATION_FAILED");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   // Ensuring a retry happened and succeeds.
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, ResponseInvalidParameters) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "Error=INVALID_PARAMETERS");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::INVALID_PARAMETERS, status_);
   EXPECT_EQ(std::string(), registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, ResponseInvalidSender) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "Error=INVALID_SENDER");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::INVALID_SENDER, status_);
   EXPECT_EQ(std::string(), registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, ResponseInvalidSenderBadRequest) {
   CreateRequest("sender1");
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_BAD_REQUEST, "Error=INVALID_SENDER");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::INVALID_SENDER, status_);
   EXPECT_EQ(std::string(), registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, RequestNotSuccessful) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   net::URLRequestStatus request_status(net::URLRequestStatus::FAILED, 1);
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   fetcher->set_status(request_status);
 
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   // Ensuring a retry happened and succeeded.
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, ResponseHttpNotOk) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   // Ensuring a retry happened and succeeded.
   SetResponseStatusAndString(net::HTTP_OK, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::SUCCESS, status_);
   EXPECT_EQ("2501", registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, MaximumAttemptsReachedWithZeroRetries) {
   set_max_retry_count(0);
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::REACHED_MAX_RETRIES, status_);
   EXPECT_EQ(std::string(), registration_id_);
 }
 
 TEST_F(RegistrationRequestTest, MaximumAttemptsReached) {
-  CreateRequest("sender1,sender2");
+  CreateRequest(kDeveloperId);
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_GATEWAY_TIMEOUT, "token=2501");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(RegistrationRequest::REACHED_MAX_RETRIES, status_);
   EXPECT_EQ(std::string(), registration_id_);
 }
 
 }  // namespace gcm