Home | History | Annotate | Download | only in http 
      1 // Copyright (c) 2011 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 <string>
      6 
      7 #include "base/strings/string16.h"
      8 #include "base/strings/string_util.h"
      9 #include "base/strings/stringprintf.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "net/base/net_errors.h"
     12 #include "net/http/http_auth_cache.h"
     13 #include "net/http/http_auth_handler.h"
     14 #include "testing/gtest/include/gtest/gtest.h"
     15 
     16 using base::ASCIIToUTF16;
     17 
     18 namespace net {
     19 
     20 namespace {
     21 
     22 class MockAuthHandler : public HttpAuthHandler {
     23  public:
     24   MockAuthHandler(HttpAuth::Scheme scheme,
     25                   const std::string& realm,
     26                   HttpAuth::Target target) {
     27     // Can't use initializer list since these are members of the base class.
     28     auth_scheme_ = scheme;
     29     realm_ = realm;
     30     score_ = 1;
     31     target_ = target;
     32     properties_ = 0;
     33   }
     34 
     35   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
     36       HttpAuthChallengeTokenizer* challenge) OVERRIDE {
     37     return HttpAuth::AUTHORIZATION_RESULT_REJECT;
     38   }
     39 
     40  protected:
     41   virtual bool Init(HttpAuthChallengeTokenizer* challenge) OVERRIDE {
     42     return false;  // Unused.
     43   }
     44 
     45   virtual int GenerateAuthTokenImpl(const AuthCredentials*,
     46                                     const HttpRequestInfo*,
     47                                     const CompletionCallback& callback,
     48                                     std::string* auth_token) OVERRIDE {
     49     *auth_token = "mock-credentials";
     50     return OK;
     51   }
     52 
     53 
     54  private:
     55   virtual ~MockAuthHandler() {}
     56 };
     57 
     58 const char* kRealm1 = "Realm1";
     59 const char* kRealm2 = "Realm2";
     60 const char* kRealm3 = "Realm3";
     61 const char* kRealm4 = "Realm4";
     62 const char* kRealm5 = "Realm5";
     63 const base::string16 k123(ASCIIToUTF16("123"));
     64 const base::string16 k1234(ASCIIToUTF16("1234"));
     65 const base::string16 kAdmin(ASCIIToUTF16("admin"));
     66 const base::string16 kAlice(ASCIIToUTF16("alice"));
     67 const base::string16 kAlice2(ASCIIToUTF16("alice2"));
     68 const base::string16 kPassword(ASCIIToUTF16("password"));
     69 const base::string16 kRoot(ASCIIToUTF16("root"));
     70 const base::string16 kUsername(ASCIIToUTF16("username"));
     71 const base::string16 kWileCoyote(ASCIIToUTF16("wilecoyote"));
     72 
     73 AuthCredentials CreateASCIICredentials(const char* username,
     74                                        const char* password) {
     75   return AuthCredentials(ASCIIToUTF16(username), ASCIIToUTF16(password));
     76 }
     77 
     78 }  // namespace
     79 
     80 // Test adding and looking-up cache entries (both by realm and by path).
     81 TEST(HttpAuthCacheTest, Basic) {
     82   GURL origin("http://www.google.com");
     83   HttpAuthCache cache;
     84   HttpAuthCache::Entry* entry;
     85 
     86   // Add cache entries for 4 realms: "Realm1", "Realm2", "Realm3" and
     87   // "Realm4"
     88 
     89   scoped_ptr<HttpAuthHandler> realm1_handler(
     90       new MockAuthHandler(HttpAuth::AUTH_SCHEME_BASIC,
     91                           kRealm1,
     92                           HttpAuth::AUTH_SERVER));
     93   cache.Add(origin, realm1_handler->realm(), realm1_handler->auth_scheme(),
     94             "Basic realm=Realm1",
     95             CreateASCIICredentials("realm1-user", "realm1-password"),
     96             "/foo/bar/index.html");
     97 
     98   scoped_ptr<HttpAuthHandler> realm2_handler(
     99       new MockAuthHandler(HttpAuth::AUTH_SCHEME_BASIC,
    100                           kRealm2,
    101                           HttpAuth::AUTH_SERVER));
    102   cache.Add(origin, realm2_handler->realm(), realm2_handler->auth_scheme(),
    103             "Basic realm=Realm2",
    104             CreateASCIICredentials("realm2-user", "realm2-password"),
    105             "/foo2/index.html");
    106 
    107   scoped_ptr<HttpAuthHandler> realm3_basic_handler(
    108       new MockAuthHandler(HttpAuth::AUTH_SCHEME_BASIC,
    109                           kRealm3,
    110                           HttpAuth::AUTH_PROXY));
    111   cache.Add(
    112       origin,
    113       realm3_basic_handler->realm(),
    114       realm3_basic_handler->auth_scheme(),
    115       "Basic realm=Realm3",
    116       CreateASCIICredentials("realm3-basic-user", "realm3-basic-password"),
    117       std::string());
    118 
    119   scoped_ptr<HttpAuthHandler> realm3_digest_handler(
    120       new MockAuthHandler(HttpAuth::AUTH_SCHEME_DIGEST,
    121                           kRealm3,
    122                           HttpAuth::AUTH_PROXY));
    123   cache.Add(origin, realm3_digest_handler->realm(),
    124             realm3_digest_handler->auth_scheme(), "Digest realm=Realm3",
    125             CreateASCIICredentials("realm3-digest-user",
    126                                    "realm3-digest-password"),
    127             "/baz/index.html");
    128 
    129   scoped_ptr<HttpAuthHandler> realm4_basic_handler(
    130       new MockAuthHandler(HttpAuth::AUTH_SCHEME_BASIC,
    131                           kRealm4,
    132                           HttpAuth::AUTH_SERVER));
    133   cache.Add(origin, realm4_basic_handler->realm(),
    134             realm4_basic_handler->auth_scheme(), "Basic realm=Realm4",
    135             CreateASCIICredentials("realm4-basic-user",
    136                                    "realm4-basic-password"),
    137             "/");
    138 
    139   // There is no Realm5
    140   entry = cache.Lookup(origin, kRealm5, HttpAuth::AUTH_SCHEME_BASIC);
    141   EXPECT_TRUE(NULL == entry);
    142 
    143   // While Realm3 does exist, the origin scheme is wrong.
    144   entry = cache.Lookup(GURL("https://www.google.com"), kRealm3,
    145                        HttpAuth::AUTH_SCHEME_BASIC);
    146   EXPECT_TRUE(NULL == entry);
    147 
    148   // Realm, origin scheme ok, authentication scheme wrong
    149   entry = cache.Lookup
    150       (GURL("http://www.google.com"), kRealm1, HttpAuth::AUTH_SCHEME_DIGEST);
    151   EXPECT_TRUE(NULL == entry);
    152 
    153   // Valid lookup by origin, realm, scheme.
    154   entry = cache.Lookup(
    155       GURL("http://www.google.com:80"), kRealm3, HttpAuth::AUTH_SCHEME_BASIC);
    156   ASSERT_FALSE(NULL == entry);
    157   EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, entry->scheme());
    158   EXPECT_EQ(kRealm3, entry->realm());
    159   EXPECT_EQ("Basic realm=Realm3", entry->auth_challenge());
    160   EXPECT_EQ(ASCIIToUTF16("realm3-basic-user"), entry->credentials().username());
    161   EXPECT_EQ(ASCIIToUTF16("realm3-basic-password"),
    162             entry->credentials().password());
    163 
    164   // Valid lookup by origin, realm, scheme when there's a duplicate
    165   // origin, realm in the cache
    166   entry = cache.Lookup(
    167       GURL("http://www.google.com:80"), kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
    168   ASSERT_FALSE(NULL == entry);
    169   EXPECT_EQ(HttpAuth::AUTH_SCHEME_DIGEST, entry->scheme());
    170   EXPECT_EQ(kRealm3, entry->realm());
    171   EXPECT_EQ("Digest realm=Realm3", entry->auth_challenge());
    172   EXPECT_EQ(ASCIIToUTF16("realm3-digest-user"),
    173             entry->credentials().username());
    174   EXPECT_EQ(ASCIIToUTF16("realm3-digest-password"),
    175             entry->credentials().password());
    176 
    177   // Valid lookup by realm.
    178   entry = cache.Lookup(origin, kRealm2, HttpAuth::AUTH_SCHEME_BASIC);
    179   ASSERT_FALSE(NULL == entry);
    180   EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, entry->scheme());
    181   EXPECT_EQ(kRealm2, entry->realm());
    182   EXPECT_EQ("Basic realm=Realm2", entry->auth_challenge());
    183   EXPECT_EQ(ASCIIToUTF16("realm2-user"), entry->credentials().username());
    184   EXPECT_EQ(ASCIIToUTF16("realm2-password"), entry->credentials().password());
    185 
    186   // Check that subpaths are recognized.
    187   HttpAuthCache::Entry* realm2_entry = cache.Lookup(
    188       origin, kRealm2, HttpAuth::AUTH_SCHEME_BASIC);
    189   HttpAuthCache::Entry* realm4_entry = cache.Lookup(
    190       origin, kRealm4, HttpAuth::AUTH_SCHEME_BASIC);
    191   EXPECT_FALSE(NULL == realm2_entry);
    192   EXPECT_FALSE(NULL == realm4_entry);
    193   // Realm4 applies to '/' and Realm2 applies to '/foo2/'.
    194   // LookupByPath() should return the closest enclosing path.
    195   // Positive tests:
    196   entry = cache.LookupByPath(origin, "/foo2/index.html");
    197   EXPECT_TRUE(realm2_entry == entry);
    198   entry = cache.LookupByPath(origin, "/foo2/foobar.html");
    199   EXPECT_TRUE(realm2_entry == entry);
    200   entry = cache.LookupByPath(origin, "/foo2/bar/index.html");
    201   EXPECT_TRUE(realm2_entry == entry);
    202   entry = cache.LookupByPath(origin, "/foo2/");
    203   EXPECT_TRUE(realm2_entry == entry);
    204   entry = cache.LookupByPath(origin, "/foo2");
    205   EXPECT_TRUE(realm4_entry == entry);
    206   entry = cache.LookupByPath(origin, "/");
    207   EXPECT_TRUE(realm4_entry == entry);
    208 
    209   // Negative tests:
    210   entry = cache.LookupByPath(origin, "/foo3/index.html");
    211   EXPECT_FALSE(realm2_entry == entry);
    212   entry = cache.LookupByPath(origin, std::string());
    213   EXPECT_FALSE(realm2_entry == entry);
    214 
    215   // Confirm we find the same realm, different auth scheme by path lookup
    216   HttpAuthCache::Entry* realm3_digest_entry =
    217       cache.Lookup(origin, kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
    218   EXPECT_FALSE(NULL == realm3_digest_entry);
    219   entry = cache.LookupByPath(origin, "/baz/index.html");
    220   EXPECT_TRUE(realm3_digest_entry == entry);
    221   entry = cache.LookupByPath(origin, "/baz/");
    222   EXPECT_TRUE(realm3_digest_entry == entry);
    223   entry = cache.LookupByPath(origin, "/baz");
    224   EXPECT_FALSE(realm3_digest_entry == entry);
    225 
    226   // Confirm we find the same realm, different auth scheme by path lookup
    227   HttpAuthCache::Entry* realm3DigestEntry =
    228       cache.Lookup(origin, kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
    229   EXPECT_FALSE(NULL == realm3DigestEntry);
    230   entry = cache.LookupByPath(origin, "/baz/index.html");
    231   EXPECT_TRUE(realm3DigestEntry == entry);
    232   entry = cache.LookupByPath(origin, "/baz/");
    233   EXPECT_TRUE(realm3DigestEntry == entry);
    234   entry = cache.LookupByPath(origin, "/baz");
    235   EXPECT_FALSE(realm3DigestEntry == entry);
    236 
    237   // Lookup using empty path (may be used for proxy).
    238   entry = cache.LookupByPath(origin, std::string());
    239   EXPECT_FALSE(NULL == entry);
    240   EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, entry->scheme());
    241   EXPECT_EQ(kRealm3, entry->realm());
    242 }
    243 
    244 TEST(HttpAuthCacheTest, AddPath) {
    245   HttpAuthCache::Entry entry;
    246 
    247   // All of these paths have a common root /1/2/2/4/5/
    248   entry.AddPath("/1/2/3/4/5/x.txt");
    249   entry.AddPath("/1/2/3/4/5/y.txt");
    250   entry.AddPath("/1/2/3/4/5/z.txt");
    251 
    252   EXPECT_EQ(1U, entry.paths_.size());
    253   EXPECT_EQ("/1/2/3/4/5/", entry.paths_.front());
    254 
    255   // Add a new entry (not a subpath).
    256   entry.AddPath("/1/XXX/q");
    257   EXPECT_EQ(2U, entry.paths_.size());
    258   EXPECT_EQ("/1/XXX/", entry.paths_.front());
    259   EXPECT_EQ("/1/2/3/4/5/", entry.paths_.back());
    260 
    261   // Add containing paths of /1/2/3/4/5/ -- should swallow up the deeper paths.
    262   entry.AddPath("/1/2/3/4/x.txt");
    263   EXPECT_EQ(2U, entry.paths_.size());
    264   EXPECT_EQ("/1/2/3/4/", entry.paths_.front());
    265   EXPECT_EQ("/1/XXX/", entry.paths_.back());
    266   entry.AddPath("/1/2/3/x");
    267   EXPECT_EQ(2U, entry.paths_.size());
    268   EXPECT_EQ("/1/2/3/", entry.paths_.front());
    269   EXPECT_EQ("/1/XXX/", entry.paths_.back());
    270 
    271   entry.AddPath("/index.html");
    272   EXPECT_EQ(1U, entry.paths_.size());
    273   EXPECT_EQ("/", entry.paths_.front());
    274 }
    275 
    276 // Calling Add when the realm entry already exists, should append that
    277 // path.
    278 TEST(HttpAuthCacheTest, AddToExistingEntry) {
    279   HttpAuthCache cache;
    280   GURL origin("http://www.foobar.com:70");
    281   const std::string auth_challenge = "Basic realm=MyRealm";
    282 
    283   scoped_ptr<HttpAuthHandler> handler(
    284       new MockAuthHandler(
    285           HttpAuth::AUTH_SCHEME_BASIC, "MyRealm", HttpAuth::AUTH_SERVER));
    286   HttpAuthCache::Entry* orig_entry = cache.Add(
    287       origin, handler->realm(), handler->auth_scheme(), auth_challenge,
    288       CreateASCIICredentials("user1", "password1"), "/x/y/z/");
    289   cache.Add(origin, handler->realm(), handler->auth_scheme(), auth_challenge,
    290             CreateASCIICredentials("user2", "password2"), "/z/y/x/");
    291   cache.Add(origin, handler->realm(), handler->auth_scheme(), auth_challenge,
    292             CreateASCIICredentials("user3", "password3"), "/z/y");
    293 
    294   HttpAuthCache::Entry* entry = cache.Lookup(
    295       origin, "MyRealm", HttpAuth::AUTH_SCHEME_BASIC);
    296 
    297   EXPECT_TRUE(entry == orig_entry);
    298   EXPECT_EQ(ASCIIToUTF16("user3"), entry->credentials().username());
    299   EXPECT_EQ(ASCIIToUTF16("password3"), entry->credentials().password());
    300 
    301   EXPECT_EQ(2U, entry->paths_.size());
    302   EXPECT_EQ("/z/", entry->paths_.front());
    303   EXPECT_EQ("/x/y/z/", entry->paths_.back());
    304 }
    305 
    306 TEST(HttpAuthCacheTest, Remove) {
    307   GURL origin("http://foobar2.com");
    308 
    309   scoped_ptr<HttpAuthHandler> realm1_handler(
    310       new MockAuthHandler(
    311           HttpAuth::AUTH_SCHEME_BASIC, kRealm1, HttpAuth::AUTH_SERVER));
    312 
    313   scoped_ptr<HttpAuthHandler> realm2_handler(
    314       new MockAuthHandler(
    315           HttpAuth::AUTH_SCHEME_BASIC, kRealm2, HttpAuth::AUTH_SERVER));
    316 
    317   scoped_ptr<HttpAuthHandler> realm3_basic_handler(
    318       new MockAuthHandler(
    319           HttpAuth::AUTH_SCHEME_BASIC, kRealm3, HttpAuth::AUTH_SERVER));
    320 
    321   scoped_ptr<HttpAuthHandler> realm3_digest_handler(
    322       new MockAuthHandler(
    323           HttpAuth::AUTH_SCHEME_DIGEST, kRealm3, HttpAuth::AUTH_SERVER));
    324 
    325   HttpAuthCache cache;
    326   cache.Add(origin, realm1_handler->realm(), realm1_handler->auth_scheme(),
    327             "basic realm=Realm1", AuthCredentials(kAlice, k123), "/");
    328   cache.Add(origin, realm2_handler->realm(), realm2_handler->auth_scheme(),
    329             "basic realm=Realm2", CreateASCIICredentials("bob", "princess"),
    330             "/");
    331   cache.Add(origin, realm3_basic_handler->realm(),
    332             realm3_basic_handler->auth_scheme(), "basic realm=Realm3",
    333             AuthCredentials(kAdmin, kPassword), "/");
    334   cache.Add(origin, realm3_digest_handler->realm(),
    335             realm3_digest_handler->auth_scheme(), "digest realm=Realm3",
    336             AuthCredentials(kRoot, kWileCoyote), "/");
    337 
    338   // Fails, because there is no realm "Realm5".
    339   EXPECT_FALSE(cache.Remove(
    340       origin, kRealm5, HttpAuth::AUTH_SCHEME_BASIC,
    341       AuthCredentials(kAlice, k123)));
    342 
    343   // Fails because the origin is wrong.
    344   EXPECT_FALSE(cache.Remove(GURL("http://foobar2.com:100"),
    345                             kRealm1,
    346                             HttpAuth::AUTH_SCHEME_BASIC,
    347                             AuthCredentials(kAlice, k123)));
    348 
    349   // Fails because the username is wrong.
    350   EXPECT_FALSE(cache.Remove(
    351       origin, kRealm1, HttpAuth::AUTH_SCHEME_BASIC,
    352       AuthCredentials(kAlice2, k123)));
    353 
    354   // Fails because the password is wrong.
    355   EXPECT_FALSE(cache.Remove(
    356       origin, kRealm1, HttpAuth::AUTH_SCHEME_BASIC,
    357       AuthCredentials(kAlice, k1234)));
    358 
    359   // Fails because the authentication type is wrong.
    360   EXPECT_FALSE(cache.Remove(
    361       origin, kRealm1, HttpAuth::AUTH_SCHEME_DIGEST,
    362       AuthCredentials(kAlice, k123)));
    363 
    364   // Succeeds.
    365   EXPECT_TRUE(cache.Remove(
    366       origin, kRealm1, HttpAuth::AUTH_SCHEME_BASIC,
    367       AuthCredentials(kAlice, k123)));
    368 
    369   // Fails because we just deleted the entry!
    370   EXPECT_FALSE(cache.Remove(
    371       origin, kRealm1, HttpAuth::AUTH_SCHEME_BASIC,
    372       AuthCredentials(kAlice, k123)));
    373 
    374   // Succeed when there are two authentication types for the same origin,realm.
    375   EXPECT_TRUE(cache.Remove(
    376       origin, kRealm3, HttpAuth::AUTH_SCHEME_DIGEST,
    377       AuthCredentials(kRoot, kWileCoyote)));
    378 
    379   // Succeed as above, but when entries were added in opposite order
    380   cache.Add(origin, realm3_digest_handler->realm(),
    381             realm3_digest_handler->auth_scheme(), "digest realm=Realm3",
    382             AuthCredentials(kRoot, kWileCoyote), "/");
    383   EXPECT_TRUE(cache.Remove(
    384       origin, kRealm3, HttpAuth::AUTH_SCHEME_BASIC,
    385       AuthCredentials(kAdmin, kPassword)));
    386 
    387   // Make sure that removing one entry still leaves the other available for
    388   // lookup.
    389   HttpAuthCache::Entry* entry = cache.Lookup(
    390       origin, kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
    391   EXPECT_FALSE(NULL == entry);
    392 }
    393 
    394 TEST(HttpAuthCacheTest, UpdateStaleChallenge) {
    395   HttpAuthCache cache;
    396   GURL origin("http://foobar2.com");
    397   scoped_ptr<HttpAuthHandler> digest_handler(
    398       new MockAuthHandler(
    399           HttpAuth::AUTH_SCHEME_DIGEST, kRealm1, HttpAuth::AUTH_PROXY));
    400   HttpAuthCache::Entry* entry_pre = cache.Add(
    401       origin,
    402       digest_handler->realm(),
    403       digest_handler->auth_scheme(),
    404       "Digest realm=Realm1,"
    405       "nonce=\"s3MzvFhaBAA=4c520af5acd9d8d7ae26947529d18c8eae1e98f4\"",
    406       CreateASCIICredentials("realm-digest-user", "realm-digest-password"),
    407       "/baz/index.html");
    408   ASSERT_TRUE(entry_pre != NULL);
    409 
    410   EXPECT_EQ(2, entry_pre->IncrementNonceCount());
    411   EXPECT_EQ(3, entry_pre->IncrementNonceCount());
    412   EXPECT_EQ(4, entry_pre->IncrementNonceCount());
    413 
    414   bool update_success = cache.UpdateStaleChallenge(
    415       origin,
    416       digest_handler->realm(),
    417       digest_handler->auth_scheme(),
    418       "Digest realm=Realm1,"
    419       "nonce=\"claGgoRXBAA=7583377687842fdb7b56ba0555d175baa0b800e3\","
    420       "stale=\"true\"");
    421   EXPECT_TRUE(update_success);
    422 
    423   // After the stale update, the entry should still exist in the cache and
    424   // the nonce count should be reset to 0.
    425   HttpAuthCache::Entry* entry_post = cache.Lookup(
    426       origin,
    427       digest_handler->realm(),
    428       digest_handler->auth_scheme());
    429   ASSERT_TRUE(entry_post != NULL);
    430   EXPECT_EQ(2, entry_post->IncrementNonceCount());
    431 
    432   // UpdateStaleChallenge will fail if an entry doesn't exist in the cache.
    433   bool update_failure = cache.UpdateStaleChallenge(
    434       origin,
    435       kRealm2,
    436       digest_handler->auth_scheme(),
    437       "Digest realm=Realm2,"
    438       "nonce=\"claGgoRXBAA=7583377687842fdb7b56ba0555d175baa0b800e3\","
    439       "stale=\"true\"");
    440   EXPECT_FALSE(update_failure);
    441 }
    442 
    443 TEST(HttpAuthCacheTest, UpdateAllFrom) {
    444   GURL origin("http://example.com");
    445   std::string path("/some/path");
    446   std::string another_path("/another/path");
    447 
    448   scoped_ptr<HttpAuthHandler> realm1_handler(
    449       new MockAuthHandler(
    450           HttpAuth::AUTH_SCHEME_BASIC, kRealm1, HttpAuth::AUTH_SERVER));
    451 
    452   scoped_ptr<HttpAuthHandler> realm2_handler(
    453       new MockAuthHandler(
    454           HttpAuth::AUTH_SCHEME_BASIC, kRealm2, HttpAuth::AUTH_PROXY));
    455 
    456   scoped_ptr<HttpAuthHandler> realm3_digest_handler(
    457       new MockAuthHandler(
    458           HttpAuth::AUTH_SCHEME_DIGEST, kRealm3, HttpAuth::AUTH_SERVER));
    459 
    460   scoped_ptr<HttpAuthHandler> realm4_handler(
    461       new MockAuthHandler(
    462           HttpAuth::AUTH_SCHEME_BASIC, kRealm4, HttpAuth::AUTH_SERVER));
    463 
    464   HttpAuthCache first_cache;
    465   HttpAuthCache::Entry* entry;
    466 
    467   first_cache.Add(origin, realm1_handler->realm(),
    468                   realm1_handler->auth_scheme(), "basic realm=Realm1",
    469                   AuthCredentials(kAlice, k123), path);
    470   first_cache.Add(origin, realm2_handler->realm(),
    471                   realm2_handler->auth_scheme(), "basic realm=Realm2",
    472                   AuthCredentials(kAlice2, k1234), path);
    473   first_cache.Add(origin, realm3_digest_handler->realm(),
    474                   realm3_digest_handler->auth_scheme(), "digest realm=Realm3",
    475                   AuthCredentials(kRoot, kWileCoyote), path);
    476   entry = first_cache.Add(
    477       origin, realm3_digest_handler->realm(),
    478       realm3_digest_handler->auth_scheme(), "digest realm=Realm3",
    479       AuthCredentials(kRoot, kWileCoyote), another_path);
    480 
    481   EXPECT_EQ(2, entry->IncrementNonceCount());
    482 
    483   HttpAuthCache second_cache;
    484   // Will be overwritten by kRoot:kWileCoyote.
    485   second_cache.Add(origin, realm3_digest_handler->realm(),
    486                    realm3_digest_handler->auth_scheme(), "digest realm=Realm3",
    487                    AuthCredentials(kAlice2, k1234), path);
    488   // Should be left intact.
    489   second_cache.Add(origin, realm4_handler->realm(),
    490                    realm4_handler->auth_scheme(), "basic realm=Realm4",
    491                    AuthCredentials(kAdmin, kRoot), path);
    492 
    493   second_cache.UpdateAllFrom(first_cache);
    494 
    495   // Copied from first_cache.
    496   entry = second_cache.Lookup(origin, kRealm1, HttpAuth::AUTH_SCHEME_BASIC);
    497   EXPECT_TRUE(NULL != entry);
    498   EXPECT_EQ(kAlice, entry->credentials().username());
    499   EXPECT_EQ(k123, entry->credentials().password());
    500 
    501   // Copied from first_cache.
    502   entry = second_cache.Lookup(origin, kRealm2, HttpAuth::AUTH_SCHEME_BASIC);
    503   EXPECT_TRUE(NULL != entry);
    504   EXPECT_EQ(kAlice2, entry->credentials().username());
    505   EXPECT_EQ(k1234, entry->credentials().password());
    506 
    507   // Overwritten from first_cache.
    508   entry = second_cache.Lookup(origin, kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
    509   EXPECT_TRUE(NULL != entry);
    510   EXPECT_EQ(kRoot, entry->credentials().username());
    511   EXPECT_EQ(kWileCoyote, entry->credentials().password());
    512   // Nonce count should get copied.
    513   EXPECT_EQ(3, entry->IncrementNonceCount());
    514 
    515   // All paths should get copied.
    516   entry = second_cache.LookupByPath(origin, another_path);
    517   EXPECT_TRUE(NULL != entry);
    518   EXPECT_EQ(kRoot, entry->credentials().username());
    519   EXPECT_EQ(kWileCoyote, entry->credentials().password());
    520 
    521   // Left intact in second_cache.
    522   entry = second_cache.Lookup(origin, kRealm4, HttpAuth::AUTH_SCHEME_BASIC);
    523   EXPECT_TRUE(NULL != entry);
    524   EXPECT_EQ(kAdmin, entry->credentials().username());
    525   EXPECT_EQ(kRoot, entry->credentials().password());
    526 }
    527 
    528 // Test fixture class for eviction tests (contains helpers for bulk
    529 // insertion and existence testing).
    530 class HttpAuthCacheEvictionTest : public testing::Test {
    531  protected:
    532   HttpAuthCacheEvictionTest() : origin_("http://www.google.com") { }
    533 
    534   std::string GenerateRealm(int realm_i) {
    535     return base::StringPrintf("Realm %d", realm_i);
    536   }
    537 
    538   std::string GeneratePath(int realm_i, int path_i) {
    539     return base::StringPrintf("/%d/%d/x/y", realm_i, path_i);
    540   }
    541 
    542   void AddRealm(int realm_i) {
    543     AddPathToRealm(realm_i, 0);
    544   }
    545 
    546   void AddPathToRealm(int realm_i, int path_i) {
    547     cache_.Add(origin_,
    548                GenerateRealm(realm_i),
    549                HttpAuth::AUTH_SCHEME_BASIC,
    550                std::string(),
    551                AuthCredentials(kUsername, kPassword),
    552                GeneratePath(realm_i, path_i));
    553   }
    554 
    555   void CheckRealmExistence(int realm_i, bool exists) {
    556     const HttpAuthCache::Entry* entry =
    557         cache_.Lookup(
    558             origin_, GenerateRealm(realm_i), HttpAuth::AUTH_SCHEME_BASIC);
    559     if (exists) {
    560       EXPECT_FALSE(entry == NULL);
    561       EXPECT_EQ(GenerateRealm(realm_i), entry->realm());
    562     } else {
    563       EXPECT_TRUE(entry == NULL);
    564     }
    565   }
    566 
    567   void CheckPathExistence(int realm_i, int path_i, bool exists) {
    568     const HttpAuthCache::Entry* entry =
    569         cache_.LookupByPath(origin_, GeneratePath(realm_i, path_i));
    570     if (exists) {
    571       EXPECT_FALSE(entry == NULL);
    572       EXPECT_EQ(GenerateRealm(realm_i), entry->realm());
    573     } else {
    574       EXPECT_TRUE(entry == NULL);
    575     }
    576   }
    577 
    578   GURL origin_;
    579   HttpAuthCache cache_;
    580 
    581   static const int kMaxPaths = HttpAuthCache::kMaxNumPathsPerRealmEntry;
    582   static const int kMaxRealms = HttpAuthCache::kMaxNumRealmEntries;
    583 };
    584 
    585 // Add the maxinim number of realm entries to the cache. Each of these entries
    586 // must still be retrievable. Next add three more entries -- since the cache is
    587 // full this causes FIFO eviction of the first three entries.
    588 TEST_F(HttpAuthCacheEvictionTest, RealmEntryEviction) {
    589   for (int i = 0; i < kMaxRealms; ++i)
    590     AddRealm(i);
    591 
    592   for (int i = 0; i < kMaxRealms; ++i)
    593     CheckRealmExistence(i, true);
    594 
    595   for (int i = 0; i < 3; ++i)
    596     AddRealm(i + kMaxRealms);
    597 
    598   for (int i = 0; i < 3; ++i)
    599     CheckRealmExistence(i, false);
    600 
    601   for (int i = 0; i < kMaxRealms; ++i)
    602     CheckRealmExistence(i + 3, true);
    603 }
    604 
    605 // Add the maximum number of paths to a single realm entry. Each of these
    606 // paths should be retrievable. Next add 3 more paths -- since the cache is
    607 // full this causes FIFO eviction of the first three paths.
    608 TEST_F(HttpAuthCacheEvictionTest, RealmPathEviction) {
    609   for (int i = 0; i < kMaxPaths; ++i)
    610     AddPathToRealm(0, i);
    611 
    612   for (int i = 1; i < kMaxRealms; ++i)
    613     AddRealm(i);
    614 
    615   for (int i = 0; i < 3; ++i)
    616     AddPathToRealm(0, i + kMaxPaths);
    617 
    618   for (int i = 0; i < 3; ++i)
    619     CheckPathExistence(0, i, false);
    620 
    621   for (int i = 0; i < kMaxPaths; ++i)
    622     CheckPathExistence(0, i + 3, true);
    623 
    624   for (int i = 0; i < kMaxRealms; ++i)
    625     CheckRealmExistence(i, true);
    626 }
    627 
    628 }  // namespace net
    629