src/components/invalidation/sync_system_resources_unittest.cc

   1 // Copyright 2014 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 "components/invalidation/sync_system_resources.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/callback.h"
  12 #include "base/message_loop/message_loop.h"
  13
  14 #include "components/invalidation/push_client_channel.h"
  15 #include "components/invalidation/state_writer.h"
  16 #include "google/cacheinvalidation/include/types.h"
  17 #include "jingle/notifier/listener/fake_push_client.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace syncer {
  22 namespace {
  23
  24 using ::testing::_;
  25 using ::testing::SaveArg;
  26
  27 class MockStateWriter : public StateWriter {
  28  public:
  29   MOCK_METHOD1(WriteState, void(const std::string&));
  30 };
  31
  32 class MockClosure {
  33  public:
  34   MOCK_CONST_METHOD0(Run, void(void));
  35   base::Closure* CreateClosure() {
  36     return new base::Closure(
  37         base::Bind(&MockClosure::Run, base::Unretained(this)));
  38   }
  39 };
  40
  41 class MockStorageCallback {
  42  public:
  43   MOCK_CONST_METHOD1(Run, void(invalidation::Status));
  44   base::Callback<void(invalidation::Status)>* CreateCallback() {
  45     return new base::Callback<void(invalidation::Status)>(
  46         base::Bind(&MockStorageCallback::Run, base::Unretained(this)));
  47   }
  48 };
  49
  50 class SyncSystemResourcesTest : public testing::Test {
  51  protected:
  52   SyncSystemResourcesTest()
  53       : push_client_channel_(
  54             scoped_ptr<notifier::PushClient>(new notifier::FakePushClient())),
  55         sync_system_resources_(&push_client_channel_, &mock_state_writer_) {}
  56
  57   virtual ~SyncSystemResourcesTest() {}
  58
  59   void ScheduleShouldNotRun() {
  60     {
  61       // Owned by ScheduleImmediately.
  62       MockClosure mock_closure;
  63       base::Closure* should_not_run = mock_closure.CreateClosure();
  64       EXPECT_CALL(mock_closure, Run()).Times(0);
  65       sync_system_resources_.internal_scheduler()->Schedule(
  66           invalidation::Scheduler::NoDelay(), should_not_run);
  67     }
  68     {
  69       // Owned by ScheduleOnListenerThread.
  70       MockClosure mock_closure;
  71       base::Closure* should_not_run = mock_closure.CreateClosure();
  72       EXPECT_CALL(mock_closure, Run()).Times(0);
  73       sync_system_resources_.listener_scheduler()->Schedule(
  74           invalidation::Scheduler::NoDelay(), should_not_run);
  75     }
  76     {
  77       // Owned by ScheduleWithDelay.
  78       MockClosure mock_closure;
  79       base::Closure* should_not_run = mock_closure.CreateClosure();
  80       EXPECT_CALL(mock_closure, Run()).Times(0);
  81       sync_system_resources_.internal_scheduler()->Schedule(
  82           invalidation::TimeDelta::FromSeconds(0), should_not_run);
  83     }
  84   }
  85
  86   // Needed by |sync_system_resources_|.
  87   base::MessageLoop message_loop_;
  88   MockStateWriter mock_state_writer_;
  89   PushClientChannel push_client_channel_;
  90   SyncSystemResources sync_system_resources_;
  91
  92  private:
  93   DISALLOW_COPY_AND_ASSIGN(SyncSystemResourcesTest);
  94 };
  95
  96 // Make sure current_time() doesn't crash or leak.
  97 TEST_F(SyncSystemResourcesTest, CurrentTime) {
  98   invalidation::Time current_time =
  99       sync_system_resources_.internal_scheduler()->GetCurrentTime();
 100   DVLOG(1) << "current_time returned: " << current_time.ToInternalValue();
 101 }
 102
 103 // Make sure Log() doesn't crash or leak.
 104 TEST_F(SyncSystemResourcesTest, Log) {
 105   sync_system_resources_.logger()->Log(SyncLogger::INFO_LEVEL,
 106                                          __FILE__, __LINE__, "%s %d",
 107                                          "test string", 5);
 108 }
 109
 110 TEST_F(SyncSystemResourcesTest, ScheduleBeforeStart) {
 111   ScheduleShouldNotRun();
 112   sync_system_resources_.Start();
 113 }
 114
 115 TEST_F(SyncSystemResourcesTest, ScheduleAfterStop) {
 116   sync_system_resources_.Start();
 117   sync_system_resources_.Stop();
 118   ScheduleShouldNotRun();
 119 }
 120
 121 TEST_F(SyncSystemResourcesTest, ScheduleAndStop) {
 122   sync_system_resources_.Start();
 123   ScheduleShouldNotRun();
 124   sync_system_resources_.Stop();
 125 }
 126
 127 TEST_F(SyncSystemResourcesTest, ScheduleAndDestroy) {
 128   sync_system_resources_.Start();
 129   ScheduleShouldNotRun();
 130 }
 131
 132 TEST_F(SyncSystemResourcesTest, ScheduleImmediately) {
 133   sync_system_resources_.Start();
 134   MockClosure mock_closure;
 135   EXPECT_CALL(mock_closure, Run());
 136   sync_system_resources_.internal_scheduler()->Schedule(
 137       invalidation::Scheduler::NoDelay(), mock_closure.CreateClosure());
 138   message_loop_.RunUntilIdle();
 139 }
 140
 141 TEST_F(SyncSystemResourcesTest, ScheduleOnListenerThread) {
 142   sync_system_resources_.Start();
 143   MockClosure mock_closure;
 144   EXPECT_CALL(mock_closure, Run());
 145   sync_system_resources_.listener_scheduler()->Schedule(
 146       invalidation::Scheduler::NoDelay(), mock_closure.CreateClosure());
 147   EXPECT_TRUE(
 148       sync_system_resources_.internal_scheduler()->IsRunningOnThread());
 149   message_loop_.RunUntilIdle();
 150 }
 151
 152 TEST_F(SyncSystemResourcesTest, ScheduleWithZeroDelay) {
 153   sync_system_resources_.Start();
 154   MockClosure mock_closure;
 155   EXPECT_CALL(mock_closure, Run());
 156   sync_system_resources_.internal_scheduler()->Schedule(
 157       invalidation::TimeDelta::FromSeconds(0), mock_closure.CreateClosure());
 158   message_loop_.RunUntilIdle();
 159 }
 160
 161 // TODO(akalin): Figure out how to test with a non-zero delay.
 162
 163 TEST_F(SyncSystemResourcesTest, WriteState) {
 164   sync_system_resources_.Start();
 165   EXPECT_CALL(mock_state_writer_, WriteState(_));
 166   // Owned by WriteState.
 167   MockStorageCallback mock_storage_callback;
 168   invalidation::Status results(invalidation::Status::PERMANENT_FAILURE,
 169                                "fake-failure");
 170   EXPECT_CALL(mock_storage_callback, Run(_))
 171       .WillOnce(SaveArg<0>(&results));
 172   sync_system_resources_.storage()->WriteKey(
 173       std::string(), "state", mock_storage_callback.CreateCallback());
 174   message_loop_.RunUntilIdle();
 175   EXPECT_EQ(invalidation::Status(invalidation::Status::SUCCESS, std::string()),
 176             results);
 177 }
 178
 179 class TestSyncNetworkChannel : public SyncNetworkChannel {
 180  public:
 181   TestSyncNetworkChannel() {}
 182   virtual ~TestSyncNetworkChannel() {}
 183
 184   using SyncNetworkChannel::NotifyNetworkStatusChange;
 185   using SyncNetworkChannel::NotifyChannelStateChange;
 186   using SyncNetworkChannel::DeliverIncomingMessage;
 187
 188   virtual void SendMessage(const std::string& message) OVERRIDE {
 189   }
 190
 191   virtual void UpdateCredentials(const std::string& email,
 192       const std::string& token) OVERRIDE {
 193   }
 194
 195   virtual int GetInvalidationClientType() OVERRIDE {
 196     return 0;
 197   }
 198
 199   virtual void RequestDetailedStatus(
 200       base::Callback<void(const base::DictionaryValue&)> callback) OVERRIDE {
 201     base::DictionaryValue value;
 202     callback.Run(value);
 203   }
 204 };
 205
 206 class SyncNetworkChannelTest
 207     : public testing::Test,
 208       public SyncNetworkChannel::Observer {
 209  protected:
 210   SyncNetworkChannelTest()
 211       : last_invalidator_state_(DEFAULT_INVALIDATION_ERROR),
 212         connected_(false) {
 213     network_channel_.AddObserver(this);
 214     network_channel_.AddNetworkStatusReceiver(
 215         invalidation::NewPermanentCallback(
 216             this, &SyncNetworkChannelTest::OnNetworkStatusChange));
 217   }
 218
 219   virtual ~SyncNetworkChannelTest() {
 220     network_channel_.RemoveObserver(this);
 221   }
 222
 223   virtual void OnNetworkChannelStateChanged(
 224       InvalidatorState invalidator_state) OVERRIDE {
 225     last_invalidator_state_ = invalidator_state;
 226   }
 227
 228   void OnNetworkStatusChange(bool connected) {
 229     connected_ = connected;
 230   }
 231
 232   TestSyncNetworkChannel network_channel_;
 233   InvalidatorState last_invalidator_state_;
 234   bool connected_;
 235 };
 236
 237 // Simulate channel state change. It should propagate to observer.
 238 TEST_F(SyncNetworkChannelTest, ChannelStateChange) {
 239   EXPECT_EQ(DEFAULT_INVALIDATION_ERROR, last_invalidator_state_);
 240   network_channel_.NotifyChannelStateChange(INVALIDATIONS_ENABLED);
 241   EXPECT_EQ(INVALIDATIONS_ENABLED, last_invalidator_state_);
 242   network_channel_.NotifyChannelStateChange(INVALIDATION_CREDENTIALS_REJECTED);
 243   EXPECT_EQ(INVALIDATION_CREDENTIALS_REJECTED, last_invalidator_state_);
 244 }
 245
 246 // Simulate network state change. It should propagate to cacheinvalidations.
 247 TEST_F(SyncNetworkChannelTest, NetworkStateChange) {
 248   EXPECT_FALSE(connected_);
 249   network_channel_.NotifyNetworkStatusChange(true);
 250   EXPECT_TRUE(connected_);
 251   network_channel_.NotifyNetworkStatusChange(false);
 252   EXPECT_FALSE(connected_);
 253 }
 254
 255 }  // namespace
 256 }  // namespace syncer