Identity API: add multi-account support to token cache and request queues

chrome/browser/extensions/api/identity/identity_mint_queue_unittest.cc

Index: chrome/browser/extensions/api/identity/identity_mint_queue_unittest.cc
diff --git a/chrome/browser/extensions/api/identity/identity_mint_queue_unittest.cc b/chrome/browser/extensions/api/identity/identity_mint_queue_unittest.cc
index dc2128e0d36510297a49c0ea322fba2baa90d13e..96cdd435bc96d28e249099477ad53963e56d1550 100644
--- a/chrome/browser/extensions/api/identity/identity_mint_queue_unittest.cc
+++ b/chrome/browser/extensions/api/identity/identity_mint_queue_unittest.cc
@@ -6,9 +6,11 @@
 
 #include <vector>
 
+#include "base/memory/scoped_ptr.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using extensions::ExtensionTokenKey;
 using extensions::IdentityMintRequestQueue;
 
 namespace {
@@ -18,168 +20,95 @@ class MockRequest : public extensions::IdentityMintRequestQueue::Request {
   MOCK_METHOD1(StartMintToken, void(IdentityMintRequestQueue::MintType));
 };
 
+scoped_ptr<ExtensionTokenKey> ExtensionIdToKey(
+    const std::string& extension_id) {
+  return scoped_ptr<ExtensionTokenKey>(new ExtensionTokenKey(
+      extension_id, "user_id", std::set<std::string>()));
+}
+
 }  // namespace
 
 TEST(IdentityMintQueueTest, SerialRequests) {
   IdentityMintRequestQueue::MintType type =
       IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE;
   IdentityMintRequestQueue queue;
-  std::string extension_id("ext_id");
+  scoped_ptr<ExtensionTokenKey> key(ExtensionIdToKey("ext_id"));
   MockRequest request1;
   MockRequest request2;
 
   EXPECT_CALL(request1, StartMintToken(type)).Times(1);
-  queue.RequestStart(type, extension_id, std::set<std::string>(), &request1);
-  queue.RequestComplete(type, extension_id, std::set<std::string>(), &request1);
+  queue.RequestStart(type, *key, &request1);
+  queue.RequestComplete(type, *key, &request1);
 
   EXPECT_CALL(request2, StartMintToken(type)).Times(1);
-  queue.RequestStart(type, extension_id, std::set<std::string>(), &request2);
-  queue.RequestComplete(type, extension_id, std::set<std::string>(), &request2);
+  queue.RequestStart(type, *key, &request2);
+  queue.RequestComplete(type, *key, &request2);
 }
 
 TEST(IdentityMintQueueTest, InteractiveType) {
   IdentityMintRequestQueue::MintType type =
       IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE;
   IdentityMintRequestQueue queue;
-  std::string extension_id("ext_id");
+  scoped_ptr<ExtensionTokenKey> key(ExtensionIdToKey("ext_id"));
   MockRequest request1;
 
   EXPECT_CALL(request1, StartMintToken(type)).Times(1);
-  queue.RequestStart(type, extension_id, std::set<std::string>(), &request1);
-  queue.RequestComplete(type, extension_id, std::set<std::string>(), &request1);
+  queue.RequestStart(type, *key, &request1);
+  queue.RequestComplete(type, *key, &request1);
 }
 
 TEST(IdentityMintQueueTest, ParallelRequests) {
   IdentityMintRequestQueue::MintType type =
       IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE;
   IdentityMintRequestQueue queue;
-  std::string extension_id("ext_id");
+  scoped_ptr<ExtensionTokenKey> key(ExtensionIdToKey("ext_id"));
   MockRequest request1;
   MockRequest request2;
   MockRequest request3;
 
   EXPECT_CALL(request1, StartMintToken(type)).Times(1);
-  queue.RequestStart(type, extension_id, std::set<std::string>(), &request1);
-  queue.RequestStart(type, extension_id, std::set<std::string>(), &request2);
-  queue.RequestStart(type, extension_id, std::set<std::string>(), &request3);
+  queue.RequestStart(type, *key, &request1);
+  queue.RequestStart(type, *key, &request2);
+  queue.RequestStart(type, *key, &request3);
 
   EXPECT_CALL(request2, StartMintToken(type)).Times(1);
-  queue.RequestComplete(type, extension_id, std::set<std::string>(), &request1);
+  queue.RequestComplete(type, *key, &request1);
 
   EXPECT_CALL(request3, StartMintToken(type)).Times(1);
-  queue.RequestComplete(type, extension_id, std::set<std::string>(), &request2);
-
-  queue.RequestComplete(type, extension_id, std::set<std::string>(), &request3);
-}
-
-TEST(IdentityMintQueueTest, ParallelRequestsFromTwoExtensions) {
-  IdentityMintRequestQueue::MintType type =
-      IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE;
-  IdentityMintRequestQueue queue;
-  std::string extension_id1("ext_id_1");
-  std::string extension_id2("ext_id_2");
-  MockRequest request1;
-  MockRequest request2;
-
-  EXPECT_CALL(request1, StartMintToken(type)).Times(1);
-  EXPECT_CALL(request2, StartMintToken(type)).Times(1);
-  queue.RequestStart(type, extension_id1, std::set<std::string>(), &request1);
-  queue.RequestStart(type, extension_id2, std::set<std::string>(), &request2);
+  queue.RequestComplete(type, *key, &request2);
 
-  queue.RequestComplete(type, extension_id1,
-                        std::set<std::string>(), &request1);
-  queue.RequestComplete(type, extension_id2,
-                        std::set<std::string>(), &request2);
+  queue.RequestComplete(type, *key, &request3);
 }
 
