NOT FOR REVIEW

components/wifi_sync/wifi_credential_syncable_service_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/wifi_sync/wifi_credential_syncable_service_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
 #include "components/wifi_sync/wifi_config_delegate.h"
+#include "components/wifi_sync/wifi_config_observer.h"
 #include "components/wifi_sync/wifi_credential.h"
 #include "components/wifi_sync/wifi_security_class.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/api/fake_sync_change_processor.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/internal_api/public/attachments/attachment_service_proxy_for_test.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace wifi_sync {
 
 using syncer::FakeSyncChangeProcessor;
 using syncer::SyncErrorFactoryMock;
 
 namespace {
 
 const char kSsid[] = "fake-ssid";
 const char kSsidNonUtf8[] = "\xc0";
 
 // Fake implementation of WifiConfigDelegate, which provides the
 // ability to check how many times a WifiConfigDelegate method has
 // been called.
 class FakeWifiConfigDelegate : public WifiConfigDelegate {
  public:
-  FakeWifiConfigDelegate() : add_count_(0) {}
+  FakeWifiConfigDelegate()
+      : add_count_(0) {}
   ~FakeWifiConfigDelegate() override {}
 
   // WifiConfigDelegate implementation.
   void AddToLocalNetworks(const WifiCredential& network_credential) override {
     ++add_count_;
   }
 
   // Returns the number of times the AddToLocalNetworks method has
   // been called.
   unsigned int add_count() const { return add_count_; }
 
  private:
   // The number of times AddToLocalNetworks has been called on this fake.
   unsigned int add_count_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeWifiConfigDelegate);
 };
 
+// Fake implementation of WifiConfigObserver, which provides the
+// ability to check how many times a WifiConfigObserver method has
+// been called.
+class FakeWifiConfigObserver : public WifiConfigObserver {
+ public:
+  FakeWifiConfigObserver()
+      : start_syncing_called_(false),
+        stop_syncing_called_(false) {}
+  ~FakeWifiConfigObserver() override {}
+
+  // WifiConfigObserver implementation.
+  void StartSyncing(
+      base::WeakPtr<WifiCredentialSyncableService> syncable_service) override {
+    start_syncing_called_ = true;
+  }
+  void StopSyncing() override {
+    stop_syncing_called_ = true;
+  }
+
+  // Returns whether or not the StartSyncing method has been called.
+  bool start_syncing_called() const { return start_syncing_called_; }
+
+  // Returns whether or not the StopSyncing method has been called.
+  bool stop_syncing_called() const { return stop_syncing_called_; }
+
+ private:
+  // Whether or not StartSyncing has been called on this fake.
+  bool start_syncing_called_;
+
+  // Whether or not StopSyncing has been called on this fake.
+  bool stop_syncing_called_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeWifiConfigObserver);
+};
+
 // Unit tests for WifiCredentialSyncableService.
 class WifiCredentialSyncableServiceTest : public testing::Test {
  protected:
   WifiCredentialSyncableServiceTest()
       : config_delegate_(new FakeWifiConfigDelegate()),
+        config_observer_(new FakeWifiConfigObserver()),
         change_processor_(nullptr) {
     syncable_service_.reset(
         new WifiCredentialSyncableServiceImpl(
-            make_scoped_ptr(config_delegate_)));
+            make_scoped_ptr(config_delegate_),
+            make_scoped_ptr(config_observer_)));
   }
 
   // Wrappers for methods in WifiCredentialSyncableService.
+  void StopSyncing() {
+    syncable_service_->StopSyncing(syncer::WIFI_CREDENTIALS);
+  }
   syncer::SyncError ProcessSyncChanges(
       const syncer::SyncChangeList& change_list) {
     return syncable_service_->ProcessSyncChanges(FROM_HERE, change_list);
   }
-  bool AddToSyncedNetworks(const std::string& item_id,
-                           const WifiCredential& credential) {
-    return syncable_service_->AddToSyncedNetworks(item_id, credential);
+  bool AddToSyncedNetworks(const WifiCredential& credential) {
+    return syncable_service_->AddToSyncedNetworks(credential);
   }
 
   // Returns the number of change requests received by
   // |change_processor_|.
   int change_processor_changes_size() {
     CHECK(change_processor_);
     return change_processor_->changes().size();
   }
 
+  // Returns whether or not StartSyncing has been called on
+  // |config_observer_|.
+  bool config_observer_start_syncing_called() {
+    return config_observer_->start_syncing_called();
+  }
+
+  // Returns whether or not StopSyncing been called on
+  // |config_observer_|.
+  bool config_observer_stop_syncing_called() {
+    return config_observer_->stop_syncing_called();
+  }
+
   // Returns the number of times AddToLocalNetworks has been called on
   // |config_delegate_|.
   unsigned int config_delegate_add_count() {
     return config_delegate_->add_count();
   }
 
   // Returns a new WifiCredential constructed from the given parameters.
   WifiCredential MakeCredential(const std::string& ssid,
                                 WifiSecurityClass security_class,
                                 const std::string& passphrase) {
@@ skipping 43 matching lines @@
         new FakeSyncChangeProcessor());
     change_processor_ = change_processor.get();
     syncable_service_->MergeDataAndStartSyncing(
         syncer::WIFI_CREDENTIALS, syncer::SyncDataList(),
         change_processor.Pass(), make_scoped_ptr(new SyncErrorFactoryMock()));
   }
 
  private:
   scoped_ptr<WifiCredentialSyncableService> syncable_service_;
   FakeWifiConfigDelegate* config_delegate_;    // Owned by |syncable_service_|
