Identity API: add chrome.identity.getAccounts

chrome/browser/extensions/api/identity/identity_apitest.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 <set>
+#include <string>
+#include <vector>
+
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/identity/identity_api.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/api/identity.h"
 #include "chrome/common/extensions/api/identity/oauth2_manifest_handler.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_switches.h"
 #include "components/signin/core/browser/signin_manager.h"
+#include "components/signin/core/common/profile_management_switches.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/common/id_util.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_mint_token_flow.h"
 #include "grit/browser_resources.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 302 matching lines @@
   std::string scope_ui_oauth_error_;
   bool login_ui_shown_;
   bool scope_ui_shown_;
 };
 
 class MockQueuedMintRequest : public IdentityMintRequestQueue::Request {
  public:
   MOCK_METHOD1(StartMintToken, void(IdentityMintRequestQueue::MintType));
 };
 
+class IdentityGetAccountsFunctionTest : public ExtensionBrowserTest {
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    command_line->AppendSwitch(switches::kExtensionsMultiAccount);
+  }
+
+ protected:
+  void SetAccountState(AccountIds ids, bool is_signed_in) {
+    IdentityAPI::GetFactoryInstance()->Get(profile())->SetAccountStateForTest(
+        ids, is_signed_in);
+  }
+
+  AccountIds CreateIds(std::string email, std::string obfid) {
+    AccountIds ids;
+    ids.account_key = email;
+    ids.email = email;
+    ids.gaia = obfid;
+    return ids;
+  }
+
+  testing::AssertionResult ExpectGetAccounts(
+      const std::vector<std::string>& accounts) {
+    scoped_refptr<IdentityGetAccountsFunction> func(
+        new IdentityGetAccountsFunction);
+    func->set_extension(utils::CreateEmptyExtension(kExtensionId).get());
+    if (!utils::RunFunction(
+            func.get(), std::string("[]"), browser(), utils::NONE)) {
+      return GenerateFailureResult(accounts, NULL)
+             << "getAccounts did not return a result.";
+    }
+    const base::ListValue* results = func->GetResultList();
+    if (!results || (results->GetSize() != accounts.size()))
+      return GenerateFailureResult(accounts, results);
+
+    std::set<std::string> result_ids;
+    for (base::ListValue::const_iterator it = results->begin();
+         it != results->end();
+         ++it) {
+      scoped_ptr<api::identity::AccountInfo> info =
+          api::identity::AccountInfo::FromValue(**it);
+      if (info.get())
+        result_ids.insert(info->id);
+      else
+        return GenerateFailureResult(accounts, results);
+    }
+
+    for (std::vector<std::string>::const_iterator it = accounts.begin();
+         it != accounts.end();
+         ++it) {
+      if (result_ids.find(*it) == result_ids.end())
+        return GenerateFailureResult(accounts, results);
+    }
+
+    return testing::AssertionResult(true);
+  }
+
+  testing::AssertionResult GenerateFailureResult(
+      const ::std::vector<std::string>& accounts,
+      const base::ListValue* results) {
+    testing::Message msg("Expected: ");
+    for (std::vector<std::string>::const_iterator it = accounts.begin();
+         it != accounts.end();
+         ++it) {
+      msg << *it << " ";
+    }
+    msg << "Actual: ";
+    if (!results) {
+      msg << "NULL";
+    } else {
+      for (base::ListValue::const_iterator it = results->begin();
+           it != results->end();
+           ++it) {
+        scoped_ptr<api::identity::AccountInfo> info =
+            api::identity::AccountInfo::FromValue(**it);
+        if (info.get())
+          msg << info->id << " ";
+        else
+          msg << *it << "<-" << (*it)->GetType() << " ";
+      }
+    }
+
+    return testing::AssertionFailure(msg);
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(IdentityGetAccountsFunctionTest, MultiAccountOn) {
+  EXPECT_TRUE(switches::IsExtensionsMultiAccount());
+}
+
+IN_PROC_BROWSER_TEST_F(IdentityGetAccountsFunctionTest, NoneSignedIn) {
+  EXPECT_TRUE(ExpectGetAccounts(std::vector<std::string>()));
+}
+
+IN_PROC_BROWSER_TEST_F(IdentityGetAccountsFunctionTest,
+                       PrimaryAccountSignedIn) {
+  SetAccountState(CreateIds("primary@example.com", "1"), true);
+  std::vector<std::string> primary;
+  primary.push_back("1");
+  EXPECT_TRUE(ExpectGetAccounts(primary));
+}
+
+IN_PROC_BROWSER_TEST_F(IdentityGetAccountsFunctionTest, TwoAccountsSignedIn) {
+  SetAccountState(CreateIds("primary@example.com", "1"), true);
+  SetAccountState(CreateIds("secondary@example.com", "2"), true);
+  std::vector<std::string> two_accounts;
+  two_accounts.push_back("1");
+  two_accounts.push_back("2");
+  EXPECT_TRUE(ExpectGetAccounts(two_accounts));
+}
+
+class IdentityOldProfilesGetAccountsFunctionTest
+    : public IdentityGetAccountsFunctionTest {
+  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
+    // Don't add the multi-account switch that parent class would have.
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(IdentityOldProfilesGetAccountsFunctionTest,
+                       MultiAccountOff) {
+  EXPECT_FALSE(switches::IsExtensionsMultiAccount());
+}
+
+IN_PROC_BROWSER_TEST_F(IdentityOldProfilesGetAccountsFunctionTest,
+                       TwoAccountsSignedIn) {
+  SetAccountState(CreateIds("primary@example.com", "1"), true);
+  SetAccountState(CreateIds("secondary@example.com", "2"), true);
+  std::vector<std::string> only_primary;
+  only_primary.push_back("1");
+  EXPECT_TRUE(ExpectGetAccounts(only_primary));
+}
+
 class GetAuthTokenFunctionTest : public AsyncExtensionBrowserTest {
  protected:
   enum OAuth2Fields {
     NONE = 0,
     CLIENT_ID = 1,
     SCOPES = 2,
     AS_COMPONENT = 4
   };
 
   virtual ~GetAuthTokenFunctionTest() {}
@@ skipping 971 matching lines @@
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 }  // namespace extensions
 
 // Tests the chrome.identity API implemented by custom JS bindings .
 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, ChromeIdentityJsBindings) {
   ASSERT_TRUE(RunExtensionTest("identity/js_bindings")) << message_;
 }