sync/internal_api/js_sync_manager_observer_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/internal_api/js_sync_manager_observer.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/location.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/values.h"
  11 #include "sync/internal_api/public/base/model_type.h"
  12 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
  13 #include "sync/internal_api/public/util/sync_string_conversions.h"
  14 #include "sync/internal_api/public/util/weak_handle.h"
  15 #include "sync/js/js_event_details.h"
  16 #include "sync/js/js_test_util.h"
  17 #include "sync/protocol/sync_protocol_error.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 namespace syncer {
  21 namespace {
  22
  23 using ::testing::InSequence;
  24 using ::testing::StrictMock;
  25
  26 class JsSyncManagerObserverTest : public testing::Test {
  27  protected:
  28   JsSyncManagerObserverTest() {
  29     js_sync_manager_observer_.SetJsEventHandler(
  30         mock_js_event_handler_.AsWeakHandle());
  31   }
  32
  33  private:
  34   // This must be destroyed after the member variables below in order
  35   // for WeakHandles to be destroyed properly.
  36   base::MessageLoop message_loop_;
  37
  38  protected:
  39   StrictMock<MockJsEventHandler> mock_js_event_handler_;
  40   JsSyncManagerObserver js_sync_manager_observer_;
  41
  42   void PumpLoop() {
  43     message_loop_.RunUntilIdle();
  44   }
  45 };
  46
  47 TEST_F(JsSyncManagerObserverTest, NoArgNotifiations) {
  48   InSequence dummy;
  49
  50   EXPECT_CALL(mock_js_event_handler_,
  51               HandleJsEvent("onStopSyncingPermanently",
  52                             HasDetails(JsEventDetails())));
  53
  54   js_sync_manager_observer_.OnStopSyncingPermanently();
  55   PumpLoop();
  56 }
  57
  58 TEST_F(JsSyncManagerObserverTest, OnInitializationComplete) {
  59   base::DictionaryValue expected_details;
  60   syncer::ModelTypeSet restored_types;
  61   restored_types.Put(BOOKMARKS);
  62   restored_types.Put(NIGORI);
  63   expected_details.Set("restoredTypes", ModelTypeSetToValue(restored_types));
  64
  65   EXPECT_CALL(mock_js_event_handler_,
  66               HandleJsEvent("onInitializationComplete",
  67                             HasDetailsAsDictionary(expected_details)));
  68
  69   js_sync_manager_observer_.OnInitializationComplete(
  70       WeakHandle<JsBackend>(),
  71       WeakHandle<DataTypeDebugInfoListener>(),
  72       true,
  73       restored_types);
  74   PumpLoop();
  75 }
  76
  77 TEST_F(JsSyncManagerObserverTest, OnSyncCycleCompleted) {
  78   sessions::SyncSessionSnapshot snapshot(
  79       sessions::ModelNeutralState(),
  80       ProgressMarkerMap(),
  81       false,
  82       5,
  83       2,
  84       7,
  85       false,
  86       0,
  87       base::Time::Now(),
  88       std::vector<int>(MODEL_TYPE_COUNT, 0),
  89       std::vector<int>(MODEL_TYPE_COUNT, 0),
  90       sync_pb::GetUpdatesCallerInfo::UNKNOWN);
  91   base::DictionaryValue expected_details;
  92   expected_details.Set("snapshot", snapshot.ToValue());
  93
  94   EXPECT_CALL(mock_js_event_handler_,
  95               HandleJsEvent("onSyncCycleCompleted",
  96                             HasDetailsAsDictionary(expected_details)));
  97
  98   js_sync_manager_observer_.OnSyncCycleCompleted(snapshot);
  99   PumpLoop();
 100 }
 101
 102 TEST_F(JsSyncManagerObserverTest, OnActionableError) {
 103   SyncProtocolError sync_error;
 104   sync_error.action = CLEAR_USER_DATA_AND_RESYNC;
 105   sync_error.error_type = TRANSIENT_ERROR;
 106   base::DictionaryValue expected_details;
 107   expected_details.Set("syncError", sync_error.ToValue());
 108
 109   EXPECT_CALL(mock_js_event_handler_,
 110               HandleJsEvent("onActionableError",
 111                            HasDetailsAsDictionary(expected_details)));
 112
 113   js_sync_manager_observer_.OnActionableError(sync_error);
 114   PumpLoop();
 115 }
 116
 117
 118 TEST_F(JsSyncManagerObserverTest, OnConnectionStatusChange) {
 119   const ConnectionStatus kStatus = CONNECTION_AUTH_ERROR;
 120   base::DictionaryValue expected_details;
 121   expected_details.SetString("status",
 122                              ConnectionStatusToString(kStatus));
 123
 124   EXPECT_CALL(mock_js_event_handler_,
 125               HandleJsEvent("onConnectionStatusChange",
 126                             HasDetailsAsDictionary(expected_details)));
 127
 128   js_sync_manager_observer_.OnConnectionStatusChange(kStatus);
 129   PumpLoop();
 130 }
 131
 132 }  // namespace
 133 }  // namespace syncer