chrome/browser/sync_file_system/syncable_file_system_util_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 "chrome/browser/sync_file_system/syncable_file_system_util.h"
   6
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/message_loop/message_loop_proxy.h"
  11 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
  12 #include "chrome/browser/sync_file_system/local/local_file_sync_context.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "webkit/browser/fileapi/external_mount_points.h"
  15 #include "webkit/common/fileapi/file_system_types.h"
  16
  17 using fileapi::ExternalMountPoints;
  18 using fileapi::FileSystemURL;
  19
  20 namespace sync_file_system {
  21
  22 namespace {
  23
  24 const char kSyncableFileSystemRootURI[] =
  25     "filesystem:http://www.example.com/external/syncfs/";
  26 const char kNonRegisteredFileSystemRootURI[] =
  27     "filesystem:http://www.example.com/external/non_registered/";
  28 const char kNonSyncableFileSystemRootURI[] =
  29     "filesystem:http://www.example.com/temporary/";
  30
  31 const char kOrigin[] = "http://www.example.com/";
  32 const base::FilePath::CharType kPath[] = FILE_PATH_LITERAL("dir/file");
  33
  34 FileSystemURL CreateFileSystemURL(const std::string& url) {
  35   return ExternalMountPoints::GetSystemInstance()->CrackURL(GURL(url));
  36 }
  37
  38 base::FilePath CreateNormalizedFilePath(const base::FilePath::CharType* path) {
  39   return base::FilePath(path).NormalizePathSeparators();
  40 }
  41
  42 }  // namespace
  43
  44 TEST(SyncableFileSystemUtilTest, GetSyncableFileSystemRootURI) {
  45   const GURL root = GetSyncableFileSystemRootURI(GURL(kOrigin));
  46   EXPECT_TRUE(root.is_valid());
  47   EXPECT_EQ(GURL(kSyncableFileSystemRootURI), root);
  48 }
  49
  50 TEST(SyncableFileSystemUtilTest, CreateSyncableFileSystemURL) {
  51   RegisterSyncableFileSystem();
  52
  53   const base::FilePath path(kPath);
  54   const FileSystemURL expected_url =
  55       CreateFileSystemURL(kSyncableFileSystemRootURI + path.AsUTF8Unsafe());
  56   const FileSystemURL url = CreateSyncableFileSystemURL(GURL(kOrigin), path);
  57
  58   EXPECT_TRUE(url.is_valid());
  59   EXPECT_EQ(expected_url, url);
  60
  61   RevokeSyncableFileSystem();
  62 }
  63
  64 TEST(SyncableFileSystemUtilTest,
  65        SerializeAndDesirializeSyncableFileSystemURL) {
  66   RegisterSyncableFileSystem();
  67
  68   const std::string expected_url_str = kSyncableFileSystemRootURI +
  69       CreateNormalizedFilePath(kPath).AsUTF8Unsafe();
  70   const FileSystemURL expected_url = CreateFileSystemURL(expected_url_str);
  71   const FileSystemURL url = CreateSyncableFileSystemURL(
  72       GURL(kOrigin), base::FilePath(kPath));
  73
  74   std::string serialized;
  75   EXPECT_TRUE(SerializeSyncableFileSystemURL(url, &serialized));
  76   EXPECT_EQ(expected_url_str, serialized);
  77
  78   FileSystemURL deserialized;
  79   EXPECT_TRUE(DeserializeSyncableFileSystemURL(serialized, &deserialized));
  80   EXPECT_TRUE(deserialized.is_valid());
  81   EXPECT_EQ(expected_url, deserialized);
  82
  83   RevokeSyncableFileSystem();
  84 }
  85
  86 TEST(SyncableFileSystemUtilTest,
  87      FailInSerializingAndDeserializingSyncableFileSystemURL) {
  88   RegisterSyncableFileSystem();
  89
  90   const base::FilePath normalized_path = CreateNormalizedFilePath(kPath);
  91   const std::string non_registered_url =
  92       kNonRegisteredFileSystemRootURI + normalized_path.AsUTF8Unsafe();
  93   const std::string non_syncable_url =
  94       kNonSyncableFileSystemRootURI + normalized_path.AsUTF8Unsafe();
  95
  96   // Expected to fail in serializing URLs of non-registered filesystem and
  97   // non-syncable filesystem.
  98   std::string serialized;
  99   EXPECT_FALSE(SerializeSyncableFileSystemURL(
 100       CreateFileSystemURL(non_registered_url), &serialized));
 101   EXPECT_FALSE(SerializeSyncableFileSystemURL(
 102       CreateFileSystemURL(non_syncable_url), &serialized));
 103
 104   // Expected to fail in deserializing a string that represents URLs of
 105   // non-registered filesystem and non-syncable filesystem.
 106   FileSystemURL deserialized;
 107   EXPECT_FALSE(DeserializeSyncableFileSystemURL(
 108       non_registered_url, &deserialized));
 109   EXPECT_FALSE(DeserializeSyncableFileSystemURL(
 110       non_syncable_url, &deserialized));
 111
 112   RevokeSyncableFileSystem();
 113 }
 114
 115 TEST(SyncableFileSystemUtilTest, SyncableFileSystemURL_IsParent) {
 116   RegisterSyncableFileSystem();
 117
 118   const std::string root1 = sync_file_system::GetSyncableFileSystemRootURI(
 119       GURL("http://foo.com")).spec();
 120   const std::string root2 = sync_file_system::GetSyncableFileSystemRootURI(
 121       GURL("http://bar.com")).spec();
 122
 123   const std::string parent("dir");
 124   const std::string child("dir/child");
 125
 126   // True case.
 127   EXPECT_TRUE(CreateFileSystemURL(root1 + parent).IsParent(
 128       CreateFileSystemURL(root1 + child)));
 129   EXPECT_TRUE(CreateFileSystemURL(root2 + parent).IsParent(
 130       CreateFileSystemURL(root2 + child)));
 131
 132   // False case: different origin.
 133   EXPECT_FALSE(CreateFileSystemURL(root1 + parent).IsParent(
 134       CreateFileSystemURL(root2 + child)));
 135   EXPECT_FALSE(CreateFileSystemURL(root2 + parent).IsParent(
 136       CreateFileSystemURL(root1 + child)));
 137
 138   RevokeSyncableFileSystem();
 139 }
 140
 141 }  // namespace sync_file_system