src/chrome/browser/sync_file_system/drive_backend_v1/remote_sync_operation_resolver_unittest.cc

   1 // Copyright 2013 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 <sstream>
   6 #include <string>
   7 #include <vector>
   8
   9 #include "chrome/browser/sync_file_system/drive_backend_v1/remote_sync_operation_resolver.h"
  10 #include "chrome/browser/sync_file_system/file_change.h"
  11 #include "chrome/browser/sync_file_system/sync_file_type.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace sync_file_system {
  15
  16 namespace {
  17
  18 struct Input {
  19   SyncFileType local_file_type;
  20   FileChangeList local_changes;
  21
  22   std::string DebugString() {
  23     std::ostringstream ss;
  24     ss << "LocalFileType: " << local_file_type
  25        << ", LocalChanges: " << local_changes.DebugString();
  26     return ss.str();
  27   }
  28 };
  29
  30 template <typename type, size_t array_size>
  31 std::vector<type> CreateList(const type (&inputs)[array_size]) {
  32   return std::vector<type>(inputs, inputs + array_size);
  33 }
  34
  35 FileChangeList CreateEmptyChange() {
  36   return FileChangeList();
  37 }
  38
  39 FileChangeList CreateAddOrUpdateFileChange() {
  40   FileChangeList list;
  41   list.Update(FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
  42                          SYNC_FILE_TYPE_FILE));
  43   return list;
  44 }
  45
  46 FileChangeList CreateAddDirectoryChange() {
  47   FileChangeList list;
  48   list.Update(FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
  49                          SYNC_FILE_TYPE_DIRECTORY));
  50   return list;
  51 }
  52
  53 FileChangeList CreateDeleteFileChange() {
  54   FileChangeList list;
  55   list.Update(FileChange(FileChange::FILE_CHANGE_DELETE,
  56                          SYNC_FILE_TYPE_FILE));
  57   return list;
  58 }
  59
  60 FileChangeList CreateDeleteDirectoryChange() {
  61   FileChangeList list;
  62   list.Update(FileChange(FileChange::FILE_CHANGE_DELETE,
  63                          SYNC_FILE_TYPE_DIRECTORY));
  64   return list;
  65 }
  66
  67 std::vector<Input> CreateInput() {
  68   const Input inputs[] = {
  69     { SYNC_FILE_TYPE_UNKNOWN, CreateEmptyChange() },
  70     { SYNC_FILE_TYPE_UNKNOWN, CreateAddOrUpdateFileChange() },
  71     { SYNC_FILE_TYPE_UNKNOWN, CreateAddDirectoryChange() },
  72     { SYNC_FILE_TYPE_UNKNOWN, CreateDeleteFileChange() },
  73     { SYNC_FILE_TYPE_UNKNOWN, CreateDeleteDirectoryChange() },
  74
  75     { SYNC_FILE_TYPE_FILE, CreateEmptyChange() },
  76     { SYNC_FILE_TYPE_FILE, CreateAddOrUpdateFileChange() },
  77     { SYNC_FILE_TYPE_FILE, CreateAddDirectoryChange() },
  78     { SYNC_FILE_TYPE_FILE, CreateDeleteFileChange() },
  79     { SYNC_FILE_TYPE_FILE, CreateDeleteDirectoryChange() },
  80
  81     { SYNC_FILE_TYPE_DIRECTORY, CreateEmptyChange() },
  82     { SYNC_FILE_TYPE_DIRECTORY, CreateAddOrUpdateFileChange() },
  83     { SYNC_FILE_TYPE_DIRECTORY, CreateAddDirectoryChange() },
  84     { SYNC_FILE_TYPE_DIRECTORY, CreateDeleteFileChange() },
  85     { SYNC_FILE_TYPE_DIRECTORY, CreateDeleteDirectoryChange() },
  86   };
  87   return CreateList(inputs);
  88 }
  89
  90 }  // namespace
  91
  92 class RemoteSyncOperationResolverTest : public testing::Test {
  93  public:
  94   RemoteSyncOperationResolverTest() {}
  95
  96  protected:
  97   typedef RemoteSyncOperationResolver Resolver;
  98   typedef std::vector<SyncOperationType> ExpectedTypes;
  99
 100  private:
 101   DISALLOW_COPY_AND_ASSIGN(RemoteSyncOperationResolverTest);
 102 };
 103
 104 TEST_F(RemoteSyncOperationResolverTest, ResolveForAddOrUpdateFile) {
 105   const SyncOperationType kExpectedTypes[] = {
 106     SYNC_OPERATION_ADD_FILE,
 107     SYNC_OPERATION_FAIL,
 108     SYNC_OPERATION_FAIL,
 109     SYNC_OPERATION_ADD_FILE,
 110     SYNC_OPERATION_ADD_FILE,
 111
 112     SYNC_OPERATION_UPDATE_FILE,
 113     SYNC_OPERATION_CONFLICT,
 114     SYNC_OPERATION_FAIL,
 115     SYNC_OPERATION_FAIL,
 116     SYNC_OPERATION_FAIL,
 117
 118     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 119     SYNC_OPERATION_FAIL,
 120     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 121     SYNC_OPERATION_FAIL,
 122     SYNC_OPERATION_FAIL,
 123   };
 124
 125   ExpectedTypes expected_types = CreateList(kExpectedTypes);
 126   std::vector<Input> inputs = CreateInput();
 127
 128   ASSERT_EQ(expected_types.size(), inputs.size());
 129   for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i)
 130     EXPECT_EQ(expected_types[i],
 131               Resolver::ResolveForAddOrUpdateFile(
 132                   inputs[i].local_changes, inputs[i].local_file_type))
 133         << "Case " << i << ":  (" << inputs[i].DebugString() << ")";
 134 }
 135
 136 TEST_F(RemoteSyncOperationResolverTest, ResolveForAddOrUpdateFileInConflict) {
 137   const SyncOperationType kExpectedTypes[] = {
 138     SYNC_OPERATION_FAIL,
 139     SYNC_OPERATION_FAIL,
 140     SYNC_OPERATION_FAIL,
 141     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 142     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 143
 144     SYNC_OPERATION_CONFLICT,
 145     SYNC_OPERATION_CONFLICT,
 146     SYNC_OPERATION_FAIL,
 147     SYNC_OPERATION_FAIL,
 148     SYNC_OPERATION_FAIL,
 149
 150     SYNC_OPERATION_FAIL,
 151     SYNC_OPERATION_FAIL,
 152     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 153     SYNC_OPERATION_FAIL,
 154     SYNC_OPERATION_FAIL,
 155   };
 156
 157   ExpectedTypes expected_types = CreateList(kExpectedTypes);
 158   std::vector<Input> inputs = CreateInput();
 159
 160   ASSERT_EQ(expected_types.size(), inputs.size());
 161   for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i)
 162     EXPECT_EQ(expected_types[i],
 163               Resolver::ResolveForAddOrUpdateFileInConflict(
 164                   inputs[i].local_changes, inputs[i].local_file_type))
 165         << "Case " << i << ": (" << inputs[i].DebugString() << ")";
 166 }
 167
 168 TEST_F(RemoteSyncOperationResolverTest, ResolveForAddDirectory) {
 169   const SyncOperationType kExpectedTypes[] = {
 170     SYNC_OPERATION_ADD_DIRECTORY,
 171     SYNC_OPERATION_FAIL,
 172     SYNC_OPERATION_FAIL,
 173     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 174     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 175
 176     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 177     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 178     SYNC_OPERATION_FAIL,
 179     SYNC_OPERATION_FAIL,
 180     SYNC_OPERATION_FAIL,
 181
 182     SYNC_OPERATION_NONE,
 183     SYNC_OPERATION_FAIL,
 184     SYNC_OPERATION_NONE,
 185     SYNC_OPERATION_FAIL,
 186     SYNC_OPERATION_FAIL,
 187   };
 188
 189   ExpectedTypes expected_types = CreateList(kExpectedTypes);
 190   std::vector<Input> inputs = CreateInput();
 191
 192   ASSERT_EQ(expected_types.size(), inputs.size());
 193   for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i)
 194     EXPECT_EQ(expected_types[i],
 195               Resolver::ResolveForAddDirectory(
 196                   inputs[i].local_changes, inputs[i].local_file_type))
 197         << "Case " << i << ": (" << inputs[i].DebugString() << ")";
 198 }
 199
 200 TEST_F(RemoteSyncOperationResolverTest, ResolveForAddDirectoryInConflict) {
 201   const SyncOperationType kExpectedTypes[] = {
 202     SYNC_OPERATION_FAIL,
 203     SYNC_OPERATION_FAIL,
 204     SYNC_OPERATION_FAIL,
 205     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 206     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 207
 208     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 209     SYNC_OPERATION_RESOLVE_TO_REMOTE,
 210     SYNC_OPERATION_FAIL,
 211     SYNC_OPERATION_FAIL,
 212     SYNC_OPERATION_FAIL,
 213
 214     SYNC_OPERATION_FAIL,
 215     SYNC_OPERATION_FAIL,
 216     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 217     SYNC_OPERATION_FAIL,
 218     SYNC_OPERATION_FAIL,
 219   };
 220
 221   ExpectedTypes expected_types = CreateList(kExpectedTypes);
 222   std::vector<Input> inputs = CreateInput();
 223
 224   ASSERT_EQ(expected_types.size(), inputs.size());
 225   for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i)
 226     EXPECT_EQ(expected_types[i],
 227               Resolver::ResolveForAddDirectoryInConflict(
 228                   inputs[i].local_changes, inputs[i].local_file_type))
 229         << "Case " << i << ": (" << inputs[i].DebugString() << ")";
 230 }
 231
 232 TEST_F(RemoteSyncOperationResolverTest, ResolveForDeleteFile) {
 233   const SyncOperationType kExpectedTypes[] = {
 234     SYNC_OPERATION_DELETE_METADATA,
 235     SYNC_OPERATION_FAIL,
 236     SYNC_OPERATION_FAIL,
 237     SYNC_OPERATION_DELETE_METADATA,
 238     SYNC_OPERATION_DELETE_METADATA,
 239
 240     SYNC_OPERATION_DELETE,
 241     SYNC_OPERATION_NONE,
 242     SYNC_OPERATION_FAIL,
 243     SYNC_OPERATION_FAIL,
 244     SYNC_OPERATION_FAIL,
 245
 246     SYNC_OPERATION_NONE,
 247     SYNC_OPERATION_FAIL,
 248     SYNC_OPERATION_NONE,
 249     SYNC_OPERATION_FAIL,
 250     SYNC_OPERATION_FAIL,
 251   };
 252
 253   ExpectedTypes expected_types = CreateList(kExpectedTypes);
 254   std::vector<Input> inputs = CreateInput();
 255
 256   ASSERT_EQ(expected_types.size(), inputs.size());
 257   for (ExpectedTypes::size_type i = 0; i < inputs.size(); ++i)
 258     EXPECT_EQ(expected_types[i],
 259               Resolver::ResolveForDeleteFile(
 260                   inputs[i].local_changes, inputs[i].local_file_type))
 261         << "Case " << i << ": (" << inputs[i].DebugString() << ")";
 262 }
 263
 264 TEST_F(RemoteSyncOperationResolverTest, ResolveForDeleteFileInConflict) {
 265   const SyncOperationType kExpectedTypes[] = {
 266     SYNC_OPERATION_FAIL,
 267     SYNC_OPERATION_FAIL,
 268     SYNC_OPERATION_FAIL,
 269     SYNC_OPERATION_DELETE_METADATA,
 270     SYNC_OPERATION_DELETE_METADATA,
 271
 272     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 273     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 274     SYNC_OPERATION_FAIL,
 275     SYNC_OPERATION_FAIL,
 276     SYNC_OPERATION_FAIL,
 277
 278     SYNC_OPERATION_FAIL,
 279     SYNC_OPERATION_FAIL,
 280     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 281     SYNC_OPERATION_FAIL,
 282     SYNC_OPERATION_FAIL,
 283   };
 284
 285   ExpectedTypes expected_types = CreateList(kExpectedTypes);
 286   std::vector<Input> inputs = CreateInput();
 287
 288   ASSERT_EQ(expected_types.size(), inputs.size());
 289   for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i)
 290     EXPECT_EQ(expected_types[i],
 291               Resolver::ResolveForDeleteFileInConflict(
 292                   inputs[i].local_changes, inputs[i].local_file_type))
 293         << "Case " << i << ": (" << inputs[i].DebugString() << ")";
 294 }
 295
 296 TEST_F(RemoteSyncOperationResolverTest, ResolveForDeleteDirectory) {
 297   const SyncOperationType kExpectedTypes[] = {
 298     SYNC_OPERATION_NONE,
 299     SYNC_OPERATION_FAIL,
 300     SYNC_OPERATION_FAIL,
 301     SYNC_OPERATION_NONE,
 302     SYNC_OPERATION_NONE,
 303
 304     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 305     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 306     SYNC_OPERATION_FAIL,
 307     SYNC_OPERATION_FAIL,
 308     SYNC_OPERATION_FAIL,
 309
 310     SYNC_OPERATION_DELETE,
 311     SYNC_OPERATION_FAIL,
 312     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 313     SYNC_OPERATION_FAIL,
 314     SYNC_OPERATION_FAIL,
 315   };
 316
 317   ExpectedTypes expected_types = CreateList(kExpectedTypes);
 318   std::vector<Input> inputs = CreateInput();
 319
 320   ASSERT_EQ(expected_types.size(), inputs.size());
 321   for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i)
 322     EXPECT_EQ(expected_types[i],
 323               Resolver::ResolveForDeleteDirectory(
 324                   inputs[i].local_changes, inputs[i].local_file_type))
 325         << "Case " << i << ": (" << inputs[i].DebugString() << ")";
 326 }
 327
 328 TEST_F(RemoteSyncOperationResolverTest, ResolveForDeleteDirectoryInConflict) {
 329   const SyncOperationType kExpectedTypes[] = {
 330     SYNC_OPERATION_FAIL,
 331     SYNC_OPERATION_FAIL,
 332     SYNC_OPERATION_FAIL,
 333     SYNC_OPERATION_DELETE_METADATA,
 334     SYNC_OPERATION_DELETE_METADATA,
 335
 336     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 337     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 338     SYNC_OPERATION_FAIL,
 339     SYNC_OPERATION_FAIL,
 340     SYNC_OPERATION_FAIL,
 341
 342     SYNC_OPERATION_FAIL,
 343     SYNC_OPERATION_FAIL,
 344     SYNC_OPERATION_RESOLVE_TO_LOCAL,
 345     SYNC_OPERATION_FAIL,
 346     SYNC_OPERATION_FAIL,
 347   };
 348
 349   ExpectedTypes expected_types = CreateList(kExpectedTypes);
 350   std::vector<Input> inputs = CreateInput();
 351
 352   ASSERT_EQ(expected_types.size(), inputs.size());
 353   for (ExpectedTypes::size_type i = 0; i < expected_types.size(); ++i)
 354     EXPECT_EQ(expected_types[i],
 355               Resolver::ResolveForDeleteDirectoryInConflict(
 356                   inputs[i].local_changes, inputs[i].local_file_type))
 357         << "Case " << i << ": (" << inputs[i].DebugString() << ")";
 358 }
 359
 360 }  // namespace sync_file_system