Isolates generic DnsClient from AsyncHostResolver.

net/dns/async_host_resolver_unittest.cc

 // Copyright (c) 2011 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 "net/dns/async_host_resolver.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/stl_util.h"
 #include "net/base/host_cache.h"
+#include "net/base/net_errors.h"
 #include "net/base/net_log.h"
-#include "net/base/rand_callback.h"
 #include "net/base/sys_addrinfo.h"
+#include "net/base/test_completion_callback.h"
+#include "net/dns/dns_client.h"
+#include "net/dns/dns_query.h"
+#include "net/dns/dns_response.h"
 #include "net/dns/dns_test_util.h"
-#include "net/socket/socket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
+const int kPortNum = 80;
+const size_t kMaxTransactions = 2;
+const size_t kMaxPendingRequests = 1;
+
 void VerifyAddressList(const std::vector<const char*>& ip_addresses,
                        int port,
                        const AddressList& addrlist) {
   ASSERT_LT(0u, ip_addresses.size());
   ASSERT_NE(static_cast<addrinfo*>(NULL), addrlist.head());
 
   IPAddressNumber ip_number;
   const struct addrinfo* ainfo = addrlist.head();
   for (std::vector<const char*>::const_iterator i = ip_addresses.begin();
        i != ip_addresses.end(); ++i, ainfo = ainfo->ai_next) {
     ASSERT_NE(static_cast<addrinfo*>(NULL), ainfo);
     EXPECT_EQ(sizeof(struct sockaddr_in), ainfo->ai_addrlen);
 
     const struct sockaddr* sa = ainfo->ai_addr;
     const struct sockaddr_in* sa_in = (const struct sockaddr_in*) sa;
     EXPECT_TRUE(htons(port) == sa_in->sin_port);
     EXPECT_STREQ(*i, NetAddressToString(sa, ainfo->ai_addrlen).c_str());
   }
   ASSERT_EQ(static_cast<addrinfo*>(NULL), ainfo);
 }
 
+class MockDnsClient : public DnsClient,
+                      public base::SupportsWeakPtr<MockDnsClient> {
+ public:
+  // Using WeakPtr to support cancellation.
+  // All MockRequests succeed unless canceled or MockDnsClient is destroyed.
+  class MockRequest : public DnsClient::Request,
+                      public base::SupportsWeakPtr<MockRequest> {
+   public:
+    MockRequest(const base::StringPiece& qname,
+                uint16 qtype,
+                const RequestCallback& callback,
+                const base::WeakPtr<MockDnsClient>& client)
+      : Request(qname, qtype, callback), started_(false), client_(client) {

[mmenke, 2011/12/02 00:53:55]

nit:  4 space indent.

[szym, 2011/12/05 23:06:28]

Done.

+    }
+
+    int Start() OVERRIDE {
+      EXPECT_FALSE(started_);
+      started_ = true;
+      MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&MockRequest::Finish, AsWeakPtr()));
+      return ERR_IO_PENDING;
+    }
+
+   private:
+    void Finish() {
+      if (!client_) {
+        DoCallback(ERR_DNS_SERVER_FAILED, NULL);
+        return;
+      }
+      DoCallback(OK, client_->responses[Key(qname(), qtype())]);
+    }
+
+    bool started_;
+    base::WeakPtr<MockDnsClient> client_;
+  };
+
+  typedef std::pair<std::string, uint16> Key;
+
+  MockDnsClient() : num_requests(0) {}
+  ~MockDnsClient() {
+    STLDeleteValues(&responses);
+  }
+
+  Request* CreateRequest(const base::StringPiece& qname,
+                         uint16 qtype,
+                         const RequestCallback& callback,
+                         const BoundNetLog&) {
+    ++num_requests;
+    return new MockRequest(qname, qtype, callback, AsWeakPtr());
+  }
+
+  int num_requests;
+  std::map<Key, DnsResponse*> responses;
+};
+
 }  // namespace
 
