Home | History | Annotate | Download | only in dns 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/dns/single_request_host_resolver.h"
      6 
      7 #include "net/base/address_list.h"
      8 #include "net/base/net_errors.h"
      9 #include "net/base/net_log.h"
     10 #include "net/base/test_completion_callback.h"
     11 #include "net/dns/mock_host_resolver.h"
     12 #include "testing/gtest/include/gtest/gtest.h"
     13 
     14 namespace net {
     15 
     16 namespace {
     17 
     18 // Helper class used by SingleRequestHostResolverTest.Cancel test.
     19 // It checks that only one request is outstanding at a time, and that
     20 // it is cancelled before the class is destroyed.
     21 class HangingHostResolver : public HostResolver {
     22  public:
     23   HangingHostResolver() : outstanding_request_(NULL) {}
     24 
     25   virtual ~HangingHostResolver() {
     26     EXPECT_TRUE(!has_outstanding_request());
     27   }
     28 
     29   bool has_outstanding_request() const {
     30     return outstanding_request_ != NULL;
     31   }
     32 
     33   virtual int Resolve(const RequestInfo& info,
     34                       RequestPriority priority,
     35                       AddressList* addresses,
     36                       const CompletionCallback& callback,
     37                       RequestHandle* out_req,
     38                       const BoundNetLog& net_log) OVERRIDE {
     39     EXPECT_FALSE(has_outstanding_request());
     40     outstanding_request_ = reinterpret_cast<RequestHandle>(0x1234);
     41     *out_req = outstanding_request_;
     42 
     43     // Never complete this request! Caller is expected to cancel it
     44     // before destroying the resolver.
     45     return ERR_IO_PENDING;
     46   }
     47 
     48   virtual int ResolveFromCache(const RequestInfo& info,
     49                                AddressList* addresses,
     50                                const BoundNetLog& net_log) OVERRIDE {
     51     NOTIMPLEMENTED();
     52     return ERR_UNEXPECTED;
     53   }
     54 
     55   virtual void CancelRequest(RequestHandle req) OVERRIDE {
     56     EXPECT_TRUE(has_outstanding_request());
     57     EXPECT_EQ(req, outstanding_request_);
     58     outstanding_request_ = NULL;
     59   }
     60 
     61  private:
     62   RequestHandle outstanding_request_;
     63 
     64   DISALLOW_COPY_AND_ASSIGN(HangingHostResolver);
     65 };
     66 
     67 // Test that a regular end-to-end lookup returns the expected result.
     68 TEST(SingleRequestHostResolverTest, NormalResolve) {
     69   // Create a host resolver dependency that returns address "199.188.1.166"
     70   // for resolutions of "watsup".
     71   MockHostResolver resolver;
     72   resolver.rules()->AddIPLiteralRule("watsup", "199.188.1.166", std::string());
     73 
     74   SingleRequestHostResolver single_request_resolver(&resolver);
     75 
     76   // Resolve "watsup:90" using our SingleRequestHostResolver.
     77   AddressList addrlist;
     78   TestCompletionCallback callback;
     79   HostResolver::RequestInfo request(HostPortPair("watsup", 90));
     80   int rv = single_request_resolver.Resolve(
     81       request, DEFAULT_PRIORITY, &addrlist, callback.callback(), BoundNetLog());
     82   EXPECT_EQ(ERR_IO_PENDING, rv);
     83   EXPECT_EQ(OK, callback.WaitForResult());
     84 
     85   // Verify that the result is what we specified in the MockHostResolver.
     86   ASSERT_FALSE(addrlist.empty());
     87   EXPECT_EQ("199.188.1.166", addrlist.front().ToStringWithoutPort());
     88 }
     89 
     90 // Test that the Cancel() method cancels any outstanding request.
     91 TEST(SingleRequestHostResolverTest, Cancel) {
     92   HangingHostResolver resolver;
     93 
     94   {
     95     SingleRequestHostResolver single_request_resolver(&resolver);
     96 
     97     // Resolve "watsup:90" using our SingleRequestHostResolver.
     98     AddressList addrlist;
     99     TestCompletionCallback callback;
    100     HostResolver::RequestInfo request(HostPortPair("watsup", 90));
    101     int rv = single_request_resolver.Resolve(request,
    102                                              DEFAULT_PRIORITY,
    103                                              &addrlist,
    104                                              callback.callback(),
    105                                              BoundNetLog());
    106     EXPECT_EQ(ERR_IO_PENDING, rv);
    107     EXPECT_TRUE(resolver.has_outstanding_request());
    108   }
    109 
    110   // Now that the SingleRequestHostResolver has been destroyed, the
    111   // in-progress request should have been aborted.
    112   EXPECT_FALSE(resolver.has_outstanding_request());
    113 }
    114 
    115 // Test that the Cancel() method is a no-op when there is no outstanding
    116 // request.
    117 TEST(SingleRequestHostResolverTest, CancelWhileNoPendingRequest) {
    118   HangingHostResolver resolver;
    119   SingleRequestHostResolver single_request_resolver(&resolver);
    120   single_request_resolver.Cancel();
    121 
    122   // To pass, HangingHostResolver should not have received a cancellation
    123   // request (since there is nothing to cancel). If it does, it will crash.
    124 }
    125 
    126 } // namespace
    127 
    128 }  // namespace net
    129