Support getting and deleting token for Instance ID.

google_apis/gcm/engine/unregistration_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"
 #include "google_apis/gcm/engine/unregistration_request.h"
 #include "google_apis/gcm/monitoring/fake_gcm_stats_recorder.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 const uint64 kAndroidId = 42UL;
 const char kLoginHeader[] = "AidLogin";
 const char kAppId[] = "TestAppId";
 const char kDeletedAppId[] = "deleted=TestAppId";
 const char kRegistrationURL[] = "http://foo.bar/register";
 const uint64 kSecurityToken = 77UL;
+const char kChromeVersion[] = "40.0.0.1";
+const char kInstanceId[] = "IID1";
+const char kDeveloperId[] = "Project1";
+const char kScope[] = "GCM";
 
 // Backoff policy for testing registration request.
 const net::BackoffEntry::Policy kDefaultBackoffPolicy = {
   // Number of initial errors (in sequence) to ignore before applying
   // exponential back-off rules.
   // Explicitly set to 2 to skip the delay on the first retry, as we are not
   // trying to test the backoff itself, but rather the fact that retry happens.
   1,
 
   // Initial delay for exponential back-off in ms.
@@ skipping 18 matching lines @@
 };
 }  // namespace
 
 class UnregistrationRequestTest : public testing::Test {
  public:
   UnregistrationRequestTest();
   ~UnregistrationRequestTest() override;
 
   void UnregistrationCallback(UnregistrationRequest::Status status);
 
-  void CreateRequest();
+  void CreateRequestFromRequestInfo(
+      scoped_ptr<UnregistrationRequest::RequestInfo> request_info);
   void SetResponseStatusAndString(net::HttpStatusCode status_code,
                                   const std::string& response_body);
   void CompleteFetch();
 
  protected:
   bool callback_called_;
   UnregistrationRequest::Status status_;
   scoped_ptr<UnregistrationRequest> request_;
   base::MessageLoop message_loop_;
   net::TestURLFetcherFactory url_fetcher_factory_;
   scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter_;
   FakeGCMStatsRecorder recorder_;
 };
 
 UnregistrationRequestTest::UnregistrationRequestTest()
     : callback_called_(false),
       status_(UnregistrationRequest::UNREGISTRATION_STATUS_COUNT),
       url_request_context_getter_(new net::TestURLRequestContextGetter(
           message_loop_.message_loop_proxy())) {}
 
 UnregistrationRequestTest::~UnregistrationRequestTest() {}
 
 void UnregistrationRequestTest::UnregistrationCallback(
     UnregistrationRequest::Status status) {
   callback_called_ = true;
   status_ = status;
 }
 
-void UnregistrationRequestTest::CreateRequest() {
+void UnregistrationRequestTest::CreateRequestFromRequestInfo(
+    scoped_ptr<UnregistrationRequest::RequestInfo> request_info) {
   request_.reset(new UnregistrationRequest(
       GURL(kRegistrationURL),
-      UnregistrationRequest::RequestInfo(kAndroidId,
-                                         kSecurityToken,
-                                         kAppId),
+      request_info.Pass(),
       kDefaultBackoffPolicy,
       base::Bind(&UnregistrationRequestTest::UnregistrationCallback,
                  base::Unretained(this)),
       url_request_context_getter_.get(),
       &recorder_));
 }
 
 void UnregistrationRequestTest::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 UnregistrationRequestTest::CompleteFetch() {
   status_ = UnregistrationRequest::UNREGISTRATION_STATUS_COUNT;
   callback_called_ = false;
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
-TEST_F(UnregistrationRequestTest, RequestDataPassedToFetcher) {
+class GCMUnregistrationRequestTest : public UnregistrationRequestTest {
+ public:
+  GCMUnregistrationRequestTest();
+  ~GCMUnregistrationRequestTest() override;
+
+  void CreateRequest();
+};
+
+GCMUnregistrationRequestTest::GCMUnregistrationRequestTest() {
+}
+
+GCMUnregistrationRequestTest::~GCMUnregistrationRequestTest() {
+}
+
+void GCMUnregistrationRequestTest::CreateRequest() {
+  scoped_ptr<UnregistrationRequest::GCMRequestInfo> request_info(
+      new UnregistrationRequest::GCMRequestInfo);
+  request_info->set_android_id(kAndroidId);
+  request_info->set_security_token(kSecurityToken);
+  request_info->set_app_id(kAppId);
+  CreateRequestFromRequestInfo(request_info.Pass());
+}
+
+TEST_F(GCMUnregistrationRequestTest, RequestDataPassedToFetcher) {
   CreateRequest();
   request_->Start();
 
   // Get data sent by request.
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   EXPECT_EQ(GURL(kRegistrationURL), fetcher->GetOriginalURL());
 
   // Verify that authorization header was put together properly.
@@ skipping 27 matching lines @@
     ASSERT_TRUE(iter != expected_pairs.end()) << data_tokenizer.token();
     ASSERT_TRUE(data_tokenizer.GetNext()) << data_tokenizer.token();
     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(UnregistrationRequestTest, SuccessfulUnregistration) {
+TEST_F(GCMUnregistrationRequestTest, SuccessfulUnregistration) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, kDeletedAppId);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::SUCCESS, status_);
 }
 
-TEST_F(UnregistrationRequestTest, ResponseHttpStatusNotOK) {
+TEST_F(GCMUnregistrationRequestTest, ResponseHttpStatusNotOK) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_UNAUTHORIZED, "");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::HTTP_NOT_OK, status_);
 }
 
