services/network/http_cache_data_counter_unittest.cc - chromium/src - Git at Google

 // Copyright 2018 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 "services/network/http_cache_data_counter.h"

 #include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>

 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/test/bind_test_util.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "services/network/network_context.h"
 #include "services/network/network_service.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace network {

 namespace {

 struct CacheTestEntry {
   const char* url;
   const char* date;
   int size;
 };

 constexpr CacheTestEntry kCacheEntries[] = {
     {"http://www.google.com", "15 Jun 1975", 1024},
     {"https://www.google.com", "15 Jun 1985", 2048},
     {"http://www.wikipedia.com", "15 Jun 1995", 4096},
     {"https://www.wikipedia.com", "15 Jun 2005", 8192},
     {"http://localhost:1234/mysite", "15 Jun 2015", 16384},
     {"https://localhost:1234/mysite", "15 Jun 2016", 32768},
     {"http://localhost:3456/yoursite", "15 Jun 2017", 65536},
     {"https://localhost:3456/yoursite", "15 Jun 2018", 512}};

 mojom::NetworkContextParamsPtr CreateContextParams() {
   mojom::NetworkContextParamsPtr params = mojom::NetworkContextParams::New();
   // Use a fixed proxy config, to avoid dependencies on local network
   // configuration.
   params->initial_proxy_config = net::ProxyConfigWithAnnotation::CreateDirect();
   return params;
 }

 class HttpCacheDataCounterTest : public testing::Test {
  public:
   HttpCacheDataCounterTest()
       : scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::IO),
         network_service_(NetworkService::CreateForTesting()) {}

   ~HttpCacheDataCounterTest() override = default;

   void SetUp() override {
     ASSERT_TRUE(cache_dir_.CreateUniqueTempDir());
     InitNetworkContext();

     net::HttpCache* cache = network_context_->url_request_context()
                                 ->http_transaction_factory()
                                 ->GetCache();
     ASSERT_TRUE(cache);
     {
       net::TestCompletionCallback callback;
       int rv = cache->GetBackend(&backend_, callback.callback());
       ASSERT_EQ(net::OK, callback.GetResult(rv));
       ASSERT_TRUE(backend_);
     }

     // Create some entries in the cache.
     for (const CacheTestEntry& test_entry : kCacheEntries) {
       disk_cache::Entry* entry = nullptr;
       net::TestCompletionCallback create_entry_callback;
       int rv = backend_->CreateEntry(test_entry.url, net::HIGHEST, &entry,
                                      create_entry_callback.callback());
       ASSERT_EQ(net::OK, create_entry_callback.GetResult(rv));
       ASSERT_TRUE(entry);

       auto io_buf = base::MakeRefCounted<net::IOBuffer>(test_entry.size);
       std::fill(io_buf->data(), io_buf->data() + test_entry.size, 0);

       net::TestCompletionCallback write_data_callback;
       rv = entry->WriteData(1, 0, io_buf.get(), test_entry.size,
                             write_data_callback.callback(), true);
       ASSERT_EQ(static_cast<int>(test_entry.size),
                 write_data_callback.GetResult(rv));

       base::Time time;
       ASSERT_TRUE(base::Time::FromString(test_entry.date, &time));
       entry->SetLastUsedTimeForTest(time);
       entry->Close();
       scoped_task_environment_.RunUntilIdle();
     }
   }

   void ExpectClose(int actual, int expected) {
     int margin = std::max(256, expected / 5);
     int expected_min = expected - margin;
     int expected_max = expected + margin;
     EXPECT_LE(expected_min, actual);
     EXPECT_LE(actual, expected_max);
     EXPECT_GE(actual, 0);
   }

   int SizeBetween(int first, int last) {
     int size = 0;
     for (int pos = first; pos < last; ++pos)
       size += kCacheEntries[pos].size;
     return size;
   }

   int SizeAll() { return SizeBetween(0, base::size(kCacheEntries)); }

   static std::pair<bool, int64_t> CountBetween(NetworkContext* network_context,
                                                base::Time start_time,
                                                base::Time end_time) {
     base::RunLoop run_loop;
     std::pair<bool, int64_t> result(false, net::ERR_FAILED);
     std::unique_ptr<HttpCacheDataCounter> own_counter =
         HttpCacheDataCounter::CreateAndStart(
             network_context->url_request_context(), start_time, end_time,
             base::BindLambdaForTesting([&](HttpCacheDataCounter* counter,
                                            bool upper_bound,
                                            int64_t size_or_error) {
               EXPECT_EQ(counter, own_counter.get());
               result = std::make_pair(upper_bound, size_or_error);
               run_loop.Quit();
             }));
     run_loop.Run();
     return result;
   }

   void TestCountBetween(int start_index, int end_index) {
     DCHECK_LE(0, start_index);
     DCHECK_LT(start_index, static_cast<int>(base::size(kCacheEntries)));
     DCHECK_LE(0, end_index);
     DCHECK_LT(end_index, static_cast<int>(base::size(kCacheEntries)));

     base::Time start_time;
     ASSERT_TRUE(
         base::Time::FromString(kCacheEntries[start_index].date, &start_time));

     base::Time end_time;
     ASSERT_TRUE(
         base::Time::FromString(kCacheEntries[end_index].date, &end_time));

     // The upper bound is "exclusive" but appropriximately so; make it clearly
     // exclusive.
     end_time -= base::TimeDelta::FromDays(1);

     auto result = CountBetween(network_context_.get(), start_time, end_time);
     ASSERT_GE(result.second, 0);
     if (result.first) {  // upper bound
       ExpectClose(result.second, SizeAll());
     } else {
       ExpectClose(result.second, SizeBetween(start_index, end_index));
     }
   }

  protected:
   void InitNetworkContext() {
     mojom::NetworkContextParamsPtr context_params = CreateContextParams();
     context_params->http_cache_enabled = true;
     context_params->http_cache_path = cache_dir_.GetPath();

     network_context_ = std::make_unique<NetworkContext>(
         network_service_.get(), mojo::MakeRequest(&network_context_ptr_),
         std::move(context_params));
   }

   base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::ScopedTempDir cache_dir_;
   std::unique_ptr<NetworkService> network_service_;
   std::unique_ptr<NetworkContext> network_context_;

   // Stores the NetworkContextPtr of the most recently created NetworkContext.
   mojom::NetworkContextPtr network_context_ptr_;
   disk_cache::Backend* backend_ = nullptr;
 };

 TEST_F(HttpCacheDataCounterTest, Basic) {
   auto result =
       CountBetween(network_context_.get(), base::Time(), base::Time::Max());
   EXPECT_EQ(false, result.first);
   ExpectClose(result.second, SizeAll());

   // Backwards interval to make sure we don't hit DCHECKs.
   TestCountBetween(1, 0);

   // Technically backwards, too.
   TestCountBetween(0, 0);

   // Empty interval.
   TestCountBetween(0, 1);

   // Some non-empty ones.
   TestCountBetween(0, 3);
   TestCountBetween(2, 5);
 }

 // Return the sensible thing (0 bytes used) when there is no cache.
 TEST(HttpCacheDataCounterTestNoCache, BeSensible) {
   base::test::ScopedTaskEnvironment scoped_task_environment(
       base::test::ScopedTaskEnvironment::MainThreadType::IO);
   std::unique_ptr<NetworkService> network_service(
       NetworkService::CreateForTesting());
   std::unique_ptr<NetworkContext> network_context;
   mojom::NetworkContextPtr network_context_ptr;

   mojom::NetworkContextParamsPtr context_params = CreateContextParams();
   context_params->http_cache_enabled = false;

   network_context = std::make_unique<NetworkContext>(
       network_service.get(), mojo::MakeRequest(&network_context_ptr),
       std::move(context_params));
   auto result = HttpCacheDataCounterTest::CountBetween(
       network_context.get(), base::Time(), base::Time::Max());
   EXPECT_EQ(false, result.first);
   EXPECT_EQ(0, result.second);
 }

 }  // namespace

 }  // namespace network
	// Copyright 2018 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 "services/network/http_cache_data_counter.h"

	#include <algorithm>
	#include <memory>
	#include <string>
	#include <utility>
	#include <vector>

	#include "base/bind.h"
	#include "base/files/scoped_temp_dir.h"
	#include "base/run_loop.h"
	#include "base/stl_util.h"
	#include "base/test/bind_test_util.h"
	#include "base/test/scoped_task_environment.h"
	#include "base/threading/thread_task_runner_handle.h"
	#include "net/base/cache_type.h"
	#include "net/base/net_errors.h"
	#include "net/base/test_completion_callback.h"
	#include "net/disk_cache/disk_cache.h"
	#include "net/http/http_cache.h"
	#include "net/http/http_network_session.h"
	#include "net/http/http_server_properties_manager.h"
	#include "net/http/http_transaction_factory.h"
	#include "net/url_request/url_request_context.h"
	#include "services/network/network_context.h"
	#include "services/network/network_service.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace network {

	namespace {

	struct CacheTestEntry {
	const char* url;
	const char* date;
	int size;
	};

	constexpr CacheTestEntry kCacheEntries[] = {
	{"http://www.google.com", "15 Jun 1975", 1024},
	{"https://www.google.com", "15 Jun 1985", 2048},
	{"http://www.wikipedia.com", "15 Jun 1995", 4096},
	{"https://www.wikipedia.com", "15 Jun 2005", 8192},
	{"http://localhost:1234/mysite", "15 Jun 2015", 16384},
	{"https://localhost:1234/mysite", "15 Jun 2016", 32768},
	{"http://localhost:3456/yoursite", "15 Jun 2017", 65536},
	{"https://localhost:3456/yoursite", "15 Jun 2018", 512}};

	mojom::NetworkContextParamsPtr CreateContextParams() {
	mojom::NetworkContextParamsPtr params = mojom::NetworkContextParams::New();
	// Use a fixed proxy config, to avoid dependencies on local network
	// configuration.
	params->initial_proxy_config = net::ProxyConfigWithAnnotation::CreateDirect();
	return params;
	}

	class HttpCacheDataCounterTest : public testing::Test {
	public:
	HttpCacheDataCounterTest()
	: scoped_task_environment_(
	base::test::ScopedTaskEnvironment::MainThreadType::IO),
	network_service_(NetworkService::CreateForTesting()) {}

	~HttpCacheDataCounterTest() override = default;

	void SetUp() override {
	ASSERT_TRUE(cache_dir_.CreateUniqueTempDir());
	InitNetworkContext();

	net::HttpCache* cache = network_context_->url_request_context()
	->http_transaction_factory()
	->GetCache();
	ASSERT_TRUE(cache);
	{
	net::TestCompletionCallback callback;
	int rv = cache->GetBackend(&backend_, callback.callback());
	ASSERT_EQ(net::OK, callback.GetResult(rv));
	ASSERT_TRUE(backend_);
	}

	// Create some entries in the cache.
	for (const CacheTestEntry& test_entry : kCacheEntries) {
	disk_cache::Entry* entry = nullptr;
	net::TestCompletionCallback create_entry_callback;
	int rv = backend_->CreateEntry(test_entry.url, net::HIGHEST, &entry,
	create_entry_callback.callback());
	ASSERT_EQ(net::OK, create_entry_callback.GetResult(rv));
	ASSERT_TRUE(entry);

	auto io_buf = base::MakeRefCounted<net::IOBuffer>(test_entry.size);
	std::fill(io_buf->data(), io_buf->data() + test_entry.size, 0);

	net::TestCompletionCallback write_data_callback;
	rv = entry->WriteData(1, 0, io_buf.get(), test_entry.size,
	write_data_callback.callback(), true);
	ASSERT_EQ(static_cast<int>(test_entry.size),
	write_data_callback.GetResult(rv));

	base::Time time;
	ASSERT_TRUE(base::Time::FromString(test_entry.date, &time));
	entry->SetLastUsedTimeForTest(time);
	entry->Close();
	scoped_task_environment_.RunUntilIdle();
	}
	}

	void ExpectClose(int actual, int expected) {
	int margin = std::max(256, expected / 5);
	int expected_min = expected - margin;
	int expected_max = expected + margin;
	EXPECT_LE(expected_min, actual);
	EXPECT_LE(actual, expected_max);
	EXPECT_GE(actual, 0);
	}

	int SizeBetween(int first, int last) {
	int size = 0;
	for (int pos = first; pos < last; ++pos)
	size += kCacheEntries[pos].size;
	return size;
	}

	int SizeAll() { return SizeBetween(0, base::size(kCacheEntries)); }

	static std::pair<bool, int64_t> CountBetween(NetworkContext* network_context,
	base::Time start_time,
	base::Time end_time) {
	base::RunLoop run_loop;
	std::pair<bool, int64_t> result(false, net::ERR_FAILED);
	std::unique_ptr<HttpCacheDataCounter> own_counter =
	HttpCacheDataCounter::CreateAndStart(
	network_context->url_request_context(), start_time, end_time,
	base::BindLambdaForTesting([&](HttpCacheDataCounter* counter,
	bool upper_bound,
	int64_t size_or_error) {
	EXPECT_EQ(counter, own_counter.get());
	result = std::make_pair(upper_bound, size_or_error);
	run_loop.Quit();
	}));
	run_loop.Run();
	return result;
	}

	void TestCountBetween(int start_index, int end_index) {
	DCHECK_LE(0, start_index);
	DCHECK_LT(start_index, static_cast<int>(base::size(kCacheEntries)));
	DCHECK_LE(0, end_index);
	DCHECK_LT(end_index, static_cast<int>(base::size(kCacheEntries)));

	base::Time start_time;
	ASSERT_TRUE(
	base::Time::FromString(kCacheEntries[start_index].date, &start_time));

	base::Time end_time;
	ASSERT_TRUE(
	base::Time::FromString(kCacheEntries[end_index].date, &end_time));

	// The upper bound is "exclusive" but appropriximately so; make it clearly
	// exclusive.
	end_time -= base::TimeDelta::FromDays(1);

	auto result = CountBetween(network_context_.get(), start_time, end_time);
	ASSERT_GE(result.second, 0);
	if (result.first) { // upper bound
	ExpectClose(result.second, SizeAll());
	} else {
	ExpectClose(result.second, SizeBetween(start_index, end_index));
	}
	}

	protected:
	void InitNetworkContext() {
	mojom::NetworkContextParamsPtr context_params = CreateContextParams();
	context_params->http_cache_enabled = true;
	context_params->http_cache_path = cache_dir_.GetPath();

	network_context_ = std::make_unique<NetworkContext>(
	network_service_.get(), mojo::MakeRequest(&network_context_ptr_),
	std::move(context_params));
	}

	base::test::ScopedTaskEnvironment scoped_task_environment_;
	base::ScopedTempDir cache_dir_;
	std::unique_ptr<NetworkService> network_service_;
	std::unique_ptr<NetworkContext> network_context_;

	// Stores the NetworkContextPtr of the most recently created NetworkContext.
	mojom::NetworkContextPtr network_context_ptr_;
	disk_cache::Backend* backend_ = nullptr;
	};

	TEST_F(HttpCacheDataCounterTest, Basic) {
	auto result =
	CountBetween(network_context_.get(), base::Time(), base::Time::Max());
	EXPECT_EQ(false, result.first);
	ExpectClose(result.second, SizeAll());

	// Backwards interval to make sure we don't hit DCHECKs.
	TestCountBetween(1, 0);

	// Technically backwards, too.
	TestCountBetween(0, 0);

	// Empty interval.
	TestCountBetween(0, 1);

	// Some non-empty ones.
	TestCountBetween(0, 3);
	TestCountBetween(2, 5);
	}

	// Return the sensible thing (0 bytes used) when there is no cache.
	TEST(HttpCacheDataCounterTestNoCache, BeSensible) {
	base::test::ScopedTaskEnvironment scoped_task_environment(
	base::test::ScopedTaskEnvironment::MainThreadType::IO);
	std::unique_ptr<NetworkService> network_service(
	NetworkService::CreateForTesting());
	std::unique_ptr<NetworkContext> network_context;
	mojom::NetworkContextPtr network_context_ptr;

	mojom::NetworkContextParamsPtr context_params = CreateContextParams();
	context_params->http_cache_enabled = false;

	network_context = std::make_unique<NetworkContext>(
	network_service.get(), mojo::MakeRequest(&network_context_ptr),
	std::move(context_params));
	auto result = HttpCacheDataCounterTest::CountBetween(
	network_context.get(), base::Time(), base::Time::Max());
	EXPECT_EQ(false, result.first);
	EXPECT_EQ(0, result.second);
	}

	} // namespace

	} // namespace network