Home | History | Annotate | Download | only in quic 
      1 // Copyright 2013 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/files/file_path.h"
      8 #include "base/memory/singleton.h"
      9 #include "base/path_service.h"
     10 #include "base/strings/string_number_conversions.h"
     11 #include "base/strings/string_piece.h"
     12 #include "net/tools/balsa/balsa_headers.h"
     13 #include "net/tools/quic/quic_in_memory_cache.h"
     14 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
     15 #include "testing/gtest/include/gtest/gtest.h"
     16 
     17 using base::IntToString;
     18 using base::StringPiece;
     19 
     20 namespace net {
     21 namespace tools {
     22 namespace test {
     23 
     24 class QuicInMemoryCacheTest : public ::testing::Test {
     25  protected:
     26   QuicInMemoryCacheTest() {
     27     base::FilePath path;
     28     PathService::Get(base::DIR_SOURCE_ROOT, &path);
     29     path = path.AppendASCII("net").AppendASCII("data")
     30         .AppendASCII("quic_in_memory_cache_data");
     31     // The file path is known to be an ascii string.
     32     FLAGS_quic_in_memory_cache_dir = path.MaybeAsASCII();
     33   }
     34 
     35   void CreateRequest(std::string host,
     36                      std::string path,
     37                      net::BalsaHeaders* headers) {
     38     headers->SetRequestFirstlineFromStringPieces("GET", path, "HTTP/1.1");
     39     headers->ReplaceOrAppendHeader("host", host);
     40   }
     41 
     42   virtual void SetUp() OVERRIDE {
     43     QuicInMemoryCachePeer::ResetForTests();
     44   }
     45 
     46   // This method was copied from end_to_end_test.cc in this directory.
     47   void AddToCache(const StringPiece& method,
     48                   const StringPiece& path,
     49                   const StringPiece& version,
     50                   const StringPiece& response_code,
     51                   const StringPiece& response_detail,
     52                   const StringPiece& body) {
     53     BalsaHeaders request_headers, response_headers;
     54     request_headers.SetRequestFirstlineFromStringPieces(method,
     55                                                         path,
     56                                                         version);
     57     response_headers.SetRequestFirstlineFromStringPieces(version,
     58                                                          response_code,
     59                                                          response_detail);
     60     response_headers.AppendHeader("content-length",
     61                                   base::IntToString(body.length()));
     62 
     63     // Check if response already exists and matches.
     64     QuicInMemoryCache* cache = QuicInMemoryCache::GetInstance();
     65     const QuicInMemoryCache::Response* cached_response =
     66         cache->GetResponse(request_headers);
     67     if (cached_response != NULL) {
     68       std::string cached_response_headers_str, response_headers_str;
     69       cached_response->headers().DumpToString(&cached_response_headers_str);
     70       response_headers.DumpToString(&response_headers_str);
     71       CHECK_EQ(cached_response_headers_str, response_headers_str);
     72       CHECK_EQ(cached_response->body(), body);
     73       return;
     74     }
     75     cache->AddResponse(request_headers, response_headers, body);
     76   }
     77 };
     78 
     79 TEST_F(QuicInMemoryCacheTest, AddResponseGetResponse) {
     80   std::string response_body("hello response");
     81   AddToCache("GET", "https://www.google.com/bar",
     82              "HTTP/1.1", "200", "OK", response_body);
     83   net::BalsaHeaders request_headers;
     84   CreateRequest("www.google.com", "/bar", &request_headers);
     85   QuicInMemoryCache* cache = QuicInMemoryCache::GetInstance();
     86   const QuicInMemoryCache::Response* response =
     87       cache->GetResponse(request_headers);
     88   ASSERT_TRUE(response);
     89   EXPECT_EQ("200", response->headers().response_code());
     90   EXPECT_EQ(response_body.size(), response->body().length());
     91 
     92   CreateRequest("", "https://www.google.com/bar", &request_headers);
     93   response = cache->GetResponse(request_headers);
     94   ASSERT_TRUE(response);
     95   EXPECT_EQ("200", response->headers().response_code());
     96   EXPECT_EQ(response_body.size(), response->body().length());
     97 }
     98 
     99 TEST_F(QuicInMemoryCacheTest, ReadsCacheDir) {
    100   net::BalsaHeaders request_headers;
    101   CreateRequest("quic.test.url", "/index.html", &request_headers);
    102 
    103   const QuicInMemoryCache::Response* response =
    104       QuicInMemoryCache::GetInstance()->GetResponse(request_headers);
    105   ASSERT_TRUE(response);
    106   std::string value;
    107   response->headers().GetAllOfHeaderAsString("Connection", &value);
    108   EXPECT_EQ("200", response->headers().response_code());
    109   EXPECT_EQ("Keep-Alive", value);
    110   EXPECT_LT(0U, response->body().length());
    111 }
    112 
    113 TEST_F(QuicInMemoryCacheTest, ReadsCacheDirHttp) {
    114   net::BalsaHeaders request_headers;
    115   CreateRequest("", "http://quic.test.url/index.html", &request_headers);
    116 
    117   const QuicInMemoryCache::Response* response =
    118       QuicInMemoryCache::GetInstance()->GetResponse(request_headers);
    119   ASSERT_TRUE(response);
    120   std::string value;
    121   response->headers().GetAllOfHeaderAsString("Connection", &value);
    122   EXPECT_EQ("200", response->headers().response_code());
    123   EXPECT_EQ("Keep-Alive", value);
    124   EXPECT_LT(0U, response->body().length());
    125 }
    126 
    127 TEST_F(QuicInMemoryCacheTest, GetResponseNoMatch) {
    128   net::BalsaHeaders request_headers;
    129   CreateRequest("www.google.com", "/index.html", &request_headers);
    130 
    131   const QuicInMemoryCache::Response* response =
    132       QuicInMemoryCache::GetInstance()->GetResponse(request_headers);
    133   ASSERT_FALSE(response);
    134 }
    135 
    136 }  // namespace test
    137 }  // namespace tools
    138 }  // namespace net
    139