Added authentication scheme as key to HttpAuthCache.

net/http/http_auth_cache_unittest.cc

 // Copyright (c) 2010 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 "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_auth_cache.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 51 matching lines @@
   scoped_refptr<HttpAuthHandler> realm1_handler =
       new MockAuthHandler("basic", "Realm1", HttpAuth::AUTH_SERVER);
   cache.Add(origin, realm1_handler, L"realm1-user", L"realm1-password",
             "/foo/bar/index.html");
 
   scoped_refptr<HttpAuthHandler> realm2_handler =
       new MockAuthHandler("basic", "Realm2", HttpAuth::AUTH_SERVER);
   cache.Add(origin, realm2_handler, L"realm2-user", L"realm2-password",
             "/foo2/index.html");
 
-  scoped_refptr<HttpAuthHandler> realm3_handler =
+  scoped_refptr<HttpAuthHandler> realm3_basic_handler =
       new MockAuthHandler("basic", "Realm3", HttpAuth::AUTH_PROXY);
-  cache.Add(origin, realm3_handler, L"realm3-user", L"realm3-password", "");
+  cache.Add(origin, realm3_basic_handler, L"realm3-basic-user",
+            L"realm3-basic-password", "");
+
+  scoped_refptr<HttpAuthHandler> realm3_digest_handler =
+      new MockAuthHandler("digest", "Realm3", HttpAuth::AUTH_PROXY);
+  cache.Add(origin, realm3_digest_handler, L"realm3-digest-user",
+            L"realm3-digest-password", "/baz/index.html");
 
   // There is no Realm4
-  entry = cache.LookupByRealm(origin, "Realm4");
+  entry = cache.Lookup(origin, "Realm4", "basic");
   EXPECT_TRUE(NULL == entry);
 
   // While Realm3 does exist, the origin scheme is wrong.
-  entry = cache.LookupByRealm(GURL("https://www.google.com"), "Realm3");
+  entry = cache.Lookup(GURL("https://www.google.com"), "Realm3",
+                       "basic");
   EXPECT_TRUE(NULL == entry);
 
-  // Valid lookup by realm.
-  entry = cache.LookupByRealm(GURL("http://www.google.com:80"), "Realm3");
+  // Realm, origin scheme ok, authentication scheme wrong
+  entry = cache.Lookup(GURL("http://www.google.com"), "Realm1", "digest");
+  EXPECT_TRUE(NULL == entry);
+
+  // Valid lookup by origin, realm, scheme.
+  entry = cache.Lookup(GURL("http://www.google.com:80"), "Realm3", "basic");
   EXPECT_FALSE(NULL == entry);
-  EXPECT_TRUE(entry->handler() == realm3_handler.get());
-  EXPECT_EQ(L"realm3-user", entry->username());
-  EXPECT_EQ(L"realm3-password", entry->password());
+  EXPECT_TRUE(entry->handler() == realm3_basic_handler.get());
+  EXPECT_EQ(L"realm3-basic-user", entry->username());
+  EXPECT_EQ(L"realm3-basic-password", entry->password());
+
+  // Valid lookup by origin, realm, scheme when there's a duplicate
+  // origin, realm in the cache
+  entry = cache.Lookup(GURL("http://www.google.com:80"), "Realm3", "digest");
+  EXPECT_FALSE(NULL == entry);
+  EXPECT_TRUE(entry->handler() == realm3_digest_handler.get());
+  EXPECT_EQ(L"realm3-digest-user", entry->username());
+  EXPECT_EQ(L"realm3-digest-password", entry->password());
 
   // Valid lookup by realm.
-  entry = cache.LookupByRealm(origin, "Realm2");
+  entry = cache.Lookup(origin, "Realm2", "basic");
   EXPECT_FALSE(NULL == entry);
   EXPECT_TRUE(entry->handler() == realm2_handler.get());
   EXPECT_EQ(L"realm2-user", entry->username());
   EXPECT_EQ(L"realm2-password", entry->password());
 
   // Check that subpaths are recognized.
-  HttpAuthCache::Entry* realm2Entry = cache.LookupByRealm(origin, "Realm2");
-  EXPECT_FALSE(NULL == realm2Entry);
+  HttpAuthCache::Entry* realm2_entry = cache.Lookup(origin, "Realm2", "basic");
+  EXPECT_FALSE(NULL == realm2_entry);
   // Positive tests:
   entry = cache.LookupByPath(origin, "/foo2/index.html");
-  EXPECT_TRUE(realm2Entry == entry);
+  EXPECT_TRUE(realm2_entry == entry);
   entry = cache.LookupByPath(origin, "/foo2/foobar.html");
