Automatically update LogDnsClient's DNS config

components/certificate_transparency/log_dns_client_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/certificate_transparency/log_dns_client.h"
 
 #include <algorithm>
 #include <numeric>
 #include <utility>
 #include <vector>
@@ skipping 14 matching lines @@
 #include "net/dns/dns_protocol.h"
 #include "net/log/net_log.h"
 #include "net/socket/socket_test_util.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace certificate_transparency {
 namespace {
 
+using ::testing::IsEmpty;
 using ::testing::IsNull;
+using ::testing::Not;
 using ::testing::NotNull;
 using net::test::IsError;
 using net::test::IsOk;
 
 constexpr char kLeafHash[] =
     "\x1f\x25\xe1\xca\xba\x4f\xf9\xb8\x27\x24\x83\x0f\xca\x60\xe4\xc2\xbe\xa8"
     "\xc3\xa9\x44\x1c\x27\xb0\xb4\x3e\x6a\x96\x94\xc7\xb8\x04";
 
+// Necessary to expose SetDnsConfig for testing.
+class DnsChangeNotifier : public net::NetworkChangeNotifier {
+ public:
+  static void SetInitialDnsConfig(const net::DnsConfig& config) {
+    net::NetworkChangeNotifier::SetInitialDnsConfig(config);
+  }
+
+  static void SetDnsConfig(const net::DnsConfig& config) {
+    net::NetworkChangeNotifier::SetDnsConfig(config);
+  }
+};
+
 // Always return min, to simplify testing.
 // This should result in the DNS query ID always being 0.
 int FakeRandInt(int min, int max) {
   return min;
 }
 
 std::vector<char> CreateDnsTxtRequest(base::StringPiece qname) {
   std::string encoded_qname;
   EXPECT_TRUE(net::DNSDomainFromDot(qname, &encoded_qname));
 
@@ skipping 198 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockSocketData);
 };
 
 const net::MockRead MockSocketData::eof_(net::SYNCHRONOUS,
                                          net::ERR_IO_PENDING,
                                          2);
 
 class LogDnsClientTest : public ::testing::TestWithParam<net::IoMode> {
  protected:
-  LogDnsClientTest() {
+  LogDnsClientTest() :
+    network_change_notifier_(net::NetworkChangeNotifier::CreateMock()) {
+    net::DnsConfig dns_config;
     // Use an invalid nameserver address. This prevents the tests accidentally
     // sending real DNS queries. The mock sockets don't care that the address
     // is invalid.
-    dns_config_.nameservers.push_back(net::IPEndPoint());
+    dns_config.nameservers.push_back(net::IPEndPoint());
     // Don't attempt retransmissions - just fail.
-    dns_config_.attempts = 1;
+    dns_config.attempts = 1;
     // This ensures timeouts are long enough for memory tests.
-    dns_config_.timeout = TestTimeouts::action_timeout();
+    dns_config.timeout = TestTimeouts::action_timeout();
     // Simplify testing - don't require random numbers for the source port.
     // This means our FakeRandInt function should only be called to get query
     // IDs.
-    dns_config_.randomize_ports = false;
+    dns_config.randomize_ports = false;
+
+    DnsChangeNotifier::SetInitialDnsConfig(dns_config);
   }
 
   void ExpectRequestAndErrorResponse(base::StringPiece qname, uint8_t rcode) {
     std::vector<char> request = CreateDnsTxtRequest(qname);
     std::vector<char> response = CreateDnsErrorResponse(request, rcode);
 
     mock_socket_data_.emplace_back(new MockSocketData(request, response));
     mock_socket_data_.back()->SetReadMode(GetParam());
     mock_socket_data_.back()->AddToFactory(&socket_factory_);
   }
 
   void ExpectRequestAndSocketError(base::StringPiece qname, int net_error) {
     std::vector<char> request = CreateDnsTxtRequest(qname);
 
     mock_socket_data_.emplace_back(new MockSocketData(request, net_error));
     mock_socket_data_.back()->SetReadMode(GetParam());
     mock_socket_data_.back()->AddToFactory(&socket_factory_);
   }
 
   void ExpectRequestAndTimeout(base::StringPiece qname) {
     std::vector<char> request = CreateDnsTxtRequest(qname);
 
     mock_socket_data_.emplace_back(new MockSocketData(request));
     mock_socket_data_.back()->SetReadMode(GetParam());
     mock_socket_data_.back()->AddToFactory(&socket_factory_);
 
     // Speed up timeout tests.
-    dns_config_.timeout = TestTimeouts::tiny_timeout();
+    net::DnsConfig dns_config;
+    DnsChangeNotifier::GetDnsConfig(&dns_config);
+    dns_config.timeout = TestTimeouts::tiny_timeout();
+    DnsChangeNotifier::SetDnsConfig(dns_config);
   }
 
   void ExpectLeafIndexRequestAndResponse(base::StringPiece qname,
                                          base::StringPiece leaf_index) {
     // Prepend size to leaf_index to create the query answer (rdata)
     ASSERT_LE(leaf_index.size(), 0xFFul);  // size must fit into a single byte
     std::string answer = leaf_index.as_string();
     answer.insert(answer.begin(), static_cast<char>(leaf_index.size()));
 
     ExpectRequestAndResponse(qname, answer);
@@ skipping 12 matching lines @@
     proof.insert(proof.begin(), static_cast<char>(proof.size()));
 
     ExpectRequestAndResponse(qname, proof);
   }
 
   void QueryLeafIndex(base::StringPiece log_domain,
                       base::StringPiece leaf_hash,
                       MockLeafIndexCallback* callback) {
     std::unique_ptr<net::DnsClient> dns_client = CreateDnsClient();
     LogDnsClient log_client(std::move(dns_client), net::BoundNetLog());
+    net::NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests();
 
     log_client.QueryLeafIndex(log_domain, leaf_hash, callback->AsCallback());
     callback->WaitUntilRun();
   }
 
   void QueryAuditProof(base::StringPiece log_domain,
                        uint64_t leaf_index,
                        uint64_t tree_size,
                        MockAuditProofCallback* callback) {
     std::unique_ptr<net::DnsClient> dns_client = CreateDnsClient();
     LogDnsClient log_client(std::move(dns_client), net::BoundNetLog());
+    net::NetworkChangeNotifier::NotifyObserversOfInitialDNSConfigReadForTests();
 
     log_client.QueryAuditProof(log_domain, leaf_index, tree_size,
                                callback->AsCallback());
     callback->WaitUntilRun();
   }
 
+  std::unique_ptr<net::DnsClient> CreateDnsClient() {
+    return net::DnsClient::CreateClientForTesting(nullptr, &socket_factory_,
+                                                  base::Bind(&FakeRandInt));
+  }
+
  private:
-  std::unique_ptr<net::DnsClient> CreateDnsClient() {
-    std::unique_ptr<net::DnsClient> client =
-        net::DnsClient::CreateClientForTesting(nullptr, &socket_factory_,
-                                               base::Bind(&FakeRandInt));
-    client->SetConfig(dns_config_);
-    return client;
-  }
 
   void ExpectRequestAndResponse(base::StringPiece qname,
                                 base::StringPiece answer) {
     std::vector<char> request = CreateDnsTxtRequest(qname);
     std::vector<char> response = CreateDnsTxtResponse(request, answer);
 
     mock_socket_data_.emplace_back(new MockSocketData(request, response));
     mock_socket_data_.back()->SetReadMode(GetParam());
     mock_socket_data_.back()->AddToFactory(&socket_factory_);
   }
 
-  net::DnsConfig dns_config_;
+  // This will be the NetworkChangeNotifier singleton for the duration of the
+  // test. It is accessed statically by LogDnsClient.
+  std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
+  // Queues and handles asynchronous DNS tasks. Indirectly used by LogDnsClient,
+  // the underlying net::DnsClient, and NetworkChangeNotifier.
   base::MessageLoopForIO message_loop_;
+  // One MockSocketData for each socket that is created. This corresponds to one
+  // for each DNS request sent.
   std::vector<std::unique_ptr<MockSocketData>> mock_socket_data_;
+  // Provides as many mock sockets as there are entries in |mock_socket_data_|.
   net::MockClientSocketFactory socket_factory_;
 };
 
 TEST_P(LogDnsClientTest, QueryLeafIndex) {
   ExpectLeafIndexRequestAndResponse(
       "D4S6DSV2J743QJZEQMH4UYHEYK7KRQ5JIQOCPMFUHZVJNFGHXACA.hash.ct.test.",
       "123456");
 
   MockLeafIndexCallback callback;
   QueryLeafIndex("ct.test", kLeafHash, &callback);
@@ skipping 346 matching lines @@
 TEST_P(LogDnsClientTest, QueryAuditProofReportsTimeout) {
   ExpectRequestAndTimeout("0.123456.999999.tree.ct.test.");
 
   MockAuditProofCallback callback;
   QueryAuditProof("ct.test", 123456, 999999, &callback);
   ASSERT_TRUE(callback.called());
   EXPECT_THAT(callback.net_error(), IsError(net::ERR_DNS_TIMED_OUT));
   EXPECT_THAT(callback.proof(), IsNull());
 }
 
+TEST_P(LogDnsClientTest, AdoptsLatestDnsConfigIfValid) {
+  std::unique_ptr<net::DnsClient> tmp = CreateDnsClient();
+  net::DnsClient* dns_client = tmp.get();
+  LogDnsClient log_client(std::move(tmp), net::BoundNetLog());
+
+  // Get the current DNS config, modify it and broadcast the update.
+  net::DnsConfig config(*dns_client->GetConfig());
+  ASSERT_NE(123, config.attempts);
+  config.attempts = 123;
+  DnsChangeNotifier::SetDnsConfig(config);
+
+  // Let the DNS config change propogate.
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(123, dns_client->GetConfig()->attempts);
+}
+
+TEST_P(LogDnsClientTest, IgnoresLatestDnsConfigIfInvalid) {
+  std::unique_ptr<net::DnsClient> tmp = CreateDnsClient();
+  net::DnsClient* dns_client = tmp.get();
+  LogDnsClient log_client(std::move(tmp), net::BoundNetLog());
+
+  // Get the current DNS config, modify it and broadcast the update.
+  net::DnsConfig config(*dns_client->GetConfig());
+  ASSERT_THAT(config.nameservers, Not(IsEmpty()));
+  config.nameservers.clear();  // Makes config invalid
+  DnsChangeNotifier::SetDnsConfig(config);
+
+  // Let the DNS config change propogate.
+  base::RunLoop().RunUntilIdle();
+  EXPECT_THAT(dns_client->GetConfig()->nameservers, Not(IsEmpty()));
+}
+
 INSTANTIATE_TEST_CASE_P(ReadMode,
                         LogDnsClientTest,
                         ::testing::Values(net::IoMode::ASYNC,
                                           net::IoMode::SYNCHRONOUS));
 
 }  // namespace
 }  // namespace certificate_transparency