Allow a callback to populate mock DNS responses.

net/dns/dns_test_util.h

 // Copyright (c) 2012 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.
 
 #ifndef NET_DNS_DNS_TEST_UTIL_H_
 #define NET_DNS_DNS_TEST_UTIL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "base/big_endian.h"
+#include "base/callback_forward.h"
 #include "net/dns/dns_client.h"
 #include "net/dns/dns_config_service.h"
 #include "net/dns/dns_protocol.h"
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 // Query/response set for www.google.com, ID is fixed to 0.
 static const char kT0HostName[] = "www.google.com";
 static const uint16_t kT0Qtype = dns_protocol::kTypeA;
@@ skipping 133 matching lines @@
 class MockTransactionFactory;
 
 struct MockDnsClientRule {
   enum Result {
     FAIL,     // Fail asynchronously with ERR_NAME_NOT_RESOLVED.
     TIMEOUT,  // Fail asynchronously with ERR_DNS_TIMEOUT.
     EMPTY,    // Return an empty response.
     OK,       // Return a response with loopback address.
   };
 
+  // The type of callback invoked in order to prepare a response to a mock DNS
+  // request. An empty response will be created, which can then be manipulated
+  // via the |response_header| and |answer_writer|. It must return net::OK
+  // when done, unless it is intended that the request fail, in which case it
+  // must return a different net::Error.
+  using ResponseCallback =
+      base::Callback<int(dns_protocol::Header* response_header,
+                         base::BigEndianWriter* answer_writer)>;

[mmenke, 2016/06/02 19:46:05]

Can you just use mock UDP sockets for this?

Reasons:

* That makes for integration-y tests, making sure DnsTransactions can handle
whever new requests you throw at it.
* That's more flexible.  Makes it easier to send malformed packets containing
whatever you want, so we don't end up having to add yet another API for that, if
we discover we need it.
* It's also less new code.

+
+  // Expect a mock DNS request with the given |prefix| and |qtype|.
+  // The response is dictated by |result|.
   // If |delay| is true, matching transactions will be delayed until triggered
   // by the consumer.
-  MockDnsClientRule(const std::string& prefix_arg,
-                    uint16_t qtype_arg,
-                    Result result_arg,
-                    bool delay)
-      : result(result_arg),
-        prefix(prefix_arg),
-        qtype(qtype_arg),
-        delay(delay) {}
+  MockDnsClientRule(const std::string& prefix,
+                    uint16_t qtype,
+                    Result result,
+                    bool delay);
 
-  Result result;
+  // Expect a mock DNS request with the given |prefix| and |qtype|.
+  // In response, invoke |response_callback|, which can modify the response
+  // header, write answers into the response, or return a net::Error.
+  // If |delay| is true, matching transactions will be delayed until triggered
+  // by the consumer.
+  MockDnsClientRule(const std::string& prefix,
+                    uint16_t qtype,
+                    ResponseCallback response_callback,
+                    bool delay);
+
+  MockDnsClientRule(const MockDnsClientRule& copy);
+  MockDnsClientRule(MockDnsClientRule&& move);
+
+  ~MockDnsClientRule();
+
+  ResponseCallback response_callback;
   std::string prefix;
   uint16_t qtype;
   bool delay;
 };
 
 typedef std::vector<MockDnsClientRule> MockDnsClientRuleList;
 
 // MockDnsClient provides MockTransactionFactory.
 class MockDnsClient : public DnsClient {
  public:
@@ skipping 11 matching lines @@
 
  private:
   DnsConfig config_;
   std::unique_ptr<MockTransactionFactory> factory_;
   std::unique_ptr<AddressSorter> address_sorter_;
 };
 
 }  // namespace net
 
 #endif  // NET_DNS_DNS_TEST_UTIL_H_