components: add wifi_sync component

components/wifi_sync/wifi_credential_syncable_service_unittest.cc

+// Copyright 2014 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.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "sync/api/fake_sync_change_processor.h"
+#include "sync/api/sync_error_factory_mock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace wifi_sync {
+
+class WifiCredentialSyncableServiceTest : public testing::Test {
+  void SetUp() {
+    syncable_service_.reset(new WifiCredentialSyncableService(nullptr));
+    sync_change_processor_ = nullptr;
+    sync_error_factory_ = nullptr;
+  }
+
+ protected:
+  void StartSyncing() {
+    auto change_processor =
+        make_scoped_ptr(new syncer::FakeSyncChangeProcessor());
+    auto error_factory = make_scoped_ptr(new syncer::SyncErrorFactoryMock());
+    sync_change_processor_ = change_processor.get();
+    sync_error_factory_ = error_factory.get();
+    syncable_service_->MergeDataAndStartSyncing(
+        WifiCredentialSyncableService::kModelType,
+        syncer::SyncDataList(),
+        make_scoped_ptr(change_processor.release()),
+        make_scoped_ptr(error_factory.release()));
+  }
+
+  void StopSyncing() {
+    syncable_service_->StopSyncing(WifiCredentialSyncableService::kModelType);
+  }
+
+  const WifiCredentialSyncableService &GetSyncableService() {
+    return *syncable_service_;
+  }
+
+  syncer::SyncChangeProcessor* GetSyncChangeProcessor() {
+    return syncable_service_->sync_processor_.get();

[erikwright (departed), 2014/11/17 20:18:58]

Why access this via invasive 'friend' declaration when it's _you_ that
instantiated and supplied this dependency. You already keep a reference to it in
sync_change_processor_. Use that.

Ditto for all the other accesses to private members. Remove them, and then
remove the friend declaration.

Friend declarations should be a last resort. In fact, I don't personally believe
they are _ever_ required.

[mukesh agrawal, 2014/11/18 17:17:44]

Done.

Removed this getter. Also removed StopSyncingClearsNonConstFields, since all it
was doing was checking private members of WifiCredentialSyncableService. And
since the SyncableService doesn't (yet) do anything other than set its internal
state, I've removed the unit tests file.

+  }
+
+  syncer::SyncErrorFactory* GetSyncErrorFactory() {
+    return syncable_service_->sync_error_handler_.get();
+  }
+
+  const syncer::FakeSyncChangeProcessor* sync_change_processor() const {
+    return sync_change_processor_;
+  }
+
+  const syncer::SyncErrorFactoryMock* sync_error_factory() const {
+    return sync_error_factory_;
+  }
+
+ private:
+  scoped_ptr<WifiCredentialSyncableService> syncable_service_;
+  // When non-null, |fake_sync_change_processor_| and
+  // |sync_error_factory_mock_| are owned by |syncable_service_|.
+  syncer::FakeSyncChangeProcessor* sync_change_processor_;
+  syncer::SyncErrorFactoryMock* sync_error_factory_;
+};
+
+TEST_F(WifiCredentialSyncableServiceTest,
+       StartSyncingSetsChangeProcessorAndErrorHandler) {
+  StartSyncing();
+  EXPECT_EQ(sync_change_processor(), GetSyncChangeProcessor());

[erikwright (departed), 2014/11/17 20:18:58]

You are asserting that the class correctly stored a parameter as a member
variable? This is not necessary.

You should be asserting that the class correctly did whatever it is
contractually obligated to do to the supplied dependency. Did it send the right
changes to be processed? Does it use the error factory appropriately (whatever
is appropriate)?

[mukesh agrawal, 2014/11/18 17:17:44]

Done. (Removed this test, since the class doesn't yet do anything with its
dependencies. Testing that the class DTRT with the dependencies will come when I
add the ability to modify the data, in later CLs.)

+  EXPECT_EQ(sync_error_factory(), GetSyncErrorFactory());
+}
+
+TEST_F(WifiCredentialSyncableServiceTest, StopSyncingClearsNonConstFields) {
+  StartSyncing();
+  StopSyncing();
+  EXPECT_EQ(nullptr, GetSyncChangeProcessor());
+  EXPECT_EQ(nullptr, GetSyncErrorFactory());
+}
+
+}  // namespace wifi_sync