src/chrome/browser/google_apis/gdata_wapi_parser_unittest.cc

   1 // Copyright (c) 2012 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/google_apis/gdata_wapi_parser.h"
   6
   7 #include <string>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/json/json_file_value_serializer.h"
  11 #include "base/logging.h"
  12 #include "base/time/time.h"
  13 #include "base/values.h"
  14 #include "chrome/browser/google_apis/test_util.h"
  15 #include "chrome/browser/google_apis/time_util.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace google_apis {
  19
  20 // TODO(nhiroki): Move json files to out of 'chromeos' directory
  21 // (http://crbug.com/149788).
  22 // Test document feed parsing.
  23 TEST(GDataWAPIParserTest, ResourceListJsonParser) {
  24   std::string error;
  25   scoped_ptr<base::Value> document =
  26       test_util::LoadJSONFile("gdata/basic_feed.json");
  27   ASSERT_TRUE(document.get());
  28   ASSERT_EQ(base::Value::TYPE_DICTIONARY, document->GetType());
  29   scoped_ptr<ResourceList> feed(ResourceList::ExtractAndParse(*document));
  30   ASSERT_TRUE(feed.get());
  31
  32   base::Time update_time;
  33   ASSERT_TRUE(util::GetTimeFromString("2011-12-14T01:03:21.151Z",
  34                                                    &update_time));
  35
  36   EXPECT_EQ(1, feed->start_index());
  37   EXPECT_EQ(1000, feed->items_per_page());
  38   EXPECT_EQ(update_time, feed->updated_time());
  39
  40   // Check authors.
  41   ASSERT_EQ(1U, feed->authors().size());
  42   EXPECT_EQ("tester", feed->authors()[0]->name());
  43   EXPECT_EQ("tester@testing.com", feed->authors()[0]->email());
  44
  45   // Check links.
  46   ASSERT_EQ(6U, feed->links().size());
  47   const Link* self_link = feed->GetLinkByType(Link::LINK_SELF);
  48   ASSERT_TRUE(self_link);
  49   EXPECT_EQ("https://self_link/", self_link->href().spec());
  50   EXPECT_EQ("application/atom+xml", self_link->mime_type());
  51
  52   const Link* resumable_link =
  53       feed->GetLinkByType(Link::LINK_RESUMABLE_CREATE_MEDIA);
  54   ASSERT_TRUE(resumable_link);
  55   EXPECT_EQ("https://resumable_create_media_link/",
  56             resumable_link->href().spec());
  57   EXPECT_EQ("application/atom+xml", resumable_link->mime_type());
  58
  59   // Check entries.
  60   ASSERT_EQ(4U, feed->entries().size());
  61
  62   // Check a folder entry.
  63   const ResourceEntry* folder_entry = feed->entries()[0];
  64   ASSERT_TRUE(folder_entry);
  65   EXPECT_EQ(ENTRY_KIND_FOLDER, folder_entry->kind());
  66   EXPECT_EQ("\"HhMOFgcNHSt7ImBr\"", folder_entry->etag());
  67   EXPECT_EQ("folder:sub_sub_directory_folder_id", folder_entry->resource_id());
  68   EXPECT_EQ("https://1_folder_id", folder_entry->id());
  69   EXPECT_EQ("Entry 1 Title", folder_entry->title());
  70   base::Time entry1_update_time;
  71   base::Time entry1_publish_time;
  72   ASSERT_TRUE(util::GetTimeFromString("2011-04-01T18:34:08.234Z",
  73                                                    &entry1_update_time));
  74   ASSERT_TRUE(util::GetTimeFromString("2010-11-07T05:03:54.719Z",
  75                                                    &entry1_publish_time));
  76   EXPECT_EQ(entry1_update_time, folder_entry->updated_time());
  77   EXPECT_EQ(entry1_publish_time, folder_entry->published_time());
  78
  79   ASSERT_EQ(1U, folder_entry->authors().size());
  80   EXPECT_EQ("entry_tester", folder_entry->authors()[0]->name());
  81   EXPECT_EQ("entry_tester@testing.com", folder_entry->authors()[0]->email());
  82   EXPECT_EQ("https://1_folder_content_url/",
  83             folder_entry->download_url().spec());
  84   EXPECT_EQ("application/atom+xml;type=feed",
  85             folder_entry->content_mime_type());
  86
  87   ASSERT_EQ(1U, folder_entry->resource_links().size());
  88   const ResourceLink* feed_link = folder_entry->resource_links()[0];
  89   ASSERT_TRUE(feed_link);
  90   ASSERT_EQ(ResourceLink::FEED_LINK_ACL, feed_link->type());
  91
  92   const Link* entry1_alternate_link =
  93       folder_entry->GetLinkByType(Link::LINK_ALTERNATE);
  94   ASSERT_TRUE(entry1_alternate_link);
  95   EXPECT_EQ("https://1_folder_alternate_link/",
  96             entry1_alternate_link->href().spec());
  97   EXPECT_EQ("text/html", entry1_alternate_link->mime_type());
  98
  99   const Link* entry1_edit_link = folder_entry->GetLinkByType(Link::LINK_EDIT);
 100   ASSERT_TRUE(entry1_edit_link);
 101   EXPECT_EQ("https://1_edit_link/", entry1_edit_link->href().spec());
 102   EXPECT_EQ("application/atom+xml", entry1_edit_link->mime_type());
 103
 104   // Check a file entry.
 105   const ResourceEntry* file_entry = feed->entries()[1];
 106   ASSERT_TRUE(file_entry);
 107   EXPECT_EQ(ENTRY_KIND_FILE, file_entry->kind());
 108   EXPECT_EQ("filename.m4a", file_entry->filename());
 109   EXPECT_EQ("sugg_file_name.m4a", file_entry->suggested_filename());
 110   EXPECT_EQ("3b4382ebefec6e743578c76bbd0575ce", file_entry->file_md5());
 111   EXPECT_EQ(892721, file_entry->file_size());
 112   const Link* file_parent_link = file_entry->GetLinkByType(Link::LINK_PARENT);
 113   ASSERT_TRUE(file_parent_link);
 114   EXPECT_EQ("https://file_link_parent/", file_parent_link->href().spec());
 115   EXPECT_EQ("application/atom+xml", file_parent_link->mime_type());
 116   EXPECT_EQ("Medical", file_parent_link->title());
 117   const Link* file_open_with_link =
 118     file_entry->GetLinkByType(Link::LINK_OPEN_WITH);
 119   ASSERT_TRUE(file_open_with_link);
 120   EXPECT_EQ("https://xml_file_entry_open_with_link/",
 121             file_open_with_link->href().spec());
 122   EXPECT_EQ("application/atom+xml", file_open_with_link->mime_type());
 123   EXPECT_EQ("the_app_id", file_open_with_link->app_id());
 124   EXPECT_EQ(654321, file_entry->changestamp());
 125
 126   const Link* file_unknown_link = file_entry->GetLinkByType(Link::LINK_UNKNOWN);
 127   ASSERT_TRUE(file_unknown_link);
 128   EXPECT_EQ("https://xml_file_fake_entry_open_with_link/",
 129             file_unknown_link->href().spec());
 130   EXPECT_EQ("application/atom+xml", file_unknown_link->mime_type());
 131   EXPECT_EQ("", file_unknown_link->app_id());
 132
 133   // Check a file entry.
 134   const ResourceEntry* resource_entry = feed->entries()[2];
 135   ASSERT_TRUE(resource_entry);
 136   EXPECT_EQ(ENTRY_KIND_DOCUMENT, resource_entry->kind());
 137   EXPECT_TRUE(resource_entry->is_hosted_document());
 138   EXPECT_TRUE(resource_entry->is_google_document());
 139   EXPECT_FALSE(resource_entry->is_external_document());
 140
 141   // Check an external document entry.
 142   const ResourceEntry* app_entry = feed->entries()[3];
 143   ASSERT_TRUE(app_entry);
 144   EXPECT_EQ(ENTRY_KIND_EXTERNAL_APP, app_entry->kind());
 145   EXPECT_TRUE(app_entry->is_hosted_document());
 146   EXPECT_TRUE(app_entry->is_external_document());
 147   EXPECT_FALSE(app_entry->is_google_document());
 148 }
 149
 150
 151 // Test document feed parsing.
 152 TEST(GDataWAPIParserTest, ResourceEntryJsonParser) {
 153   std::string error;
 154   scoped_ptr<base::Value> document =
 155       test_util::LoadJSONFile("gdata/file_entry.json");
 156   ASSERT_TRUE(document.get());
 157   ASSERT_EQ(base::Value::TYPE_DICTIONARY, document->GetType());
 158   scoped_ptr<ResourceEntry> entry(ResourceEntry::ExtractAndParse(*document));
 159   ASSERT_TRUE(entry.get());
 160
 161   EXPECT_EQ(ENTRY_KIND_FILE, entry->kind());
 162   EXPECT_EQ("\"HhMOFgxXHit7ImBr\"", entry->etag());
 163   EXPECT_EQ("file:2_file_resource_id", entry->resource_id());
 164   EXPECT_EQ("2_file_id", entry->id());
 165   EXPECT_EQ("File 1.mp3", entry->title());
 166   base::Time entry1_update_time;
 167   base::Time entry1_publish_time;
 168   ASSERT_TRUE(util::GetTimeFromString("2011-12-14T00:40:47.330Z",
 169                                       &entry1_update_time));
 170   ASSERT_TRUE(util::GetTimeFromString("2011-12-13T00:40:47.330Z",
 171                                       &entry1_publish_time));
 172   EXPECT_EQ(entry1_update_time, entry->updated_time());
 173   EXPECT_EQ(entry1_publish_time, entry->published_time());
 174
 175   EXPECT_EQ(1U, entry->authors().size());
 176   EXPECT_EQ("tester", entry->authors()[0]->name());
 177   EXPECT_EQ("tester@testing.com", entry->authors()[0]->email());
 178   EXPECT_EQ("https://file_content_url/",
 179             entry->download_url().spec());
 180   EXPECT_EQ("audio/mpeg",
 181             entry->content_mime_type());
 182
 183   // Check feed links.
 184   ASSERT_EQ(1U, entry->resource_links().size());
 185   const ResourceLink* feed_link_1 = entry->resource_links()[0];
 186   ASSERT_TRUE(feed_link_1);
 187   EXPECT_EQ(ResourceLink::FEED_LINK_REVISIONS, feed_link_1->type());
 188
 189   // Check links.
 190   ASSERT_EQ(8U, entry->links().size());
 191   const Link* entry1_alternate_link =
 192       entry->GetLinkByType(Link::LINK_ALTERNATE);
 193   ASSERT_TRUE(entry1_alternate_link);
 194   EXPECT_EQ("https://file_link_alternate/",
 195             entry1_alternate_link->href().spec());
 196   EXPECT_EQ("text/html", entry1_alternate_link->mime_type());
 197
 198   const Link* entry1_edit_link = entry->GetLinkByType(Link::LINK_EDIT_MEDIA);
 199   ASSERT_TRUE(entry1_edit_link);
 200   EXPECT_EQ("https://file_edit_media/",
 201             entry1_edit_link->href().spec());
 202   EXPECT_EQ("audio/mpeg", entry1_edit_link->mime_type());
 203
 204   const Link* entry1_self_link = entry->GetLinkByType(Link::LINK_SELF);
 205   ASSERT_TRUE(entry1_self_link);
 206   EXPECT_EQ("https://file1_link_self/file%3A2_file_resource_id",
 207             entry1_self_link->href().spec());
 208   EXPECT_EQ("application/atom+xml", entry1_self_link->mime_type());
 209   EXPECT_EQ("", entry1_self_link->app_id());
 210
 211   const Link* entry1_open_with_link =
 212       entry->GetLinkByType(Link::LINK_OPEN_WITH);
 213   ASSERT_TRUE(entry1_open_with_link);
 214   EXPECT_EQ("https://entry1_open_with_link/",
 215             entry1_open_with_link->href().spec());
 216   EXPECT_EQ("application/atom+xml", entry1_open_with_link->mime_type());
 217   EXPECT_EQ("the_app_id", entry1_open_with_link->app_id());
 218
 219   const Link* entry1_unknown_link = entry->GetLinkByType(Link::LINK_UNKNOWN);
 220   ASSERT_TRUE(entry1_unknown_link);
 221   EXPECT_EQ("https://entry1_fake_entry_open_with_link/",
 222             entry1_unknown_link->href().spec());
 223   EXPECT_EQ("application/atom+xml", entry1_unknown_link->mime_type());
 224   EXPECT_EQ("", entry1_unknown_link->app_id());
 225
 226   // Check a file properties.
 227   EXPECT_EQ(ENTRY_KIND_FILE, entry->kind());
 228   EXPECT_EQ("File 1.mp3", entry->filename());
 229   EXPECT_EQ("File 1.mp3", entry->suggested_filename());
 230   EXPECT_EQ("3b4382ebefec6e743578c76bbd0575ce", entry->file_md5());
 231   EXPECT_EQ(892721, entry->file_size());
 232
 233   // WAPI doesn't provide image metadata, but these fields are available
 234   // since this class can wrap data received from Drive API (via a converter).
 235   EXPECT_EQ(-1, entry->image_width());
 236   EXPECT_EQ(-1, entry->image_height());
 237   EXPECT_EQ(-1, entry->image_rotation());
 238 }
 239
 240 TEST(GDataWAPIParserTest, AccountMetadataParser) {
 241   scoped_ptr<base::Value> document =
 242       test_util::LoadJSONFile("gdata/account_metadata.json");
 243   ASSERT_TRUE(document.get());
 244   base::DictionaryValue* document_dict = NULL;
 245   base::DictionaryValue* entry_value = NULL;
 246   ASSERT_TRUE(document->GetAsDictionary(&document_dict));
 247   ASSERT_TRUE(document_dict->GetDictionary(std::string("entry"), &entry_value));
 248   ASSERT_TRUE(entry_value);
 249
 250   scoped_ptr<AccountMetadata> metadata(
 251       AccountMetadata::CreateFrom(*document));
 252   ASSERT_TRUE(metadata.get());
 253   EXPECT_EQ(GG_LONGLONG(6789012345), metadata->quota_bytes_used());
 254   EXPECT_EQ(GG_LONGLONG(9876543210), metadata->quota_bytes_total());
 255   EXPECT_EQ(654321, metadata->largest_changestamp());
 256   EXPECT_EQ(2U, metadata->installed_apps().size());
 257   const InstalledApp* first_app = metadata->installed_apps()[0];
 258   const InstalledApp* second_app = metadata->installed_apps()[1];
 259
 260   ASSERT_TRUE(first_app);
 261   EXPECT_EQ("Drive App 1", first_app->app_name());
 262   EXPECT_EQ("Drive App Object 1", first_app->object_type());
 263   EXPECT_TRUE(first_app->supports_create());
 264   EXPECT_EQ("https://chrome.google.com/webstore/detail/abcdefabcdef",
 265             first_app->GetProductUrl().spec());
 266
 267   ASSERT_EQ(2U, first_app->primary_mimetypes().size());
 268   EXPECT_EQ("application/test_type_1",
 269             *first_app->primary_mimetypes()[0]);
 270   EXPECT_EQ("application/vnd.google-apps.drive-sdk.11111111",
 271             *first_app->primary_mimetypes()[1]);
 272
 273   ASSERT_EQ(1U, first_app->secondary_mimetypes().size());
 274   EXPECT_EQ("image/jpeg", *first_app->secondary_mimetypes()[0]);
 275
 276   ASSERT_EQ(2U, first_app->primary_extensions().size());
 277   EXPECT_EQ("ext_1", *first_app->primary_extensions()[0]);
 278   EXPECT_EQ("ext_2", *first_app->primary_extensions()[1]);
 279
 280   ASSERT_EQ(1U, first_app->secondary_extensions().size());
 281   EXPECT_EQ("ext_3", *first_app->secondary_extensions()[0]);
 282
 283   ASSERT_EQ(1U, first_app->app_icons().size());
 284   EXPECT_EQ(AppIcon::ICON_DOCUMENT, first_app->app_icons()[0]->category());
 285   EXPECT_EQ(16, first_app->app_icons()[0]->icon_side_length());
 286   GURL icon_url = first_app->app_icons()[0]->GetIconURL();
 287   EXPECT_EQ("https://www.google.com/images/srpr/logo3w.png", icon_url.spec());
 288   InstalledApp::IconList icons =
 289     first_app->GetIconsForCategory(AppIcon::ICON_DOCUMENT);
 290   EXPECT_EQ("https://www.google.com/images/srpr/logo3w.png",
 291             icons[0].second.spec());
 292   icons = first_app->GetIconsForCategory(AppIcon::ICON_SHARED_DOCUMENT);
 293   EXPECT_TRUE(icons.empty());
 294
 295   ASSERT_TRUE(second_app);
 296   EXPECT_EQ("Drive App 2", second_app->app_name());
 297   EXPECT_EQ("Drive App Object 2", second_app->object_type());
 298   EXPECT_EQ("https://chrome.google.com/webstore/detail/deadbeefdeadbeef",
 299             second_app->GetProductUrl().spec());
 300   EXPECT_FALSE(second_app->supports_create());
 301   EXPECT_EQ(2U, second_app->primary_mimetypes().size());
 302   EXPECT_EQ(0U, second_app->secondary_mimetypes().size());
 303   EXPECT_EQ(1U, second_app->primary_extensions().size());
 304   EXPECT_EQ(0U, second_app->secondary_extensions().size());
 305 }
 306
 307 TEST(GDataWAPIParserTest, ClassifyEntryKindByFileExtension) {
 308   EXPECT_EQ(
 309       ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 310       ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 311       ResourceEntry::ClassifyEntryKindByFileExtension(
 312           base::FilePath(FILE_PATH_LITERAL("Test.gdoc"))));
 313   EXPECT_EQ(
 314       ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 315       ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 316       ResourceEntry::ClassifyEntryKindByFileExtension(
 317           base::FilePath(FILE_PATH_LITERAL("Test.gsheet"))));
 318   EXPECT_EQ(
 319       ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 320       ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 321       ResourceEntry::ClassifyEntryKindByFileExtension(
 322           base::FilePath(FILE_PATH_LITERAL("Test.gslides"))));
 323   EXPECT_EQ(
 324       ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 325       ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 326       ResourceEntry::ClassifyEntryKindByFileExtension(
 327           base::FilePath(FILE_PATH_LITERAL("Test.gdraw"))));
 328   EXPECT_EQ(
 329       ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 330       ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 331       ResourceEntry::ClassifyEntryKindByFileExtension(
 332           base::FilePath(FILE_PATH_LITERAL("Test.gtable"))));
 333   EXPECT_EQ(
 334       ResourceEntry::KIND_OF_EXTERNAL_DOCUMENT |
 335       ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 336       ResourceEntry::ClassifyEntryKindByFileExtension(
 337           base::FilePath(FILE_PATH_LITERAL("Test.glink"))));
 338   EXPECT_EQ(
 339       ResourceEntry::KIND_OF_NONE,
 340       ResourceEntry::ClassifyEntryKindByFileExtension(
 341           base::FilePath(FILE_PATH_LITERAL("Test.tar.gz"))));
 342   EXPECT_EQ(
 343       ResourceEntry::KIND_OF_NONE,
 344       ResourceEntry::ClassifyEntryKindByFileExtension(
 345           base::FilePath(FILE_PATH_LITERAL("Test.txt"))));
 346   EXPECT_EQ(
 347       ResourceEntry::KIND_OF_NONE,
 348       ResourceEntry::ClassifyEntryKindByFileExtension(
 349           base::FilePath(FILE_PATH_LITERAL("Test"))));
 350   EXPECT_EQ(
 351       ResourceEntry::KIND_OF_NONE,
 352       ResourceEntry::ClassifyEntryKindByFileExtension(
 353           base::FilePath()));
 354 }
 355
 356 TEST(GDataWAPIParserTest, ResourceEntryClassifyEntryKind) {
 357   EXPECT_EQ(ResourceEntry::KIND_OF_NONE,
 358             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_UNKNOWN));
 359   EXPECT_EQ(ResourceEntry::KIND_OF_NONE,
 360             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_ITEM));
 361   EXPECT_EQ(ResourceEntry::KIND_OF_NONE,
 362             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_SITE));
 363   EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 364             ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 365             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_DOCUMENT));
 366   EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 367             ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 368             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_SPREADSHEET));
 369   EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 370             ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 371             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_PRESENTATION));
 372   EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 373             ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 374             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_DRAWING));
 375   EXPECT_EQ(ResourceEntry::KIND_OF_GOOGLE_DOCUMENT |
 376             ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 377             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_TABLE));
 378   EXPECT_EQ(ResourceEntry::KIND_OF_EXTERNAL_DOCUMENT |
 379             ResourceEntry::KIND_OF_HOSTED_DOCUMENT,
 380             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_EXTERNAL_APP));
 381   EXPECT_EQ(ResourceEntry::KIND_OF_FOLDER,
 382             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_FOLDER));
 383   EXPECT_EQ(ResourceEntry::KIND_OF_FILE,
 384             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_FILE));
 385   EXPECT_EQ(ResourceEntry::KIND_OF_FILE,
 386             ResourceEntry::ClassifyEntryKind(ENTRY_KIND_PDF));
 387 }
 388
 389 }  // namespace google_apis