components/invalidation/impl/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/impl/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/impl/push_client_channel.h"
  15 #include "components/invalidation/impl/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   ~SyncSystemResourcesTest() override {}
  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   ~TestSyncNetworkChannel() override {}
 183
 184   using SyncNetworkChannel::NotifyNetworkStatusChange;
 185   using SyncNetworkChannel::NotifyChannelStateChange;
 186   using SyncNetworkChannel::DeliverIncomingMessage;
 187
 188   void SendMessage(const std::string& message) override {}
 189
 190   void UpdateCredentials(const std::string& email,
 191                          const std::string& token) override {}
 192
 193   int GetInvalidationClientType() override { return 0; }
 194
 195   void RequestDetailedStatus(
 196       base::Callback<void(const base::DictionaryValue&)> callback) override {
 197     base::DictionaryValue value;
 198     callback.Run(value);
 199   }
 200 };
 201
 202 class SyncNetworkChannelTest
 203     : public testing::Test,
 204       public SyncNetworkChannel::Observer {
 205  protected:
 206   SyncNetworkChannelTest()
 207       : last_invalidator_state_(DEFAULT_INVALIDATION_ERROR),
 208         connected_(false) {
 209     network_channel_.AddObserver(this);
 210     network_channel_.AddNetworkStatusReceiver(
 211         invalidation::NewPermanentCallback(
 212             this, &SyncNetworkChannelTest::OnNetworkStatusChange));
 213   }
 214
 215   ~SyncNetworkChannelTest() override { network_channel_.RemoveObserver(this); }
 216
 217   void OnNetworkChannelStateChanged(
 218       InvalidatorState invalidator_state) override {
 219     last_invalidator_state_ = invalidator_state;
 220   }
 221
 222   void OnNetworkStatusChange(bool connected) {
 223     connected_ = connected;
 224   }
 225
 226   TestSyncNetworkChannel network_channel_;
 227   InvalidatorState last_invalidator_state_;
 228   bool connected_;
 229 };
 230
 231 // Simulate channel state change. It should propagate to observer.
 232 TEST_F(SyncNetworkChannelTest, ChannelStateChange) {
 233   EXPECT_EQ(DEFAULT_INVALIDATION_ERROR, last_invalidator_state_);
 234   network_channel_.NotifyChannelStateChange(INVALIDATIONS_ENABLED);
 235   EXPECT_EQ(INVALIDATIONS_ENABLED, last_invalidator_state_);
 236   network_channel_.NotifyChannelStateChange(INVALIDATION_CREDENTIALS_REJECTED);
 237   EXPECT_EQ(INVALIDATION_CREDENTIALS_REJECTED, last_invalidator_state_);
 238 }
 239
 240 // Simulate network state change. It should propagate to cacheinvalidations.
 241 TEST_F(SyncNetworkChannelTest, NetworkStateChange) {
 242   EXPECT_FALSE(connected_);
 243   network_channel_.NotifyNetworkStatusChange(true);
 244   EXPECT_TRUE(connected_);
 245   network_channel_.NotifyNetworkStatusChange(false);
 246   EXPECT_FALSE(connected_);
 247 }
 248
 249 }  // namespace
 250 }  // namespace syncer