2696 lines
101 KiB
C++
2696 lines
101 KiB
C++
// Copyright 2012 The Chromium Authors
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "net/dns/host_cache.h"
|
|
|
|
#include <map>
|
|
#include <memory>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "base/format_macros.h"
|
|
#include "base/functional/bind.h"
|
|
#include "base/functional/callback.h"
|
|
#include "base/functional/callback_helpers.h"
|
|
#include "base/json/json_reader.h"
|
|
#include "base/json/json_writer.h"
|
|
#include "base/ranges/algorithm.h"
|
|
#include "base/strings/strcat.h"
|
|
#include "base/strings/string_number_conversions.h"
|
|
#include "base/strings/string_piece.h"
|
|
#include "base/strings/string_util.h"
|
|
#include "base/strings/stringprintf.h"
|
|
#include "base/time/time.h"
|
|
#include "base/values.h"
|
|
#include "net/base/connection_endpoint_metadata.h"
|
|
#include "net/base/host_port_pair.h"
|
|
#include "net/base/ip_address.h"
|
|
#include "net/base/ip_endpoint.h"
|
|
#include "net/base/network_anonymization_key.h"
|
|
#include "net/base/schemeful_site.h"
|
|
#include "net/dns/host_resolver_internal_result.h"
|
|
#include "net/dns/host_resolver_results_test_util.h"
|
|
#include "net/dns/https_record_rdata.h"
|
|
#include "net/dns/public/host_resolver_results.h"
|
|
#include "testing/gmock/include/gmock/gmock.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
#include "url/gurl.h"
|
|
#include "url/scheme_host_port.h"
|
|
#include "url/url_constants.h"
|
|
|
|
using ::testing::_;
|
|
using ::testing::ElementsAre;
|
|
using ::testing::ElementsAreArray;
|
|
using ::testing::IsEmpty;
|
|
using ::testing::Optional;
|
|
using ::testing::Pair;
|
|
using ::testing::Pointee;
|
|
using ::testing::Property;
|
|
using ::testing::UnorderedElementsAre;
|
|
|
|
namespace net {
|
|
|
|
namespace {
|
|
|
|
const int kMaxCacheEntries = 10;
|
|
|
|
// Builds a key for |hostname|, defaulting the query type to unspecified.
|
|
HostCache::Key Key(const std::string& hostname) {
|
|
return HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, hostname, 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
}
|
|
|
|
bool FoobarIndexIsOdd(const std::string& foobarx_com) {
|
|
return (foobarx_com[6] - '0') % 2 == 1;
|
|
}
|
|
|
|
class MockPersistenceDelegate : public HostCache::PersistenceDelegate {
|
|
public:
|
|
void ScheduleWrite() override { ++num_changes_; }
|
|
|
|
int num_changes() const { return num_changes_; }
|
|
|
|
private:
|
|
int num_changes_ = 0;
|
|
};
|
|
|
|
MATCHER_P(EntryContentsEqual,
|
|
entry,
|
|
base::StrCat({"contents ", negation ? "!=" : "==", " contents of ",
|
|
testing::PrintToString(entry)})) {
|
|
return arg.ContentsEqual(entry);
|
|
}
|
|
|
|
IPAddress MakeIP(base::StringPiece literal) {
|
|
IPAddress ret;
|
|
CHECK(ret.AssignFromIPLiteral(literal));
|
|
return ret;
|
|
}
|
|
|
|
std::vector<IPEndPoint> MakeEndpoints(std::vector<std::string> my_addresses) {
|
|
std::vector<IPEndPoint> out(my_addresses.size());
|
|
base::ranges::transform(my_addresses, out.begin(),
|
|
[](auto& s) { return IPEndPoint(MakeIP(s), 0); });
|
|
return out;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
TEST(HostCacheTest, Basic) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Start at t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{"foobar.com"},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add an entry for "foobar.com" at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key1, now)->second.error() == entry.error());
|
|
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// Advance to t=5.
|
|
now += base::Seconds(5);
|
|
|
|
// Add an entry for "foobar2.com" at t=5.
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
cache.Set(key2, entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(2U, cache.size());
|
|
|
|
// Advance to t=9
|
|
now += base::Seconds(4);
|
|
|
|
// Verify that the entries we added are still retrievable, and usable.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key2, now));
|
|
|
|
// Advance to t=10; key is now expired.
|
|
now += base::Seconds(1);
|
|
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
|
|
// Update key1, so it is no longer expired.
|
|
cache.Set(key1, entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(2U, cache.size());
|
|
|
|
// Both entries should still be retrievable and usable.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
|
|
// Advance to t=20; both entries are now expired.
|
|
now += base::Seconds(10);
|
|
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
}
|
|
|
|
TEST(HostCacheTest, GetEndpoints) {
|
|
std::vector<IPEndPoint> ip_endpoints = {IPEndPoint(IPAddress(1, 1, 1, 1), 0),
|
|
IPEndPoint(IPAddress(2, 2, 2, 2), 0)};
|
|
HostCache::Entry entry(OK, ip_endpoints, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
EXPECT_THAT(entry.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ip_endpoints))));
|
|
}
|
|
|
|
TEST(HostCacheTest, GetEmptyEndpoints) {
|
|
HostCache::Entry entry(ERR_NAME_NOT_RESOLVED, /*ip_endpoints=*/{},
|
|
/*aliases=*/{}, HostCache::Entry::SOURCE_DNS);
|
|
EXPECT_THAT(entry.GetEndpoints(), Optional(IsEmpty()));
|
|
}
|
|
|
|
TEST(HostCacheTest, GetEmptyEndpointsWithMetadata) {
|
|
HostCache::Entry entry(ERR_NAME_NOT_RESOLVED, /*ip_endpoints=*/{},
|
|
/*aliases=*/{}, HostCache::Entry::SOURCE_DNS);
|
|
|
|
// Merge in non-empty metadata.
|
|
ConnectionEndpointMetadata metadata;
|
|
metadata.supported_protocol_alpns = {"h3", "h2"};
|
|
HostCache::Entry metadata_entry(
|
|
OK,
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>{
|
|
{1u, metadata}},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
auto merged_entry = HostCache::Entry::MergeEntries(entry, metadata_entry);
|
|
|
|
// Result should still be empty.
|
|
EXPECT_THAT(merged_entry.GetEndpoints(), Optional(IsEmpty()));
|
|
}
|
|
|
|
TEST(HostCacheTest, GetMissingEndpoints) {
|
|
HostCache::Entry entry(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS);
|
|
EXPECT_FALSE(entry.GetEndpoints());
|
|
}
|
|
|
|
TEST(HostCacheTest, GetMissingEndpointsWithMetadata) {
|
|
HostCache::Entry entry(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS);
|
|
|
|
// Merge in non-empty metadata.
|
|
ConnectionEndpointMetadata metadata;
|
|
metadata.supported_protocol_alpns = {"h3", "h2"};
|
|
HostCache::Entry metadata_entry(
|
|
OK,
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>{
|
|
{1u, metadata}},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
auto merged_entry = HostCache::Entry::MergeEntries(entry, metadata_entry);
|
|
|
|
// Result should still be `nullopt`.
|
|
EXPECT_FALSE(merged_entry.GetEndpoints());
|
|
}
|
|
|
|
// Test that Keys without scheme are allowed and treated as completely different
|
|
// from similar Keys with scheme.
|
|
TEST(HostCacheTest, HandlesKeysWithoutScheme) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key("host1.test", DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey());
|
|
HostCache::Key key_with_scheme(
|
|
url::SchemeHostPort(url::kHttpsScheme, "host1.test", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
ASSERT_NE(key, key_with_scheme);
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
ASSERT_EQ(0U, cache.size());
|
|
ASSERT_FALSE(cache.Lookup(key, now));
|
|
ASSERT_FALSE(cache.Lookup(key_with_scheme, now));
|
|
|
|
// Add entry for `key`.
|
|
cache.Set(key, entry, now, kTTL);
|
|
EXPECT_EQ(1U, cache.size());
|
|
EXPECT_TRUE(cache.Lookup(key, now));
|
|
EXPECT_FALSE(cache.Lookup(key_with_scheme, now));
|
|
|
|
// Add entry for `key_with_scheme`.
|
|
cache.Set(key_with_scheme, entry, now, kTTL);
|
|
EXPECT_EQ(2U, cache.size());
|
|
EXPECT_TRUE(cache.Lookup(key, now));
|
|
EXPECT_TRUE(cache.Lookup(key_with_scheme, now));
|
|
|
|
// Clear the cache and try adding in reverse order.
|
|
cache.clear();
|
|
ASSERT_EQ(0U, cache.size());
|
|
ASSERT_FALSE(cache.Lookup(key, now));
|
|
ASSERT_FALSE(cache.Lookup(key_with_scheme, now));
|
|
|
|
// Add entry for `key_with_scheme`.
|
|
cache.Set(key_with_scheme, entry, now, kTTL);
|
|
EXPECT_EQ(1U, cache.size());
|
|
EXPECT_FALSE(cache.Lookup(key, now));
|
|
EXPECT_TRUE(cache.Lookup(key_with_scheme, now));
|
|
|
|
// Add entry for `key`.
|
|
cache.Set(key, entry, now, kTTL);
|
|
EXPECT_EQ(2U, cache.size());
|
|
EXPECT_TRUE(cache.Lookup(key, now));
|
|
EXPECT_TRUE(cache.Lookup(key_with_scheme, now));
|
|
}
|
|
|
|
// Make sure NetworkAnonymizationKey is respected.
|
|
TEST(HostCacheTest, NetworkAnonymizationKey) {
|
|
const url::SchemeHostPort kHost(url::kHttpsScheme, "hostname.test", 443);
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
const SchemefulSite kSite1(GURL("https://site1.test/"));
|
|
const auto kNetworkAnonymizationKey1 =
|
|
NetworkAnonymizationKey::CreateSameSite(kSite1);
|
|
const SchemefulSite kSite2(GURL("https://site2.test/"));
|
|
const auto kNetworkAnonymizationKey2 =
|
|
NetworkAnonymizationKey::CreateSameSite(kSite2);
|
|
|
|
HostCache::Key key1(kHost, DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, kNetworkAnonymizationKey1);
|
|
HostCache::Key key2(kHost, DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, kNetworkAnonymizationKey2);
|
|
HostCache::Entry entry1 =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
HostCache::Entry entry2 =
|
|
HostCache::Entry(ERR_FAILED, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Start at t=0.
|
|
base::TimeTicks now;
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add an entry for kNetworkAnonymizationKey1.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry1, now, kTTL);
|
|
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result =
|
|
cache.Lookup(key1, now);
|
|
ASSERT_TRUE(result);
|
|
EXPECT_EQ(kNetworkAnonymizationKey1, result->first.network_anonymization_key);
|
|
EXPECT_EQ(OK, result->second.error());
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// Add a different entry for kNetworkAnonymizationKey2.
|
|
cache.Set(key2, entry2, now, 3 * kTTL);
|
|
result = cache.Lookup(key1, now);
|
|
ASSERT_TRUE(result);
|
|
EXPECT_EQ(kNetworkAnonymizationKey1, result->first.network_anonymization_key);
|
|
EXPECT_EQ(OK, result->second.error());
|
|
result = cache.Lookup(key2, now);
|
|
ASSERT_TRUE(result);
|
|
EXPECT_EQ(kNetworkAnonymizationKey2, result->first.network_anonymization_key);
|
|
EXPECT_EQ(ERR_FAILED, result->second.error());
|
|
EXPECT_EQ(2U, cache.size());
|
|
|
|
// Advance time so that first entry times out. Second entry should remain.
|
|
now += 2 * kTTL;
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
result = cache.Lookup(key2, now);
|
|
ASSERT_TRUE(result);
|
|
EXPECT_EQ(kNetworkAnonymizationKey2, result->first.network_anonymization_key);
|
|
EXPECT_EQ(ERR_FAILED, result->second.error());
|
|
}
|
|
|
|
// Try caching entries for a failed resolve attempt -- since we set the TTL of
|
|
// such entries to 0 it won't store, but it will kick out the previous result.
|
|
TEST(HostCacheTest, NoCacheZeroTTL) {
|
|
const base::TimeDelta kSuccessEntryTTL = base::Seconds(10);
|
|
const base::TimeDelta kFailureEntryTTL = base::Seconds(0);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Set t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry, now, kFailureEntryTTL);
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// We disallow use of negative entries.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
|
|
// Now overwrite with a valid entry, and then overwrite with negative entry
|
|
// again -- the valid entry should be kicked out.
|
|
cache.Set(key1, entry, now, kSuccessEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry, now, kFailureEntryTTL);
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
}
|
|
|
|
// Try caching entries for a failed resolves for 10 seconds.
|
|
TEST(HostCacheTest, CacheNegativeEntry) {
|
|
const base::TimeDelta kFailureEntryTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Start at t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add an entry for "foobar.com" at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry, now, kFailureEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// Advance to t=5.
|
|
now += base::Seconds(5);
|
|
|
|
// Add an entry for "foobar2.com" at t=5.
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
cache.Set(key2, entry, now, kFailureEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(2U, cache.size());
|
|
|
|
// Advance to t=9
|
|
now += base::Seconds(4);
|
|
|
|
// Verify that the entries we added are still retrievable, and usable.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
|
|
// Advance to t=10; key1 is now expired.
|
|
now += base::Seconds(1);
|
|
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
|
|
// Update key1, so it is no longer expired.
|
|
cache.Set(key1, entry, now, kFailureEntryTTL);
|
|
// Re-uses existing entry storage.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(2U, cache.size());
|
|
|
|
// Both entries should still be retrievable and usable.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
|
|
// Advance to t=20; both entries are now expired.
|
|
now += base::Seconds(10);
|
|
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
}
|
|
|
|
// Tests that the same hostname can be duplicated in the cache, so long as
|
|
// the query type differs.
|
|
TEST(HostCacheTest, DnsQueryTypeIsPartOfKey) {
|
|
const base::TimeDelta kSuccessEntryTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1(url::SchemeHostPort(url::kHttpScheme, "foobar.com", 80),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
HostCache::Key key2(url::SchemeHostPort(url::kHttpScheme, "foobar.com", 80),
|
|
DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add an entry for ("foobar.com", UNSPECIFIED) at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry, now, kSuccessEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// Add an entry for ("foobar.com", IPV4_ONLY) at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
cache.Set(key2, entry, now, kSuccessEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(2U, cache.size());
|
|
|
|
// Even though the hostnames were the same, we should have two unique
|
|
// entries (because the address families differ).
|
|
EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key2, now));
|
|
}
|
|
|
|
// Tests that the same hostname can be duplicated in the cache, so long as
|
|
// the HostResolverFlags differ.
|
|
TEST(HostCacheTest, HostResolverFlagsArePartOfKey) {
|
|
const url::SchemeHostPort kHost(url::kHttpsScheme, "foobar.test", 443);
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1(kHost, DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
HostCache::Key key2(kHost, DnsQueryType::A, HOST_RESOLVER_CANONNAME,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey());
|
|
HostCache::Key key3(kHost, DnsQueryType::A, HOST_RESOLVER_LOOPBACK_ONLY,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey());
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add an entry for ("foobar.com", IPV4, NONE) at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// Add an entry for ("foobar.com", IPV4, CANONNAME) at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
cache.Set(key2, entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(2U, cache.size());
|
|
|
|
// Add an entry for ("foobar.com", IPV4, LOOPBACK_ONLY) at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key3, now));
|
|
cache.Set(key3, entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key3, now));
|
|
EXPECT_EQ(3U, cache.size());
|
|
|
|
// Even though the hostnames were the same, we should have two unique
|
|
// entries (because the HostResolverFlags differ).
|
|
EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key2, now));
|
|
EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key3, now));
|
|
EXPECT_NE(cache.Lookup(key2, now), cache.Lookup(key3, now));
|
|
}
|
|
|
|
// Tests that the same hostname can be duplicated in the cache, so long as
|
|
// the HostResolverSource differs.
|
|
TEST(HostCacheTest, HostResolverSourceIsPartOfKey) {
|
|
const url::SchemeHostPort kHost(url::kHttpsScheme, "foobar.test", 443);
|
|
const base::TimeDelta kSuccessEntryTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1(kHost, DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey());
|
|
HostCache::Key key2(kHost, DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::DNS, NetworkAnonymizationKey());
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add an entry for ("foobar.com", UNSPECIFIED, ANY) at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry, now, kSuccessEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// Add an entry for ("foobar.com", UNSPECIFIED, DNS) at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
cache.Set(key2, entry, now, kSuccessEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(2U, cache.size());
|
|
|
|
// Even though the hostnames were the same, we should have two unique
|
|
// entries (because the HostResolverSource differs).
|
|
EXPECT_NE(cache.Lookup(key1, now), cache.Lookup(key2, now));
|
|
}
|
|
|
|
// Tests that the same hostname can be duplicated in the cache, so long as
|
|
// the secure field in the key differs.
|
|
TEST(HostCacheTest, SecureIsPartOfKey) {
|
|
const url::SchemeHostPort kHost(url::kHttpsScheme, "foobar.test", 443);
|
|
const base::TimeDelta kSuccessEntryTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// t=0.
|
|
base::TimeTicks now;
|
|
HostCache::EntryStaleness stale;
|
|
|
|
HostCache::Key key1(kHost, DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
key1.secure = true;
|
|
HostCache::Key key2(kHost, DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
key2.secure = false;
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add an entry for ("foobar.com", IPV4, true /* secure */) at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry, now, kSuccessEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// Lookup a key that is identical to the inserted key except for the secure
|
|
// field.
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
EXPECT_FALSE(cache.LookupStale(key2, now, &stale));
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result;
|
|
result = cache.Lookup(key2, now, true /* ignore_secure */);
|
|
EXPECT_TRUE(result);
|
|
EXPECT_TRUE(result->first.secure);
|
|
result = cache.LookupStale(key2, now, &stale, true /* ignore_secure */);
|
|
EXPECT_TRUE(result);
|
|
EXPECT_TRUE(result->first.secure);
|
|
|
|
// Add an entry for ("foobar.com", IPV4, false */ secure */) at t=0.
|
|
cache.Set(key2, entry, now, kSuccessEntryTTL);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_TRUE(cache.LookupStale(key2, now, &stale));
|
|
EXPECT_EQ(2U, cache.size());
|
|
}
|
|
|
|
TEST(HostCacheTest, PreferLessStaleMoreSecure) {
|
|
const url::SchemeHostPort kHost(url::kHttpsScheme, "foobar.test", 443);
|
|
const base::TimeDelta kSuccessEntryTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// t=0.
|
|
base::TimeTicks now;
|
|
HostCache::EntryStaleness stale;
|
|
|
|
HostCache::Key insecure_key(kHost, DnsQueryType::A, 0,
|
|
HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
HostCache::Key secure_key(kHost, DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
secure_key.secure = true;
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add both insecure and secure entries.
|
|
cache.Set(insecure_key, entry, now, kSuccessEntryTTL);
|
|
cache.Set(secure_key, entry, now, kSuccessEntryTTL);
|
|
EXPECT_EQ(insecure_key, cache.Lookup(insecure_key, now)->first);
|
|
EXPECT_EQ(secure_key, cache.Lookup(secure_key, now)->first);
|
|
// Secure key is preferred when equally stale.
|
|
EXPECT_EQ(secure_key,
|
|
cache.Lookup(insecure_key, now, true /* ignore_secure */)->first);
|
|
EXPECT_EQ(secure_key,
|
|
cache.Lookup(insecure_key, now, true /* ignore_secure */)->first);
|
|
|
|
// Simulate network change.
|
|
cache.Invalidate();
|
|
|
|
// Re-add insecure entry.
|
|
cache.Set(insecure_key, entry, now, kSuccessEntryTTL);
|
|
EXPECT_EQ(insecure_key, cache.Lookup(insecure_key, now)->first);
|
|
EXPECT_FALSE(cache.Lookup(secure_key, now));
|
|
EXPECT_EQ(secure_key, cache.LookupStale(secure_key, now, &stale)->first);
|
|
// Result with fewer network changes is preferred.
|
|
EXPECT_EQ(
|
|
insecure_key,
|
|
cache.LookupStale(secure_key, now, &stale, true /* ignore-secure */)
|
|
->first);
|
|
|
|
// Add both insecure and secure entries to a cleared cache, still at t=0.
|
|
cache.clear();
|
|
cache.Set(insecure_key, entry, now, base::Seconds(20));
|
|
cache.Set(secure_key, entry, now, kSuccessEntryTTL);
|
|
|
|
// Advance to t=15 to expire the secure entry only.
|
|
now += base::Seconds(15);
|
|
EXPECT_EQ(insecure_key, cache.Lookup(insecure_key, now)->first);
|
|
EXPECT_FALSE(cache.Lookup(secure_key, now));
|
|
EXPECT_EQ(secure_key, cache.LookupStale(secure_key, now, &stale)->first);
|
|
// Non-expired result is preferred.
|
|
EXPECT_EQ(
|
|
insecure_key,
|
|
cache.LookupStale(secure_key, now, &stale, true /* ignore-secure */)
|
|
->first);
|
|
}
|
|
|
|
TEST(HostCacheTest, NoCache) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
// Disable caching.
|
|
HostCache cache(0);
|
|
EXPECT_TRUE(cache.caching_is_disabled());
|
|
|
|
// Set t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
// Lookup and Set should have no effect.
|
|
EXPECT_FALSE(cache.Lookup(Key("foobar.com"), now));
|
|
cache.Set(Key("foobar.com"), entry, now, kTTL);
|
|
EXPECT_FALSE(cache.Lookup(Key("foobar.com"), now));
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
}
|
|
|
|
TEST(HostCacheTest, Clear) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Set t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
|
|
// Add three entries.
|
|
cache.Set(Key("foobar1.com"), entry, now, kTTL);
|
|
cache.Set(Key("foobar2.com"), entry, now, kTTL);
|
|
cache.Set(Key("foobar3.com"), entry, now, kTTL);
|
|
|
|
EXPECT_EQ(3u, cache.size());
|
|
|
|
cache.clear();
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
}
|
|
|
|
TEST(HostCacheTest, ClearForHosts) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Set t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
|
|
// Add several entries.
|
|
cache.Set(Key("foobar1.com"), entry, now, kTTL);
|
|
cache.Set(Key("foobar2.com"), entry, now, kTTL);
|
|
cache.Set(Key("foobar3.com"), entry, now, kTTL);
|
|
cache.Set(Key("foobar4.com"), entry, now, kTTL);
|
|
cache.Set(Key("foobar5.com"), entry, now, kTTL);
|
|
|
|
EXPECT_EQ(5u, cache.size());
|
|
|
|
// Clear the hosts matching a certain predicate, such as the number being odd.
|
|
cache.ClearForHosts(base::BindRepeating(&FoobarIndexIsOdd));
|
|
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_TRUE(cache.Lookup(Key("foobar2.com"), now));
|
|
EXPECT_TRUE(cache.Lookup(Key("foobar4.com"), now));
|
|
|
|
// Passing null callback will delete all hosts.
|
|
cache.ClearForHosts(base::NullCallback());
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
}
|
|
|
|
// Try to add too many entries to cache; it should evict the one with the oldest
|
|
// expiration time.
|
|
TEST(HostCacheTest, Evict) {
|
|
HostCache cache(2);
|
|
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
HostCache::Key key3 = Key("foobar3.com");
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
EXPECT_FALSE(cache.Lookup(key3, now));
|
|
|
|
// |key1| expires in 10 seconds, but |key2| in just 5.
|
|
cache.Set(key1, entry, now, base::Seconds(10));
|
|
cache.Set(key2, entry, now, base::Seconds(5));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_FALSE(cache.Lookup(key3, now));
|
|
|
|
// |key2| should be chosen for eviction, since it expires sooner.
|
|
cache.Set(key3, entry, now, base::Seconds(10));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
EXPECT_TRUE(cache.Lookup(key3, now));
|
|
}
|
|
|
|
// Try to retrieve stale entries from the cache. They should be returned by
|
|
// |LookupStale()| but not |Lookup()|, with correct |EntryStaleness| data.
|
|
TEST(HostCacheTest, Stale) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Start at t=0.
|
|
base::TimeTicks now;
|
|
HostCache::EntryStaleness stale;
|
|
|
|
HostCache::Key key = Key("foobar.com");
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0U, cache.size());
|
|
|
|
// Add an entry for "foobar.com" at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key, now));
|
|
EXPECT_FALSE(cache.LookupStale(key, now, &stale));
|
|
cache.Set(key, entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key, now));
|
|
EXPECT_TRUE(cache.LookupStale(key, now, &stale));
|
|
EXPECT_FALSE(stale.is_stale());
|
|
EXPECT_EQ(0, stale.stale_hits);
|
|
|
|
EXPECT_EQ(1U, cache.size());
|
|
|
|
// Advance to t=5.
|
|
now += base::Seconds(5);
|
|
|
|
EXPECT_TRUE(cache.Lookup(key, now));
|
|
EXPECT_TRUE(cache.LookupStale(key, now, &stale));
|
|
EXPECT_FALSE(stale.is_stale());
|
|
EXPECT_EQ(0, stale.stale_hits);
|
|
|
|
// Advance to t=15.
|
|
now += base::Seconds(10);
|
|
|
|
EXPECT_FALSE(cache.Lookup(key, now));
|
|
EXPECT_TRUE(cache.LookupStale(key, now, &stale));
|
|
EXPECT_TRUE(stale.is_stale());
|
|
EXPECT_EQ(base::Seconds(5), stale.expired_by);
|
|
EXPECT_EQ(0, stale.network_changes);
|
|
EXPECT_EQ(1, stale.stale_hits);
|
|
|
|
// Advance to t=20.
|
|
now += base::Seconds(5);
|
|
|
|
EXPECT_FALSE(cache.Lookup(key, now));
|
|
EXPECT_TRUE(cache.LookupStale(key, now, &stale));
|
|
EXPECT_TRUE(stale.is_stale());
|
|
EXPECT_EQ(base::Seconds(10), stale.expired_by);
|
|
EXPECT_EQ(0, stale.network_changes);
|
|
EXPECT_EQ(2, stale.stale_hits);
|
|
|
|
// Simulate network change.
|
|
cache.Invalidate();
|
|
|
|
EXPECT_FALSE(cache.Lookup(key, now));
|
|
EXPECT_TRUE(cache.LookupStale(key, now, &stale));
|
|
EXPECT_TRUE(stale.is_stale());
|
|
EXPECT_EQ(base::Seconds(10), stale.expired_by);
|
|
EXPECT_EQ(1, stale.network_changes);
|
|
EXPECT_EQ(3, stale.stale_hits);
|
|
}
|
|
|
|
TEST(HostCacheTest, EvictStale) {
|
|
HostCache cache(2);
|
|
|
|
base::TimeTicks now;
|
|
HostCache::EntryStaleness stale;
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
HostCache::Key key3 = Key("foobar3.com");
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
EXPECT_FALSE(cache.Lookup(key3, now));
|
|
|
|
// |key1| expires in 10 seconds.
|
|
cache.Set(key1, entry, now, base::Seconds(10));
|
|
EXPECT_EQ(1u, cache.size());
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
EXPECT_FALSE(cache.Lookup(key3, now));
|
|
|
|
// Simulate network change, expiring the cache.
|
|
cache.Invalidate();
|
|
|
|
EXPECT_EQ(1u, cache.size());
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.LookupStale(key1, now, &stale));
|
|
EXPECT_EQ(1, stale.network_changes);
|
|
|
|
// Advance to t=1.
|
|
now += base::Seconds(1);
|
|
|
|
// |key2| expires before |key1| would originally have expired.
|
|
cache.Set(key2, entry, now, base::Seconds(5));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.LookupStale(key1, now, &stale));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_FALSE(cache.Lookup(key3, now));
|
|
|
|
// |key1| should be chosen for eviction, since it is stale.
|
|
cache.Set(key3, entry, now, base::Seconds(1));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
EXPECT_FALSE(cache.LookupStale(key1, now, &stale));
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_TRUE(cache.Lookup(key3, now));
|
|
|
|
// Advance to t=6.
|
|
now += base::Seconds(5);
|
|
|
|
// Insert |key1| again. |key3| should be evicted.
|
|
cache.Set(key1, entry, now, base::Seconds(10));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
EXPECT_TRUE(cache.LookupStale(key2, now, &stale));
|
|
EXPECT_FALSE(cache.Lookup(key3, now));
|
|
EXPECT_FALSE(cache.LookupStale(key3, now, &stale));
|
|
}
|
|
|
|
// Pinned entries should not be evicted, even if the cache is full and the Entry
|
|
// has expired.
|
|
TEST(HostCacheTest, NoEvictPinned) {
|
|
HostCache cache(2);
|
|
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
HostCache::Key key3 = Key("foobar3.com");
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
entry.set_pinning(true);
|
|
|
|
cache.Set(key1, entry, now, base::Seconds(5));
|
|
now += base::Seconds(10);
|
|
cache.Set(key2, entry, now, base::Seconds(5));
|
|
now += base::Seconds(10);
|
|
cache.Set(key3, entry, now, base::Seconds(5));
|
|
|
|
// There are 3 entries in this cache whose nominal max size is 2.
|
|
EXPECT_EQ(3u, cache.size());
|
|
EXPECT_TRUE(cache.LookupStale(key1, now, nullptr));
|
|
EXPECT_TRUE(cache.LookupStale(key2, now, nullptr));
|
|
EXPECT_TRUE(cache.Lookup(key3, now));
|
|
}
|
|
|
|
// Obsolete pinned entries should be evicted normally.
|
|
TEST(HostCacheTest, EvictObsoletePinned) {
|
|
HostCache cache(2);
|
|
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
HostCache::Key key3 = Key("foobar3.com");
|
|
HostCache::Key key4 = Key("foobar4.com");
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
entry.set_pinning(true);
|
|
|
|
// |key2| should be preserved, since it expires later.
|
|
cache.Set(key1, entry, now, base::Seconds(5));
|
|
cache.Set(key2, entry, now, base::Seconds(10));
|
|
cache.Set(key3, entry, now, base::Seconds(5));
|
|
// There are 3 entries in this cache whose nominal max size is 2.
|
|
EXPECT_EQ(3u, cache.size());
|
|
|
|
cache.Invalidate();
|
|
// |Invalidate()| does not trigger eviction.
|
|
EXPECT_EQ(3u, cache.size());
|
|
|
|
// |Set()| triggers an eviction, leaving only |key2| in cache,
|
|
// before adding |key4|
|
|
cache.Set(key4, entry, now, base::Seconds(2));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_FALSE(cache.LookupStale(key1, now, nullptr));
|
|
EXPECT_TRUE(cache.LookupStale(key2, now, nullptr));
|
|
EXPECT_FALSE(cache.LookupStale(key3, now, nullptr));
|
|
EXPECT_TRUE(cache.LookupStale(key4, now, nullptr));
|
|
}
|
|
|
|
// An active pin is preserved if the record is
|
|
// replaced due to a Set() call without the pin.
|
|
TEST(HostCacheTest, PreserveActivePin) {
|
|
HostCache cache(2);
|
|
|
|
base::TimeTicks now;
|
|
|
|
// Make entry1 and entry2, identical except for IP and pinned flag.
|
|
IPEndPoint endpoint1(IPAddress(192, 0, 2, 1), 0);
|
|
IPEndPoint endpoint2(IPAddress(192, 0, 2, 2), 0);
|
|
HostCache::Entry entry1 = HostCache::Entry(OK, {endpoint1}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
HostCache::Entry entry2 = HostCache::Entry(OK, {endpoint2}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
entry1.set_pinning(true);
|
|
|
|
HostCache::Key key = Key("foobar.com");
|
|
|
|
// Insert entry1, and verify that it can be retrieved with the
|
|
// correct IP and |pinning()| == true.
|
|
cache.Set(key, entry1, now, base::Seconds(10));
|
|
const auto* pair1 = cache.Lookup(key, now);
|
|
ASSERT_TRUE(pair1);
|
|
const HostCache::Entry& result1 = pair1->second;
|
|
EXPECT_THAT(
|
|
result1.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ElementsAre(endpoint1)))));
|
|
EXPECT_THAT(result1.pinning(), Optional(true));
|
|
|
|
// Insert |entry2|, and verify that it when it is retrieved, it
|
|
// has the new IP, and the "pinned" flag copied from |entry1|.
|
|
cache.Set(key, entry2, now, base::Seconds(10));
|
|
const auto* pair2 = cache.Lookup(key, now);
|
|
ASSERT_TRUE(pair2);
|
|
const HostCache::Entry& result2 = pair2->second;
|
|
EXPECT_THAT(
|
|
result2.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ElementsAre(endpoint2)))));
|
|
EXPECT_THAT(result2.pinning(), Optional(true));
|
|
}
|
|
|
|
// An obsolete cache pin is not preserved if the record is replaced.
|
|
TEST(HostCacheTest, DontPreserveObsoletePin) {
|
|
HostCache cache(2);
|
|
|
|
base::TimeTicks now;
|
|
|
|
// Make entry1 and entry2, identical except for IP and "pinned" flag.
|
|
IPEndPoint endpoint1(IPAddress(192, 0, 2, 1), 0);
|
|
IPEndPoint endpoint2(IPAddress(192, 0, 2, 2), 0);
|
|
HostCache::Entry entry1 = HostCache::Entry(OK, {endpoint1}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
HostCache::Entry entry2 = HostCache::Entry(OK, {endpoint2}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
entry1.set_pinning(true);
|
|
|
|
HostCache::Key key = Key("foobar.com");
|
|
|
|
// Insert entry1, and verify that it can be retrieved with the
|
|
// correct IP and |pinning()| == true.
|
|
cache.Set(key, entry1, now, base::Seconds(10));
|
|
const auto* pair1 = cache.Lookup(key, now);
|
|
ASSERT_TRUE(pair1);
|
|
const HostCache::Entry& result1 = pair1->second;
|
|
EXPECT_THAT(
|
|
result1.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ElementsAre(endpoint1)))));
|
|
EXPECT_THAT(result1.pinning(), Optional(true));
|
|
|
|
// Make entry1 obsolete.
|
|
cache.Invalidate();
|
|
|
|
// Insert |entry2|, and verify that it when it is retrieved, it
|
|
// has the new IP, and the "pinned" flag is not copied from |entry1|.
|
|
cache.Set(key, entry2, now, base::Seconds(10));
|
|
const auto* pair2 = cache.Lookup(key, now);
|
|
ASSERT_TRUE(pair2);
|
|
const HostCache::Entry& result2 = pair2->second;
|
|
EXPECT_THAT(
|
|
result2.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ElementsAre(endpoint2)))));
|
|
EXPECT_THAT(result2.pinning(), Optional(false));
|
|
}
|
|
|
|
// An active pin is removed if the record is replaced by a Set() call
|
|
// with the pin flag set to false.
|
|
TEST(HostCacheTest, Unpin) {
|
|
HostCache cache(2);
|
|
|
|
base::TimeTicks now;
|
|
|
|
// Make entry1 and entry2, identical except for IP and pinned flag.
|
|
IPEndPoint endpoint1(IPAddress(192, 0, 2, 1), 0);
|
|
IPEndPoint endpoint2(IPAddress(192, 0, 2, 2), 0);
|
|
HostCache::Entry entry1 = HostCache::Entry(OK, {endpoint1}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
HostCache::Entry entry2 = HostCache::Entry(OK, {endpoint2}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
entry1.set_pinning(true);
|
|
entry2.set_pinning(false);
|
|
|
|
HostCache::Key key = Key("foobar.com");
|
|
|
|
// Insert entry1, and verify that it can be retrieved with the
|
|
// correct IP and |pinning()| == true.
|
|
cache.Set(key, entry1, now, base::Seconds(10));
|
|
const auto* pair1 = cache.Lookup(key, now);
|
|
ASSERT_TRUE(pair1);
|
|
const HostCache::Entry& result1 = pair1->second;
|
|
EXPECT_THAT(
|
|
result1.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ElementsAre(endpoint1)))));
|
|
EXPECT_THAT(result1.pinning(), Optional(true));
|
|
|
|
// Insert |entry2|, and verify that it when it is retrieved, it
|
|
// has the new IP, and the "pinned" flag is now false.
|
|
cache.Set(key, entry2, now, base::Seconds(10));
|
|
const auto* pair2 = cache.Lookup(key, now);
|
|
ASSERT_TRUE(pair2);
|
|
const HostCache::Entry& result2 = pair2->second;
|
|
EXPECT_THAT(
|
|
result2.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ElementsAre(endpoint2)))));
|
|
EXPECT_THAT(result2.pinning(), Optional(false));
|
|
}
|
|
|
|
// Tests the less than and equal operators for HostCache::Key work.
|
|
TEST(HostCacheTest, KeyComparators) {
|
|
struct CacheTestParameters {
|
|
CacheTestParameters(const HostCache::Key key1,
|
|
const HostCache::Key key2,
|
|
int expected_comparison)
|
|
: key1(key1), key2(key2), expected_comparison(expected_comparison) {}
|
|
|
|
// Inputs.
|
|
HostCache::Key key1;
|
|
HostCache::Key key2;
|
|
|
|
// Expectation.
|
|
// -1 means key1 is less than key2
|
|
// 0 means key1 equals key2
|
|
// 1 means key1 is greater than key2
|
|
int expected_comparison;
|
|
};
|
|
std::vector<CacheTestParameters> tests = {
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
0},
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
1},
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
-1},
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host2", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
-1},
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host2", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
1},
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host2", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
-1},
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, HOST_RESOLVER_CANONNAME,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
-1},
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, HOST_RESOLVER_CANONNAME,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
1},
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, HOST_RESOLVER_CANONNAME,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host2", 443),
|
|
DnsQueryType::UNSPECIFIED, HOST_RESOLVER_CANONNAME,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
-1},
|
|
// 9: Different host scheme.
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
1},
|
|
// 10: Different host port.
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 1544),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
-1},
|
|
// 11: Same host name without scheme/port.
|
|
{HostCache::Key("host1", DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
HostCache::Key("host1", DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
0},
|
|
// 12: Different host name without scheme/port.
|
|
{HostCache::Key("host1", DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
HostCache::Key("host2", DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
-1},
|
|
// 13: Only one with scheme/port.
|
|
{HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey()),
|
|
HostCache::Key("host1", DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey()),
|
|
-1},
|
|
};
|
|
HostCache::Key insecure_key =
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
HostCache::Key secure_key =
|
|
HostCache::Key(url::SchemeHostPort(url::kHttpsScheme, "host1", 443),
|
|
DnsQueryType::UNSPECIFIED, 0, HostResolverSource::ANY,
|
|
NetworkAnonymizationKey());
|
|
secure_key.secure = true;
|
|
tests.emplace_back(insecure_key, secure_key, -1);
|
|
|
|
for (size_t i = 0; i < std::size(tests); ++i) {
|
|
SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i));
|
|
|
|
const HostCache::Key& key1 = tests[i].key1;
|
|
const HostCache::Key& key2 = tests[i].key2;
|
|
|
|
switch (tests[i].expected_comparison) {
|
|
case -1:
|
|
EXPECT_TRUE(key1 < key2);
|
|
EXPECT_FALSE(key2 < key1);
|
|
break;
|
|
case 0:
|
|
EXPECT_FALSE(key1 < key2);
|
|
EXPECT_FALSE(key2 < key1);
|
|
break;
|
|
case 1:
|
|
EXPECT_FALSE(key1 < key2);
|
|
EXPECT_TRUE(key2 < key1);
|
|
break;
|
|
default:
|
|
FAIL() << "Invalid expectation. Can be only -1, 0, 1";
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(HostCacheTest, SerializeAndDeserializeWithExpirations) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Start at t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key expire_by_time_key = Key("expire.by.time.test");
|
|
HostCache::Key expire_by_changes_key = Key("expire.by.changes.test");
|
|
|
|
IPEndPoint endpoint(IPAddress(1, 2, 3, 4), 0);
|
|
HostCache::Entry entry = HostCache::Entry(OK, {endpoint}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
|
|
// Add an entry for `expire_by_time_key` at t=0.
|
|
EXPECT_FALSE(cache.Lookup(expire_by_time_key, now));
|
|
cache.Set(expire_by_time_key, entry, now, kTTL);
|
|
EXPECT_THAT(cache.Lookup(expire_by_time_key, now),
|
|
Pointee(Pair(expire_by_time_key, EntryContentsEqual(entry))));
|
|
|
|
EXPECT_EQ(1u, cache.size());
|
|
|
|
// Advance to t=5.
|
|
now += base::Seconds(5);
|
|
|
|
// Add entry for `expire_by_changes_key` at t=5.
|
|
EXPECT_FALSE(cache.Lookup(expire_by_changes_key, now));
|
|
cache.Set(expire_by_changes_key, entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(expire_by_changes_key, now));
|
|
EXPECT_EQ(2u, cache.size());
|
|
|
|
EXPECT_EQ(0u, cache.last_restore_size());
|
|
|
|
// Advance to t=12, and serialize/deserialize the cache.
|
|
now += base::Seconds(7);
|
|
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, false /* include_staleness */,
|
|
HostCache::SerializationType::kRestorable);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
|
|
HostCache::EntryStaleness stale;
|
|
|
|
// The `expire_by_time_key` entry is stale due to both network changes and
|
|
// expiration time.
|
|
EXPECT_FALSE(restored_cache.Lookup(expire_by_time_key, now));
|
|
EXPECT_THAT(restored_cache.LookupStale(expire_by_time_key, now, &stale),
|
|
Pointee(Pair(expire_by_time_key, EntryContentsEqual(entry))));
|
|
EXPECT_EQ(1, stale.network_changes);
|
|
// Time to TimeTicks conversion is fuzzy, so just check that expected and
|
|
// actual expiration times are close.
|
|
EXPECT_GT(base::Milliseconds(100),
|
|
(base::Seconds(2) - stale.expired_by).magnitude());
|
|
|
|
// The `expire_by_changes_key` entry is stale only due to network changes.
|
|
EXPECT_FALSE(restored_cache.Lookup(expire_by_changes_key, now));
|
|
EXPECT_THAT(restored_cache.LookupStale(expire_by_changes_key, now, &stale),
|
|
Pointee(Pair(expire_by_changes_key, EntryContentsEqual(entry))));
|
|
EXPECT_EQ(1, stale.network_changes);
|
|
EXPECT_GT(base::Milliseconds(100),
|
|
(base::Seconds(-3) - stale.expired_by).magnitude());
|
|
|
|
EXPECT_EQ(2u, restored_cache.last_restore_size());
|
|
}
|
|
|
|
// Test that any changes between serialization and restore are preferred over
|
|
// old restored entries.
|
|
TEST(HostCacheTest, SerializeAndDeserializeWithChanges) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Start at t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key to_serialize_key1 = Key("to.serialize1.test");
|
|
HostCache::Key to_serialize_key2 = Key("to.serialize2.test");
|
|
HostCache::Key other_key = Key("other.test");
|
|
|
|
IPEndPoint endpoint(IPAddress(1, 1, 1, 1), 0);
|
|
HostCache::Entry serialized_entry = HostCache::Entry(
|
|
OK, {endpoint}, /*aliases=*/{}, HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
IPEndPoint replacement_endpoint(IPAddress(2, 2, 2, 2), 0);
|
|
HostCache::Entry replacement_entry =
|
|
HostCache::Entry(OK, {replacement_endpoint}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
IPEndPoint other_endpoint(IPAddress(3, 3, 3, 3), 0);
|
|
HostCache::Entry other_entry = HostCache::Entry(
|
|
OK, {other_endpoint}, /*aliases=*/{}, HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
|
|
// Add `to_serialize_key1` and `to_serialize_key2`
|
|
EXPECT_FALSE(cache.Lookup(to_serialize_key1, now));
|
|
cache.Set(to_serialize_key1, serialized_entry, now, kTTL);
|
|
EXPECT_THAT(
|
|
cache.Lookup(to_serialize_key1, now),
|
|
Pointee(Pair(to_serialize_key1, EntryContentsEqual(serialized_entry))));
|
|
EXPECT_FALSE(cache.Lookup(to_serialize_key2, now));
|
|
cache.Set(to_serialize_key2, serialized_entry, now, kTTL);
|
|
EXPECT_THAT(
|
|
cache.Lookup(to_serialize_key2, now),
|
|
Pointee(Pair(to_serialize_key2, EntryContentsEqual(serialized_entry))));
|
|
EXPECT_EQ(2u, cache.size());
|
|
|
|
// Serialize the cache.
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, false /* include_staleness */,
|
|
HostCache::SerializationType::kRestorable);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
|
|
// Add entries for `to_serialize_key1` and `other_key` to the new cache
|
|
// before restoring the serialized one. The `to_serialize_key1` result is
|
|
// different from the original.
|
|
EXPECT_FALSE(restored_cache.Lookup(to_serialize_key1, now));
|
|
restored_cache.Set(to_serialize_key1, replacement_entry, now, kTTL);
|
|
EXPECT_THAT(
|
|
restored_cache.Lookup(to_serialize_key1, now),
|
|
Pointee(Pair(to_serialize_key1, EntryContentsEqual(replacement_entry))));
|
|
EXPECT_EQ(1u, restored_cache.size());
|
|
|
|
EXPECT_FALSE(restored_cache.Lookup(other_key, now));
|
|
restored_cache.Set(other_key, other_entry, now, kTTL);
|
|
EXPECT_THAT(restored_cache.Lookup(other_key, now),
|
|
Pointee(Pair(other_key, EntryContentsEqual(other_entry))));
|
|
EXPECT_EQ(2u, restored_cache.size());
|
|
|
|
EXPECT_EQ(0u, restored_cache.last_restore_size());
|
|
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
EXPECT_EQ(1u, restored_cache.last_restore_size());
|
|
|
|
HostCache::EntryStaleness stale;
|
|
|
|
// Expect `to_serialize_key1` has the replacement entry.
|
|
EXPECT_THAT(
|
|
restored_cache.Lookup(to_serialize_key1, now),
|
|
Pointee(Pair(to_serialize_key1, EntryContentsEqual(replacement_entry))));
|
|
|
|
// Expect `to_serialize_key2` has the original entry.
|
|
EXPECT_THAT(
|
|
restored_cache.LookupStale(to_serialize_key2, now, &stale),
|
|
Pointee(Pair(to_serialize_key2, EntryContentsEqual(serialized_entry))));
|
|
|
|
// Expect no change for `other_key`.
|
|
EXPECT_THAT(restored_cache.Lookup(other_key, now),
|
|
Pointee(Pair(other_key, EntryContentsEqual(other_entry))));
|
|
}
|
|
|
|
TEST(HostCacheTest, SerializeAndDeserializeAddresses) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
// Start at t=0.
|
|
base::TimeTicks now;
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
key1.secure = true;
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
HostCache::Key key3 = Key("foobar3.com");
|
|
HostCache::Key key4 = Key("foobar4.com");
|
|
|
|
IPAddress address_ipv4(1, 2, 3, 4);
|
|
IPAddress address_ipv6(0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
|
IPEndPoint endpoint_ipv4(address_ipv4, 0);
|
|
IPEndPoint endpoint_ipv6(address_ipv6, 0);
|
|
|
|
HostCache::Entry entry1 = HostCache::Entry(
|
|
OK, {endpoint_ipv4}, /*aliases=*/{}, HostCache::Entry::SOURCE_UNKNOWN);
|
|
HostCache::Entry entry2 =
|
|
HostCache::Entry(OK, {endpoint_ipv6, endpoint_ipv4}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
HostCache::Entry entry3 = HostCache::Entry(
|
|
OK, {endpoint_ipv6}, /*aliases=*/{}, HostCache::Entry::SOURCE_UNKNOWN);
|
|
HostCache::Entry entry4 = HostCache::Entry(
|
|
OK, {endpoint_ipv4}, /*aliases=*/{}, HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(0u, cache.size());
|
|
|
|
// Add an entry for "foobar.com" at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, entry1, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_TRUE(cache.Lookup(key1, now)->second.error() == entry1.error());
|
|
|
|
EXPECT_EQ(1u, cache.size());
|
|
|
|
// Advance to t=5.
|
|
now += base::Seconds(5);
|
|
|
|
// Add entries for "foobar2.com" and "foobar3.com" at t=5.
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
cache.Set(key2, entry2, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(2u, cache.size());
|
|
|
|
EXPECT_FALSE(cache.Lookup(key3, now));
|
|
cache.Set(key3, entry3, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key3, now));
|
|
EXPECT_EQ(3u, cache.size());
|
|
|
|
EXPECT_EQ(0u, cache.last_restore_size());
|
|
|
|
// Advance to t=12, ansd serialize the cache.
|
|
now += base::Seconds(7);
|
|
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, false /* include_staleness */,
|
|
HostCache::SerializationType::kRestorable);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
|
|
// Add entries for "foobar3.com" and "foobar4.com" to the cache before
|
|
// restoring it. The "foobar3.com" result is different from the original.
|
|
EXPECT_FALSE(restored_cache.Lookup(key3, now));
|
|
restored_cache.Set(key3, entry1, now, kTTL);
|
|
EXPECT_TRUE(restored_cache.Lookup(key3, now));
|
|
EXPECT_EQ(1u, restored_cache.size());
|
|
|
|
EXPECT_FALSE(restored_cache.Lookup(key4, now));
|
|
restored_cache.Set(key4, entry4, now, kTTL);
|
|
EXPECT_TRUE(restored_cache.Lookup(key4, now));
|
|
EXPECT_EQ(2u, restored_cache.size());
|
|
|
|
EXPECT_EQ(0u, restored_cache.last_restore_size());
|
|
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
|
|
HostCache::EntryStaleness stale;
|
|
|
|
// The "foobar.com" entry is stale due to both network changes and expiration
|
|
// time.
|
|
EXPECT_FALSE(restored_cache.Lookup(key1, now));
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result1 =
|
|
restored_cache.LookupStale(key1, now, &stale);
|
|
EXPECT_TRUE(result1);
|
|
EXPECT_TRUE(result1->first.secure);
|
|
ASSERT_TRUE(result1->second.ip_endpoints());
|
|
EXPECT_FALSE(result1->second.text_records());
|
|
EXPECT_FALSE(result1->second.hostnames());
|
|
EXPECT_EQ(1u, result1->second.ip_endpoints()->size());
|
|
EXPECT_EQ(endpoint_ipv4, result1->second.ip_endpoints()->front());
|
|
EXPECT_EQ(1, stale.network_changes);
|
|
// Time to TimeTicks conversion is fuzzy, so just check that expected and
|
|
// actual expiration times are close.
|
|
EXPECT_GT(base::Milliseconds(100),
|
|
(base::Seconds(2) - stale.expired_by).magnitude());
|
|
|
|
// The "foobar2.com" entry is stale only due to network changes.
|
|
EXPECT_FALSE(restored_cache.Lookup(key2, now));
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result2 =
|
|
restored_cache.LookupStale(key2, now, &stale);
|
|
EXPECT_TRUE(result2);
|
|
EXPECT_FALSE(result2->first.secure);
|
|
ASSERT_TRUE(result2->second.ip_endpoints());
|
|
EXPECT_EQ(2u, result2->second.ip_endpoints()->size());
|
|
EXPECT_EQ(endpoint_ipv6, result2->second.ip_endpoints()->front());
|
|
EXPECT_EQ(endpoint_ipv4, result2->second.ip_endpoints()->back());
|
|
EXPECT_EQ(1, stale.network_changes);
|
|
EXPECT_GT(base::Milliseconds(100),
|
|
(base::Seconds(-3) - stale.expired_by).magnitude());
|
|
|
|
// The "foobar3.com" entry is the new one, not the restored one.
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result3 =
|
|
restored_cache.Lookup(key3, now);
|
|
EXPECT_TRUE(result3);
|
|
ASSERT_TRUE(result3->second.ip_endpoints());
|
|
EXPECT_EQ(1u, result3->second.ip_endpoints()->size());
|
|
EXPECT_EQ(endpoint_ipv4, result3->second.ip_endpoints()->front());
|
|
|
|
// The "foobar4.com" entry is still present and usable.
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result4 =
|
|
restored_cache.Lookup(key4, now);
|
|
EXPECT_TRUE(result4);
|
|
ASSERT_TRUE(result4->second.ip_endpoints());
|
|
EXPECT_EQ(1u, result4->second.ip_endpoints()->size());
|
|
EXPECT_EQ(endpoint_ipv4, result4->second.ip_endpoints()->front());
|
|
|
|
EXPECT_EQ(2u, restored_cache.last_restore_size());
|
|
}
|
|
|
|
TEST(HostCacheTest, SerializeAndDeserializeEntryWithoutScheme) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
|
|
HostCache::Key key("host.test", DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, NetworkAnonymizationKey());
|
|
HostCache::Entry entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{},
|
|
/*aliases=*/{}, HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
base::TimeTicks now;
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
cache.Set(key, entry, now, kTTL);
|
|
ASSERT_TRUE(cache.Lookup(key, now));
|
|
ASSERT_EQ(cache.size(), 1u);
|
|
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, /*include_staleness=*/false,
|
|
HostCache::SerializationType::kRestorable);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
EXPECT_EQ(restored_cache.size(), 1u);
|
|
|
|
HostCache::EntryStaleness staleness;
|
|
EXPECT_THAT(restored_cache.LookupStale(key, now, &staleness),
|
|
Pointee(Pair(key, EntryContentsEqual(entry))));
|
|
}
|
|
|
|
TEST(HostCacheTest, SerializeAndDeserializeWithNetworkAnonymizationKey) {
|
|
const url::SchemeHostPort kHost =
|
|
url::SchemeHostPort(url::kHttpsScheme, "hostname.test", 443);
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
const SchemefulSite kSite(GURL("https://site.test/"));
|
|
const auto kNetworkAnonymizationKey =
|
|
NetworkAnonymizationKey::CreateSameSite(kSite);
|
|
const SchemefulSite kOpaqueSite;
|
|
const auto kOpaqueNetworkAnonymizationKey =
|
|
NetworkAnonymizationKey::CreateSameSite(kOpaqueSite);
|
|
|
|
HostCache::Key key1(kHost, DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, kNetworkAnonymizationKey);
|
|
HostCache::Key key2(kHost, DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, kOpaqueNetworkAnonymizationKey);
|
|
|
|
IPEndPoint endpoint(IPAddress(1, 2, 3, 4), 0);
|
|
HostCache::Entry entry = HostCache::Entry(OK, {endpoint}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
base::TimeTicks now;
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
cache.Set(key1, entry, now, kTTL);
|
|
cache.Set(key2, entry, now, kTTL);
|
|
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(kNetworkAnonymizationKey,
|
|
cache.Lookup(key1, now)->first.network_anonymization_key);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(kOpaqueNetworkAnonymizationKey,
|
|
cache.Lookup(key2, now)->first.network_anonymization_key);
|
|
EXPECT_EQ(2u, cache.size());
|
|
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, false /* include_staleness */,
|
|
HostCache::SerializationType::kRestorable);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
EXPECT_EQ(1u, restored_cache.size());
|
|
|
|
HostCache::EntryStaleness stale;
|
|
EXPECT_THAT(restored_cache.LookupStale(key1, now, &stale),
|
|
Pointee(Pair(key1, EntryContentsEqual(entry))));
|
|
EXPECT_FALSE(restored_cache.Lookup(key2, now));
|
|
}
|
|
|
|
TEST(HostCacheTest, SerializeForDebugging) {
|
|
const url::SchemeHostPort kHost(url::kHttpsScheme, "hostname.test", 443);
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
const NetworkAnonymizationKey kNetworkAnonymizationKey =
|
|
NetworkAnonymizationKey::CreateTransient();
|
|
|
|
HostCache::Key key(kHost, DnsQueryType::UNSPECIFIED, 0,
|
|
HostResolverSource::ANY, kNetworkAnonymizationKey);
|
|
|
|
IPEndPoint endpoint(IPAddress(1, 2, 3, 4), 0);
|
|
HostCache::Entry entry = HostCache::Entry(OK, {endpoint}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
base::TimeTicks now;
|
|
HostCache cache(kMaxCacheEntries);
|
|
|
|
cache.Set(key, entry, now, kTTL);
|
|
|
|
EXPECT_TRUE(cache.Lookup(key, now));
|
|
EXPECT_EQ(kNetworkAnonymizationKey,
|
|
cache.Lookup(key, now)->first.network_anonymization_key);
|
|
EXPECT_EQ(1u, cache.size());
|
|
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, false /* include_staleness */,
|
|
HostCache::SerializationType::kDebug);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
EXPECT_FALSE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
|
|
ASSERT_EQ(1u, serialized_cache.size());
|
|
ASSERT_TRUE(serialized_cache[0].is_dict());
|
|
const std::string* nik_string =
|
|
serialized_cache[0].GetDict().FindString("network_anonymization_key");
|
|
ASSERT_TRUE(nik_string);
|
|
ASSERT_EQ(kNetworkAnonymizationKey.ToDebugString(), *nik_string);
|
|
}
|
|
|
|
TEST(HostCacheTest, SerializeAndDeserialize_Text) {
|
|
base::TimeTicks now;
|
|
|
|
base::TimeDelta ttl = base::Seconds(99);
|
|
std::vector<std::string> text_records({"foo", "bar"});
|
|
HostCache::Key key(url::SchemeHostPort(url::kHttpsScheme, "example.com", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::DNS,
|
|
NetworkAnonymizationKey());
|
|
key.secure = true;
|
|
HostCache::Entry entry(OK, text_records, HostCache::Entry::SOURCE_DNS, ttl);
|
|
EXPECT_TRUE(entry.text_records());
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
cache.Set(key, entry, now, ttl);
|
|
EXPECT_EQ(1u, cache.size());
|
|
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, false /* include_staleness */,
|
|
HostCache::SerializationType::kRestorable);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
|
|
ASSERT_EQ(1u, serialized_cache.size());
|
|
ASSERT_EQ(1u, restored_cache.size());
|
|
HostCache::EntryStaleness stale;
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result =
|
|
restored_cache.LookupStale(key, now, &stale);
|
|
EXPECT_THAT(result, Pointee(Pair(key, EntryContentsEqual(entry))));
|
|
EXPECT_THAT(result->second.text_records(), Optional(text_records));
|
|
}
|
|
|
|
TEST(HostCacheTest, SerializeAndDeserialize_Hostname) {
|
|
base::TimeTicks now;
|
|
|
|
base::TimeDelta ttl = base::Seconds(99);
|
|
std::vector<HostPortPair> hostnames(
|
|
{HostPortPair("example.com", 95), HostPortPair("chromium.org", 122)});
|
|
HostCache::Key key(url::SchemeHostPort(url::kHttpsScheme, "example.com", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::DNS,
|
|
NetworkAnonymizationKey());
|
|
HostCache::Entry entry(OK, hostnames, HostCache::Entry::SOURCE_DNS, ttl);
|
|
EXPECT_TRUE(entry.hostnames());
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
cache.Set(key, entry, now, ttl);
|
|
EXPECT_EQ(1u, cache.size());
|
|
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, false /* include_staleness */,
|
|
HostCache::SerializationType::kRestorable);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
|
|
ASSERT_EQ(1u, restored_cache.size());
|
|
HostCache::EntryStaleness stale;
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result =
|
|
restored_cache.LookupStale(key, now, &stale);
|
|
EXPECT_THAT(result, Pointee(Pair(key, EntryContentsEqual(entry))));
|
|
EXPECT_THAT(result->second.hostnames(), Optional(hostnames));
|
|
}
|
|
|
|
TEST(HostCacheTest, SerializeAndDeserializeEndpointResult) {
|
|
base::TimeTicks now;
|
|
|
|
base::TimeDelta ttl = base::Seconds(99);
|
|
HostCache::Key key(url::SchemeHostPort(url::kHttpsScheme, "example.com", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::DNS,
|
|
NetworkAnonymizationKey());
|
|
IPEndPoint ipv6_endpoint(
|
|
IPAddress(1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4), 110);
|
|
IPEndPoint ipv4_endpoint1(IPAddress(1, 1, 1, 1), 80);
|
|
IPEndPoint ipv4_endpoint2(IPAddress(2, 2, 2, 2), 90);
|
|
IPEndPoint other_ipv4_endpoint(IPAddress(3, 3, 3, 3), 100);
|
|
std::string ipv6_alias = "ipv6_alias.test";
|
|
std::string ipv4_alias = "ipv4_alias.test";
|
|
std::string other_alias = "other_alias.test";
|
|
std::vector<IPEndPoint> ip_endpoints = {ipv6_endpoint, ipv4_endpoint1,
|
|
ipv4_endpoint2, other_ipv4_endpoint};
|
|
std::set<std::string> aliases = {ipv6_alias, ipv4_alias, other_alias};
|
|
HostCache::Entry entry(OK, ip_endpoints, aliases,
|
|
HostCache::Entry::SOURCE_DNS, ttl);
|
|
|
|
std::set<std::string> canonical_names = {ipv6_alias, ipv4_alias};
|
|
entry.set_canonical_names(canonical_names);
|
|
|
|
EXPECT_TRUE(entry.GetEndpoints());
|
|
|
|
ConnectionEndpointMetadata metadata1;
|
|
metadata1.supported_protocol_alpns = {"h3", "h2"};
|
|
metadata1.ech_config_list = {'f', 'o', 'o'};
|
|
metadata1.target_name = ipv6_alias;
|
|
ConnectionEndpointMetadata metadata2;
|
|
metadata2.supported_protocol_alpns = {"h2", "h4"};
|
|
metadata2.target_name = ipv4_alias;
|
|
HostCache::Entry metadata_entry(
|
|
OK,
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>{
|
|
{1u, metadata1}, {2u, metadata2}},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
auto merged_entry = HostCache::Entry::MergeEntries(entry, metadata_entry);
|
|
|
|
EXPECT_THAT(merged_entry.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ip_endpoints))));
|
|
EXPECT_THAT(
|
|
merged_entry.GetMetadatas(),
|
|
testing::Optional(testing::ElementsAre(
|
|
ExpectConnectionEndpointMetadata(testing::ElementsAre("h3", "h2"),
|
|
testing::ElementsAre('f', 'o', 'o'),
|
|
ipv6_alias),
|
|
ExpectConnectionEndpointMetadata(testing::ElementsAre("h2", "h4"),
|
|
IsEmpty(), ipv4_alias))));
|
|
EXPECT_THAT(merged_entry.canonical_names(),
|
|
testing::Optional(UnorderedElementsAre(ipv4_alias, ipv6_alias)));
|
|
|
|
HostCache cache(kMaxCacheEntries);
|
|
cache.Set(key, merged_entry, now, ttl);
|
|
EXPECT_EQ(1u, cache.size());
|
|
|
|
base::Value::List serialized_cache;
|
|
cache.GetList(serialized_cache, false /* include_staleness */,
|
|
HostCache::SerializationType::kRestorable);
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(serialized_cache));
|
|
|
|
// Check `serialized_cache` can be encoded as JSON. This ensures it has no
|
|
// binary values.
|
|
std::string json;
|
|
EXPECT_TRUE(base::JSONWriter::Write(serialized_cache, &json));
|
|
|
|
ASSERT_EQ(1u, restored_cache.size());
|
|
HostCache::EntryStaleness stale;
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result =
|
|
restored_cache.LookupStale(key, now, &stale);
|
|
|
|
ASSERT_TRUE(result);
|
|
EXPECT_THAT(result, Pointee(Pair(key, EntryContentsEqual(merged_entry))));
|
|
EXPECT_THAT(result->second.GetEndpoints(),
|
|
Optional(ElementsAre(ExpectEndpointResult(ip_endpoints))));
|
|
EXPECT_THAT(
|
|
result->second.GetMetadatas(),
|
|
testing::Optional(testing::ElementsAre(
|
|
ExpectConnectionEndpointMetadata(testing::ElementsAre("h3", "h2"),
|
|
testing::ElementsAre('f', 'o', 'o'),
|
|
ipv6_alias),
|
|
ExpectConnectionEndpointMetadata(testing::ElementsAre("h2", "h4"),
|
|
IsEmpty(), ipv4_alias))));
|
|
EXPECT_THAT(result->second.canonical_names(),
|
|
testing::Optional(UnorderedElementsAre(ipv4_alias, ipv6_alias)));
|
|
|
|
EXPECT_THAT(result->second.aliases(), Pointee(aliases));
|
|
}
|
|
|
|
TEST(HostCacheTest, DeserializeNoEndpointNoAliase) {
|
|
base::TimeDelta ttl = base::Seconds(99);
|
|
std::string expiration_time_str = base::NumberToString(
|
|
(base::Time::Now() + ttl).since_origin().InMicroseconds());
|
|
|
|
auto dict = base::JSONReader::Read(base::StringPrintf(
|
|
R"(
|
|
[ {
|
|
"dns_query_type": 1,
|
|
"expiration": "%s",
|
|
"flags": 0,
|
|
"host_resolver_source": 2,
|
|
"hostname": "example.com",
|
|
"network_anonymization_key": [ ],
|
|
"port": 443,
|
|
"scheme": "https",
|
|
"secure": false
|
|
} ]
|
|
)",
|
|
expiration_time_str.c_str()));
|
|
ASSERT_TRUE(dict);
|
|
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
ASSERT_TRUE(dict->is_list());
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(dict->GetList()));
|
|
|
|
ASSERT_EQ(1u, restored_cache.size());
|
|
|
|
HostCache::Key key(url::SchemeHostPort(url::kHttpsScheme, "example.com", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::DNS,
|
|
NetworkAnonymizationKey());
|
|
|
|
HostCache::EntryStaleness stale;
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result =
|
|
restored_cache.LookupStale(key, base::TimeTicks::Now(), &stale);
|
|
|
|
ASSERT_TRUE(result);
|
|
EXPECT_THAT(result->second.aliases(), Pointee(ElementsAre()));
|
|
EXPECT_THAT(result->second.ip_endpoints(), Pointee(ElementsAre()));
|
|
}
|
|
|
|
TEST(HostCacheTest, DeserializeLegacyAddresses) {
|
|
base::TimeDelta ttl = base::Seconds(99);
|
|
std::string expiration_time_str = base::NumberToString(
|
|
(base::Time::Now() + ttl).since_origin().InMicroseconds());
|
|
|
|
auto dict = base::JSONReader::Read(base::StringPrintf(
|
|
R"(
|
|
[ {
|
|
"addresses": [ "2000::", "1.2.3.4" ],
|
|
"dns_query_type": 1,
|
|
"expiration": "%s",
|
|
"flags": 0,
|
|
"host_resolver_source": 2,
|
|
"hostname": "example.com",
|
|
"network_anonymization_key": [ ],
|
|
"port": 443,
|
|
"scheme": "https",
|
|
"secure": false
|
|
} ]
|
|
)",
|
|
expiration_time_str.c_str()));
|
|
ASSERT_TRUE(dict);
|
|
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
ASSERT_TRUE(dict->is_list());
|
|
EXPECT_TRUE(restored_cache.RestoreFromListValue(dict->GetList()));
|
|
|
|
ASSERT_EQ(1u, restored_cache.size());
|
|
|
|
HostCache::Key key(url::SchemeHostPort(url::kHttpsScheme, "example.com", 443),
|
|
DnsQueryType::A, 0, HostResolverSource::DNS,
|
|
NetworkAnonymizationKey());
|
|
|
|
HostCache::EntryStaleness stale;
|
|
const std::pair<const HostCache::Key, HostCache::Entry>* result =
|
|
restored_cache.LookupStale(key, base::TimeTicks::Now(), &stale);
|
|
|
|
ASSERT_TRUE(result);
|
|
EXPECT_THAT(result->second.ip_endpoints(),
|
|
Pointee(ElementsAreArray(MakeEndpoints({"2000::", "1.2.3.4"}))));
|
|
EXPECT_THAT(result->second.aliases(), Pointee(ElementsAre()));
|
|
}
|
|
|
|
TEST(HostCacheTest, DeserializeInvalidQueryTypeIntegrity) {
|
|
base::TimeDelta ttl = base::Seconds(99);
|
|
std::string expiration_time_str = base::NumberToString(
|
|
(base::Time::Now() + ttl).since_origin().InMicroseconds());
|
|
|
|
// RestoreFromListValue doesn't support dns_query_type=6 (INTEGRITY).
|
|
auto dict = base::JSONReader::Read(base::StringPrintf(
|
|
R"(
|
|
[ {
|
|
"addresses": [ "2000::", "1.2.3.4" ],
|
|
"dns_query_type": 6,
|
|
"expiration": "%s",
|
|
"flags": 0,
|
|
"host_resolver_source": 2,
|
|
"hostname": "example.com",
|
|
"network_isolation_key": [ ],
|
|
"port": 443,
|
|
"scheme": "https",
|
|
"secure": false
|
|
} ]
|
|
)",
|
|
expiration_time_str.c_str()));
|
|
ASSERT_TRUE(dict);
|
|
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
ASSERT_TRUE(dict->is_list());
|
|
EXPECT_FALSE(restored_cache.RestoreFromListValue(dict->GetList()));
|
|
|
|
ASSERT_EQ(0u, restored_cache.size());
|
|
}
|
|
|
|
TEST(HostCacheTest, DeserializeInvalidQueryTypeHttpsExperimental) {
|
|
base::TimeDelta ttl = base::Seconds(99);
|
|
std::string expiration_time_str = base::NumberToString(
|
|
(base::Time::Now() + ttl).since_origin().InMicroseconds());
|
|
|
|
// RestoreFromListValue doesn't support dns_query_type=8 (HTTPS_EXPERIMENTAL).
|
|
auto dict = base::JSONReader::Read(base::StringPrintf(
|
|
R"(
|
|
[ {
|
|
"addresses": [ "2000::", "1.2.3.4" ],
|
|
"dns_query_type": 8,
|
|
"expiration": "%s",
|
|
"flags": 0,
|
|
"host_resolver_source": 2,
|
|
"hostname": "example.com",
|
|
"network_isolation_key": [ ],
|
|
"port": 443,
|
|
"scheme": "https",
|
|
"secure": false
|
|
} ]
|
|
)",
|
|
expiration_time_str.c_str()));
|
|
ASSERT_TRUE(dict);
|
|
|
|
HostCache restored_cache(kMaxCacheEntries);
|
|
ASSERT_TRUE(dict->is_list());
|
|
EXPECT_FALSE(restored_cache.RestoreFromListValue(dict->GetList()));
|
|
|
|
ASSERT_EQ(0u, restored_cache.size());
|
|
}
|
|
|
|
TEST(HostCacheTest, PersistenceDelegate) {
|
|
const base::TimeDelta kTTL = base::Seconds(10);
|
|
HostCache cache(kMaxCacheEntries);
|
|
MockPersistenceDelegate delegate;
|
|
cache.set_persistence_delegate(&delegate);
|
|
|
|
HostCache::Key key1 = Key("foobar.com");
|
|
HostCache::Key key2 = Key("foobar2.com");
|
|
|
|
HostCache::Entry ok_entry =
|
|
HostCache::Entry(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
std::vector<IPEndPoint> other_endpoints = {
|
|
IPEndPoint(IPAddress(1, 1, 1, 1), 300)};
|
|
HostCache::Entry other_entry(OK, std::move(other_endpoints), /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
HostCache::Entry error_entry =
|
|
HostCache::Entry(ERR_NAME_NOT_RESOLVED, /*ip_endpoints=*/{},
|
|
/*aliases=*/{}, HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
// Start at t=0.
|
|
base::TimeTicks now;
|
|
EXPECT_EQ(0u, cache.size());
|
|
|
|
// Add two entries at t=0.
|
|
EXPECT_FALSE(cache.Lookup(key1, now));
|
|
cache.Set(key1, ok_entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(1u, cache.size());
|
|
EXPECT_EQ(1, delegate.num_changes());
|
|
|
|
EXPECT_FALSE(cache.Lookup(key2, now));
|
|
cache.Set(key2, error_entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key2, now));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_EQ(2, delegate.num_changes());
|
|
|
|
// Advance to t=5.
|
|
now += base::Seconds(5);
|
|
|
|
// Changes that shouldn't trigger a write:
|
|
// Add an entry for "foobar.com" with different expiration time.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
cache.Set(key1, ok_entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_EQ(2, delegate.num_changes());
|
|
|
|
// Add an entry for "foobar.com" with different TTL.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
cache.Set(key1, ok_entry, now, kTTL - base::Seconds(5));
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_EQ(2, delegate.num_changes());
|
|
|
|
// Changes that should trigger a write:
|
|
// Add an entry for "foobar.com" with different address list.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
cache.Set(key1, other_entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_EQ(3, delegate.num_changes());
|
|
|
|
// Add an entry for "foobar2.com" with different error.
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
cache.Set(key2, ok_entry, now, kTTL);
|
|
EXPECT_TRUE(cache.Lookup(key1, now));
|
|
EXPECT_EQ(2u, cache.size());
|
|
EXPECT_EQ(4, delegate.num_changes());
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEndpointsWithAliases) {
|
|
const IPAddress kAddressFront(1, 2, 3, 4);
|
|
const IPEndPoint kEndpointFront(kAddressFront, 0);
|
|
HostCache::Entry front(OK, {kEndpointFront}, {"alias1", "alias2", "alias3"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
front.set_text_records(std::vector<std::string>{"text1"});
|
|
const HostPortPair kHostnameFront("host", 1);
|
|
front.set_hostnames(std::vector<HostPortPair>{kHostnameFront});
|
|
|
|
const IPAddress kAddressBack(0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0);
|
|
const IPEndPoint kEndpointBack(kAddressBack, 0);
|
|
HostCache::Entry back(OK, {kEndpointBack}, {"alias2", "alias4", "alias5"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
back.set_text_records(std::vector<std::string>{"text2"});
|
|
const HostPortPair kHostnameBack("host", 2);
|
|
back.set_hostnames(std::vector<HostPortPair>{kHostnameBack});
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(OK, result.error());
|
|
EXPECT_EQ(HostCache::Entry::SOURCE_DNS, result.source());
|
|
|
|
ASSERT_TRUE(result.ip_endpoints());
|
|
EXPECT_THAT(*result.ip_endpoints(),
|
|
ElementsAre(kEndpointFront, kEndpointBack));
|
|
EXPECT_THAT(result.text_records(), Optional(ElementsAre("text1", "text2")));
|
|
|
|
EXPECT_THAT(result.hostnames(),
|
|
Optional(ElementsAre(kHostnameFront, kHostnameBack)));
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(
|
|
*result.aliases(),
|
|
UnorderedElementsAre("alias1", "alias2", "alias3", "alias4", "alias5"));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEndpointsKeepEndpointsOrder) {
|
|
std::vector<IPEndPoint> front_addresses =
|
|
MakeEndpoints({"::1", "0.0.0.2", "0.0.0.4"});
|
|
std::vector<IPEndPoint> back_addresses =
|
|
MakeEndpoints({"0.0.0.2", "0.0.0.2", "::3", "::3", "0.0.0.4"});
|
|
|
|
HostCache::Entry front(OK, front_addresses, /*aliases=*/{"front"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
HostCache::Entry back(OK, back_addresses, /*aliases=*/{"back"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
ASSERT_TRUE(result.ip_endpoints());
|
|
EXPECT_THAT(
|
|
*result.ip_endpoints(),
|
|
ElementsAreArray(MakeEndpoints({"::1", "0.0.0.2", "0.0.0.4", "0.0.0.2",
|
|
"0.0.0.2", "::3", "::3", "0.0.0.4"})));
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(), UnorderedElementsAre("front", "back"));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeMetadatas) {
|
|
ConnectionEndpointMetadata front_metadata;
|
|
front_metadata.supported_protocol_alpns = {"h5", "h6", "monster truck rally"};
|
|
front_metadata.ech_config_list = {'h', 'i'};
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>
|
|
front_metadata_map{{4u, front_metadata}};
|
|
HostCache::Entry front(OK, front_metadata_map, HostCache::Entry::SOURCE_DNS);
|
|
|
|
ConnectionEndpointMetadata back_metadata;
|
|
back_metadata.supported_protocol_alpns = {"h5"};
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>
|
|
back_metadata_map{{2u, back_metadata}};
|
|
HostCache::Entry back(OK, back_metadata_map, HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry result = HostCache::Entry::MergeEntries(front, back);
|
|
|
|
// Expect `GetEndpoints()` to ignore metadatas if no `IPEndPoint`s.
|
|
EXPECT_FALSE(result.GetEndpoints());
|
|
|
|
// Expect order irrelevant for endpoint metadata merging.
|
|
result = HostCache::Entry::MergeEntries(back, front);
|
|
EXPECT_FALSE(result.GetEndpoints());
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeMetadatasWithIpEndpointsDifferentCanonicalName) {
|
|
std::string target_name = "example.com";
|
|
std::string other_target_name = "other.example.com";
|
|
ConnectionEndpointMetadata metadata;
|
|
metadata.supported_protocol_alpns = {"h5", "h6", "monster truck rally"};
|
|
metadata.ech_config_list = {'h', 'i'};
|
|
metadata.target_name = target_name;
|
|
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata> metadata_map{
|
|
{4u, metadata}};
|
|
HostCache::Entry metadata_entry(OK, metadata_map,
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
// Expect `GetEndpoints()` to always ignore metadatas with no `IPEndPoint`s.
|
|
EXPECT_FALSE(metadata_entry.GetEndpoints());
|
|
|
|
// Merge in an `IPEndPoint` with different canonical name.
|
|
IPEndPoint ip_endpoint(IPAddress(1, 1, 1, 1), 0);
|
|
HostCache::Entry with_ip_endpoint(OK, {ip_endpoint}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
with_ip_endpoint.set_canonical_names(
|
|
std::set<std::string>{other_target_name});
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(metadata_entry, with_ip_endpoint);
|
|
|
|
// Expect `GetEndpoints()` not to return the metadata.
|
|
EXPECT_THAT(result.GetEndpoints(),
|
|
Optional(ElementsAre(
|
|
ExpectEndpointResult(std::vector<IPEndPoint>{ip_endpoint}))));
|
|
|
|
// Expect merge order irrelevant.
|
|
EXPECT_EQ(result,
|
|
HostCache::Entry::MergeEntries(with_ip_endpoint, metadata_entry));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeMetadatasWithIpEndpointsMatchingCanonicalName) {
|
|
std::string target_name = "example.com";
|
|
ConnectionEndpointMetadata metadata;
|
|
metadata.supported_protocol_alpns = {"h5", "h6", "monster truck rally"};
|
|
metadata.ech_config_list = {'h', 'i'};
|
|
metadata.target_name = target_name;
|
|
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata> metadata_map{
|
|
{4u, metadata}};
|
|
HostCache::Entry metadata_entry(OK, metadata_map,
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
// Expect `GetEndpoints()` to always ignore metadatas with no `IPEndPoint`s.
|
|
EXPECT_FALSE(metadata_entry.GetEndpoints());
|
|
|
|
// Merge in an `IPEndPoint` with different canonical name.
|
|
IPEndPoint ip_endpoint(IPAddress(1, 1, 1, 1), 0);
|
|
HostCache::Entry with_ip_endpoint(OK, {ip_endpoint}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
with_ip_endpoint.set_canonical_names(std::set<std::string>{target_name});
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(metadata_entry, with_ip_endpoint);
|
|
|
|
// Expect `GetEndpoints()` to return the metadata.
|
|
EXPECT_THAT(result.GetEndpoints(),
|
|
Optional(ElementsAre(
|
|
ExpectEndpointResult(ElementsAre(ip_endpoint), metadata),
|
|
ExpectEndpointResult(ElementsAre(ip_endpoint)))));
|
|
|
|
// Expect merge order irrelevant.
|
|
EXPECT_EQ(result,
|
|
HostCache::Entry::MergeEntries(with_ip_endpoint, metadata_entry));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeMultipleMetadatasWithIpEndpoints) {
|
|
std::string target_name = "example.com";
|
|
ConnectionEndpointMetadata front_metadata;
|
|
front_metadata.supported_protocol_alpns = {"h5", "h6", "monster truck rally"};
|
|
front_metadata.ech_config_list = {'h', 'i'};
|
|
front_metadata.target_name = target_name;
|
|
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>
|
|
front_metadata_map{{4u, front_metadata}};
|
|
HostCache::Entry front(OK, front_metadata_map, HostCache::Entry::SOURCE_DNS);
|
|
|
|
ConnectionEndpointMetadata back_metadata;
|
|
back_metadata.supported_protocol_alpns = {"h5"};
|
|
back_metadata.target_name = target_name;
|
|
std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>
|
|
back_metadata_map{{2u, back_metadata}};
|
|
HostCache::Entry back(OK, back_metadata_map, HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry merged_metadatas =
|
|
HostCache::Entry::MergeEntries(front, back);
|
|
HostCache::Entry reversed_merged_metadatas =
|
|
HostCache::Entry::MergeEntries(back, front);
|
|
|
|
// Expect `GetEndpoints()` to always ignore metadatas with no `IPEndPoint`s.
|
|
EXPECT_FALSE(merged_metadatas.GetEndpoints());
|
|
EXPECT_FALSE(reversed_merged_metadatas.GetEndpoints());
|
|
|
|
// Merge in an `IPEndPoint`.
|
|
IPEndPoint ip_endpoint(IPAddress(1, 1, 1, 1), 0);
|
|
HostCache::Entry with_ip_endpoint(OK, {ip_endpoint}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
with_ip_endpoint.set_canonical_names(std::set<std::string>{target_name});
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(merged_metadatas, with_ip_endpoint);
|
|
|
|
// Expect `back_metadata` before `front_metadata` because it has lower
|
|
// priority number.
|
|
EXPECT_THAT(
|
|
result.GetEndpoints(),
|
|
Optional(ElementsAre(
|
|
ExpectEndpointResult(ElementsAre(ip_endpoint), back_metadata),
|
|
ExpectEndpointResult(ElementsAre(ip_endpoint), front_metadata),
|
|
ExpectEndpointResult(ElementsAre(ip_endpoint)))));
|
|
|
|
// Expect merge order irrelevant.
|
|
EXPECT_EQ(result, HostCache::Entry::MergeEntries(reversed_merged_metadatas,
|
|
with_ip_endpoint));
|
|
EXPECT_EQ(result,
|
|
HostCache::Entry::MergeEntries(with_ip_endpoint, merged_metadatas));
|
|
EXPECT_EQ(result, HostCache::Entry::MergeEntries(with_ip_endpoint,
|
|
reversed_merged_metadatas));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeAliases) {
|
|
HostCache::Entry front(OK, /*ip_endpoints=*/{},
|
|
/*aliases=*/{"foo1.test", "foo2.test", "foo3.test"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry back(OK, /*ip_endpoints=*/{},
|
|
/*aliases=*/{"foo2.test", "foo4.test"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry expected(
|
|
OK, /*ip_endpoints=*/{},
|
|
/*aliases=*/{"foo1.test", "foo2.test", "foo3.test", "foo4.test"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry result = HostCache::Entry::MergeEntries(front, back);
|
|
EXPECT_EQ(result, expected);
|
|
|
|
// Expect order irrelevant for alias merging.
|
|
result = HostCache::Entry::MergeEntries(back, front);
|
|
EXPECT_EQ(result, expected);
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_frontEmpty) {
|
|
HostCache::Entry front(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS);
|
|
|
|
const IPAddress kAddressBack(0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0);
|
|
const IPEndPoint kEndpointBack(kAddressBack, 0);
|
|
HostCache::Entry back(OK, {kEndpointBack}, {"alias1", "alias2", "alias3"},
|
|
HostCache::Entry::SOURCE_DNS, base::Hours(4));
|
|
back.set_text_records(std::vector<std::string>{"text2"});
|
|
const HostPortPair kHostnameBack("host", 2);
|
|
back.set_hostnames(std::vector<HostPortPair>{kHostnameBack});
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(OK, result.error());
|
|
EXPECT_EQ(HostCache::Entry::SOURCE_DNS, result.source());
|
|
|
|
ASSERT_TRUE(result.ip_endpoints());
|
|
EXPECT_THAT(*result.ip_endpoints(), ElementsAre(kEndpointBack));
|
|
EXPECT_THAT(result.text_records(), Optional(ElementsAre("text2")));
|
|
EXPECT_THAT(result.hostnames(), Optional(ElementsAre(kHostnameBack)));
|
|
|
|
EXPECT_EQ(base::Hours(4), result.ttl());
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(),
|
|
UnorderedElementsAre("alias1", "alias2", "alias3"));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_backEmpty) {
|
|
const IPAddress kAddressFront(1, 2, 3, 4);
|
|
const IPEndPoint kEndpointFront(kAddressFront, 0);
|
|
HostCache::Entry front(OK, {kEndpointFront}, {"alias1", "alias2", "alias3"},
|
|
HostCache::Entry::SOURCE_DNS, base::Minutes(5));
|
|
front.set_text_records(std::vector<std::string>{"text1"});
|
|
const HostPortPair kHostnameFront("host", 1);
|
|
front.set_hostnames(std::vector<HostPortPair>{kHostnameFront});
|
|
|
|
HostCache::Entry back(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(OK, result.error());
|
|
EXPECT_EQ(HostCache::Entry::SOURCE_DNS, result.source());
|
|
|
|
ASSERT_TRUE(result.ip_endpoints());
|
|
EXPECT_THAT(*result.ip_endpoints(), ElementsAre(kEndpointFront));
|
|
EXPECT_THAT(result.text_records(), Optional(ElementsAre("text1")));
|
|
EXPECT_THAT(result.hostnames(), Optional(ElementsAre(kHostnameFront)));
|
|
|
|
EXPECT_EQ(base::Minutes(5), result.ttl());
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(),
|
|
UnorderedElementsAre("alias1", "alias2", "alias3"));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_bothEmpty) {
|
|
HostCache::Entry front(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS);
|
|
HostCache::Entry back(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(ERR_NAME_NOT_RESOLVED, result.error());
|
|
EXPECT_EQ(HostCache::Entry::SOURCE_DNS, result.source());
|
|
|
|
EXPECT_FALSE(result.ip_endpoints());
|
|
EXPECT_FALSE(result.text_records());
|
|
EXPECT_FALSE(result.hostnames());
|
|
EXPECT_FALSE(result.has_ttl());
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_frontWithAliasesNoAddressesBackWithBoth) {
|
|
HostCache::Entry front(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS);
|
|
std::set<std::string> aliases_front({"alias0", "alias1", "alias2"});
|
|
front.set_aliases(aliases_front);
|
|
|
|
const IPAddress kAddressBack(0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0);
|
|
const IPEndPoint kEndpointBack(kAddressBack, 0);
|
|
HostCache::Entry back(OK, {kEndpointBack}, {"alias1", "alias2", "alias3"},
|
|
HostCache::Entry::SOURCE_DNS, base::Hours(4));
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(OK, result.error());
|
|
EXPECT_EQ(HostCache::Entry::SOURCE_DNS, result.source());
|
|
|
|
ASSERT_TRUE(result.ip_endpoints());
|
|
EXPECT_THAT(*result.ip_endpoints(), ElementsAre(kEndpointBack));
|
|
|
|
EXPECT_EQ(base::Hours(4), result.ttl());
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(),
|
|
UnorderedElementsAre("alias0", "alias1", "alias2", "alias3"));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_backWithAliasesNoAddressesFrontWithBoth) {
|
|
HostCache::Entry back(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS);
|
|
std::set<std::string> aliases_back({"alias1", "alias2", "alias3"});
|
|
back.set_aliases(aliases_back);
|
|
|
|
const IPAddress kAddressFront(0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0);
|
|
const IPEndPoint kEndpointFront(kAddressFront, 0);
|
|
HostCache::Entry front(OK, {kEndpointFront}, {"alias0", "alias1", "alias2"},
|
|
HostCache::Entry::SOURCE_DNS, base::Hours(4));
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(OK, result.error());
|
|
EXPECT_EQ(HostCache::Entry::SOURCE_DNS, result.source());
|
|
|
|
ASSERT_TRUE(result.ip_endpoints());
|
|
EXPECT_THAT(*result.ip_endpoints(), ElementsAre(kEndpointFront));
|
|
|
|
EXPECT_EQ(base::Hours(4), result.ttl());
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(),
|
|
UnorderedElementsAre("alias0", "alias1", "alias2", "alias3"));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_frontWithAddressesNoAliasesBackWithBoth) {
|
|
const IPAddress kAddressFront(1, 2, 3, 4);
|
|
const IPEndPoint kEndpointFront(kAddressFront, 0);
|
|
HostCache::Entry front(OK, {kEndpointFront}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_DNS, base::Hours(4));
|
|
|
|
const IPAddress kAddressBack(0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0);
|
|
const IPEndPoint kEndpointBack(kAddressBack, 0);
|
|
HostCache::Entry back(OK, {kEndpointBack}, {"alias1", "alias2", "alias3"},
|
|
HostCache::Entry::SOURCE_DNS, base::Hours(4));
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(OK, result.error());
|
|
EXPECT_EQ(HostCache::Entry::SOURCE_DNS, result.source());
|
|
|
|
ASSERT_TRUE(result.ip_endpoints());
|
|
EXPECT_THAT(*result.ip_endpoints(),
|
|
ElementsAre(kEndpointFront, kEndpointBack));
|
|
|
|
EXPECT_EQ(base::Hours(4), result.ttl());
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(),
|
|
UnorderedElementsAre("alias1", "alias2", "alias3"));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_backWithAddressesNoAliasesFrontWithBoth) {
|
|
const IPAddress kAddressFront(1, 2, 3, 4);
|
|
const IPEndPoint kEndpointFront(kAddressFront, 0);
|
|
HostCache::Entry front(OK, {kEndpointFront}, {"alias1", "alias2", "alias3"},
|
|
HostCache::Entry::SOURCE_DNS, base::Hours(4));
|
|
const IPAddress kAddressBack(0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0);
|
|
const IPEndPoint kEndpointBack(kAddressBack, 0);
|
|
HostCache::Entry back(OK, {kEndpointBack}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_DNS, base::Hours(4));
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(OK, result.error());
|
|
EXPECT_EQ(HostCache::Entry::SOURCE_DNS, result.source());
|
|
|
|
ASSERT_TRUE(result.ip_endpoints());
|
|
EXPECT_THAT(*result.ip_endpoints(),
|
|
ElementsAre(kEndpointFront, kEndpointBack));
|
|
|
|
EXPECT_EQ(base::Hours(4), result.ttl());
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(),
|
|
UnorderedElementsAre("alias1", "alias2", "alias3"));
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_differentTtl) {
|
|
HostCache::Entry front(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS,
|
|
base::Days(12));
|
|
HostCache::Entry back(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS,
|
|
base::Seconds(42));
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
EXPECT_EQ(base::Seconds(42), result.ttl());
|
|
}
|
|
|
|
TEST(HostCacheTest, MergeEntries_FrontCannonnamePreserved) {
|
|
HostCache::Entry front(OK, /*ip_endpoints=*/{}, /*aliases=*/{"name1"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry back(OK, /*ip_endpoints=*/{}, /*aliases=*/{"name2"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(), UnorderedElementsAre("name1", "name2"));
|
|
}
|
|
|
|
// Test that the back canonname can be used if there is no front cannonname.
|
|
TEST(HostCacheTest, MergeEntries_BackCannonnameUsable) {
|
|
HostCache::Entry front(OK, /*ip_endpoints=*/{}, /*aliases=*/{},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry back(OK, /*ip_endpoints=*/{}, /*aliases=*/{"name2"},
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
HostCache::Entry result =
|
|
HostCache::Entry::MergeEntries(std::move(front), std::move(back));
|
|
|
|
ASSERT_TRUE(result.aliases());
|
|
EXPECT_THAT(*result.aliases(), UnorderedElementsAre("name2"));
|
|
}
|
|
|
|
TEST(HostCacheTest, ConvertFromInternalAddressResult) {
|
|
const std::vector<IPEndPoint> kEndpoints{
|
|
IPEndPoint(IPAddress(2, 2, 2, 2), 46)};
|
|
constexpr base::TimeDelta kTtl1 = base::Minutes(45);
|
|
constexpr base::TimeDelta kTtl2 = base::Minutes(40);
|
|
constexpr base::TimeDelta kTtl3 = base::Minutes(55);
|
|
|
|
std::vector<std::unique_ptr<HostResolverInternalResult>> results;
|
|
results.push_back(std::make_unique<HostResolverInternalDataResult>(
|
|
"endpoint.test", DnsQueryType::AAAA, base::TimeTicks() + kTtl1,
|
|
base::Time() + kTtl1, HostResolverInternalResult::Source::kDns,
|
|
kEndpoints, std::vector<std::string>{}, std::vector<HostPortPair>{}));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain1.test", DnsQueryType::AAAA, base::TimeTicks() + kTtl2,
|
|
base::Time() + kTtl2, HostResolverInternalResult::Source::kDns,
|
|
"domain2.test"));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain2.test", DnsQueryType::AAAA, base::TimeTicks() + kTtl3,
|
|
base::Time() + kTtl3, HostResolverInternalResult::Source::kDns,
|
|
"endpoint.test"));
|
|
|
|
HostCache::Entry converted(std::move(results), base::Time(),
|
|
base::TimeTicks());
|
|
|
|
// Expect kTtl2 because it is the min TTL.
|
|
HostCache::Entry expected(
|
|
OK, kEndpoints,
|
|
/*aliases=*/{"domain1.test", "domain2.test", "endpoint.test"},
|
|
HostCache::Entry::SOURCE_DNS, kTtl2);
|
|
expected.set_canonical_names(std::set<std::string>{"endpoint.test"});
|
|
|
|
// Entries converted from HostResolverInternalDataResults do not differentiate
|
|
// between empty and no-data for the various data types, so need to set empty
|
|
// strings and hostname entries into `expected`.
|
|
expected.set_text_records(std::vector<std::string>());
|
|
expected.set_hostnames(std::vector<HostPortPair>());
|
|
|
|
EXPECT_EQ(converted, expected);
|
|
}
|
|
|
|
TEST(HostCacheTest, ConvertFromInternalMetadataResult) {
|
|
const std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>
|
|
kMetadatas{{1, ConnectionEndpointMetadata({"h2", "h3"},
|
|
/*ech_config_list=*/{},
|
|
"target.test")}};
|
|
constexpr base::TimeDelta kTtl1 = base::Minutes(45);
|
|
constexpr base::TimeDelta kTtl2 = base::Minutes(40);
|
|
constexpr base::TimeDelta kTtl3 = base::Minutes(55);
|
|
|
|
std::vector<std::unique_ptr<HostResolverInternalResult>> results;
|
|
results.push_back(std::make_unique<HostResolverInternalMetadataResult>(
|
|
"endpoint.test", DnsQueryType::HTTPS, base::TimeTicks() + kTtl1,
|
|
base::Time() + kTtl1, HostResolverInternalResult::Source::kDns,
|
|
kMetadatas));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain1.test", DnsQueryType::HTTPS, base::TimeTicks() + kTtl2,
|
|
base::Time() + kTtl2, HostResolverInternalResult::Source::kDns,
|
|
"domain2.test"));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain2.test", DnsQueryType::HTTPS, base::TimeTicks() + kTtl3,
|
|
base::Time() + kTtl3, HostResolverInternalResult::Source::kDns,
|
|
"endpoint.test"));
|
|
|
|
HostCache::Entry converted(std::move(results), base::Time(),
|
|
base::TimeTicks());
|
|
|
|
// Expect kTtl2 because it is the min TTL.
|
|
HostCache::Entry expected(OK, kMetadatas, HostCache::Entry::SOURCE_DNS,
|
|
kTtl2);
|
|
expected.set_https_record_compatibility(std::vector<bool>{true});
|
|
|
|
EXPECT_EQ(converted, expected);
|
|
}
|
|
|
|
// Test the case of compatible HTTPS records but no metadata of use to Chrome.
|
|
// Represented in internal result type as an empty metadata result. Represented
|
|
// in HostCache::Entry as empty metadata with at least one true in
|
|
// `https_record_compatibility_`.
|
|
TEST(HostCacheTest, ConvertFromCompatibleOnlyInternalMetadataResult) {
|
|
const std::multimap<HttpsRecordPriority, ConnectionEndpointMetadata>
|
|
kMetadatas;
|
|
constexpr base::TimeDelta kTtl1 = base::Minutes(45);
|
|
constexpr base::TimeDelta kTtl2 = base::Minutes(40);
|
|
constexpr base::TimeDelta kTtl3 = base::Minutes(55);
|
|
|
|
std::vector<std::unique_ptr<HostResolverInternalResult>> results;
|
|
results.push_back(std::make_unique<HostResolverInternalMetadataResult>(
|
|
"endpoint.test", DnsQueryType::HTTPS, base::TimeTicks() + kTtl1,
|
|
base::Time() + kTtl1, HostResolverInternalResult::Source::kDns,
|
|
kMetadatas));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain1.test", DnsQueryType::HTTPS, base::TimeTicks() + kTtl2,
|
|
base::Time() + kTtl2, HostResolverInternalResult::Source::kDns,
|
|
"domain2.test"));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain2.test", DnsQueryType::HTTPS, base::TimeTicks() + kTtl3,
|
|
base::Time() + kTtl3, HostResolverInternalResult::Source::kDns,
|
|
"endpoint.test"));
|
|
|
|
HostCache::Entry converted(std::move(results), base::Time(),
|
|
base::TimeTicks());
|
|
|
|
// Expect kTtl2 because it is the min TTL.
|
|
HostCache::Entry expected(ERR_NAME_NOT_RESOLVED, kMetadatas,
|
|
HostCache::Entry::SOURCE_DNS, kTtl2);
|
|
expected.set_https_record_compatibility(std::vector<bool>{true});
|
|
|
|
EXPECT_EQ(converted, expected);
|
|
}
|
|
|
|
TEST(HostCacheTest, ConvertFromInternalErrorResult) {
|
|
constexpr base::TimeDelta kTtl1 = base::Minutes(45);
|
|
constexpr base::TimeDelta kTtl2 = base::Minutes(40);
|
|
constexpr base::TimeDelta kTtl3 = base::Minutes(55);
|
|
|
|
std::vector<std::unique_ptr<HostResolverInternalResult>> results;
|
|
results.push_back(std::make_unique<HostResolverInternalErrorResult>(
|
|
"endpoint.test", DnsQueryType::A, base::TimeTicks() + kTtl1,
|
|
base::Time() + kTtl1, HostResolverInternalResult::Source::kDns,
|
|
ERR_NAME_NOT_RESOLVED));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain1.test", DnsQueryType::A, base::TimeTicks() + kTtl2,
|
|
base::Time() + kTtl2, HostResolverInternalResult::Source::kDns,
|
|
"domain2.test"));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain2.test", DnsQueryType::A, base::TimeTicks() + kTtl3,
|
|
base::Time() + kTtl3, HostResolverInternalResult::Source::kDns,
|
|
"endpoint.test"));
|
|
|
|
HostCache::Entry converted(std::move(results), base::Time(),
|
|
base::TimeTicks());
|
|
|
|
// Expect kTtl2 because it is the min TTL.
|
|
HostCache::Entry expected(ERR_NAME_NOT_RESOLVED, HostCache::Entry::SOURCE_DNS,
|
|
kTtl2);
|
|
|
|
EXPECT_EQ(converted, expected);
|
|
}
|
|
|
|
TEST(HostCacheTest, ConvertFromNonCachableInternalErrorResult) {
|
|
constexpr base::TimeDelta kTtl1 = base::Minutes(45);
|
|
constexpr base::TimeDelta kTtl2 = base::Minutes(40);
|
|
|
|
std::vector<std::unique_ptr<HostResolverInternalResult>> results;
|
|
results.push_back(std::make_unique<HostResolverInternalErrorResult>(
|
|
"endpoint.test", DnsQueryType::AAAA, /*expiration=*/absl::nullopt,
|
|
/*timed_expiration=*/absl::nullopt,
|
|
HostResolverInternalResult::Source::kDns, ERR_NAME_NOT_RESOLVED));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain1.test", DnsQueryType::AAAA, base::TimeTicks() + kTtl1,
|
|
base::Time() + kTtl1, HostResolverInternalResult::Source::kDns,
|
|
"domain2.test"));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain2.test", DnsQueryType::AAAA, base::TimeTicks() + kTtl2,
|
|
base::Time() + kTtl2, HostResolverInternalResult::Source::kDns,
|
|
"endpoint.test"));
|
|
|
|
HostCache::Entry converted(std::move(results), base::Time(),
|
|
base::TimeTicks());
|
|
|
|
// Expect no TTL because error is non-cachable (has no TTL itself).
|
|
HostCache::Entry expected(ERR_NAME_NOT_RESOLVED,
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
EXPECT_EQ(converted, expected);
|
|
}
|
|
|
|
TEST(HostCacheTest, ConvertFromInternalAliasOnlyResult) {
|
|
constexpr base::TimeDelta kTtl1 = base::Minutes(45);
|
|
constexpr base::TimeDelta kTtl2 = base::Minutes(40);
|
|
|
|
std::vector<std::unique_ptr<HostResolverInternalResult>> results;
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain1.test", DnsQueryType::A, base::TimeTicks() + kTtl1,
|
|
base::Time() + kTtl1, HostResolverInternalResult::Source::kDns,
|
|
"domain2.test"));
|
|
results.push_back(std::make_unique<HostResolverInternalAliasResult>(
|
|
"domain2.test", DnsQueryType::A, base::TimeTicks() + kTtl2,
|
|
base::Time() + kTtl2, HostResolverInternalResult::Source::kDns,
|
|
"endpoint.test"));
|
|
|
|
HostCache::Entry converted(std::move(results), base::Time(),
|
|
base::TimeTicks());
|
|
|
|
// Expect no TTL because alias-only results are not cacheable.
|
|
HostCache::Entry expected(ERR_NAME_NOT_RESOLVED,
|
|
HostCache::Entry::SOURCE_DNS);
|
|
|
|
EXPECT_EQ(converted, expected);
|
|
}
|
|
|
|
TEST(HostCacheTest, ConvertFromEmptyInternalResult) {
|
|
HostCache::Entry converted({}, base::Time(), base::TimeTicks());
|
|
HostCache::Entry expected(ERR_NAME_NOT_RESOLVED,
|
|
HostCache::Entry::SOURCE_UNKNOWN);
|
|
|
|
EXPECT_EQ(converted, expected);
|
|
}
|
|
|
|
} // namespace net
|