net/http/disk_cache_based_quic_server_info_unittest.cc

   1 // Copyright 2014 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 "net/http/disk_cache_based_quic_server_info.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/compiler_specific.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "net/base/net_errors.h"
  12 #include "net/http/mock_http_cache.h"
  13 #include "net/quic/crypto/quic_server_info.h"
  14 #include "net/quic/quic_server_id.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace net {
  18 namespace {
  19
  20 // This is an empty transaction, needed to register the URL and the test mode.
  21 const MockTransaction kHostInfoTransaction1 = {
  22   "quicserverinfo:https://www.google.com:443",
  23   "",
  24   base::Time(),
  25   "",
  26   LOAD_NORMAL,
  27   "",
  28   "",
  29   base::Time(),
  30   "",
  31   TEST_MODE_NORMAL,
  32   NULL,
  33   0
  34 };
  35
  36 const MockTransaction kHostInfoTransaction2 = {
  37   "quicserverinfo:http://www.google.com:80",
  38   "",
  39   base::Time(),
  40   "",
  41   LOAD_NORMAL,
  42   "",
  43   "",
  44   base::Time(),
  45   "",
  46   TEST_MODE_NORMAL,
  47   NULL,
  48   0
  49 };
  50
  51 }  // namespace
  52
  53 // Tests that we can delete a DiskCacheBasedQuicServerInfo object in a
  54 // completion callback for DiskCacheBasedQuicServerInfo::WaitForDataReady.
  55 TEST(DiskCacheBasedQuicServerInfo, DeleteInCallback) {
  56   // Use the blocking mock backend factory to force asynchronous completion
  57   // of quic_server_info->WaitForDataReady(), so that the callback will run.
  58   MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
  59   MockHttpCache cache(factory);
  60   QuicServerId server_id("www.verisign.com", 443, true, PRIVACY_MODE_DISABLED);
  61   scoped_ptr<QuicServerInfo> quic_server_info(
  62       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
  63   quic_server_info->Start();
  64   TestCompletionCallback callback;
  65   int rv = quic_server_info->WaitForDataReady(callback.callback());
  66   EXPECT_EQ(ERR_IO_PENDING, rv);
  67   // Now complete the backend creation and let the callback run.
  68   factory->FinishCreation();
  69   EXPECT_EQ(OK, callback.GetResult(rv));
  70 }
  71
  72 // Tests the basic logic of storing, retrieving and updating data.
  73 TEST(DiskCacheBasedQuicServerInfo, Update) {
  74   MockHttpCache cache;
  75   AddMockTransaction(&kHostInfoTransaction1);
  76   TestCompletionCallback callback;
  77
  78   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
  79   scoped_ptr<QuicServerInfo> quic_server_info(
  80       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
  81   quic_server_info->Start();
  82   int rv = quic_server_info->WaitForDataReady(callback.callback());
  83   EXPECT_EQ(OK, callback.GetResult(rv));
  84
  85   QuicServerInfo::State* state = quic_server_info->mutable_state();
  86   EXPECT_TRUE(state->certs.empty());
  87   const string server_config_a = "server_config_a";
  88   const string source_address_token_a = "source_address_token_a";
  89   const string server_config_sig_a = "server_config_sig_a";
  90   const string cert_a = "cert_a";
  91   const string cert_b = "cert_b";
  92
  93   state->server_config = server_config_a;
  94   state->source_address_token = source_address_token_a;
  95   state->server_config_sig = server_config_sig_a;
  96   state->certs.push_back(cert_a);
  97   quic_server_info->Persist();
  98
  99   // Wait until Persist() does the work.
 100   base::MessageLoop::current()->RunUntilIdle();
 101
 102   // Open the stored QuicServerInfo.
 103   quic_server_info.reset(
 104       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 105   quic_server_info->Start();
 106   rv = quic_server_info->WaitForDataReady(callback.callback());
 107   EXPECT_EQ(OK, callback.GetResult(rv));
 108
 109   // And now update the data.
 110   state = quic_server_info->mutable_state();
 111   state->certs.push_back(cert_b);
 112
 113   // Fail instead of DCHECKing double creates.
 114   cache.disk_cache()->set_double_create_check(false);
 115   quic_server_info->Persist();
 116   base::MessageLoop::current()->RunUntilIdle();
 117
 118   // Verify that the state was updated.
 119   quic_server_info.reset(
 120       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 121   quic_server_info->Start();
 122   rv = quic_server_info->WaitForDataReady(callback.callback());
 123   EXPECT_EQ(OK, callback.GetResult(rv));
 124   EXPECT_TRUE(quic_server_info->IsDataReady());
 125
 126   const QuicServerInfo::State& state1 = quic_server_info->state();
 127   EXPECT_EQ(server_config_a, state1.server_config);
 128   EXPECT_EQ(source_address_token_a, state1.source_address_token);
 129   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
 130   EXPECT_EQ(2U, state1.certs.size());
 131   EXPECT_EQ(cert_a, state1.certs[0]);
 132   EXPECT_EQ(cert_b, state1.certs[1]);
 133
 134   RemoveMockTransaction(&kHostInfoTransaction1);
 135 }
 136
 137 // Test that demonstrates different info is returned when the ports differ.
 138 TEST(DiskCacheBasedQuicServerInfo, UpdateDifferentPorts) {
 139   MockHttpCache cache;
 140   AddMockTransaction(&kHostInfoTransaction1);
 141   AddMockTransaction(&kHostInfoTransaction2);
 142   TestCompletionCallback callback;
 143
 144   // Persist data for port 443.
 145   QuicServerId server_id1("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 146   scoped_ptr<QuicServerInfo> quic_server_info1(
 147       new DiskCacheBasedQuicServerInfo(server_id1, cache.http_cache()));
 148   quic_server_info1->Start();
 149   int rv = quic_server_info1->WaitForDataReady(callback.callback());
 150   EXPECT_EQ(OK, callback.GetResult(rv));
 151
 152   QuicServerInfo::State* state1 = quic_server_info1->mutable_state();
 153   EXPECT_TRUE(state1->certs.empty());
 154   const string server_config_a = "server_config_a";
 155   const string source_address_token_a = "source_address_token_a";
 156   const string server_config_sig_a = "server_config_sig_a";
 157   const string cert_a = "cert_a";
 158
 159   state1->server_config = server_config_a;
 160   state1->source_address_token = source_address_token_a;
 161   state1->server_config_sig = server_config_sig_a;
 162   state1->certs.push_back(cert_a);
 163   quic_server_info1->Persist();
 164
 165   // Wait until Persist() does the work.
 166   base::MessageLoop::current()->RunUntilIdle();
 167
 168   // Persist data for port 80.
 169   QuicServerId server_id2("www.google.com", 80, false, PRIVACY_MODE_DISABLED);
 170   scoped_ptr<QuicServerInfo> quic_server_info2(
 171       new DiskCacheBasedQuicServerInfo(server_id2, cache.http_cache()));
 172   quic_server_info2->Start();
 173   rv = quic_server_info2->WaitForDataReady(callback.callback());
 174   EXPECT_EQ(OK, callback.GetResult(rv));
 175
 176   QuicServerInfo::State* state2 = quic_server_info2->mutable_state();
 177   EXPECT_TRUE(state2->certs.empty());
 178   const string server_config_b = "server_config_b";
 179   const string source_address_token_b = "source_address_token_b";
 180   const string server_config_sig_b = "server_config_sig_b";
 181   const string cert_b = "cert_b";
 182
 183   state2->server_config = server_config_b;
 184   state2->source_address_token = source_address_token_b;
 185   state2->server_config_sig = server_config_sig_b;
 186   state2->certs.push_back(cert_b);
 187   quic_server_info2->Persist();
 188
 189   // Wait until Persist() does the work.
 190   base::MessageLoop::current()->RunUntilIdle();
 191
 192   // Verify the stored QuicServerInfo for port 443.
 193   scoped_ptr<QuicServerInfo> quic_server_info(
 194       new DiskCacheBasedQuicServerInfo(server_id1, cache.http_cache()));
 195   quic_server_info->Start();
 196   rv = quic_server_info->WaitForDataReady(callback.callback());
 197   EXPECT_EQ(OK, callback.GetResult(rv));
 198   EXPECT_TRUE(quic_server_info->IsDataReady());
 199
 200   const QuicServerInfo::State& state_a = quic_server_info->state();
 201   EXPECT_EQ(server_config_a, state_a.server_config);
 202   EXPECT_EQ(source_address_token_a, state_a.source_address_token);
 203   EXPECT_EQ(server_config_sig_a, state_a.server_config_sig);
 204   EXPECT_EQ(1U, state_a.certs.size());
 205   EXPECT_EQ(cert_a, state_a.certs[0]);
 206
 207   // Verify the stored QuicServerInfo for port 80.
 208   quic_server_info.reset(
 209       new DiskCacheBasedQuicServerInfo(server_id2, cache.http_cache()));
 210   quic_server_info->Start();
 211   rv = quic_server_info->WaitForDataReady(callback.callback());
 212   EXPECT_EQ(OK, callback.GetResult(rv));
 213   EXPECT_TRUE(quic_server_info->IsDataReady());
 214
 215   const QuicServerInfo::State& state_b = quic_server_info->state();
 216   EXPECT_EQ(server_config_b, state_b.server_config);
 217   EXPECT_EQ(source_address_token_b, state_b.source_address_token);
 218   EXPECT_EQ(server_config_sig_b, state_b.server_config_sig);
 219   EXPECT_EQ(1U, state_b.certs.size());
 220   EXPECT_EQ(cert_b, state_b.certs[0]);
 221
 222   RemoveMockTransaction(&kHostInfoTransaction2);
 223   RemoveMockTransaction(&kHostInfoTransaction1);
 224 }
 225
 226 // Test IsReadyToPersist when there is a pending write.
 227 TEST(DiskCacheBasedQuicServerInfo, IsReadyToPersist) {
 228   MockHttpCache cache;
 229   AddMockTransaction(&kHostInfoTransaction1);
 230   TestCompletionCallback callback;
 231
 232   QuicServerId server_id("www.google.com", 443, true, PRIVACY_MODE_DISABLED);
 233   scoped_ptr<QuicServerInfo> quic_server_info(
 234       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 235   EXPECT_FALSE(quic_server_info->IsDataReady());
 236   quic_server_info->Start();
 237   int rv = quic_server_info->WaitForDataReady(callback.callback());
 238   EXPECT_EQ(OK, callback.GetResult(rv));
 239   EXPECT_TRUE(quic_server_info->IsDataReady());
 240
 241   QuicServerInfo::State* state = quic_server_info->mutable_state();
 242   EXPECT_TRUE(state->certs.empty());
 243   const string server_config_a = "server_config_a";
 244   const string source_address_token_a = "source_address_token_a";
 245   const string server_config_sig_a = "server_config_sig_a";
 246   const string cert_a = "cert_a";
 247
 248   state->server_config = server_config_a;
 249   state->source_address_token = source_address_token_a;
 250   state->server_config_sig = server_config_sig_a;
 251   state->certs.push_back(cert_a);
 252   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 253   quic_server_info->Persist();
 254
 255   // Once we call Persist, IsReadyToPersist should return false until Persist
 256   // has completed.
 257   EXPECT_FALSE(quic_server_info->IsReadyToPersist());
 258
 259   // Wait until Persist() does the work.
 260   base::MessageLoop::current()->RunUntilIdle();
 261
 262   EXPECT_TRUE(quic_server_info->IsReadyToPersist());
 263
 264   // Verify that the state was updated.
 265   quic_server_info.reset(
 266       new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
 267   quic_server_info->Start();
 268   rv = quic_server_info->WaitForDataReady(callback.callback());
 269   EXPECT_EQ(OK, callback.GetResult(rv));
 270   EXPECT_TRUE(quic_server_info->IsDataReady());
 271
 272   const QuicServerInfo::State& state1 = quic_server_info->state();
 273   EXPECT_EQ(server_config_a, state1.server_config);
 274   EXPECT_EQ(source_address_token_a, state1.source_address_token);
 275   EXPECT_EQ(server_config_sig_a, state1.server_config_sig);
 276   EXPECT_EQ(1U, state1.certs.size());
 277   EXPECT_EQ(cert_a, state1.certs[0]);
 278
 279   RemoveMockTransaction(&kHostInfoTransaction1);
 280 }
 281
 282 }  // namespace net