+  FakeWifiConfigObserver* config_observer_;    // Owned by |syncable_service_|
   FakeSyncChangeProcessor* change_processor_;  // Owned by |syncable_service_|
 
   DISALLOW_COPY_AND_ASSIGN(WifiCredentialSyncableServiceTest);
 };
 
 }  // namespace
 
 TEST_F(WifiCredentialSyncableServiceTest, ProcessSyncChangesNotStarted) {
   syncer::SyncError sync_error(ProcessSyncChanges(syncer::SyncChangeList()));
   ASSERT_TRUE(sync_error.IsSet());
   EXPECT_EQ(syncer::SyncError::UNREADY_ERROR, sync_error.error_type());
   EXPECT_EQ(0U, config_delegate_add_count());
 }
 
+TEST_F(WifiCredentialSyncableServiceTest, StartSyncing) {
+  StartSyncing();
+  EXPECT_TRUE(config_observer_start_syncing_called());
+}
+
+TEST_F(WifiCredentialSyncableServiceTest, StopSyncing) {
+  StartSyncing();
+  StopSyncing();
+  EXPECT_TRUE(config_observer_stop_syncing_called());
+}
+
 TEST_F(WifiCredentialSyncableServiceTest,
        ProcessSyncChangesActionAddSecurityClassInvalid) {
   syncer::SyncChangeList changes;
   const int sync_item_id = 1;
   changes.push_back(MakeActionAdd(
       sync_item_id, kSsidNonUtf8,
       sync_pb::WifiCredentialSpecifics::SECURITY_CLASS_INVALID, nullptr));
   StartSyncing();
   syncer::SyncError sync_error = ProcessSyncChanges(changes);
   EXPECT_FALSE(sync_error.IsSet());  // Bad items are ignored.
@@ skipping 92 matching lines @@
       2 /* sync item id */, kSsidNonUtf8,
       sync_pb::WifiCredentialSpecifics::SECURITY_CLASS_NONE, nullptr));
   StartSyncing();
   syncer::SyncError sync_error = ProcessSyncChanges(changes);
   EXPECT_FALSE(sync_error.IsSet());  // Bad items are ignored.
   EXPECT_EQ(1U, config_delegate_add_count());
 }
 
 TEST_F(WifiCredentialSyncableServiceTest, AddToSyncedNetworksNotStarted) {
   EXPECT_FALSE(AddToSyncedNetworks(
-      "fake-item-id", MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
+      MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
 }
 
 TEST_F(WifiCredentialSyncableServiceTest, AddToSyncedNetworksSuccess) {
   StartSyncing();
   EXPECT_TRUE(AddToSyncedNetworks(
-      "fake-item-id", MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
+      MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
   EXPECT_EQ(1, change_processor_changes_size());
 }
 
 TEST_F(WifiCredentialSyncableServiceTest,
        AddToSyncedNetworksDifferentSecurityClassesSuccess) {
   StartSyncing();
   EXPECT_TRUE(AddToSyncedNetworks(
-      "fake-item-id", MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
+      MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
   EXPECT_TRUE(AddToSyncedNetworks(
-      "fake-item-id-2",
       MakeCredential(kSsidNonUtf8, SECURITY_CLASS_WEP, "")));
   EXPECT_EQ(2, change_processor_changes_size());
 }
 
 TEST_F(WifiCredentialSyncableServiceTest,
        AddToSyncedNetworksDifferentSsidsSuccess) {
   StartSyncing();
   EXPECT_TRUE(AddToSyncedNetworks(
-      "fake-item-id", MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
+      MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
   EXPECT_TRUE(AddToSyncedNetworks(
-      "fake-item-id-2", MakeCredential(kSsid, SECURITY_CLASS_NONE, "")));
+      MakeCredential(kSsid, SECURITY_CLASS_NONE, "")));
   EXPECT_EQ(2, change_processor_changes_size());
 }
 
 TEST_F(WifiCredentialSyncableServiceTest,
        AddToSyncedNetworksDuplicateAddPskNetwork) {
   const std::string passphrase("psk-passphrase");
   StartSyncing();
   EXPECT_TRUE(
       AddToSyncedNetworks(
-          "fake-item-id",
           MakeCredential(kSsidNonUtf8, SECURITY_CLASS_PSK, passphrase)));
   EXPECT_EQ(1, change_processor_changes_size());
   EXPECT_FALSE(
       AddToSyncedNetworks(
-          "fake-item-id",
           MakeCredential(kSsidNonUtf8, SECURITY_CLASS_PSK, passphrase)));
   EXPECT_EQ(1, change_processor_changes_size());
 }
 
 TEST_F(WifiCredentialSyncableServiceTest,
        AddToSyncedNetworksDuplicateAddOpenNetwork) {
   StartSyncing();
   EXPECT_TRUE(
       AddToSyncedNetworks(
-          "fake-item-id",
           MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
   EXPECT_EQ(1, change_processor_changes_size());
   EXPECT_FALSE(
       AddToSyncedNetworks(
-          "fake-item-id",
           MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
   EXPECT_EQ(1, change_processor_changes_size());
 }
 
 }  // namespace wifi_sync