Build correct URL for cacheinvalidation endpoint.

sync/notifier/gcm_network_channel_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 "base/run_loop.h"
+#include "base/strings/string_util.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "sync/notifier/gcm_network_channel.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
-namespace {
 
 class TestGCMNetworkChannelDelegate : public GCMNetworkChannelDelegate {
  public:
   TestGCMNetworkChannelDelegate()
       : register_call_count_(0) {}
 
   virtual void Initialize() OVERRIDE {}
 
   virtual void RequestToken(RequestTokenCallback callback) OVERRIDE {
     request_token_callback = callback;
@@ skipping 42 matching lines @@
 };
 
 class TestGCMNetworkChannel : public GCMNetworkChannel {
  public:
   TestGCMNetworkChannel(
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_ptr<GCMNetworkChannelDelegate> delegate)
       :  GCMNetworkChannel(request_context_getter, delegate.Pass()) {
     ResetRegisterBackoffEntryForTest(&kTestBackoffPolicy);
   }
+
+ protected:
+  // On Android GCMNetworkChannel::BuildUrl hits NOTREACHED(). I still want
+  // tests to run.
+  virtual GURL BuildUrl(const std::string& registration_id) OVERRIDE {
+    return GURL("http://test.url.com");
+  }
 };
 
 class GCMNetworkChannelTest
     : public ::testing::Test,
       public SyncNetworkChannel::Observer {
  protected:
   GCMNetworkChannelTest()
       : delegate_(NULL),
         url_fetchers_created_count_(0) {
   }
@@ skipping 17 matching lines @@
             this, &GCMNetworkChannelTest::OnIncomingMessage));
     url_fetcher_factory_.reset(new net::FakeURLFetcherFactory(NULL,
         base::Bind(&GCMNetworkChannelTest::CreateURLFetcher,
             base::Unretained(this))));
   }
 
   virtual void TearDown() {
     gcm_network_channel_->RemoveObserver(this);
   }
 
+  // Helper functions to call private methods from test
+  GURL BuildUrl(const std::string& registration_id) {
+    return gcm_network_channel_->GCMNetworkChannel::BuildUrl(registration_id);
+  }
+
+  static void Base64EncodeURLSafe(const std::string& input,
+                                  std::string* output) {
+    GCMNetworkChannel::Base64EncodeURLSafe(input, output);
+  }
+
+  static bool Base64DecodeURLSafe(const std::string& input,
+                                  std::string* output) {
+    return GCMNetworkChannel::Base64DecodeURLSafe(input, output);
+  }
+
   virtual void OnNetworkChannelStateChanged(
       InvalidatorState invalidator_state) OVERRIDE {
   }
 
   void OnIncomingMessage(std::string incoming_message) {
   }
 
   GCMNetworkChannel* network_channel() {
     return gcm_network_channel_.get();
   }
