contacts: Only download contacts from "My Contacts" group.

chrome/browser/chromeos/gdata/gdata_contacts_service_browsertest.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/gdata/gdata_contacts_service.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 17 matching lines @@
 namespace gdata {
 namespace {
 
 // Path to the files that are served by the test server.
 const FilePath::CharType kTestDataPath[] =
     FILE_PATH_LITERAL("chrome/test/data");
 
 // Base URL where feeds are located on the test server.
 const char kFeedBaseUrl[] = "files/chromeos/gdata/contacts/";
 
+// Filename of JSON feed containing contact groups.
+const char kGroupsFeedFilename[] = "groups.json";
+
 // Width and height of /photo.png on the test server.
 const int kPhotoSize = 48;
 
 // Initializes |contact| using the passed-in values.
 void InitContact(const std::string& provider_id,
                  const std::string& rfc_3339_update_time,
                  bool deleted,
                  const std::string& full_name,
                  const std::string& given_name,
                  const std::string& additional_name,
@@ skipping 28 matching lines @@
 
   virtual void SetUpOnMainThread() OVERRIDE {
     ASSERT_TRUE(test_server_.Start());
     service_.reset(new GDataContactsService(browser()->profile()));
     service_->Initialize();
     service_->auth_service_for_testing()->set_access_token_for_testing(
         net::TestServer::kGDataAuthToken);
     service_->set_rewrite_photo_url_callback_for_testing(
         base::Bind(&GDataContactsServiceTest::RewritePhotoUrl,
                    base::Unretained(this)));
+    service_->set_groups_feed_url_for_testing(
+        test_server_.GetURL(std::string(kFeedBaseUrl) + kGroupsFeedFilename));
     service_->set_photo_download_timer_interval_for_testing(
         base::TimeDelta::FromMilliseconds(10));
   }
 
   virtual void CleanUpOnMainThread() {
     service_.reset();
   }
 
  protected:
-  GDataContactsService* service() { return service_.get(); }
-
   // Downloads contacts from |feed_filename| (within the chromeos/gdata/contacts
   // test data directory).  |min_update_time| is appended to the URL and the
   // resulting contacts are swapped into |contacts|.  Returns false if the
   // download failed.
   bool Download(const std::string& feed_filename,
                 const base::Time& min_update_time,
                 scoped_ptr<ScopedVector<contacts::Contact> >* contacts) {
     DCHECK(contacts);
-    service_->set_feed_url_for_testing(
+    service_->set_contacts_feed_url_for_testing(
         test_server_.GetURL(kFeedBaseUrl + feed_filename));
     service_->DownloadContacts(
         base::Bind(&GDataContactsServiceTest::OnSuccess,
                    base::Unretained(this)),
         base::Bind(&GDataContactsServiceTest::OnFailure,
                    base::Unretained(this)),
         min_update_time);
     content::RunMessageLoop();
     contacts->swap(downloaded_contacts_);
     return download_was_successful_;
   }
 
+  net::TestServer test_server_;
+  scoped_ptr<GDataContactsService> service_;
+
  private:
   // Rewrites |original_url|, a photo URL from a contacts feed, to instead point
   // at a file on |test_server_|.
   std::string RewritePhotoUrl(const std::string& original_url) {
     return test_server_.GetURL(kFeedBaseUrl + GURL(original_url).path()).spec();
   }
 
   // Handles success for Download().
   void OnSuccess(scoped_ptr<ScopedVector<contacts::Contact> > contacts) {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     download_was_successful_ = true;
     downloaded_contacts_.swap(contacts);
     MessageLoop::current()->Quit();
   }
 
   // Handles failure for Download().
   void OnFailure() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     download_was_successful_ = false;
     downloaded_contacts_.reset(new ScopedVector<contacts::Contact>());
     MessageLoop::current()->Quit();
   }
 
-  net::TestServer test_server_;
-  scoped_ptr<GDataContactsService> service_;
-
   // Was the last download successful?  Used to pass the result back from
   // OnSuccess() and OnFailure() to Download().
   bool download_was_successful_;
 
   // Used to pass downloaded contacts back to Download().
   scoped_ptr<ScopedVector<contacts::Contact> > downloaded_contacts_;
 };
 
 }  // namespace
 
 // Test that we report failure for feeds that are broken in various ways.
 IN_PROC_BROWSER_TEST_F(GDataContactsServiceTest, BrokenFeeds) {
   scoped_ptr<ScopedVector<contacts::Contact> > contacts;
   EXPECT_FALSE(Download("some_bogus_file", base::Time(), &contacts));
   EXPECT_FALSE(Download("empty.txt", base::Time(), &contacts));
   EXPECT_FALSE(Download("not_json.txt", base::Time(), &contacts));
   EXPECT_FALSE(Download("not_dictionary.json", base::Time(), &contacts));
   EXPECT_FALSE(Download("no_feed.json", base::Time(), &contacts));
   EXPECT_FALSE(Download("no_category.json", base::Time(), &contacts));
   EXPECT_FALSE(Download("wrong_category.json", base::Time(), &contacts));
 
   // Missing photos should be allowed, though (as this can occur in production).
   EXPECT_TRUE(Download("feed_photo_404.json", base::Time(), &contacts));
   ASSERT_EQ(static_cast<size_t>(1), contacts->size());
   EXPECT_FALSE((*contacts)[0]->has_raw_untrusted_photo());
 }
 
+// We should report failure when we're unable to download the contact group
+// feed.
+IN_PROC_BROWSER_TEST_F(GDataContactsServiceTest, MissingGroupsFeed) {
+  scoped_ptr<ScopedVector<contacts::Contact> > contacts;
+  service_->set_groups_feed_url_for_testing(
+      test_server_.GetURL(std::string(kFeedBaseUrl) + "404"));
+  EXPECT_FALSE(Download("feed.json", base::Time(), &contacts));
+  EXPECT_TRUE(service_->cached_my_contacts_group_id_for_testing().empty());
+}
+
+// We should also fail when the "My Contacts" group isn't listed in the group
+// feed.
+IN_PROC_BROWSER_TEST_F(GDataContactsServiceTest, NoMyContactsGroup) {
+  scoped_ptr<ScopedVector<contacts::Contact> > contacts;
+  service_->set_groups_feed_url_for_testing(
+      test_server_.GetURL(std::string(kFeedBaseUrl) +
+                          "groups_no_my_contacts.json"));
+  EXPECT_FALSE(Download("feed.json", base::Time(), &contacts));
+  EXPECT_TRUE(service_->cached_my_contacts_group_id_for_testing().empty());
+}
+
 // Check that we're able to download an empty feed and a normal-looking feed
 // with two regular contacts and one deleted one.
 IN_PROC_BROWSER_TEST_F(GDataContactsServiceTest, Download) {
   scoped_ptr<ScopedVector<contacts::Contact> > contacts;
   EXPECT_TRUE(Download("no_entries.json", base::Time(), &contacts));
   EXPECT_TRUE(contacts->empty());
 
   EXPECT_TRUE(Download("feed.json", base::Time(), &contacts));
 
+  // Check that we got the group ID for the "My Contacts" group that's hardcoded
+  // in the groups feed.
+  EXPECT_EQ(
+      "http://www.google.com/m8/feeds/groups/test.user%40gmail.com/base/6",
+      service_->cached_my_contacts_group_id_for_testing());
+
   // All of these expected values are hardcoded in the feed.
   scoped_ptr<contacts::Contact> contact1(new contacts::Contact);
   InitContact("http://example.com/1",
               "2012-06-04T15:53:36.023Z",
               false, "Joe Contact", "Joe", "", "Contact", "", "",
               contact1.get());
   contacts::test::SetPhoto(gfx::Size(kPhotoSize, kPhotoSize), contact1.get());
   contacts::test::AddEmailAddress(
       "joe.contact@gmail.com",
       contacts::Contact_AddressType_Relation_OTHER, "", true, contact1.get());
@@ skipping 47 matching lines @@
   EXPECT_EQ(contacts::test::VarContactsToString(
                 3, contact1.get(), contact2.get(), contact3.get()),
             contacts::test::ContactsToString(*contacts));
 }
 
 // Download a feed containing more photos than we're able to download in
 // parallel to check that we still end up with all the photos.
 IN_PROC_BROWSER_TEST_F(GDataContactsServiceTest, ParallelPhotoDownload) {
   // The feed used for this test contains 8 contacts.
   const int kNumContacts = 8;
-  service()->set_max_photo_downloads_per_second_for_testing(6);
+  service_->set_max_photo_downloads_per_second_for_testing(6);
   scoped_ptr<ScopedVector<contacts::Contact> > contacts;
   EXPECT_TRUE(Download("feed_multiple_photos.json", base::Time(), &contacts));
   ASSERT_EQ(static_cast<size_t>(kNumContacts), contacts->size());
 
   ScopedVector<contacts::Contact> expected_contacts;
   for (int i = 0; i < kNumContacts; ++i) {
     contacts::Contact* contact = new contacts::Contact;
     InitContact(base::StringPrintf("http://example.com/%d", i + 1),
                 "2012-06-04T15:53:36.023Z",
                 false, "", "", "", "", "", "", contact);
     contacts::test::SetPhoto(gfx::Size(kPhotoSize, kPhotoSize), contact);
     expected_contacts.push_back(contact);
   }
   EXPECT_EQ(contacts::test::ContactsToString(expected_contacts),
             contacts::test::ContactsToString(*contacts));
 }
 
 }  // namespace gdata