-  EXPECT_TRUE(realm2Entry == entry);
+  EXPECT_TRUE(realm2_entry == entry);
   entry = cache.LookupByPath(origin, "/foo2/bar/index.html");
-  EXPECT_TRUE(realm2Entry == entry);
+  EXPECT_TRUE(realm2_entry == entry);
   entry = cache.LookupByPath(origin, "/foo2/");
-  EXPECT_TRUE(realm2Entry == entry);
+  EXPECT_TRUE(realm2_entry == entry);
+
   // Negative tests:
   entry = cache.LookupByPath(origin, "/foo2");
-  EXPECT_FALSE(realm2Entry == entry);
+  EXPECT_FALSE(realm2_entry == entry);
   entry = cache.LookupByPath(origin, "/foo3/index.html");
-  EXPECT_FALSE(realm2Entry == entry);
+  EXPECT_FALSE(realm2_entry == entry);
   entry = cache.LookupByPath(origin, "");
-  EXPECT_FALSE(realm2Entry == entry);
+  EXPECT_FALSE(realm2_entry == entry);
   entry = cache.LookupByPath(origin, "/");
-  EXPECT_FALSE(realm2Entry == entry);
+  EXPECT_FALSE(realm2_entry == entry);
+
+  // Confirm we find the same realm, different auth scheme by path lookup
+  HttpAuthCache::Entry* realm3_digest_entry =
+      cache.Lookup(origin, "Realm3", "digest");
+  EXPECT_FALSE(NULL == realm3_digest_entry);
+  entry = cache.LookupByPath(origin, "/baz/index.html");
+  EXPECT_TRUE(realm3_digest_entry == entry);
+  entry = cache.LookupByPath(origin, "/baz/");
+  EXPECT_TRUE(realm3_digest_entry == entry);
+  entry = cache.LookupByPath(origin, "/baz");
+  EXPECT_FALSE(realm3_digest_entry == entry);
 
   // Lookup using empty path (may be used for proxy).
   entry = cache.LookupByPath(origin, "");
   EXPECT_FALSE(NULL == entry);
-  EXPECT_TRUE(entry->handler() == realm3_handler.get());
+  EXPECT_TRUE(entry->handler() == realm3_basic_handler.get());
   EXPECT_EQ("Realm3", entry->realm());
 }
 
 TEST(HttpAuthCacheTest, AddPath) {
   HttpAuthCache::Entry entry;
 
   // All of these paths have a common root /1/2/2/4/5/
   entry.AddPath("/1/2/3/4/5/x.txt");
   entry.AddPath("/1/2/3/4/5/y.txt");
   entry.AddPath("/1/2/3/4/5/z.txt");
@@ skipping 29 matching lines @@
   GURL origin("http://www.foobar.com:70");
 
   scoped_refptr<HttpAuthHandler> handler =
       new MockAuthHandler("basic", "MyRealm", HttpAuth::AUTH_SERVER);
 
   HttpAuthCache::Entry* orig_entry = cache.Add(
       origin, handler, L"user1", L"password1", "/x/y/z/");
   cache.Add(origin, handler, L"user2", L"password2", "/z/y/x/");
   cache.Add(origin, handler, L"user3", L"password3", "/z/y");
 
-  HttpAuthCache::Entry* entry = cache.LookupByRealm(origin, "MyRealm");
+  HttpAuthCache::Entry* entry = cache.Lookup(origin, "MyRealm", "basic");
 
   EXPECT_TRUE(entry == orig_entry);
   EXPECT_EQ(L"user3", entry->username());
   EXPECT_EQ(L"password3", entry->password());
 
   EXPECT_EQ(2U, entry->paths_.size());
   EXPECT_EQ("/z/", entry->paths_.front());
   EXPECT_EQ("/x/y/z/", entry->paths_.back());
 }
 
 TEST(HttpAuthCacheTest, Remove) {
   GURL origin("http://foobar2.com");
 
   scoped_refptr<HttpAuthHandler> realm1_handler =
       new MockAuthHandler("basic", "Realm1", HttpAuth::AUTH_SERVER);
 
   scoped_refptr<HttpAuthHandler> realm2_handler =
       new MockAuthHandler("basic", "Realm2", HttpAuth::AUTH_SERVER);
 
-  scoped_refptr<HttpAuthHandler> realm3_handler =
+  scoped_refptr<HttpAuthHandler> realm3_basic_handler =
       new MockAuthHandler("basic", "Realm3", HttpAuth::AUTH_SERVER);
 
+  scoped_refptr<HttpAuthHandler> realm3_digest_handler =
+      new MockAuthHandler("digest", "Realm3", HttpAuth::AUTH_SERVER);
+
   HttpAuthCache cache;
   cache.Add(origin, realm1_handler, L"alice", L"123", "/");
   cache.Add(origin, realm2_handler, L"bob", L"princess", "/");
-  cache.Add(origin, realm3_handler, L"admin", L"password", "/");
+  cache.Add(origin, realm3_basic_handler, L"admin", L"password", "/");
+  cache.Add(origin, realm3_digest_handler, L"root", L"wilecoyote", "/");
 
   // Fails, because there is no realm "Realm4".
-  EXPECT_FALSE(cache.Remove(origin, "Realm4", L"alice", L"123"));
+  EXPECT_FALSE(cache.Remove(origin, "Realm4", "basic", L"alice", L"123"));
 
   // Fails because the origin is wrong.
   EXPECT_FALSE(cache.Remove(
-      GURL("http://foobar2.com:100"), "Realm1", L"alice", L"123"));
+      GURL("http://foobar2.com:100"), "Realm1", "basic", L"alice", L"123"));
 
   // Fails because the username is wrong.
