sync/engine/sync_session_job_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 "sync/engine/sync_session_job.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/time.h"
  10 #include "sync/internal_api/public/base/model_type_invalidation_map.h"
  11 #include "sync/sessions/sync_session.h"
  12 #include "sync/sessions/sync_session_context.h"
  13 #include "sync/sessions/test_util.h"
  14 #include "sync/test/engine/fake_model_worker.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 using base::TimeTicks;
  19
  20 namespace syncer {
  21
  22 using sessions::SyncSession;
  23
  24 class MockDelegate : public SyncSession::Delegate {
  25  public:
  26    MockDelegate() {}
  27    ~MockDelegate() {}
  28
  29   MOCK_METHOD0(IsSyncingCurrentlySilenced, bool());
  30   MOCK_METHOD1(OnReceivedShortPollIntervalUpdate, void(const base::TimeDelta&));
  31   MOCK_METHOD1(OnReceivedLongPollIntervalUpdate ,void(const base::TimeDelta&));
  32   MOCK_METHOD1(OnReceivedSessionsCommitDelay, void(const base::TimeDelta&));
  33   MOCK_METHOD1(OnSyncProtocolError, void(const sessions::SyncSessionSnapshot&));
  34   MOCK_METHOD0(OnShouldStopSyncingPermanently, void());
  35   MOCK_METHOD1(OnSilencedUntil, void(const base::TimeTicks&));
  36 };
  37
  38 class SyncSessionJobTest : public testing::Test {
  39  public:
  40   SyncSessionJobTest() : config_params_callback_invoked_(false) {}
  41   virtual void SetUp() {
  42     routes_.clear();
  43     workers_.clear();
  44     config_params_callback_invoked_ = false;
  45     routes_[BOOKMARKS] = GROUP_PASSIVE;
  46     scoped_refptr<ModelSafeWorker> passive_worker(
  47         new FakeModelWorker(GROUP_PASSIVE));
  48     workers_.push_back(passive_worker);
  49     std::vector<ModelSafeWorker*> workers;
  50     GetWorkers(&workers);
  51     context_.reset(new sessions::SyncSessionContext(
  52         NULL,  // |connection_manager|
  53         NULL,  // |directory|
  54         workers,
  55         NULL,  // |extensions_activity_monitor|
  56         NULL,  // |throttled_data_type_tracker|
  57         std::vector<SyncEngineEventListener*>(),
  58         NULL,  // |debug_info_getter|
  59         NULL,  // |traffic_recorder|
  60         true,  // |enable keystore encryption|
  61         "fake_invalidator_client_id"));
  62     context_->set_routing_info(routes_);
  63   }
  64
  65   scoped_ptr<SyncSession> NewLocalSession() {
  66     sessions::SyncSourceInfo info(
  67         sync_pb::GetUpdatesCallerInfo::LOCAL, ModelTypeInvalidationMap());
  68     return scoped_ptr<SyncSession>(
  69         new SyncSession(context_.get(), &delegate_, info));
  70   }
  71
  72   void GetWorkers(std::vector<ModelSafeWorker*>* out) const {
  73     out->clear();
  74     for (std::vector<scoped_refptr<ModelSafeWorker> >::const_iterator it =
  75              workers_.begin(); it != workers_.end(); ++it) {
  76       out->push_back(it->get());
  77     }
  78   }
  79
  80   void ConfigurationParamsCallback() {
  81     config_params_callback_invoked_ = true;
  82   }
  83
  84   bool config_params_callback_invoked() const {
  85     return config_params_callback_invoked_;
  86   }
  87
  88   sessions::SyncSessionContext* context() { return context_.get(); }
  89   SyncSession::Delegate* delegate() { return &delegate_; }
  90   const ModelSafeRoutingInfo& routes() { return routes_; }
  91
  92   // Checks that the two jobs are "clones" as defined by SyncSessionJob,
  93   // minus location and SyncSession checking, for reuse in different
  94   // scenarios.
  95   void ExpectClonesBase(SyncSessionJob* job, SyncSessionJob* clone) {
  96     EXPECT_EQ(job->purpose(), clone->purpose());
  97     EXPECT_EQ(job->scheduled_start(), clone->scheduled_start());
  98     EXPECT_EQ(job->start_step(), clone->start_step());
  99     EXPECT_EQ(job->end_step(), clone->end_step());
 100   }
 101
 102  private:
 103   scoped_ptr<sessions::SyncSessionContext> context_;
 104   std::vector<scoped_refptr<ModelSafeWorker> > workers_;
 105   MockDelegate delegate_;
 106   ModelSafeRoutingInfo routes_;
 107   bool config_params_callback_invoked_;
 108 };
 109
 110 TEST_F(SyncSessionJobTest, Clone) {
 111   SyncSessionJob job1(SyncSessionJob::NUDGE, TimeTicks::Now(),
 112       NewLocalSession().Pass(), ConfigurationParams());
 113
 114   sessions::test_util::SimulateSuccess(job1.mutable_session(),
 115                                        job1.start_step(),
 116                                        job1.end_step());
 117   job1.Finish(false);
 118   ModelSafeRoutingInfo new_routes;
 119   new_routes[AUTOFILL] = GROUP_PASSIVE;
 120   context()->set_routing_info(new_routes);
 121   scoped_ptr<SyncSessionJob> clone1 = job1.Clone();
 122
 123   ExpectClonesBase(&job1, clone1.get());
 124   EXPECT_NE(job1.session(), clone1->session());
 125
 126   context()->set_routing_info(routes());
 127   sessions::test_util::SimulateSuccess(clone1->mutable_session(),
 128                                        clone1->start_step(),
 129                                        clone1->end_step());
 130   clone1->Finish(false);
 131   scoped_ptr<SyncSessionJob> clone2 = clone1->Clone();
 132
 133   ExpectClonesBase(clone1.get(), clone2.get());
 134   EXPECT_NE(clone1->session(), clone2->session());
 135   EXPECT_NE(clone1->session(), clone2->session());
 136
 137   clone1.reset();
 138   ExpectClonesBase(&job1, clone2.get());
 139   EXPECT_NE(job1.session(), clone2->session());
 140 }
 141
 142 TEST_F(SyncSessionJobTest, CloneAfterEarlyExit) {
 143   SyncSessionJob job1(SyncSessionJob::NUDGE, TimeTicks::Now(),
 144       NewLocalSession().Pass(), ConfigurationParams());
 145   job1.Finish(true);
 146   scoped_ptr<SyncSessionJob> job2 = job1.Clone();
 147   ExpectClonesBase(&job1, job2.get());
 148 }
 149
 150 TEST_F(SyncSessionJobTest, CloneAndAbandon) {
 151   scoped_ptr<SyncSession> session = NewLocalSession();
 152   SyncSession* session_ptr = session.get();
 153
 154   SyncSessionJob job1(SyncSessionJob::NUDGE, TimeTicks::Now(),
 155       session.Pass(), ConfigurationParams());
 156   ModelSafeRoutingInfo new_routes;
 157   new_routes[AUTOFILL] = GROUP_PASSIVE;
 158   context()->set_routing_info(new_routes);
 159
 160   scoped_ptr<SyncSessionJob> clone1 = job1.CloneAndAbandon();
 161   ExpectClonesBase(&job1, clone1.get());
 162   EXPECT_FALSE(job1.session());
 163   EXPECT_EQ(session_ptr, clone1->session());
 164 }
 165
 166 // Tests interaction between Finish and sync cycle success / failure.
 167 TEST_F(SyncSessionJobTest, Finish) {
 168   SyncSessionJob job1(SyncSessionJob::NUDGE, TimeTicks::Now(),
 169       NewLocalSession().Pass(), ConfigurationParams());
 170
 171   sessions::test_util::SimulateSuccess(job1.mutable_session(),
 172                                        job1.start_step(),
 173                                        job1.end_step());
 174   EXPECT_TRUE(job1.Finish(false /* early_exit */));
 175
 176   scoped_ptr<SyncSessionJob> job2 = job1.Clone();
 177   sessions::test_util::SimulateConnectionFailure(job2->mutable_session(),
 178                                                  job2->start_step(),
 179                                                  job2->end_step());
 180   EXPECT_FALSE(job2->Finish(false));
 181
 182   scoped_ptr<SyncSessionJob> job3 = job2->Clone();
 183   EXPECT_FALSE(job3->Finish(true));
 184 }
 185
 186 TEST_F(SyncSessionJobTest, FinishCallsReadyTask) {
 187   ConfigurationParams params;
 188   params.ready_task = base::Bind(
 189       &SyncSessionJobTest::ConfigurationParamsCallback,
 190       base::Unretained(this));
 191
 192   sessions::SyncSourceInfo info(
 193       sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
 194       ModelTypeInvalidationMap());
 195   scoped_ptr<SyncSession> session(
 196       new SyncSession(context(), delegate(), info));
 197
 198   SyncSessionJob job1(SyncSessionJob::CONFIGURATION, TimeTicks::Now(),
 199       session.Pass(), params);
 200   sessions::test_util::SimulateSuccess(job1.mutable_session(),
 201                                        job1.start_step(),
 202                                        job1.end_step());
 203   job1.Finish(false);
 204   EXPECT_TRUE(config_params_callback_invoked());
 205 }
 206
 207 }  // namespace syncer