src/chrome/browser/drive/drive_api_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/drive/drive_api_util.h"
   6
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/md5.h"
   9 #include "google_apis/drive/drive_api_parser.h"
  10 #include "google_apis/drive/gdata_wapi_parser.h"
  11 #include "google_apis/drive/test_util.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "url/gurl.h"
  14
  15 namespace drive {
  16 namespace util {
  17
  18 TEST(DriveApiUtilTest, EscapeQueryStringValue) {
  19   EXPECT_EQ("abcde", EscapeQueryStringValue("abcde"));
  20   EXPECT_EQ("\\'", EscapeQueryStringValue("'"));
  21   EXPECT_EQ("\\'abcde\\'", EscapeQueryStringValue("'abcde'"));
  22   EXPECT_EQ("\\\\", EscapeQueryStringValue("\\"));
  23   EXPECT_EQ("\\\\\\'", EscapeQueryStringValue("\\'"));
  24 }
  25
  26 TEST(DriveApiUtilTest, TranslateQuery) {
  27   EXPECT_EQ("", TranslateQuery(""));
  28   EXPECT_EQ("fullText contains 'dog'", TranslateQuery("dog"));
  29   EXPECT_EQ("fullText contains 'dog' and fullText contains 'cat'",
  30             TranslateQuery("dog cat"));
  31   EXPECT_EQ("not fullText contains 'cat'", TranslateQuery("-cat"));
  32   EXPECT_EQ("fullText contains 'dog cat'", TranslateQuery("\"dog cat\""));
  33
  34   // Should handles full-width white space correctly.
  35   // Note: \xE3\x80\x80 (\u3000) is Ideographic Space (a.k.a. Japanese
  36   //   full-width whitespace).
  37   EXPECT_EQ("fullText contains 'dog' and fullText contains 'cat'",
  38             TranslateQuery("dog" "\xE3\x80\x80" "cat"));
  39
  40   // If the quoted token is not closed (i.e. the last '"' is missing),
  41   // we handle the remaining string is one token, as a fallback.
  42   EXPECT_EQ("fullText contains 'dog cat'", TranslateQuery("\"dog cat"));
  43
  44   // For quoted text with leading '-'.
  45   EXPECT_EQ("not fullText contains 'dog cat'", TranslateQuery("-\"dog cat\""));
  46
  47   // Empty tokens should be simply ignored.
  48   EXPECT_EQ("", TranslateQuery("-"));
  49   EXPECT_EQ("", TranslateQuery("\"\""));
  50   EXPECT_EQ("", TranslateQuery("-\"\""));
  51   EXPECT_EQ("", TranslateQuery("\"\"\"\""));
  52   EXPECT_EQ("", TranslateQuery("\"\" \"\""));
  53   EXPECT_EQ("fullText contains 'dog'", TranslateQuery("\"\" dog \"\""));
  54 }
  55
  56 TEST(FileSystemUtilTest, ExtractResourceIdFromUrl) {
  57   EXPECT_EQ("file:2_file_resource_id", ExtractResourceIdFromUrl(
  58       GURL("https://file1_link_self/file:2_file_resource_id")));
  59   // %3A should be unescaped.
  60   EXPECT_EQ("file:2_file_resource_id", ExtractResourceIdFromUrl(
  61       GURL("https://file1_link_self/file%3A2_file_resource_id")));
  62
  63   // The resource ID cannot be extracted, hence empty.
  64   EXPECT_EQ("", ExtractResourceIdFromUrl(GURL("https://www.example.com/")));
  65 }
  66
  67 TEST(FileSystemUtilTest, CanonicalizeResourceId) {
  68   std::string resource_id("1YsCnrMxxgp7LDdtlFDt-WdtEIth89vA9inrILtvK-Ug");
  69
  70   // New style ID is unchanged.
  71   EXPECT_EQ(resource_id, CanonicalizeResourceId(resource_id));
  72
  73   // Drop prefixes from old style IDs.
  74   EXPECT_EQ(resource_id, CanonicalizeResourceId("document:" + resource_id));
  75   EXPECT_EQ(resource_id, CanonicalizeResourceId("spreadsheet:" + resource_id));
  76   EXPECT_EQ(resource_id, CanonicalizeResourceId("presentation:" + resource_id));
  77   EXPECT_EQ(resource_id, CanonicalizeResourceId("drawing:" + resource_id));
  78   EXPECT_EQ(resource_id, CanonicalizeResourceId("table:" + resource_id));
  79   EXPECT_EQ(resource_id, CanonicalizeResourceId("externalapp:" + resource_id));
  80 }
  81
  82 TEST(FileSystemUtilTest, ConvertAccountMetadataToAboutResource) {
  83   google_apis::AccountMetadata account_metadata;
  84   // Set up AccountMetadata instance.
  85   {
  86     account_metadata.set_quota_bytes_total(10000);
  87     account_metadata.set_quota_bytes_used(1000);
  88     account_metadata.set_largest_changestamp(100);
  89   }
  90
  91   scoped_ptr<google_apis::AboutResource> about_resource(
  92       ConvertAccountMetadataToAboutResource(
  93           account_metadata, "dummy_root_id"));
  94
  95   EXPECT_EQ(10000, about_resource->quota_bytes_total());
  96   EXPECT_EQ(1000, about_resource->quota_bytes_used());
  97   EXPECT_EQ(100, about_resource->largest_change_id());
  98   EXPECT_EQ("dummy_root_id", about_resource->root_folder_id());
  99 }
 100
 101 TEST(FileSystemUtilTest, ConvertAccountMetadataToAppList) {
 102   google_apis::AccountMetadata account_metadata;
 103   // Set up AccountMetadata instance.
 104   {
 105     ScopedVector<google_apis::InstalledApp> installed_apps;
 106     scoped_ptr<google_apis::InstalledApp> installed_app(
 107         new google_apis::InstalledApp);
 108     installed_app->set_app_id("app_id");
 109     installed_app->set_app_name("name");
 110     installed_app->set_object_type("object_type");
 111     installed_app->set_supports_create(true);
 112
 113     {
 114       ScopedVector<google_apis::Link> links;
 115       scoped_ptr<google_apis::Link> link(new google_apis::Link);
 116       link->set_type(google_apis::Link::LINK_PRODUCT);
 117       link->set_href(GURL("http://product/url"));
 118       links.push_back(link.release());
 119       installed_app->set_links(links.Pass());
 120     }
 121     {
 122       ScopedVector<std::string> primary_mimetypes;
 123       primary_mimetypes.push_back(new std::string("primary_mimetype"));
 124       installed_app->set_primary_mimetypes(primary_mimetypes.Pass());
 125     }
 126     {
 127       ScopedVector<std::string> secondary_mimetypes;
 128       secondary_mimetypes.push_back(new std::string("secondary_mimetype"));
 129       installed_app->set_secondary_mimetypes(secondary_mimetypes.Pass());
 130     }
 131     {
 132       ScopedVector<std::string> primary_extensions;
 133       primary_extensions.push_back(new std::string("primary_extension"));
 134       installed_app->set_primary_extensions(primary_extensions.Pass());
 135     }
 136     {
 137       ScopedVector<std::string> secondary_extensions;
 138       secondary_extensions.push_back(new std::string("secondary_extension"));
 139       installed_app->set_secondary_extensions(secondary_extensions.Pass());
 140     }
 141     {
 142       ScopedVector<google_apis::AppIcon> app_icons;
 143       scoped_ptr<google_apis::AppIcon> app_icon(new google_apis::AppIcon);
 144       app_icon->set_category(google_apis::AppIcon::ICON_DOCUMENT);
 145       app_icon->set_icon_side_length(10);
 146       {
 147         ScopedVector<google_apis::Link> links;
 148         scoped_ptr<google_apis::Link> link(new google_apis::Link);
 149         link->set_type(google_apis::Link::LINK_ICON);
 150         link->set_href(GURL("http://icon/url"));
 151         links.push_back(link.release());
 152         app_icon->set_links(links.Pass());
 153       }
 154       app_icons.push_back(app_icon.release());
 155       installed_app->set_app_icons(app_icons.Pass());
 156     }
 157
 158     installed_apps.push_back(installed_app.release());
 159     account_metadata.set_installed_apps(installed_apps.Pass());
 160   }
 161
 162   scoped_ptr<google_apis::AppList> app_list(
 163       ConvertAccountMetadataToAppList(account_metadata));
 164   const ScopedVector<google_apis::AppResource>& items = app_list->items();
 165   ASSERT_EQ(1U, items.size());
 166
 167   const google_apis::AppResource& app_resource = *items[0];
 168   EXPECT_EQ("app_id", app_resource.application_id());
 169   EXPECT_EQ("name", app_resource.name());
 170   EXPECT_EQ("object_type", app_resource.object_type());
 171   EXPECT_TRUE(app_resource.supports_create());
 172   const ScopedVector<std::string>& primary_mimetypes =
 173       app_resource.primary_mimetypes();
 174   ASSERT_EQ(1U, primary_mimetypes.size());
 175   EXPECT_EQ("primary_mimetype", *primary_mimetypes[0]);
 176   const ScopedVector<std::string>& secondary_mimetypes =
 177       app_resource.secondary_mimetypes();
 178   ASSERT_EQ(1U, secondary_mimetypes.size());
 179   EXPECT_EQ("secondary_mimetype", *secondary_mimetypes[0]);
 180   const ScopedVector<std::string>& primary_file_extensions =
 181       app_resource.primary_file_extensions();
 182   ASSERT_EQ(1U, primary_file_extensions.size());
 183   EXPECT_EQ("primary_extension", *primary_file_extensions[0]);
 184   const ScopedVector<std::string>& secondary_file_extensions =
 185       app_resource.secondary_file_extensions();
 186   ASSERT_EQ(1U, secondary_file_extensions.size());
 187   EXPECT_EQ("secondary_extension", *secondary_file_extensions[0]);
 188
 189   const ScopedVector<google_apis::DriveAppIcon>& icons = app_resource.icons();
 190   ASSERT_EQ(1U, icons.size());
 191   const google_apis::DriveAppIcon& icon = *icons[0];
 192   EXPECT_EQ(google_apis::DriveAppIcon::DOCUMENT, icon.category());
 193   EXPECT_EQ(10, icon.icon_side_length());
 194   EXPECT_EQ("http://icon/url", icon.icon_url().spec());
 195 }
 196
 197 TEST(FileSystemUtilTest, ConvertFileResourceToResource_Parents) {
 198   google_apis::FileResource file_resource;
 199
 200   std::vector<GURL> expected_links;
 201   expected_links.push_back(GURL("http://server/id1"));
 202   expected_links.push_back(GURL("http://server/id2"));
 203   expected_links.push_back(GURL("http://server/id3"));
 204
 205   ScopedVector<google_apis::ParentReference> parents;
 206   for (size_t i = 0; i < expected_links.size(); ++i) {
 207     google_apis::ParentReference* parent = new google_apis::ParentReference;
 208     parent->set_parent_link(expected_links[i]);
 209     parents.push_back(parent);
 210   }
 211   file_resource.set_parents(parents.Pass());
 212
 213   scoped_ptr<google_apis::ResourceEntry> entry(
 214       ConvertFileResourceToResourceEntry(file_resource));
 215   std::vector<GURL> actual_links;
 216   for (size_t i = 0; i < entry->links().size(); ++i) {
 217     if (entry->links()[i]->type() == google_apis::Link::LINK_PARENT)
 218       actual_links.push_back(entry->links()[i]->href());
 219   }
 220
 221   EXPECT_EQ(expected_links, actual_links);
 222 }
 223
 224 TEST(FileSystemUtilTest, ConvertFileResourceToResourceEntryImageMediaMetadata) {
 225   google_apis::FileResource file_resource_all_fields;
 226   google_apis::FileResource file_resource_zero_fields;
 227   google_apis::FileResource file_resource_no_fields;
 228   // Set up FileResource instances;
 229   {
 230     {
 231       google_apis::ImageMediaMetadata* image_media_metadata =
 232         file_resource_all_fields.mutable_image_media_metadata();
 233       image_media_metadata->set_width(640);
 234       image_media_metadata->set_height(480);
 235       image_media_metadata->set_rotation(90);
 236     }
 237     {
 238       google_apis::ImageMediaMetadata* image_media_metadata =
 239         file_resource_zero_fields.mutable_image_media_metadata();
 240       image_media_metadata->set_width(0);
 241       image_media_metadata->set_height(0);
 242       image_media_metadata->set_rotation(0);
 243     }
 244   }
 245
 246   // Verify the converted values.
 247   {
 248     scoped_ptr<google_apis::ResourceEntry> resource_entry(
 249         ConvertFileResourceToResourceEntry(file_resource_all_fields));
 250
 251     EXPECT_EQ(640, resource_entry->image_width());
 252     EXPECT_EQ(480, resource_entry->image_height());
 253     EXPECT_EQ(90, resource_entry->image_rotation());
 254   }
 255   {
 256     scoped_ptr<google_apis::ResourceEntry> resource_entry(
 257         ConvertFileResourceToResourceEntry(file_resource_zero_fields));
 258
 259     EXPECT_EQ(0, resource_entry->image_width());
 260     EXPECT_EQ(0, resource_entry->image_height());
 261     EXPECT_EQ(0, resource_entry->image_rotation());
 262   }
 263   {
 264     scoped_ptr<google_apis::ResourceEntry> resource_entry(
 265         ConvertFileResourceToResourceEntry(file_resource_no_fields));
 266
 267     EXPECT_EQ(-1, resource_entry->image_width());
 268     EXPECT_EQ(-1, resource_entry->image_height());
 269     EXPECT_EQ(-1, resource_entry->image_rotation());
 270   }
 271 }
 272
 273 TEST(FileSystemUtilTest, ConvertResourceEntryToFileResourceImageMediaMetadata) {
 274   google_apis::ResourceEntry resource_entry_all_fields;
 275   google_apis::ResourceEntry resource_entry_zero_fields;
 276   google_apis::ResourceEntry resource_entry_no_fields;
 277   // Set up FileResource instances;
 278   {
 279     resource_entry_all_fields.set_image_width(640);
 280     resource_entry_all_fields.set_image_height(480);
 281     resource_entry_all_fields.set_image_rotation(90);
 282
 283     resource_entry_zero_fields.set_image_width(0);
 284     resource_entry_zero_fields.set_image_height(0);
 285     resource_entry_zero_fields.set_image_rotation(0);
 286   }
 287
 288   // Verify the converted values.
 289   {
 290     scoped_ptr<google_apis::FileResource> file_resource(
 291         ConvertResourceEntryToFileResource(resource_entry_all_fields));
 292     const google_apis::ImageMediaMetadata& image_media_metadata =
 293       file_resource->image_media_metadata();
 294     EXPECT_EQ(640, image_media_metadata.width());
 295     EXPECT_EQ(480, image_media_metadata.height());
 296     EXPECT_EQ(90, image_media_metadata.rotation());
 297   }
 298   {
 299     scoped_ptr<google_apis::FileResource> file_resource(
 300         ConvertResourceEntryToFileResource(resource_entry_zero_fields));
 301     const google_apis::ImageMediaMetadata& image_media_metadata =
 302       file_resource->image_media_metadata();
 303     EXPECT_EQ(0, image_media_metadata.width());
 304     EXPECT_EQ(0, image_media_metadata.height());
 305     EXPECT_EQ(0, image_media_metadata.rotation());
 306   }
 307   {
 308     scoped_ptr<google_apis::FileResource> file_resource(
 309         ConvertResourceEntryToFileResource(resource_entry_no_fields));
 310     const google_apis::ImageMediaMetadata& image_media_metadata =
 311       file_resource->image_media_metadata();
 312     EXPECT_EQ(-1, image_media_metadata.width());
 313     EXPECT_EQ(-1, image_media_metadata.height());
 314     EXPECT_EQ(-1, image_media_metadata.rotation());
 315   }
 316 }
 317
 318 TEST(DriveAPIUtilTest, GetMd5Digest) {
 319   base::ScopedTempDir temp_dir;
 320   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 321
 322   base::FilePath path = temp_dir.path().AppendASCII("test.txt");
 323   const char kTestData[] = "abcdefghijklmnopqrstuvwxyz0123456789";
 324   ASSERT_TRUE(google_apis::test_util::WriteStringToFile(path, kTestData));
 325
 326   EXPECT_EQ(base::MD5String(kTestData), GetMd5Digest(path));
 327 }
 328
 329 }  // namespace util
 330 }  // namespace drive