-static const int kPortNum = 80;
-static const size_t kMaxTransactions = 2;
-static const size_t kMaxPendingRequests = 1;
-static int transaction_ids[] = {0, 1, 2, 3};
 
 // The following fixture sets up an environment for four different lookups
 // with their data defined in dns_test_util.h.  All tests make use of these
 // predefined variables instead of each defining their own, to avoid
 // boilerplate code in every test.  Assuming every coming query is for a
 // distinct hostname, as |kMaxTransactions| is set to 2 and
 // |kMaxPendingRequests| is set to 1, first two queries start immediately
 // and the next one is sent to pending queue; as a result, the next query
 // should either fail itself or cause the pending query to fail depending
 // on its priority.
 class AsyncHostResolverTest : public testing::Test {
  public:
   AsyncHostResolverTest()
       : info0_(HostPortPair(kT0HostName, kPortNum)),
         info1_(HostPortPair(kT1HostName, kPortNum)),
         info2_(HostPortPair(kT2HostName, kPortNum)),
         info3_(HostPortPair(kT3HostName, kPortNum)),
         ip_addresses0_(kT0IpAddresses,
             kT0IpAddresses + arraysize(kT0IpAddresses)),
         ip_addresses1_(kT1IpAddresses,
             kT1IpAddresses + arraysize(kT1IpAddresses)),
         ip_addresses2_(kT2IpAddresses,
             kT2IpAddresses + arraysize(kT2IpAddresses)),
         ip_addresses3_(kT3IpAddresses,
-            kT3IpAddresses + arraysize(kT3IpAddresses)),
-        test_prng_(std::deque<int>(
-            transaction_ids, transaction_ids + arraysize(transaction_ids))) {
-    rand_int_cb_ = base::Bind(&TestPrng::GetNext,
-                              base::Unretained(&test_prng_));
+            kT3IpAddresses + arraysize(kT3IpAddresses)) {
     // AF_INET only for now.
     info0_.set_address_family(ADDRESS_FAMILY_IPV4);
     info1_.set_address_family(ADDRESS_FAMILY_IPV4);
     info2_.set_address_family(ADDRESS_FAMILY_IPV4);
     info3_.set_address_family(ADDRESS_FAMILY_IPV4);
 
-    // Setup socket read/writes for transaction 0.
-    writes0_.push_back(
-        MockWrite(true, reinterpret_cast<const char*>(kT0QueryDatagram),
-                  arraysize(kT0QueryDatagram)));
-    reads0_.push_back(
-         MockRead(true, reinterpret_cast<const char*>(kT0ResponseDatagram),
-                  arraysize(kT0ResponseDatagram)));
-    data0_.reset(new StaticSocketDataProvider(&reads0_[0], reads0_.size(),
-                                              &writes0_[0], writes0_.size()));
+    client_.reset(new MockDnsClient());
 
-    // Setup socket read/writes for transaction 1.
-    writes1_.push_back(
-        MockWrite(true, reinterpret_cast<const char*>(kT1QueryDatagram),
-                  arraysize(kT1QueryDatagram)));
-    reads1_.push_back(
-         MockRead(true, reinterpret_cast<const char*>(kT1ResponseDatagram),
-                  arraysize(kT1ResponseDatagram)));
-    data1_.reset(new StaticSocketDataProvider(&reads1_[0], reads1_.size(),
-                                              &writes1_[0], writes1_.size()));
+    AddResponse(std::string(kT0DnsName, arraysize(kT0DnsName)), kT0Qtype,
+        new DnsResponse(reinterpret_cast<const char*>(kT0ResponseDatagram),
+                        arraysize(kT0ResponseDatagram),
+                        arraysize(kT0QueryDatagram)));
 
-    // Setup socket read/writes for transaction 2.
-    writes2_.push_back(
-        MockWrite(true, reinterpret_cast<const char*>(kT2QueryDatagram),
-                  arraysize(kT2QueryDatagram)));
-    reads2_.push_back(
-         MockRead(true, reinterpret_cast<const char*>(kT2ResponseDatagram),
-                  arraysize(kT2ResponseDatagram)));
-    data2_.reset(new StaticSocketDataProvider(&reads2_[0], reads2_.size(),
-                                              &writes2_[0], writes2_.size()));
+    AddResponse(std::string(kT1DnsName, arraysize(kT1DnsName)), kT1Qtype,
+        new DnsResponse(reinterpret_cast<const char*>(kT1ResponseDatagram),
+                        arraysize(kT1ResponseDatagram),
+                        arraysize(kT1QueryDatagram)));
 
-    // Setup socket read/writes for transaction 3.
-    writes3_.push_back(
-        MockWrite(true, reinterpret_cast<const char*>(kT3QueryDatagram),
-                  arraysize(kT3QueryDatagram)));
-    reads3_.push_back(
-         MockRead(true, reinterpret_cast<const char*>(kT3ResponseDatagram),
-                  arraysize(kT3ResponseDatagram)));
-    data3_.reset(new StaticSocketDataProvider(&reads3_[0], reads3_.size(),
-                                              &writes3_[0], writes3_.size()));
+    AddResponse(std::string(kT2DnsName, arraysize(kT2DnsName)), kT2Qtype,
+        new DnsResponse(reinterpret_cast<const char*>(kT2ResponseDatagram),
+                        arraysize(kT2ResponseDatagram),
+                        arraysize(kT2QueryDatagram)));
 
-    factory_.AddSocketDataProvider(data0_.get());
-    factory_.AddSocketDataProvider(data1_.get());
-    factory_.AddSocketDataProvider(data2_.get());
-    factory_.AddSocketDataProvider(data3_.get());
-
-    IPEndPoint dns_server;
-    bool rv0 = CreateDnsAddress(kDnsIp, kDnsPort, &dns_server);
-    DCHECK(rv0);
+    AddResponse(std::string(kT3DnsName, arraysize(kT3DnsName)), kT3Qtype,
+        new DnsResponse(reinterpret_cast<const char*>(kT3ResponseDatagram),
+                        arraysize(kT3ResponseDatagram),
+                        arraysize(kT3QueryDatagram)));
 
     resolver_.reset(
-        new AsyncHostResolver(
-            dns_server, kMaxTransactions, kMaxPendingRequests, rand_int_cb_,
-            HostCache::CreateDefaultCache(), &factory_, NULL));
+        new AsyncHostResolver(kMaxTransactions, kMaxPendingRequests,
+              HostCache::CreateDefaultCache(),
+              client_.get(), NULL));
+  }
+
+  void AddResponse(const std::string& name, uint8 type, DnsResponse* response) {
+    client_->responses[MockDnsClient::Key(name, type)] = response;
   }
 
  protected:
   AddressList addrlist0_, addrlist1_, addrlist2_, addrlist3_;
   HostResolver::RequestInfo info0_, info1_, info2_, info3_;