-  EXPECT_FALSE(cache.Remove(origin, "Realm1", L"alice2", L"123"));
+  EXPECT_FALSE(cache.Remove(origin, "Realm1", "basic", L"alice2", L"123"));
 
   // Fails because the password is wrong.
-  EXPECT_FALSE(cache.Remove(origin, "Realm1", L"alice", L"1234"));
+  EXPECT_FALSE(cache.Remove(origin, "Realm1", "basic", L"alice", L"1234"));
+
+  // Fails because the authentication type is wrong.
+  EXPECT_FALSE(cache.Remove(origin, "Realm1", "digest", L"alice", L"123"));
 
   // Succeeds.
-  EXPECT_TRUE(cache.Remove(origin, "Realm1", L"alice", L"123"));
+  EXPECT_TRUE(cache.Remove(origin, "Realm1", "basic", L"alice", L"123"));
 
   // Fails because we just deleted the entry!
-  EXPECT_FALSE(cache.Remove(origin, "Realm1", L"alice", L"123"));
+  EXPECT_FALSE(cache.Remove(origin, "Realm1", "basic", L"alice", L"123"));
+
+  // Succeed when there are two authentication types for the same origin,realm.
+  EXPECT_TRUE(cache.Remove(origin, "Realm3", "digest", L"root", L"wilecoyote"));
+
+  // Succeed as above, but when entries were added in opposite order
+  cache.Add(origin, realm3_digest_handler, L"root", L"wilecoyote", "/");
+  EXPECT_TRUE(cache.Remove(origin, "Realm3", "basic", L"admin", L"password"));
+
+  // Make sure that removing one entry still leaves the other available
+  // for lookup
+  HttpAuthCache::Entry* entry = cache.Lookup(origin, "Realm3", "digest");
+  EXPECT_FALSE(NULL == entry);
 }
 
 // Test fixture class for eviction tests (contains helpers for bulk
 // insertion and existence testing).
 class HttpAuthCacheEvictionTest : public testing::Test {
  protected:
   HttpAuthCacheEvictionTest() : origin_("http://www.google.com") { }
 
   std::string GenerateRealm(int realm_i) {
     return StringPrintf("Realm %d", realm_i);
@@ skipping 10 matching lines @@
   void AddPathToRealm(int realm_i, int path_i) {
     scoped_refptr<HttpAuthHandler> handler = new MockAuthHandler(
         "basic",
         GenerateRealm(realm_i), HttpAuth::AUTH_SERVER);
     std::string path = GeneratePath(realm_i, path_i);
     cache_.Add(origin_, handler, L"username", L"password", path);
   }
 
   void CheckRealmExistence(int realm_i, bool exists) {
     const HttpAuthCache::Entry* entry =
-        cache_.LookupByRealm(origin_, GenerateRealm(realm_i));
+      cache_.Lookup(origin_, GenerateRealm(realm_i), "basic");
     if (exists) {
       EXPECT_FALSE(entry == NULL);
       EXPECT_EQ(GenerateRealm(realm_i), entry->realm());
     } else {
       EXPECT_TRUE(entry == NULL);
     }
   }
 
   void CheckPathExistence(int realm_i, int path_i, bool exists) {
     const HttpAuthCache::Entry* entry =
@@ skipping 50 matching lines @@
     CheckPathExistence(0, i, false);
 
   for (int i = 0; i < kMaxPaths; ++i)
     CheckPathExistence(0, i + 3, true);
 
   for (int i = 0; i < kMaxRealms; ++i)
     CheckRealmExistence(i, true);
 }
 
 }  // namespace net