src/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler_unittest.cc

   1 // Copyright (c) 2012 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 "chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler_delegate.h"
  10 #include "chrome/browser/invalidation/invalidation_service.h"
  11 #include "google/cacheinvalidation/types.pb.h"
  12 #include "sync/internal_api/public/base/invalidation_test_util.h"
  13 #include "sync/notifier/object_id_invalidation_map.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 using ::testing::_;
  18 using ::testing::NotNull;
  19 using ::testing::SaveArg;
  20 using ::testing::StrictMock;
  21 using syncer::AckHandle;
  22
  23 namespace extensions {
  24
  25 namespace {
  26
  27 class MockInvalidationService : public invalidation::InvalidationService {
  28  public:
  29   MockInvalidationService();
  30   ~MockInvalidationService();
  31   MOCK_METHOD1(RegisterInvalidationHandler,
  32                void(syncer::InvalidationHandler*));
  33   MOCK_METHOD2(UpdateRegisteredInvalidationIds,
  34                void(syncer::InvalidationHandler*, const syncer::ObjectIdSet&));
  35   MOCK_METHOD1(UnregisterInvalidationHandler,
  36                void(syncer::InvalidationHandler*));
  37   MOCK_METHOD2(AcknowledgeInvalidation, void(const invalidation::ObjectId&,
  38                                              const syncer::AckHandle&));
  39   MOCK_CONST_METHOD0(GetInvalidatorState, syncer::InvalidatorState());
  40   MOCK_CONST_METHOD0(GetInvalidatorClientId, std::string());
  41
  42  private:
  43   DISALLOW_COPY_AND_ASSIGN(MockInvalidationService);
  44 };
  45
  46 MockInvalidationService::MockInvalidationService() {}
  47 MockInvalidationService::~MockInvalidationService() {}
  48
  49 class MockInvalidationHandlerDelegate
  50     : public PushMessagingInvalidationHandlerDelegate {
  51  public:
  52   MockInvalidationHandlerDelegate();
  53   ~MockInvalidationHandlerDelegate();
  54   MOCK_METHOD3(OnMessage,
  55                void(const std::string&, int, const std::string&));
  56
  57  private:
  58   DISALLOW_COPY_AND_ASSIGN(MockInvalidationHandlerDelegate);
  59 };
  60
  61 MockInvalidationHandlerDelegate::MockInvalidationHandlerDelegate() {}
  62 MockInvalidationHandlerDelegate::~MockInvalidationHandlerDelegate() {}
  63
  64 }  // namespace
  65
  66 class PushMessagingInvalidationHandlerTest : public ::testing::Test {
  67  protected:
  68   virtual void SetUp() OVERRIDE {
  69     syncer::InvalidationHandler* handler = NULL;
  70     EXPECT_CALL(service_, RegisterInvalidationHandler(NotNull()))
  71         .WillOnce(SaveArg<0>(&handler));
  72     handler_.reset(new PushMessagingInvalidationHandler(
  73         &service_, &delegate_));
  74     EXPECT_EQ(handler_.get(), handler);
  75   }
  76   virtual void TearDown() OVERRIDE {
  77     EXPECT_CALL(service_, UnregisterInvalidationHandler(handler_.get()));
  78     handler_.reset();
  79   }
  80   StrictMock<MockInvalidationService> service_;
  81   StrictMock<MockInvalidationHandlerDelegate> delegate_;
  82   scoped_ptr<PushMessagingInvalidationHandler> handler_;
  83 };
  84
  85 TEST_F(PushMessagingInvalidationHandlerTest, RegisterUnregisterExtension) {
  86   syncer::ObjectIdSet expected_ids;
  87   expected_ids.insert(invalidation::ObjectId(
  88       ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
  89       "U/cccccccccccccccccccccccccccccccc/0"));
  90   expected_ids.insert(invalidation::ObjectId(
  91       ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
  92       "U/cccccccccccccccccccccccccccccccc/1"));
  93   expected_ids.insert(invalidation::ObjectId(
  94       ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
  95       "U/cccccccccccccccccccccccccccccccc/2"));
  96   expected_ids.insert(invalidation::ObjectId(
  97       ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
  98       "U/cccccccccccccccccccccccccccccccc/3"));
  99   EXPECT_CALL(service_,
 100               UpdateRegisteredInvalidationIds(handler_.get(), expected_ids));
 101   handler_->RegisterExtension("cccccccccccccccccccccccccccccccc");
 102   EXPECT_CALL(service_,
 103               UpdateRegisteredInvalidationIds(handler_.get(),
 104                                               syncer::ObjectIdSet()));
 105   handler_->UnregisterExtension("cccccccccccccccccccccccccccccccc");
 106 }
 107
 108 TEST_F(PushMessagingInvalidationHandlerTest, Dispatch) {
 109   syncer::ObjectIdInvalidationMap invalidation_map;
 110   // A normal invalidation.
 111   invalidation_map.Insert(
 112       syncer::Invalidation::Init(
 113           invalidation::ObjectId(
 114               ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
 115               "U/dddddddddddddddddddddddddddddddd/0"),
 116           10,
 117           "payload"));
 118
 119   // An unknown version invalidation.
 120   invalidation_map.Insert(syncer::Invalidation::InitUnknownVersion(
 121       invalidation::ObjectId(
 122         ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
 123         "U/dddddddddddddddddddddddddddddddd/3")));
 124
 125   EXPECT_CALL(delegate_,
 126               OnMessage("dddddddddddddddddddddddddddddddd", 0, "payload"));
 127   EXPECT_CALL(delegate_,
 128               OnMessage("dddddddddddddddddddddddddddddddd", 3, ""));
 129
 130   syncer::ObjectIdSet ids = invalidation_map.GetObjectIds();
 131   for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end();
 132        ++it) {
 133     const syncer::Invalidation& inv = invalidation_map.ForObject(*it).back();
 134     const syncer::AckHandle& ack_handle = inv.ack_handle();
 135     EXPECT_CALL(service_, AcknowledgeInvalidation(*it, ack_handle));
 136   }
 137   handler_->OnIncomingInvalidation(invalidation_map);
 138 }
 139
 140 // Tests that malformed object IDs don't trigger spurious callbacks.
 141 TEST_F(PushMessagingInvalidationHandlerTest, DispatchInvalidObjectIds) {
 142   syncer::ObjectIdInvalidationMap invalidation_map;
 143   // Completely incorrect format.
 144   invalidation_map.Insert(syncer::Invalidation::InitUnknownVersion(
 145           invalidation::ObjectId(
 146               ipc::invalidation::ObjectSource::TEST,
 147               "Invalid")));
 148   // Incorrect source.
 149   invalidation_map.Insert(syncer::Invalidation::InitUnknownVersion(
 150           invalidation::ObjectId(
 151               ipc::invalidation::ObjectSource::TEST,
 152               "U/dddddddddddddddddddddddddddddddd/3")));
 153   // Incorrect format type.
 154   invalidation_map.Insert(syncer::Invalidation::InitUnknownVersion(
 155           invalidation::ObjectId(
 156               ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
 157               "V/dddddddddddddddddddddddddddddddd/3")));
 158   // Invalid extension ID length.
 159   invalidation_map.Insert(syncer::Invalidation::InitUnknownVersion(
 160           invalidation::ObjectId(
 161               ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
 162               "U/ddddddddddddddddddddddddddddddddd/3")));
 163   // Non-numeric subchannel.
 164   invalidation_map.Insert(syncer::Invalidation::InitUnknownVersion(
 165           invalidation::ObjectId(
 166               ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
 167               "U/dddddddddddddddddddddddddddddddd/z")));
 168   // Subchannel out of range.
 169   invalidation_map.Insert(syncer::Invalidation::InitUnknownVersion(
 170           invalidation::ObjectId(
 171               ipc::invalidation::ObjectSource::CHROME_PUSH_MESSAGING,
 172               "U/dddddddddddddddddddddddddddddddd/4")));
 173   // Invalid object IDs should still be acknowledged.
 174   syncer::ObjectIdSet ids = invalidation_map.GetObjectIds();
 175   for (syncer::ObjectIdSet::const_iterator it = ids.begin(); it != ids.end();
 176        ++it) {
 177     const syncer::Invalidation& inv = invalidation_map.ForObject(*it).back();
 178     const syncer::AckHandle& ack_handle = inv.ack_handle();
 179     EXPECT_CALL(service_, AcknowledgeInvalidation(*it, ack_handle));
 180   }
 181   handler_->OnIncomingInvalidation(invalidation_map);
 182 }
 183
 184 }  // namespace extensions