[Sync] Start implementation of migration for USS.

components/sync/engine_impl/uss_migrator_unittest.cc

Index: components/sync/engine_impl/uss_migrator_unittest.cc
diff --git a/components/sync/engine_impl/uss_migrator_unittest.cc b/components/sync/engine_impl/uss_migrator_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ee9de366d127038aebc9bc6fbcaa898e3411b2ed
--- /dev/null
+++ b/components/sync/engine_impl/uss_migrator_unittest.cc
@@ -0,0 +1,152 @@
+// Copyright 2016 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/sync/engine_impl/uss_migrator.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "components/sync/engine_impl/model_type_worker.h"
+#include "components/sync/engine_impl/test_entry_factory.h"
+#include "components/sync/protocol/model_type_state.pb.h"
+#include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/syncable_util.h"
+#include "components/sync/syncable/test_user_share.h"
+#include "components/sync/test/engine/mock_model_type_processor.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace syncer {
+
+namespace {
+
+const ModelType kModelType = PREFERENCES;
+
+std::string GenerateTagHash(const std::string& tag) {
+  return syncable::GenerateSyncableHash(kModelType, tag);
+}
+
+const char kToken1[] = "token1";
+const char kTag1[] = "tag1";
+const char kTag2[] = "tag2";
+const char kTag3[] = "tag3";
+const char kValue1[] = "value1";
+const char kValue2[] = "value2";
+const char kValue3[] = "value3";
+const std::string kHash1(GenerateTagHash(kTag1));
+
+sync_pb::EntitySpecifics GenerateSpecifics(const std::string& tag,
+                                           const std::string& value) {
+  sync_pb::EntitySpecifics specifics;
+  specifics.mutable_preference()->set_name(tag);
+  specifics.mutable_preference()->set_value(value);
+  return specifics;
+}
+
+}  // namespace
+
+class UssMigratorTest : public ::testing::Test {

[skym, 2016/10/21 15:34:21]

Test a failure case?

[maxbogue, 2016/10/24 19:02:19]

Done.

+ public:
+  UssMigratorTest() {
+    test_user_share_.SetUp();
+    entry_factory_ = base::MakeUnique<TestEntryFactory>(directory());
+    entry_factory_->CreateTypeRootNode(kModelType);
+
+    auto processor = base::MakeUnique<MockModelTypeProcessor>();
+    processor_ = processor.get();
+    worker_ = base::MakeUnique<ModelTypeWorker>(
+        kModelType, sync_pb::ModelTypeState(), false, nullptr, nullptr,
+        std::move(processor));
+  }
+
+  ~UssMigratorTest() override { test_user_share_.TearDown(); }
+
+  void SetProgressMarkerToken(const std::string& token) {
+    sync_pb::DataTypeProgressMarker progress_marker;
+    progress_marker.set_token(token);
+    directory()->SetDownloadProgress(kModelType, progress_marker);
+  }
+
+  void InsertEntity(const std::string& key, const std::string& value) {
+    const sync_pb::EntitySpecifics specifics = GenerateSpecifics(key, value);
+    entry_factory_->CreateSyncedItem(key, kModelType, false, specifics);
+  }
+
+  UserShare* user_share() { return test_user_share_.user_share(); }
+  ModelTypeWorker* worker() { return worker_.get(); }
+  MockModelTypeProcessor* processor() { return processor_; }
+
+ private:
+  syncable::Directory* directory() { return user_share()->directory.get(); }
+
+  base::MessageLoop message_loop_;
+  TestUserShare test_user_share_;
+  std::unique_ptr<TestEntryFactory> entry_factory_;
+  MockModelTypeProcessor* processor_ = nullptr;
+  std::unique_ptr<ModelTypeWorker> worker_;
+};
+
+TEST_F(UssMigratorTest, Migrate) {
+  SetProgressMarkerToken(kToken1);
+  InsertEntity(kTag1, kValue1);
+
+  MigrateDirectoryData(kModelType, user_share(), worker());

[skym, 2016/10/21 15:34:21]

Check return value.

[maxbogue, 2016/10/24 19:02:19]

Done.

+
+  EXPECT_EQ(1U, processor()->GetNumUpdateResponses());
+  EXPECT_EQ(1U, processor()->GetNthUpdateResponse(0).size());
+
+  const sync_pb::ModelTypeState& state = processor()->GetNthUpdateState(0);
+  EXPECT_EQ(kToken1, state.progress_marker().token());
+
+  UpdateResponseData update = processor()->GetNthUpdateResponse(0).at(0);
+  const EntityData& entity = update.entity.value();
+
+  EXPECT_FALSE(entity.id.empty());
+  EXPECT_EQ(kHash1, entity.client_tag_hash);
+  EXPECT_EQ(1, update.response_version);
+  EXPECT_FALSE(entity.creation_time.is_null());

[skym, 2016/10/21 15:34:21]

Would be good to verify that time type conversions are not messing things up.

[maxbogue, 2016/10/24 19:02:19]

Seems out of scope for this CL, though I've made a note that our time.h doesn't
seem to have unit tests...

[skym, 2016/10/25 15:48:12]

I disagree. You are using the time conversions. If your use of them is messed up
somehow, things would break. I think it's reasonable for both the code and the
unittests to use the same underlying functions, and I agree with you that
testing them is out of scope.

[maxbogue, 2016/10/26 23:26:15]

I added better tests here. I just read the ctime from the directory and check
that it equals the ctime and mtime the processor received.

+  EXPECT_FALSE(entity.modification_time.is_null());
+  EXPECT_EQ(kTag1, entity.non_unique_name);
+  EXPECT_FALSE(entity.is_deleted());
+  EXPECT_EQ(kTag1, entity.specifics.preference().name());
+  EXPECT_EQ(kValue1, entity.specifics.preference().value());
+}
+
+TEST_F(UssMigratorTest, MigrateMultiple) {
+  SetProgressMarkerToken(kToken1);
+  InsertEntity(kTag1, kValue1);
+  InsertEntity(kTag2, kValue2);
+  InsertEntity(kTag3, kValue3);
+
+  MigrateDirectoryData(kModelType, user_share(), worker());

[skym, 2016/10/21 15:34:21]

Check return value.

[maxbogue, 2016/10/24 19:02:19]

Done.

+
+  EXPECT_EQ(1U, processor()->GetNumUpdateResponses());
+  EXPECT_EQ(3U, processor()->GetNthUpdateResponse(0).size());
+
+  UpdateResponseDataList updates = processor()->GetNthUpdateResponse(0);
+  EXPECT_EQ(kTag1, updates.at(0).entity.value().specifics.preference().name());
+  EXPECT_EQ(kTag2, updates.at(1).entity.value().specifics.preference().name());
+  EXPECT_EQ(kTag3, updates.at(2).entity.value().specifics.preference().name());
+}
+
+TEST_F(UssMigratorTest, MigrateMultipleBatches) {
+  SetProgressMarkerToken(kToken1);
+  InsertEntity(kTag1, kValue1);
+  InsertEntity(kTag2, kValue2);
+  InsertEntity(kTag3, kValue3);
+
+  MigrateDirectoryData(kModelType, user_share(), worker(), 2);

[skym, 2016/10/21 15:34:21]

Check return value.

[maxbogue, 2016/10/24 19:02:19]

Done.

+
+  EXPECT_EQ(1U, processor()->GetNumUpdateResponses());
+  EXPECT_EQ(3U, processor()->GetNthUpdateResponse(0).size());
+
+  UpdateResponseDataList updates = processor()->GetNthUpdateResponse(0);
+  EXPECT_EQ(kTag1, updates.at(0).entity.value().specifics.preference().name());
+  EXPECT_EQ(kTag2, updates.at(1).entity.value().specifics.preference().name());
+  EXPECT_EQ(kTag3, updates.at(2).entity.value().specifics.preference().name());
+}
+
+}  // namespace syncer