@@ skipping 29 matching lines @@
  private:
   base::MessageLoop message_loop_;
   TestGCMNetworkChannelDelegate* delegate_;
   scoped_ptr<GCMNetworkChannel> gcm_network_channel_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   scoped_ptr<net::FakeURLFetcherFactory> url_fetcher_factory_;
   int url_fetchers_created_count_;
 };
 
 TEST_F(GCMNetworkChannelTest, HappyCase) {
-  GURL url("http://invalid.url.com");
-  url_fetcher_factory()->SetFakeResponse(url, std::string(), net::HTTP_OK,
+  url_fetcher_factory()->SetFakeResponse(GURL("http://test.url.com"),
+                                         std::string(),
+                                         net::HTTP_OK,
                                          net::URLRequestStatus::SUCCESS);
 
   // After construction GCMNetworkChannel should have called Register.
   EXPECT_FALSE(delegate()->register_callback.is_null());
   // Return valid registration id.
   delegate()->register_callback.Run("registration.id", gcm::GCMClient::SUCCESS);
 
   network_channel()->SendMessage("abra.cadabra");
   // SendMessage should have triggered RequestToken. No HTTP request should be
   // started yet.
@@ skipping 28 matching lines @@
   // GcmNetworkChannel should give up trying.
   EXPECT_EQ(2, delegate()->register_call_count_);
 
   network_channel()->SendMessage("abra.cadabra");
   // SendMessage shouldn't trigger RequestToken.
   EXPECT_TRUE(delegate()->request_token_callback.is_null());
   EXPECT_EQ(0, url_fetchers_created_count());
 }
 
 TEST_F(GCMNetworkChannelTest, RegisterFinishesAfterSendMessage) {
-  GURL url("http://invalid.url.com");
-  url_fetcher_factory()->SetFakeResponse(url, "", net::HTTP_OK,
-      net::URLRequestStatus::SUCCESS);
+  url_fetcher_factory()->SetFakeResponse(GURL("http://test.url.com"),
+                                         "",
+                                         net::HTTP_OK,
+                                         net::URLRequestStatus::SUCCESS);
 
   // After construction GCMNetworkChannel should have called Register.
   EXPECT_FALSE(delegate()->register_callback.is_null());
 
   network_channel()->SendMessage("abra.cadabra");
   // SendMessage shouldn't trigger RequestToken.
   EXPECT_TRUE(delegate()->request_token_callback.is_null());
   EXPECT_EQ(url_fetchers_created_count(), 0);
 
   // Return valid registration id.
@@ skipping 22 matching lines @@
   // RequestToken returns failure.
   delegate()->request_token_callback.Run(
       GoogleServiceAuthError::FromConnectionError(1), "");
 
   // Should be no HTTP requests.
   EXPECT_EQ(url_fetchers_created_count(), 0);
 }
 
 TEST_F(GCMNetworkChannelTest, AuthErrorFromServer) {
   // Setup fake response to return AUTH_ERROR.
-  GURL url("http://invalid.url.com");
-  url_fetcher_factory()->SetFakeResponse(url, "", net::HTTP_UNAUTHORIZED,
-      net::URLRequestStatus::SUCCESS);
+  url_fetcher_factory()->SetFakeResponse(GURL("http://test.url.com"),
+                                         "",
+                                         net::HTTP_UNAUTHORIZED,
+                                         net::URLRequestStatus::SUCCESS);
 
   // After construction GCMNetworkChannel should have called Register.
   EXPECT_FALSE(delegate()->register_callback.is_null());
   // Return valid registration id.
   delegate()->register_callback.Run("registration.id", gcm::GCMClient::SUCCESS);
 
   network_channel()->SendMessage("abra.cadabra");
   // SendMessage should have triggered RequestToken. No HTTP request should be
   // started yet.
   EXPECT_FALSE(delegate()->request_token_callback.is_null());
@@ skipping 16 matching lines @@
 
 TEST_F(GCMNetworkChannelTest, RequestTokenNeverCompletes) {
   network_channel()->SendMessage("abra.cadabra");
   // Return valid registration id.
   delegate()->register_callback.Run("registration.id", gcm::GCMClient::SUCCESS);
   // RequestToken should be called by now. Let's not complete and see what
   // happens.
   EXPECT_FALSE(delegate()->request_token_callback.is_null());
 }
 
-}  // namespace
+#if !defined(ANDROID)
+TEST_F(GCMNetworkChannelTest, BuildUrl) {
+  GURL url = BuildUrl("registration.id");
+  EXPECT_TRUE(url.SchemeIsHTTPOrHTTPS());
+  EXPECT_FALSE(url.host().empty());
+  EXPECT_FALSE(url.path().empty());
+  std::vector<std::string> parts;
+  Tokenize(url.path(), "/", &parts);
+  std::string buffer;
+  EXPECT_TRUE(Base64DecodeURLSafe(parts[parts.size() - 1], &buffer));
+}
+#endif
+
+TEST_F(GCMNetworkChannelTest, Base64EncodeDecode) {
+  std::string input;
+  std::string plain;
+  std::string base64;
+  // Empty string.
+  Base64EncodeURLSafe(input, &base64);
+  EXPECT_TRUE(base64.empty());
+  EXPECT_TRUE(Base64DecodeURLSafe(base64, &plain));
+  EXPECT_EQ(input, plain);
+  // String length: 1..7.
+  for (int length = 1; length < 8; length++) {
+    input = "abra.cadabra";
+    input.resize(length);
+    Base64EncodeURLSafe(input, &base64);
+    // Ensure no padding at the end.
+    EXPECT_NE(base64[base64.size() - 1], '=');
+    EXPECT_TRUE(Base64DecodeURLSafe(base64, &plain));
+    EXPECT_EQ(input, plain);
+  }
+  // Presence of '-', '_'.
+  input = "\xfb\xff";
+  Base64EncodeURLSafe(input, &base64);
+  EXPECT_EQ("-_8", base64);
+  EXPECT_TRUE(Base64DecodeURLSafe(base64, &plain));
+  EXPECT_EQ(input, plain);
+}
+
 }  // namespace syncer