-  std::vector<MockWrite> writes0_, writes1_, writes2_, writes3_;
-  std::vector<MockRead> reads0_, reads1_, reads2_, reads3_;
-  scoped_ptr<StaticSocketDataProvider> data0_, data1_, data2_, data3_;
   std::vector<const char*> ip_addresses0_, ip_addresses1_,
     ip_addresses2_, ip_addresses3_;
-  MockClientSocketFactory factory_;
-  TestPrng test_prng_;
-  RandIntCallback rand_int_cb_;
   scoped_ptr<HostResolver> resolver_;
+  scoped_ptr<MockDnsClient> client_;
   TestCompletionCallback callback0_, callback1_, callback2_, callback3_;
 };
 
 TEST_F(AsyncHostResolverTest, EmptyHostLookup) {
   info0_.set_host_port_pair(HostPortPair("", kPortNum));
   int rv = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                               BoundNetLog());
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
@@ skipping 75 matching lines @@
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses1_, kPortNum, addrlist1_);
 
   rv2 = callback2_.WaitForResult();
   EXPECT_EQ(OK, rv2);
   VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_);
 
-  EXPECT_EQ(3u, factory_.udp_client_sockets().size());
+  EXPECT_EQ(3, client_->num_requests);
 }
 
 TEST_F(AsyncHostResolverTest, SameHostLookupsConsumeSingleTransaction) {
   // We pass the info0_ to all requests.
   int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
   int rv1 = resolver_->Resolve(info0_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   int rv2 = resolver_->Resolve(info0_, &addrlist2_, callback2_.callback(), NULL,
                                BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv0);
   EXPECT_EQ(ERR_IO_PENDING, rv1);
   EXPECT_EQ(ERR_IO_PENDING, rv2);
 
   rv0 = callback0_.WaitForResult();
   EXPECT_EQ(OK, rv0);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist0_);
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_);
 
   rv2 = callback2_.WaitForResult();
   EXPECT_EQ(OK, rv2);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist2_);
 
   // Although we have three lookups, a single UDP socket was used.
-  EXPECT_EQ(1u, factory_.udp_client_sockets().size());
+  EXPECT_EQ(1, client_->num_requests);
 }
 
 TEST_F(AsyncHostResolverTest, CancelLookup) {
   HostResolver::RequestHandle req0 = NULL, req2 = NULL;
   int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(),
                                &req0, BoundNetLog());
   int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
   int rv2 = resolver_->Resolve(info2_, &addrlist2_, callback2_.callback(),
                                &req2, BoundNetLog());
@@ skipping 28 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv1);
 
   resolver_->CancelRequest(req0);
   MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(callback0_.have_result());
 
   rv1 = callback1_.WaitForResult();
   EXPECT_EQ(OK, rv1);
   VerifyAddressList(ip_addresses0_, kPortNum, addrlist1_);
 
-  EXPECT_EQ(1u, factory_.udp_client_sockets().size());
+  EXPECT_EQ(1, client_->num_requests);
 }
 
 // Test that a queued lookup completes.
 TEST_F(AsyncHostResolverTest, QueuedLookup) {
   // kMaxTransactions is 2, thus the following requests consume all
   // available transactions.
   int rv0 = resolver_->Resolve(info0_, &addrlist0_, callback0_.callback(), NULL,
                                BoundNetLog());
   int rv1 = resolver_->Resolve(info1_, &addrlist1_, callback1_.callback(), NULL,
                                BoundNetLog());
@@ skipping 148 matching lines @@
   rv_fail = callback_fail.WaitForResult();
   EXPECT_EQ(ERR_HOST_RESOLVER_QUEUE_TOO_LARGE, rv_fail);
   EXPECT_EQ(static_cast<addrinfo*>(NULL), addrlist_fail.head());
 
   rv2 = callback2_.WaitForResult();
   EXPECT_EQ(OK, rv2);
   VerifyAddressList(ip_addresses2_, kPortNum, addrlist2_);
 }
 
 }  // namespace net