-TEST(IdentityMintQueueTest, ParallelRequestsForDifferentScopes) {

[fgorski, 2013/12/02 20:54:39]

Is that one no longer relevant?

[Michael Courage, 2013/12/02 21:53:06]

Yes, it was already a little bit redundant, since
ParallelRequestsFromTwoExtensions was there. Now it's extra weird, because it's
really the ExtensionTokenKey's responsibility to make sure the scopes are
handled correctly. From the mint queue's point of view, only the equality
relation of the keys matters; specific fields don't. 

+TEST(IdentityMintQueueTest, ParallelRequestsFromTwoKeys) {
   IdentityMintRequestQueue::MintType type =
       IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE;
   IdentityMintRequestQueue queue;
-  std::string extension_id("ext_id");
+  scoped_ptr<ExtensionTokenKey> key1(ExtensionIdToKey("ext_id_1"));
+  scoped_ptr<ExtensionTokenKey> key2(ExtensionIdToKey("ext_id_2"));
   MockRequest request1;
   MockRequest request2;
-  std::set<std::string> scopes1;
-  std::set<std::string> scopes2;
-
-  scopes1.insert("a");
-  scopes1.insert("b");
-  scopes2.insert("a");
 
   EXPECT_CALL(request1, StartMintToken(type)).Times(1);
   EXPECT_CALL(request2, StartMintToken(type)).Times(1);
-  queue.RequestStart(type, extension_id, scopes1, &request1);
-  queue.RequestStart(type, extension_id, scopes2, &request2);
-
-  queue.RequestComplete(type, extension_id, scopes1, &request1);
-  queue.RequestComplete(type, extension_id, scopes2, &request2);
-}
+  queue.RequestStart(type, *key1, &request1);
+  queue.RequestStart(type, *key2, &request2);
 
-TEST(IdentityMintQueueTest, KeyComparisons) {
-  std::string extension_id1("ext_id_1");
-  std::string extension_id2("ext_id_2");
-  std::set<std::string> scopes1;
-  std::set<std::string> scopes2;
-  std::set<std::string> scopes3;
-
-  scopes1.insert("a");
-  scopes1.insert("b");
-  scopes2.insert("a");
-
-  std::vector<std::string> ids;
-  ids.push_back(extension_id1);
-  ids.push_back(extension_id2);
-
-  std::vector<std::set<std::string> > scopesets;
-  scopesets.push_back(scopes1);
-  scopesets.push_back(scopes2);
-  scopesets.push_back(scopes3);
-
-  std::vector<IdentityMintRequestQueue::RequestKey> keys;
-  typedef std::vector<
-    IdentityMintRequestQueue::RequestKey>::const_iterator
-      RequestKeyIterator;
-
-  std::vector<std::string>::const_iterator id_it;
-  std::vector<std::set<std::string> >::const_iterator scope_it;
-
-  for (id_it = ids.begin(); id_it != ids.end(); ++id_it) {
-    for (scope_it = scopesets.begin(); scope_it != scopesets.end();
-         ++scope_it) {
-      keys.push_back(IdentityMintRequestQueue::RequestKey(
-          IdentityMintRequestQueue::MINT_TYPE_NONINTERACTIVE, *id_it,
-          *scope_it));
-      keys.push_back(IdentityMintRequestQueue::RequestKey(
-          IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE, *id_it, *scope_it));
-    }
-  }
-
-  // keys should not be less than themselves
-  for (RequestKeyIterator it = keys.begin(); it != keys.end(); ++it) {
-    EXPECT_FALSE(*it < *it);
-  }
-
-  // keys should not equal different keys
-  for (RequestKeyIterator it1 = keys.begin(); it1 != keys.end(); ++it1) {
-    RequestKeyIterator it2 = it1;
-    for (++it2; it2 != keys.end(); ++it2) {
-      EXPECT_TRUE(*it1 < *it2 || *it2 < *it1);
-      EXPECT_FALSE(*it1 < *it2 && *it2 < *it1);
-    }
-  }
+  queue.RequestComplete(type, *key1, &request1);
+  queue.RequestComplete(type, *key2, &request2);
 }
 
 TEST(IdentityMintQueueTest, Empty) {
   IdentityMintRequestQueue::MintType type =
       IdentityMintRequestQueue::MINT_TYPE_INTERACTIVE;
   IdentityMintRequestQueue queue;
-  std::string extension_id("ext_id");
+  scoped_ptr<ExtensionTokenKey> key(ExtensionIdToKey("ext_id"));
   MockRequest request1;
 
-  EXPECT_TRUE(queue.empty(type, extension_id, std::set<std::string>()));
+  EXPECT_TRUE(queue.empty(type, *key));
   EXPECT_CALL(request1, StartMintToken(type)).Times(1);
-  queue.RequestStart(type, extension_id, std::set<std::string>(), &request1);
-  EXPECT_FALSE(queue.empty(type, extension_id, std::set<std::string>()));
-  queue.RequestComplete(type, extension_id, std::set<std::string>(), &request1);
-  EXPECT_TRUE(queue.empty(type, extension_id, std::set<std::string>()));
+  queue.RequestStart(type, *key, &request1);
+  EXPECT_FALSE(queue.empty(type, *key));
+  queue.RequestComplete(type, *key, &request1);
+  EXPECT_TRUE(queue.empty(type, *key));
 }