[Sync] USS: Ignore encryption changes during conflict resolution 1/2

sync/internal_api/processor_entity_tracker_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 "sync/internal_api/public/processor_entity_tracker.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/non_blocking_sync_common.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/syncable_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer_v2 {
 
+namespace {
+
+const std::string kTag1 = "tag1";
+const std::string kTag2 = "tag2";
+const std::string kTag3 = "tag3";
+const std::string kValue1 = "value1";
+const std::string kValue2 = "value2";
+const std::string kValue3 = "value3";
+
+std::string GenerateTagHash(const std::string& tag) {
+  return syncer::syncable::GenerateSyncableHash(syncer::PREFERENCES, tag);
+}
+
+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
+
 // Some simple sanity tests for the ProcessorEntityTracker.
 //
 // A lot of the more complicated sync logic is implemented in the
 // SharedModelTypeProcessor that owns the ProcessorEntityTracker.  We can't unit
 // test it here.
 //
 // Instead, we focus on simple tests to make sure that variables are getting
 // properly intialized and flags properly set.  Anything more complicated would
 // be a redundant and incomplete version of the SharedModelTypeProcessor tests.
 class ProcessorEntityTrackerTest : public ::testing::Test {
  public:
   ProcessorEntityTrackerTest()
       : kServerId("ServerID"),
         kClientTag("sample.pref.name"),
-        kClientTagHash(GetSyncableHash(kClientTag)),
+        kClientTagHash(GenerateTagHash(kClientTag)),
         kCtime(base::Time::UnixEpoch() + base::TimeDelta::FromDays(10)),
-        kMtime(base::Time::UnixEpoch() + base::TimeDelta::FromDays(20)) {
-    sync_pb::PreferenceSpecifics* pref_specifics =
-        specifics.mutable_preference();
-    pref_specifics->set_name(kClientTag);
-    pref_specifics->set_value("pref.value");
-  }
-
-  static std::string GetSyncableHash(const std::string& tag) {
-    return syncer::syncable::GenerateSyncableHash(syncer::PREFERENCES, tag);
-  }
+        kMtime(base::Time::UnixEpoch() + base::TimeDelta::FromDays(20)),
+        specifics(GenerateSpecifics(kClientTag, kValue1)) {}
 
   std::unique_ptr<ProcessorEntityTracker> NewLocalItem(const std::string& tag) {
     return std::unique_ptr<ProcessorEntityTracker>(
-        ProcessorEntityTracker::CreateNew(tag, GetSyncableHash(tag), "",
+        ProcessorEntityTracker::CreateNew(tag, GenerateTagHash(tag), "",
                                           kCtime));
   }
 
   std::unique_ptr<ProcessorEntityTracker> NewLocalItem(
       const std::string& tag,
       const sync_pb::EntitySpecifics& specifics) {
     std::unique_ptr<ProcessorEntityTracker> entity(NewLocalItem(tag));
     MakeLocalChange(entity.get(), specifics);
     return entity;
   }
@@ skipping 56 matching lines @@
   const std::string kClientTagHash;
   const base::Time kCtime;
   const base::Time kMtime;
   sync_pb::EntitySpecifics specifics;
 };
 
 TEST_F(ProcessorEntityTrackerTest, NewItem) {
   std::unique_ptr<ProcessorEntityTracker> entity(NewLocalItem("asdf"));
 
   EXPECT_EQ(entity->client_tag(), "asdf");
-  EXPECT_EQ(entity->metadata().client_tag_hash(), GetSyncableHash("asdf"));
+  EXPECT_EQ(entity->metadata().client_tag_hash(), GenerateTagHash("asdf"));
 
   EXPECT_FALSE(entity->HasCommitData());
   EXPECT_FALSE(HasSpecificsHash(entity));
 
   EXPECT_FALSE(entity->IsUnsynced());
   EXPECT_FALSE(entity->UpdateIsReflection(1));
 }
 
 TEST_F(ProcessorEntityTrackerTest, NewLocalItem) {
   std::unique_ptr<ProcessorEntityTracker> entity(
       NewLocalItem("asdf", specifics));
 
   EXPECT_EQ(1, entity->metadata().sequence_number());
   EXPECT_EQ(0, entity->metadata().acked_sequence_number());
   EXPECT_EQ(kUncommittedVersion, entity->metadata().server_version());
   EXPECT_TRUE(entity->HasCommitData());
   EXPECT_TRUE(HasSpecificsHash(entity));
   EXPECT_TRUE(entity->IsUnsynced());
   EXPECT_FALSE(entity->UpdateIsReflection(1));
 
-  entity->ReceiveCommitResponse("id", 1, 1);
+  CommitResponseData data;
+  data.id = "id";
+  data.client_tag_hash = entity->metadata().client_tag_hash();
+  data.sequence_number = 1;
+  data.response_version = 1;
+  data.specifics_hash = entity->metadata().specifics_hash();
+  entity->ReceiveCommitResponse(data);
 
   EXPECT_EQ(1, entity->metadata().sequence_number());
   EXPECT_EQ(1, entity->metadata().acked_sequence_number());
   EXPECT_EQ(1, entity->metadata().server_version());
   EXPECT_FALSE(entity->HasCommitData());
   EXPECT_TRUE(HasSpecificsHash(entity));
+  EXPECT_TRUE(entity->metadata().base_specifics_hash().empty());
   EXPECT_FALSE(entity->IsUnsynced());
   EXPECT_TRUE(entity->UpdateIsReflection(1));
 }
 
 TEST_F(ProcessorEntityTrackerTest, FromServerUpdate) {
   std::unique_ptr<ProcessorEntityTracker> entity(NewServerItem());
 
   EXPECT_EQ(entity->client_tag(), kClientTag);
   EXPECT_EQ(entity->metadata().client_tag_hash(), kClientTagHash);
   EXPECT_FALSE(HasSpecificsHash(entity));
@@ skipping 112 matching lines @@
   entity->Delete();
 
   entity->InitializeCommitRequestData(&commit_request);
   const EntityData& data3 = commit_request.entity.value();
 
   EXPECT_EQ(3, commit_request.sequence_number);
   EXPECT_TRUE(data3.is_deleted());
 }
 
 }  // namespace syncer_v2