chrome/browser/extensions/api/gcm/gcm_apitest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/run_loop.h"
   6 #include "chrome/browser/extensions/api/gcm/gcm_api.h"
   7 #include "chrome/browser/extensions/extension_apitest.h"
   8 #include "chrome/browser/profiles/profile.h"
   9 #include "chrome/browser/services/gcm/fake_gcm_profile_service.h"
  10 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
  11 #include "chrome/common/extensions/features/feature_channel.h"
  12 #include "chrome/test/base/ui_test_utils.h"
  13
  14 namespace {
  15
  16 const char kEventsExtension[] = "gcm/events";
  17
  18 }  // namespace
  19
  20 namespace extensions {
  21
  22 class GcmApiTest : public ExtensionApiTest {
  23  public:
  24   GcmApiTest() : fake_gcm_profile_service_(NULL) {}
  25
  26  protected:
  27   virtual void SetUpOnMainThread() OVERRIDE;
  28
  29   void StartCollecting();
  30
  31   const Extension* LoadTestExtension(const std::string& extension_path,
  32                                      const std::string& page_name);
  33   gcm::FakeGCMProfileService* service() const;
  34   bool ShouldSkipTest() const;
  35
  36  private:
  37   gcm::FakeGCMProfileService* fake_gcm_profile_service_;
  38 };
  39
  40 void GcmApiTest::SetUpOnMainThread() {
  41   gcm::GCMProfileServiceFactory::GetInstance()->SetTestingFactory(
  42       browser()->profile(), &gcm::FakeGCMProfileService::Build);
  43   fake_gcm_profile_service_ = static_cast<gcm::FakeGCMProfileService*>(
  44       gcm::GCMProfileServiceFactory::GetInstance()->GetForProfile(
  45           browser()->profile()));
  46   gcm::FakeGCMProfileService::EnableGCMForTesting();
  47 }
  48
  49 void GcmApiTest::StartCollecting() {
  50   service()->set_collect(true);
  51 }
  52
  53 gcm::FakeGCMProfileService* GcmApiTest::service() const {
  54   return fake_gcm_profile_service_;
  55 }
  56
  57 const Extension* GcmApiTest::LoadTestExtension(
  58     const std::string& extension_path,
  59     const std::string& page_name) {
  60   // TODO(jianli): Once the GCM API enters stable, remove |channel|.
  61   ScopedCurrentChannel channel(chrome::VersionInfo::CHANNEL_UNKNOWN);
  62
  63   const Extension* extension =
  64       LoadExtension(test_data_dir_.AppendASCII(extension_path));
  65   if (extension) {
  66     ui_test_utils::NavigateToURL(
  67         browser(), extension->GetResourceURL(page_name));
  68   }
  69   return extension;
  70 }
  71
  72 bool GcmApiTest::ShouldSkipTest() const {
  73   // TODO(jianli): Remove this once the GCM API enters stable.
  74   return chrome::VersionInfo::GetChannel() ==
  75       chrome::VersionInfo::CHANNEL_STABLE;
  76 }
  77
  78 IN_PROC_BROWSER_TEST_F(GcmApiTest, RegisterValidation) {
  79   if (ShouldSkipTest())
  80     return;
  81
  82   ASSERT_TRUE(RunExtensionTest("gcm/functions/register_validation"));
  83 }
  84
  85 IN_PROC_BROWSER_TEST_F(GcmApiTest, Register) {
  86   if (ShouldSkipTest())
  87     return;
  88
  89   StartCollecting();
  90   ASSERT_TRUE(RunExtensionTest("gcm/functions/register"));
  91
  92   // SHA1 of the public key provided in manifest.json.
  93   EXPECT_EQ("26469186F238EE08FA71C38311C6990F61D40DCA",
  94             service()->last_registered_cert());
  95   const std::vector<std::string>& sender_ids =
  96       service()->last_registered_sender_ids();
  97   EXPECT_TRUE(std::find(sender_ids.begin(), sender_ids.end(), "Sender1") !=
  98                   sender_ids.end());
  99   EXPECT_TRUE(std::find(sender_ids.begin(), sender_ids.end(), "Sender2") !=
 100                   sender_ids.end());
 101 }
 102
 103 IN_PROC_BROWSER_TEST_F(GcmApiTest, SendValidation) {
 104   if (ShouldSkipTest())
 105     return;
 106
 107   ASSERT_TRUE(RunExtensionTest("gcm/functions/send"));
 108 }
 109
 110 IN_PROC_BROWSER_TEST_F(GcmApiTest, SendMessageData) {
 111   if (ShouldSkipTest())
 112     return;
 113
 114   StartCollecting();
 115   ASSERT_TRUE(RunExtensionTest("gcm/functions/send_message_data"));
 116
 117   EXPECT_EQ("destination-id", service()->last_receiver_id());
 118   const gcm::GCMClient::OutgoingMessage& message =
 119       service()->last_sent_message();
 120   gcm::GCMClient::MessageData::const_iterator iter;
 121
 122   EXPECT_TRUE((iter = message.data.find("key1")) != message.data.end());
 123   EXPECT_EQ("value1", iter->second);
 124
 125   EXPECT_TRUE((iter = message.data.find("key2")) != message.data.end());
 126   EXPECT_EQ("value2", iter->second);
 127 }
 128
 129 IN_PROC_BROWSER_TEST_F(GcmApiTest, OnMessagesDeleted) {
 130   ResultCatcher catcher;
 131   catcher.RestrictToProfile(profile());
 132
 133   const extensions::Extension* extension =
 134       LoadTestExtension(kEventsExtension, "on_messages_deleted.html");
 135   ASSERT_TRUE(extension);
 136
 137   GcmJsEventRouter router(profile());
 138   router.OnMessagesDeleted(extension->id());
 139   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 140 }
 141
 142 IN_PROC_BROWSER_TEST_F(GcmApiTest, OnMessage) {
 143   ResultCatcher catcher;
 144   catcher.RestrictToProfile(profile());
 145
 146   const extensions::Extension* extension =
 147       LoadTestExtension(kEventsExtension, "on_message.html");
 148   ASSERT_TRUE(extension);
 149
 150   GcmJsEventRouter router(profile());
 151
 152   gcm::GCMClient::IncomingMessage message;
 153   message.data["property1"] = "value1";
 154   message.data["property2"] = "value2";
 155   router.OnMessage(extension->id(), message);
 156
 157   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 158 }
 159
 160 IN_PROC_BROWSER_TEST_F(GcmApiTest, OnSendError) {
 161   ResultCatcher catcher;
 162   catcher.RestrictToProfile(profile());
 163
 164   const extensions::Extension* extension =
 165       LoadTestExtension(kEventsExtension, "on_send_error.html");
 166   ASSERT_TRUE(extension);
 167
 168   GcmJsEventRouter router(profile());
 169   router.OnSendError(extension->id(), "error_message_1",
 170       gcm::GCMClient::ASYNC_OPERATION_PENDING);
 171   router.OnSendError(extension->id(), "error_message_2",
 172       gcm::GCMClient::SERVER_ERROR);
 173   router.OnSendError(extension->id(), "error_message_3",
 174       gcm::GCMClient::NETWORK_ERROR);
 175   router.OnSendError(extension->id(), "error_message_4",
 176       gcm::GCMClient::UNKNOWN_ERROR);
 177   router.OnSendError(extension->id(), "error_message_5",
 178       gcm::GCMClient::TTL_EXCEEDED);
 179
 180   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 181 }
 182
 183 IN_PROC_BROWSER_TEST_F(GcmApiTest, Incognito) {
 184   if (ShouldSkipTest())
 185     return;
 186
 187   ResultCatcher catcher;
 188   catcher.RestrictToProfile(profile());
 189   ResultCatcher incognito_catcher;
 190   incognito_catcher.RestrictToProfile(profile()->GetOffTheRecordProfile());
 191
 192   ASSERT_TRUE(RunExtensionTestIncognito("gcm/functions/incognito"));
 193
 194   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 195   EXPECT_TRUE(incognito_catcher.GetNextResult()) << incognito_catcher.message();
 196 }
 197
 198 }  // namespace extensions