-TEST_F(UnregistrationRequestTest, ResponseEmpty) {
+TEST_F(GCMUnregistrationRequestTest, ResponseEmpty) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_OK, kDeletedAppId);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::SUCCESS, status_);
 }
 
-TEST_F(UnregistrationRequestTest, InvalidParametersError) {
+TEST_F(GCMUnregistrationRequestTest, InvalidParametersError) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "Error=INVALID_PARAMETERS");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::INVALID_PARAMETERS, status_);
 }
 
-TEST_F(UnregistrationRequestTest, UnkwnownError) {
+TEST_F(GCMUnregistrationRequestTest, UnkwnownError) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "Error=XXX");
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::UNKNOWN_ERROR, status_);
 }
 
-TEST_F(UnregistrationRequestTest, ServiceUnavailable) {
+TEST_F(GCMUnregistrationRequestTest, ServiceUnavailable) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_SERVICE_UNAVAILABLE, "");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_OK, kDeletedAppId);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::SUCCESS, status_);
 }
 
-TEST_F(UnregistrationRequestTest, InternalServerError) {
+TEST_F(GCMUnregistrationRequestTest, InternalServerError) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_INTERNAL_SERVER_ERROR, "");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_OK, kDeletedAppId);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::SUCCESS, status_);
 }
 
-TEST_F(UnregistrationRequestTest, IncorrectAppId) {
+TEST_F(GCMUnregistrationRequestTest, IncorrectAppId) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "deleted=OtherTestAppId");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_OK, kDeletedAppId);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::SUCCESS, status_);
 }
 
