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.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/weak_handle.h"
  14 #include "sync/js/js_event_details.h"
  15 #include "sync/js/js_test_util.h"
  16 #include "sync/protocol/sync_protocol_error.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 namespace syncer {
  20 namespace {
  21
  22 using ::testing::InSequence;
  23 using ::testing::StrictMock;
  24
  25 class JsSyncManagerObserverTest : public testing::Test {
  26  protected:
  27   JsSyncManagerObserverTest() {
  28     js_sync_manager_observer_.SetJsEventHandler(
  29         mock_js_event_handler_.AsWeakHandle());
  30   }
  31
  32  private:
  33   // This must be destroyed after the member variables below in order
  34   // for WeakHandles to be destroyed properly.
  35   MessageLoop message_loop_;
  36
  37  protected:
  38   StrictMock<MockJsEventHandler> mock_js_event_handler_;
  39   JsSyncManagerObserver js_sync_manager_observer_;
  40
  41   void PumpLoop() {
  42     message_loop_.RunAllPending();
  43   }
  44 };
  45
  46 TEST_F(JsSyncManagerObserverTest, NoArgNotifiations) {
  47   InSequence dummy;
  48
  49   EXPECT_CALL(mock_js_event_handler_,
  50               HandleJsEvent("onInitializationComplete",
  51                             HasDetails(JsEventDetails())));
  52   EXPECT_CALL(mock_js_event_handler_,
  53               HandleJsEvent("onStopSyncingPermanently",
  54                             HasDetails(JsEventDetails())));
  55   EXPECT_CALL(mock_js_event_handler_,
  56               HandleJsEvent("onEncryptionComplete",
  57                             HasDetails(JsEventDetails())));
  58
  59   js_sync_manager_observer_.OnInitializationComplete(WeakHandle<JsBackend>(),
  60       true);
  61   js_sync_manager_observer_.OnStopSyncingPermanently();
  62   js_sync_manager_observer_.OnEncryptionComplete();
  63   PumpLoop();
  64 }
  65
  66 TEST_F(JsSyncManagerObserverTest, OnSyncCycleCompleted) {
  67   syncer::ModelTypePayloadMap download_progress_markers;
  68   sessions::SyncSessionSnapshot snapshot(sessions::ModelNeutralState(),
  69                                          false,
  70                                          syncer::ModelTypeSet(),
  71                                          download_progress_markers,
  72                                          false,
  73                                          true,
  74                                          8,
  75                                          5,
  76                                          2,
  77                                          7,
  78                                          sessions::SyncSourceInfo(),
  79                                          false,
  80                                          0,
  81                                          base::Time::Now(),
  82                                          false);
  83   DictionaryValue expected_details;
  84   expected_details.Set("snapshot", snapshot.ToValue());
  85
  86   EXPECT_CALL(mock_js_event_handler_,
  87               HandleJsEvent("onSyncCycleCompleted",
  88                            HasDetailsAsDictionary(expected_details)));
  89
  90   js_sync_manager_observer_.OnSyncCycleCompleted(snapshot);
  91   PumpLoop();
  92 }
  93
  94 TEST_F(JsSyncManagerObserverTest, OnActionableError) {
  95   syncer::SyncProtocolError sync_error;
  96   sync_error.action = syncer::CLEAR_USER_DATA_AND_RESYNC;
  97   sync_error.error_type = syncer::TRANSIENT_ERROR;
  98   DictionaryValue expected_details;
  99   expected_details.Set("syncError", sync_error.ToValue());
 100
 101   EXPECT_CALL(mock_js_event_handler_,
 102               HandleJsEvent("onActionableError",
 103                            HasDetailsAsDictionary(expected_details)));
 104
 105   js_sync_manager_observer_.OnActionableError(sync_error);
 106   PumpLoop();
 107 }
 108
 109
 110 TEST_F(JsSyncManagerObserverTest, OnConnectionStatusChange) {
 111   const syncer::ConnectionStatus kStatus =
 112       syncer::CONNECTION_AUTH_ERROR;
 113   DictionaryValue expected_details;
 114   expected_details.SetString("status",
 115                              syncer::ConnectionStatusToString(kStatus));
 116
 117   EXPECT_CALL(mock_js_event_handler_,
 118               HandleJsEvent("onConnectionStatusChange",
 119                             HasDetailsAsDictionary(expected_details)));
 120
 121   js_sync_manager_observer_.OnConnectionStatusChange(kStatus);
 122   PumpLoop();
 123 }
 124
 125 TEST_F(JsSyncManagerObserverTest, OnPassphraseRequired) {
 126   InSequence dummy;
 127
 128   DictionaryValue reason_passphrase_not_required_details;
 129   DictionaryValue reason_encryption_details;
 130   DictionaryValue reason_decryption_details;
 131
 132   reason_passphrase_not_required_details.SetString(
 133       "reason",
 134       syncer::PassphraseRequiredReasonToString(
 135           syncer::REASON_PASSPHRASE_NOT_REQUIRED));
 136   reason_encryption_details.SetString(
 137       "reason",
 138       syncer::PassphraseRequiredReasonToString(syncer::REASON_ENCRYPTION));
 139   reason_decryption_details.SetString(
 140       "reason",
 141       syncer::PassphraseRequiredReasonToString(syncer::REASON_DECRYPTION));
 142
 143   EXPECT_CALL(mock_js_event_handler_,
 144               HandleJsEvent("onPassphraseRequired",
 145                            HasDetailsAsDictionary(
 146                                reason_passphrase_not_required_details)));
 147   EXPECT_CALL(mock_js_event_handler_,
 148               HandleJsEvent("onPassphraseRequired",
 149                            HasDetailsAsDictionary(reason_encryption_details)));
 150   EXPECT_CALL(mock_js_event_handler_,
 151               HandleJsEvent("onPassphraseRequired",
 152                            HasDetailsAsDictionary(reason_decryption_details)));
 153
 154   js_sync_manager_observer_.OnPassphraseRequired(
 155       syncer::REASON_PASSPHRASE_NOT_REQUIRED,
 156       sync_pb::EncryptedData());
 157   js_sync_manager_observer_.OnPassphraseRequired(syncer::REASON_ENCRYPTION,
 158                                                  sync_pb::EncryptedData());
 159   js_sync_manager_observer_.OnPassphraseRequired(syncer::REASON_DECRYPTION,
 160                                                  sync_pb::EncryptedData());
 161   PumpLoop();
 162 }
 163
 164 TEST_F(JsSyncManagerObserverTest, SensitiveNotifiations) {
 165   DictionaryValue redacted_token_details;
 166   redacted_token_details.SetString("token", "<redacted>");
 167   DictionaryValue redacted_bootstrap_token_details;
 168   redacted_bootstrap_token_details.SetString("bootstrapToken", "<redacted>");
 169
 170   EXPECT_CALL(mock_js_event_handler_,
 171               HandleJsEvent("onUpdatedToken",
 172                            HasDetailsAsDictionary(redacted_token_details)));
 173   EXPECT_CALL(mock_js_event_handler_,
 174               HandleJsEvent(
 175                   "OnBootstrapTokenUpdated",
 176                   HasDetailsAsDictionary(redacted_bootstrap_token_details)));
 177
 178   js_sync_manager_observer_.OnUpdatedToken("sensitive_token");
 179   js_sync_manager_observer_.OnBootstrapTokenUpdated("sensitive_token");
 180   PumpLoop();
 181 }
 182
 183 TEST_F(JsSyncManagerObserverTest, OnEncryptedTypesChanged) {
 184   DictionaryValue expected_details;
 185   ListValue* encrypted_type_values = new ListValue();
 186   const bool encrypt_everything = false;
 187   expected_details.Set("encryptedTypes", encrypted_type_values);
 188   expected_details.SetBoolean("encryptEverything", encrypt_everything);
 189   syncer::ModelTypeSet encrypted_types;
 190
 191   for (int i = syncer::FIRST_REAL_MODEL_TYPE;
 192        i < syncer::MODEL_TYPE_COUNT; ++i) {
 193     syncer::ModelType type = syncer::ModelTypeFromInt(i);
 194     encrypted_types.Put(type);
 195     encrypted_type_values->Append(Value::CreateStringValue(
 196         syncer::ModelTypeToString(type)));
 197   }
 198
 199   EXPECT_CALL(mock_js_event_handler_,
 200               HandleJsEvent("onEncryptedTypesChanged",
 201                             HasDetailsAsDictionary(expected_details)));
 202
 203   js_sync_manager_observer_.OnEncryptedTypesChanged(
 204       encrypted_types, encrypt_everything);
 205   PumpLoop();
 206 }
 207
 208 }  // namespace
 209 }  // namespace syncer