-TEST_F(UnregistrationRequestTest, ResponseParsingFailed) {
+TEST_F(GCMUnregistrationRequestTest, ResponseParsingFailed) {
   CreateRequest();
   request_->Start();
 
   SetResponseStatusAndString(net::HTTP_OK, "some malformed response");
   CompleteFetch();
 
   EXPECT_FALSE(callback_called_);
 
   SetResponseStatusAndString(net::HTTP_OK, kDeletedAppId);
   CompleteFetch();
 
   EXPECT_TRUE(callback_called_);
   EXPECT_EQ(UnregistrationRequest::SUCCESS, status_);
 }
 
+class InstaceIDDeleteTokenRequestTest : public UnregistrationRequestTest {
+ public:
+  InstaceIDDeleteTokenRequestTest();
+  ~InstaceIDDeleteTokenRequestTest() override;
+
+  void CreateRequest(const std::string& instance_id,
+                     const std::string& authorized_entity,
+                     const std::string& scope);
+};
+
+InstaceIDDeleteTokenRequestTest::InstaceIDDeleteTokenRequestTest() {
+}
+
+InstaceIDDeleteTokenRequestTest::~InstaceIDDeleteTokenRequestTest() {
+}
+
+void InstaceIDDeleteTokenRequestTest::CreateRequest(
+    const std::string& instance_id,
+    const std::string& authorized_entity,
+    const std::string& scope) {
+  scoped_ptr<UnregistrationRequest::InstanceIDRequestInfo> request_info(
+      new UnregistrationRequest::InstanceIDRequestInfo);
+  request_info->set_chrome_version(kChromeVersion);
+  request_info->set_android_id(kAndroidId);
+  request_info->set_security_token(kSecurityToken);
+  request_info->set_app_id(kAppId);
+  request_info->set_instance_id(instance_id);
+  request_info->set_authorized_entity(authorized_entity);
+  request_info->set_scope(scope);
+  CreateRequestFromRequestInfo(request_info.Pass());
+}
+
+TEST_F(InstaceIDDeleteTokenRequestTest, RequestDataPassedToFetcher) {
+  CreateRequest(kInstanceId, kDeveloperId, kScope);
+  request_->Start();
+
+  // Get data sent by request.
+  net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
+  ASSERT_TRUE(fetcher);
+
+  EXPECT_EQ(GURL(kRegistrationURL), fetcher->GetOriginalURL());
+
+  // Verify that authorization header was put together properly.
+  net::HttpRequestHeaders headers;
+  fetcher->GetExtraRequestHeaders(&headers);
+  std::string auth_header;
+  headers.GetHeader(net::HttpRequestHeaders::kAuthorization, &auth_header);
+  base::StringTokenizer auth_tokenizer(auth_header, " :");
+  ASSERT_TRUE(auth_tokenizer.GetNext());
+  EXPECT_EQ(kLoginHeader, auth_tokenizer.token());
+  ASSERT_TRUE(auth_tokenizer.GetNext());
+  EXPECT_EQ(base::Uint64ToString(kAndroidId), auth_tokenizer.token());
+  ASSERT_TRUE(auth_tokenizer.GetNext());
+  EXPECT_EQ(base::Uint64ToString(kSecurityToken), auth_tokenizer.token());
+  std::string app_id_header;
+  headers.GetHeader("app", &app_id_header);
+  EXPECT_EQ(kAppId, app_id_header);
+
+  std::map<std::string, std::string> expected_pairs;
+  expected_pairs["gmsv"] = kChromeVersion;
+  expected_pairs["app"] = kAppId;
+  expected_pairs["device"] = base::Uint64ToString(kAndroidId);
+  expected_pairs["delete"] = "true";
+  expected_pairs["appid"] = kInstanceId;
+  expected_pairs["sender"] = kDeveloperId;
+  expected_pairs["scope"] = kScope;
+
+  // Verify data was formatted properly.
+  std::string upload_data = fetcher->upload_data();
+  base::StringTokenizer data_tokenizer(upload_data, "&=");
+  while (data_tokenizer.GetNext()) {
+    std::map<std::string, std::string>::iterator iter =
+        expected_pairs.find(data_tokenizer.token());
+    ASSERT_TRUE(iter != expected_pairs.end()) << data_tokenizer.token();
+    ASSERT_TRUE(data_tokenizer.GetNext()) << data_tokenizer.token();
+    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(InstaceIDDeleteTokenRequestTest, SuccessfulUnregistration) {
+  CreateRequest(kInstanceId, kDeveloperId, kScope);
+  request_->Start();
+
+  SetResponseStatusAndString(net::HTTP_OK, kDeletedAppId);
+  CompleteFetch();
+
+  EXPECT_TRUE(callback_called_);
+  EXPECT_EQ(UnregistrationRequest::SUCCESS, status_);
+}
+
+TEST_F(InstaceIDDeleteTokenRequestTest, ResponseHttpStatusNotOK) {
+  CreateRequest(kInstanceId, kDeveloperId, kScope);
+  request_->Start();
+
+  SetResponseStatusAndString(net::HTTP_UNAUTHORIZED, "");
+  CompleteFetch();
+
+  EXPECT_TRUE(callback_called_);
+  EXPECT_EQ(UnregistrationRequest::HTTP_NOT_OK, status_);
+}
+
 }  // namespace gcm