shill/dns_client_test.cc - third_party/platform2 - Git at Google

 // Copyright 2018 The ChromiumOS Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "shill/dns_client.h"

 #include <netdb.h>
 #include <sys/time.h>

 #include <memory>
 #include <string>
 #include <vector>

 #include <base/functional/bind.h>
 #include <base/strings/stringprintf.h>
 #include <base/test/task_environment.h>
 #include <base/time/time.h>
 #include <net-base/mock_socket.h>

 #include "shill/error.h"
 #include "shill/mock_ares.h"
 #include "shill/mock_event_dispatcher.h"

 using testing::_;
 using testing::DoAll;
 using testing::Not;
 using testing::Return;
 using testing::ReturnArg;
 using testing::SetArgPointee;
 using testing::StrEq;
 using testing::StrictMock;
 using testing::Test;

 namespace shill {

 namespace {
 const char kGoodName[] = "all-systems.mcast.net";
 const char kResult[] = "224.0.0.1";
 const char kGoodServer[] = "8.8.8.8";
 const char kBadServer[] = "10.9xx8.7";
 const char kNetworkInterface[] = "eth0";
 char kReturnAddressList0[] = {static_cast<char>(224), 0, 0, 1};
 char* kReturnAddressList[] = {kReturnAddressList0, nullptr};
 char kFakeAresChannelData = 0;
 const ares_channel kAresChannel =
     reinterpret_cast<ares_channel>(&kFakeAresChannelData);
 const base::TimeDelta kAresTimeout =
     base::Seconds(2);  // ARES transaction timeout
 const base::TimeDelta kAresWait =
     base::Seconds(1);  // Time period ARES asks caller to wait

 // Matches the base::expected<net_base::IPAddress, Error> argument that has
 // value.
 MATCHER(HasValue, "") {
   return arg.has_value();
 }

 // Matches the base::expected<net_base::IPAddress, Error> argument that has
 // error.
 MATCHER_P2(IsError, error_type, error_message, "") {
   return !arg.has_value() && error_type == arg.error().type() &&
          error_message == arg.error().message();
 }

 }  // namespace

 class DnsClientTest : public Test {
  public:
   DnsClientTest() : ares_result_(ARES_SUCCESS), address_result_(std::nullopt) {
     hostent_.h_addrtype = net_base::ToSAFamily(net_base::IPFamily::kIPv4);
     hostent_.h_length = sizeof(kReturnAddressList0);
     hostent_.h_addr_list = kReturnAddressList;
   }

   void SetUp() override { SetInActive(); }

   void TearDown() override {
     // We need to make sure the dns_client instance releases ares_
     // before the destructor for DnsClientTest deletes ares_.
     if (dns_client_) {
       dns_client_->Stop();
     }
   }

   void CallReplyCB() {
     dns_client_->ReceiveDnsReplyCB(dns_client_.get(), ares_result_, 0,
                                    &hostent_);
   }

   void CallDnsRead() { dns_client_->HandleDnsRead(fake_ares_socket_.Get()); }

   void CallDnsWrite() { dns_client_->HandleDnsWrite(fake_ares_socket_.Get()); }

   void CallTimeout() { dns_client_->HandleTimeout(); }

   void CallCompletion() { dns_client_->HandleCompletion(); }

   void CreateClient(base::TimeDelta timeout) {
     dns_client_ = std::make_unique<DnsClient>(
         net_base::IPFamily::kIPv4, kNetworkInterface, timeout, &dispatcher_,
         callback_target_.callback());
     dns_client_->ares_ = &ares_;
   }

   void SetActive() {
     const struct timeval ares_timeout = {
         .tv_sec = static_cast<time_t>(kAresWait.InSeconds()),
         .tv_usec = static_cast<suseconds_t>(kAresWait.InMicroseconds() %
                                             base::Time::kMicrosecondsPerSecond),
     };

     // Returns that ares socket is readable.
     EXPECT_CALL(ares_, GetSock(_, _, _))
         .WillRepeatedly(
             DoAll(SetArgPointee<1>(fake_ares_socket_.Get()), Return(1)));
     EXPECT_CALL(ares_, Timeout(_, _, _))
         .WillRepeatedly(DoAll(SetArgPointee<2>(ares_timeout), ReturnArg<2>()));
   }

   void SetInActive() {
     EXPECT_CALL(ares_, GetSock(_, _, _)).WillRepeatedly(Return(0));
     EXPECT_CALL(ares_, Timeout(_, _, _)).WillRepeatedly(ReturnArg<1>());
   }

   void StartValidRequest() {
     CreateClient(kAresTimeout);

     SetActive();
     EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
     EXPECT_CALL(ares_, InitOptions(_, _, _))
         .WillOnce(DoAll(SetArgPointee<0>(kAresChannel), Return(ARES_SUCCESS)));
     EXPECT_CALL(ares_, SetLocalDev(kAresChannel, StrEq(kNetworkInterface)))
         .Times(1);
     EXPECT_CALL(ares_, SetServersCsv(_, StrEq(kGoodServer)))
         .WillOnce(Return(ARES_SUCCESS));
     EXPECT_CALL(ares_, GetHostByName(kAresChannel, StrEq(kGoodName), _, _, _));
     EXPECT_CALL(ares_, Destroy(kAresChannel));

     Error error;
     ASSERT_TRUE(dns_client_->Start({kGoodServer}, kGoodName, &error));
     EXPECT_TRUE(error.IsSuccess());
   }

   void TestValidCompletion() {
     EXPECT_CALL(ares_, ProcessFd(kAresChannel, fake_ares_socket_.Get(),
                                  ARES_SOCKET_BAD))
         .WillOnce(InvokeWithoutArgs(this, &DnsClientTest::CallReplyCB));
     ExpectPostCompletionTask();
     CallDnsRead();

     // Make sure that the address value is correct as held in the DnsClient.
     const auto ipaddr = *net_base::IPAddress::CreateFromString(kResult);
     EXPECT_EQ(ipaddr, dns_client_->address_);

     // Make sure the callback gets called with a success result, and save
     // the callback address argument in |address_result_|.
     EXPECT_CALL(callback_target_, CallTarget(HasValue()))
         .WillOnce(Invoke(this, &DnsClientTest::SaveCallbackArgs));
     CallCompletion();

     // Make sure the address was successfully passed to the callback.
     EXPECT_EQ(ipaddr, address_result_);
     EXPECT_TRUE(dns_client_->address_.IsZero());
   }

   void SaveCallbackArgs(
       const base::expected<net_base::IPAddress, Error>& address) {
     if (address.has_value()) {
       address_result_ = *address;
     } else {
       error_result_ = address.error();
     }
   }

   void ExpectPostCompletionTask() {
     EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, base::TimeDelta()));
   }

   void ExpectReset() {
     EXPECT_TRUE(dns_client_->address_.GetFamily() == net_base::IPFamily::kIPv4);
     EXPECT_TRUE(dns_client_->address_.IsZero());
     EXPECT_EQ(nullptr, dns_client_->resolver_state_);
   }

  protected:
   class DnsCallbackTarget {
    public:
     DnsCallbackTarget()
         : callback_(base::BindRepeating(&DnsCallbackTarget::CallTarget,
                                         base::Unretained(this))) {}

     MOCK_METHOD(void,
                 CallTarget,
                 ((const base::expected<net_base::IPAddress, Error>&)));

     const DnsClient::ClientCallback& callback() const { return callback_; }

    private:
     DnsClient::ClientCallback callback_;
   };

   base::test::TaskEnvironment task_environment_{
       // required by base::FileDescriptorWatcher.
       base::test::TaskEnvironment::MainThreadType::IO,

       // required by base::TimeTicks::Now().
       base::test::TaskEnvironment::TimeSource::MOCK_TIME};
   net_base::MockSocket fake_ares_socket_;

   std::unique_ptr<DnsClient> dns_client_;
   StrictMock<MockEventDispatcher> dispatcher_;
   std::string queued_request_;
   StrictMock<DnsCallbackTarget> callback_target_;
   StrictMock<MockAres> ares_;
   struct hostent hostent_;
   int ares_result_;
   Error error_result_;
   std::optional<net_base::IPAddress> address_result_;
 };

 TEST_F(DnsClientTest, Constructor) {
   CreateClient(kAresTimeout);
   ExpectReset();
 }

 // Correctly handles empty server addresses.
 TEST_F(DnsClientTest, ServerJoin) {
   CreateClient(kAresTimeout);
   EXPECT_CALL(ares_, InitOptions(_, _, _))
       .WillOnce(DoAll(SetArgPointee<0>(kAresChannel), Return(ARES_SUCCESS)));
   EXPECT_CALL(ares_, SetServersCsv(_, StrEq(kGoodServer)))
       .WillOnce(Return(ARES_SUCCESS));
   EXPECT_CALL(ares_, SetLocalDev(kAresChannel, StrEq(kNetworkInterface)))
       .Times(1);
   EXPECT_CALL(ares_, GetHostByName(kAresChannel, StrEq(kGoodName), _, _, _));

   SetActive();
   EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
   Error error;
   ASSERT_TRUE(dns_client_->Start({"", kGoodServer, "", ""}, kGoodName, &error));
   EXPECT_TRUE(error.IsSuccess());
   EXPECT_CALL(ares_, Destroy(kAresChannel));
 }

 // Receive error because no DNS servers were specified.
 TEST_F(DnsClientTest, NoServers) {
   CreateClient(kAresTimeout);
   Error error;
   EXPECT_FALSE(dns_client_->Start({}, kGoodName, &error));
   EXPECT_EQ(Error::kInvalidArguments, error.type());
 }

 // Setup error because SetServersCsv failed due to invalid DNS servers.
 TEST_F(DnsClientTest, SetServersCsvInvalidServer) {
   CreateClient(kAresTimeout);
   EXPECT_CALL(ares_, InitOptions(_, _, _)).WillOnce(Return(ARES_SUCCESS));
   EXPECT_CALL(ares_, SetServersCsv(_, StrEq(kBadServer)))
       .WillOnce(Return(ARES_EBADSTR));
   Error error;
   EXPECT_FALSE(dns_client_->Start({kBadServer}, kGoodName, &error));
   EXPECT_EQ(Error::kOperationFailed, error.type());
 }

 // Setup error because InitOptions failed.
 TEST_F(DnsClientTest, InitOptionsFailure) {
   CreateClient(kAresTimeout);
   EXPECT_CALL(ares_, InitOptions(_, _, _)).WillOnce(Return(ARES_EBADFLAGS));
   Error error;
   EXPECT_FALSE(dns_client_->Start({kGoodServer}, kGoodName, &error));
   EXPECT_EQ(Error::kOperationFailed, error.type());
 }

 // Fail a second request because one is already in progress.
 TEST_F(DnsClientTest, MultipleRequest) {
   StartValidRequest();
   EXPECT_TRUE(dns_client_->IsActive());
   Error error;
   ASSERT_FALSE(dns_client_->Start({kGoodServer}, kGoodName, &error));
   EXPECT_EQ(Error::kInProgress, error.type());
 }

 TEST_F(DnsClientTest, GoodRequest) {
   StartValidRequest();
   TestValidCompletion();
 }

 TEST_F(DnsClientTest, GoodRequestWithTimeout) {
   StartValidRequest();
   // Insert an intermediate HandleTimeout callback.
   task_environment_.FastForwardBy(kAresWait);
   EXPECT_CALL(ares_, ProcessFd(kAresChannel, ARES_SOCKET_BAD, ARES_SOCKET_BAD));
   EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
   CallTimeout();
   task_environment_.FastForwardBy(kAresWait);
   TestValidCompletion();
 }

 TEST_F(DnsClientTest, GoodRequestWithDnsRead) {
   StartValidRequest();
   // Insert an intermediate HandleDnsRead callback.
   task_environment_.FastForwardBy(kAresWait);
   EXPECT_CALL(
       ares_, ProcessFd(kAresChannel, fake_ares_socket_.Get(), ARES_SOCKET_BAD));
   EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
   CallDnsRead();
   task_environment_.FastForwardBy(kAresWait);
   TestValidCompletion();
 }

 TEST_F(DnsClientTest, GoodRequestWithDnsWrite) {
   StartValidRequest();
   // Insert an intermediate HandleDnsWrite callback.
   task_environment_.FastForwardBy(kAresWait);
   EXPECT_CALL(
       ares_, ProcessFd(kAresChannel, ARES_SOCKET_BAD, fake_ares_socket_.Get()));
   EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
   CallDnsWrite();
   task_environment_.FastForwardBy(kAresWait);
   TestValidCompletion();
 }

 // Failure due to the timeout occurring during first call to RefreshHandles.
 TEST_F(DnsClientTest, TimeoutFirstRefresh) {
   CreateClient(kAresTimeout);
   EXPECT_CALL(ares_, InitOptions(_, _, _))
       .WillOnce(DoAll(SetArgPointee<0>(kAresChannel), Return(ARES_SUCCESS)));
   EXPECT_CALL(ares_, SetLocalDev(kAresChannel, StrEq(kNetworkInterface)))
       .Times(1);
   EXPECT_CALL(ares_, SetServersCsv(_, StrEq(kGoodServer)))
       .WillOnce(Return(ARES_SUCCESS));
   EXPECT_CALL(ares_, GetHostByName(kAresChannel, StrEq(kGoodName), _, _, _))
       .WillOnce([&]() {
         // Simulate the function call takes a long time.
         task_environment_.FastForwardBy(kAresTimeout);
       });
   EXPECT_CALL(callback_target_, CallTarget(Not(HasValue()))).Times(0);
   EXPECT_CALL(ares_, Destroy(kAresChannel));
   Error error;
   // Expect the DnsClient to post a completion task.  However this task will
   // never run since the Stop() gets called before returning.  We confirm
   // that the task indeed gets canceled below in ExpectReset().
   ExpectPostCompletionTask();
   ASSERT_FALSE(dns_client_->Start({kGoodServer}, kGoodName, &error));

   EXPECT_EQ(Error::kOperationTimeout, error.type());
   EXPECT_EQ(std::string(DnsClient::kErrorTimedOut), error.message());
   ExpectReset();
 }

 // Failed request due to timeout within the dns_client.
 TEST_F(DnsClientTest, TimeoutDispatcherEvent) {
   StartValidRequest();
   EXPECT_CALL(ares_, ProcessFd(kAresChannel, ARES_SOCKET_BAD, ARES_SOCKET_BAD));
   task_environment_.FastForwardBy(kAresTimeout);
   ExpectPostCompletionTask();
   CallTimeout();
   EXPECT_CALL(callback_target_, CallTarget(IsError(Error::kOperationTimeout,
                                                    DnsClient::kErrorTimedOut)));
   CallCompletion();
 }

 // Failed request due to timeout reported by ARES.
 TEST_F(DnsClientTest, TimeoutFromARES) {
   StartValidRequest();
   task_environment_.FastForwardBy(kAresWait);
   ares_result_ = ARES_ETIMEOUT;
   EXPECT_CALL(ares_, ProcessFd(kAresChannel, ARES_SOCKET_BAD, ARES_SOCKET_BAD))
       .WillOnce(InvokeWithoutArgs(this, &DnsClientTest::CallReplyCB));
   ExpectPostCompletionTask();
   CallTimeout();
   EXPECT_CALL(callback_target_, CallTarget(IsError(Error::kOperationTimeout,
                                                    DnsClient::kErrorTimedOut)));
   CallCompletion();
 }

 // Failed request due to "host not found" reported by ARES.
 TEST_F(DnsClientTest, HostNotFound) {
   StartValidRequest();
   task_environment_.FastForwardBy(kAresWait);
   ares_result_ = ARES_ENOTFOUND;
   EXPECT_CALL(ares_,
               ProcessFd(kAresChannel, fake_ares_socket_.Get(), ARES_SOCKET_BAD))
       .WillOnce(InvokeWithoutArgs(this, &DnsClientTest::CallReplyCB));
   ExpectPostCompletionTask();
   CallDnsRead();
   EXPECT_CALL(callback_target_, CallTarget(IsError(Error::kOperationFailed,
                                                    DnsClient::kErrorNotFound)));
   CallCompletion();
 }

 }  // namespace shill
	// Copyright 2018 The ChromiumOS Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "shill/dns_client.h"

	#include <netdb.h>
	#include <sys/time.h>

	#include <memory>
	#include <string>
	#include <vector>

	#include <base/functional/bind.h>
	#include <base/strings/stringprintf.h>
	#include <base/test/task_environment.h>
	#include <base/time/time.h>
	#include <net-base/mock_socket.h>

	#include "shill/error.h"
	#include "shill/mock_ares.h"
	#include "shill/mock_event_dispatcher.h"

	using testing::_;
	using testing::DoAll;
	using testing::Not;
	using testing::Return;
	using testing::ReturnArg;
	using testing::SetArgPointee;
	using testing::StrEq;
	using testing::StrictMock;
	using testing::Test;

	namespace shill {

	namespace {
	const char kGoodName[] = "all-systems.mcast.net";
	const char kResult[] = "224.0.0.1";
	const char kGoodServer[] = "8.8.8.8";
	const char kBadServer[] = "10.9xx8.7";
	const char kNetworkInterface[] = "eth0";
	char kReturnAddressList0[] = {static_cast<char>(224), 0, 0, 1};
	char* kReturnAddressList[] = {kReturnAddressList0, nullptr};
	char kFakeAresChannelData = 0;
	const ares_channel kAresChannel =
	reinterpret_cast<ares_channel>(&kFakeAresChannelData);
	const base::TimeDelta kAresTimeout =
	base::Seconds(2); // ARES transaction timeout
	const base::TimeDelta kAresWait =
	base::Seconds(1); // Time period ARES asks caller to wait

	// Matches the base::expected<net_base::IPAddress, Error> argument that has
	// value.
	MATCHER(HasValue, "") {
	return arg.has_value();
	}

	// Matches the base::expected<net_base::IPAddress, Error> argument that has
	// error.
	MATCHER_P2(IsError, error_type, error_message, "") {
	return !arg.has_value() && error_type == arg.error().type() &&
	error_message == arg.error().message();
	}

	} // namespace

	class DnsClientTest : public Test {
	public:
	DnsClientTest() : ares_result_(ARES_SUCCESS), address_result_(std::nullopt) {
	hostent_.h_addrtype = net_base::ToSAFamily(net_base::IPFamily::kIPv4);
	hostent_.h_length = sizeof(kReturnAddressList0);
	hostent_.h_addr_list = kReturnAddressList;
	}

	void SetUp() override { SetInActive(); }

	void TearDown() override {
	// We need to make sure the dns_client instance releases ares_
	// before the destructor for DnsClientTest deletes ares_.
	if (dns_client_) {
	dns_client_->Stop();
	}
	}

	void CallReplyCB() {
	dns_client_->ReceiveDnsReplyCB(dns_client_.get(), ares_result_, 0,
	&hostent_);
	}

	void CallDnsRead() { dns_client_->HandleDnsRead(fake_ares_socket_.Get()); }

	void CallDnsWrite() { dns_client_->HandleDnsWrite(fake_ares_socket_.Get()); }

	void CallTimeout() { dns_client_->HandleTimeout(); }

	void CallCompletion() { dns_client_->HandleCompletion(); }

	void CreateClient(base::TimeDelta timeout) {
	dns_client_ = std::make_unique<DnsClient>(
	net_base::IPFamily::kIPv4, kNetworkInterface, timeout, &dispatcher_,
	callback_target_.callback());
	dns_client_->ares_ = &ares_;
	}

	void SetActive() {
	const struct timeval ares_timeout = {
	.tv_sec = static_cast<time_t>(kAresWait.InSeconds()),
	.tv_usec = static_cast<suseconds_t>(kAresWait.InMicroseconds() %
	base::Time::kMicrosecondsPerSecond),
	};

	// Returns that ares socket is readable.
	EXPECT_CALL(ares_, GetSock(_, _, _))
	.WillRepeatedly(
	DoAll(SetArgPointee<1>(fake_ares_socket_.Get()), Return(1)));
	EXPECT_CALL(ares_, Timeout(_, _, _))
	.WillRepeatedly(DoAll(SetArgPointee<2>(ares_timeout), ReturnArg<2>()));
	}

	void SetInActive() {
	EXPECT_CALL(ares_, GetSock(_, _, _)).WillRepeatedly(Return(0));
	EXPECT_CALL(ares_, Timeout(_, _, _)).WillRepeatedly(ReturnArg<1>());
	}

	void StartValidRequest() {
	CreateClient(kAresTimeout);

	SetActive();
	EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
	EXPECT_CALL(ares_, InitOptions(_, _, _))
	.WillOnce(DoAll(SetArgPointee<0>(kAresChannel), Return(ARES_SUCCESS)));
	EXPECT_CALL(ares_, SetLocalDev(kAresChannel, StrEq(kNetworkInterface)))
	.Times(1);
	EXPECT_CALL(ares_, SetServersCsv(_, StrEq(kGoodServer)))
	.WillOnce(Return(ARES_SUCCESS));
	EXPECT_CALL(ares_, GetHostByName(kAresChannel, StrEq(kGoodName), _, _, _));
	EXPECT_CALL(ares_, Destroy(kAresChannel));

	Error error;
	ASSERT_TRUE(dns_client_->Start({kGoodServer}, kGoodName, &error));
	EXPECT_TRUE(error.IsSuccess());
	}

	void TestValidCompletion() {
	EXPECT_CALL(ares_, ProcessFd(kAresChannel, fake_ares_socket_.Get(),
	ARES_SOCKET_BAD))
	.WillOnce(InvokeWithoutArgs(this, &DnsClientTest::CallReplyCB));
	ExpectPostCompletionTask();
	CallDnsRead();

	// Make sure that the address value is correct as held in the DnsClient.
	const auto ipaddr = *net_base::IPAddress::CreateFromString(kResult);
	EXPECT_EQ(ipaddr, dns_client_->address_);

	// Make sure the callback gets called with a success result, and save
	// the callback address argument in \|address_result_\|.
	EXPECT_CALL(callback_target_, CallTarget(HasValue()))
	.WillOnce(Invoke(this, &DnsClientTest::SaveCallbackArgs));
	CallCompletion();

	// Make sure the address was successfully passed to the callback.
	EXPECT_EQ(ipaddr, address_result_);
	EXPECT_TRUE(dns_client_->address_.IsZero());
	}

	void SaveCallbackArgs(
	const base::expected<net_base::IPAddress, Error>& address) {
	if (address.has_value()) {
	address_result_ = *address;
	} else {
	error_result_ = address.error();
	}
	}

	void ExpectPostCompletionTask() {
	EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, base::TimeDelta()));
	}

	void ExpectReset() {
	EXPECT_TRUE(dns_client_->address_.GetFamily() == net_base::IPFamily::kIPv4);
	EXPECT_TRUE(dns_client_->address_.IsZero());
	EXPECT_EQ(nullptr, dns_client_->resolver_state_);
	}

	protected:
	class DnsCallbackTarget {
	public:
	DnsCallbackTarget()
	: callback_(base::BindRepeating(&DnsCallbackTarget::CallTarget,
	base::Unretained(this))) {}

	MOCK_METHOD(void,
	CallTarget,
	((const base::expected<net_base::IPAddress, Error>&)));

	const DnsClient::ClientCallback& callback() const { return callback_; }

	private:
	DnsClient::ClientCallback callback_;
	};

	base::test::TaskEnvironment task_environment_{
	// required by base::FileDescriptorWatcher.
	base::test::TaskEnvironment::MainThreadType::IO,

	// required by base::TimeTicks::Now().
	base::test::TaskEnvironment::TimeSource::MOCK_TIME};
	net_base::MockSocket fake_ares_socket_;

	std::unique_ptr<DnsClient> dns_client_;
	StrictMock<MockEventDispatcher> dispatcher_;
	std::string queued_request_;
	StrictMock<DnsCallbackTarget> callback_target_;
	StrictMock<MockAres> ares_;
	struct hostent hostent_;
	int ares_result_;
	Error error_result_;
	std::optional<net_base::IPAddress> address_result_;
	};

	TEST_F(DnsClientTest, Constructor) {
	CreateClient(kAresTimeout);
	ExpectReset();
	}

	// Correctly handles empty server addresses.
	TEST_F(DnsClientTest, ServerJoin) {
	CreateClient(kAresTimeout);
	EXPECT_CALL(ares_, InitOptions(_, _, _))
	.WillOnce(DoAll(SetArgPointee<0>(kAresChannel), Return(ARES_SUCCESS)));
	EXPECT_CALL(ares_, SetServersCsv(_, StrEq(kGoodServer)))
	.WillOnce(Return(ARES_SUCCESS));
	EXPECT_CALL(ares_, SetLocalDev(kAresChannel, StrEq(kNetworkInterface)))
	.Times(1);
	EXPECT_CALL(ares_, GetHostByName(kAresChannel, StrEq(kGoodName), _, _, _));

	SetActive();
	EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
	Error error;
	ASSERT_TRUE(dns_client_->Start({"", kGoodServer, "", ""}, kGoodName, &error));
	EXPECT_TRUE(error.IsSuccess());
	EXPECT_CALL(ares_, Destroy(kAresChannel));
	}

	// Receive error because no DNS servers were specified.
	TEST_F(DnsClientTest, NoServers) {
	CreateClient(kAresTimeout);
	Error error;
	EXPECT_FALSE(dns_client_->Start({}, kGoodName, &error));
	EXPECT_EQ(Error::kInvalidArguments, error.type());
	}

	// Setup error because SetServersCsv failed due to invalid DNS servers.
	TEST_F(DnsClientTest, SetServersCsvInvalidServer) {
	CreateClient(kAresTimeout);
	EXPECT_CALL(ares_, InitOptions(_, _, _)).WillOnce(Return(ARES_SUCCESS));
	EXPECT_CALL(ares_, SetServersCsv(_, StrEq(kBadServer)))
	.WillOnce(Return(ARES_EBADSTR));
	Error error;
	EXPECT_FALSE(dns_client_->Start({kBadServer}, kGoodName, &error));
	EXPECT_EQ(Error::kOperationFailed, error.type());
	}

	// Setup error because InitOptions failed.
	TEST_F(DnsClientTest, InitOptionsFailure) {
	CreateClient(kAresTimeout);
	EXPECT_CALL(ares_, InitOptions(_, _, _)).WillOnce(Return(ARES_EBADFLAGS));
	Error error;
	EXPECT_FALSE(dns_client_->Start({kGoodServer}, kGoodName, &error));
	EXPECT_EQ(Error::kOperationFailed, error.type());
	}

	// Fail a second request because one is already in progress.
	TEST_F(DnsClientTest, MultipleRequest) {
	StartValidRequest();
	EXPECT_TRUE(dns_client_->IsActive());
	Error error;
	ASSERT_FALSE(dns_client_->Start({kGoodServer}, kGoodName, &error));
	EXPECT_EQ(Error::kInProgress, error.type());
	}

	TEST_F(DnsClientTest, GoodRequest) {
	StartValidRequest();
	TestValidCompletion();
	}

	TEST_F(DnsClientTest, GoodRequestWithTimeout) {
	StartValidRequest();
	// Insert an intermediate HandleTimeout callback.
	task_environment_.FastForwardBy(kAresWait);
	EXPECT_CALL(ares_, ProcessFd(kAresChannel, ARES_SOCKET_BAD, ARES_SOCKET_BAD));
	EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
	CallTimeout();
	task_environment_.FastForwardBy(kAresWait);
	TestValidCompletion();
	}

	TEST_F(DnsClientTest, GoodRequestWithDnsRead) {
	StartValidRequest();
	// Insert an intermediate HandleDnsRead callback.
	task_environment_.FastForwardBy(kAresWait);
	EXPECT_CALL(
	ares_, ProcessFd(kAresChannel, fake_ares_socket_.Get(), ARES_SOCKET_BAD));
	EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
	CallDnsRead();
	task_environment_.FastForwardBy(kAresWait);
	TestValidCompletion();
	}

	TEST_F(DnsClientTest, GoodRequestWithDnsWrite) {
	StartValidRequest();
	// Insert an intermediate HandleDnsWrite callback.
	task_environment_.FastForwardBy(kAresWait);
	EXPECT_CALL(
	ares_, ProcessFd(kAresChannel, ARES_SOCKET_BAD, fake_ares_socket_.Get()));
	EXPECT_CALL(dispatcher_, PostDelayedTask(_, _, kAresWait));
	CallDnsWrite();
	task_environment_.FastForwardBy(kAresWait);
	TestValidCompletion();
	}

	// Failure due to the timeout occurring during first call to RefreshHandles.
	TEST_F(DnsClientTest, TimeoutFirstRefresh) {
	CreateClient(kAresTimeout);
	EXPECT_CALL(ares_, InitOptions(_, _, _))
	.WillOnce(DoAll(SetArgPointee<0>(kAresChannel), Return(ARES_SUCCESS)));
	EXPECT_CALL(ares_, SetLocalDev(kAresChannel, StrEq(kNetworkInterface)))
	.Times(1);
	EXPECT_CALL(ares_, SetServersCsv(_, StrEq(kGoodServer)))
	.WillOnce(Return(ARES_SUCCESS));
	EXPECT_CALL(ares_, GetHostByName(kAresChannel, StrEq(kGoodName), _, _, _))
	.WillOnce([&]() {
	// Simulate the function call takes a long time.
	task_environment_.FastForwardBy(kAresTimeout);
	});
	EXPECT_CALL(callback_target_, CallTarget(Not(HasValue()))).Times(0);
	EXPECT_CALL(ares_, Destroy(kAresChannel));
	Error error;
	// Expect the DnsClient to post a completion task. However this task will
	// never run since the Stop() gets called before returning. We confirm
	// that the task indeed gets canceled below in ExpectReset().
	ExpectPostCompletionTask();
	ASSERT_FALSE(dns_client_->Start({kGoodServer}, kGoodName, &error));

	EXPECT_EQ(Error::kOperationTimeout, error.type());
	EXPECT_EQ(std::string(DnsClient::kErrorTimedOut), error.message());
	ExpectReset();
	}

	// Failed request due to timeout within the dns_client.
	TEST_F(DnsClientTest, TimeoutDispatcherEvent) {
	StartValidRequest();
	EXPECT_CALL(ares_, ProcessFd(kAresChannel, ARES_SOCKET_BAD, ARES_SOCKET_BAD));
	task_environment_.FastForwardBy(kAresTimeout);
	ExpectPostCompletionTask();
	CallTimeout();
	EXPECT_CALL(callback_target_, CallTarget(IsError(Error::kOperationTimeout,
	DnsClient::kErrorTimedOut)));
	CallCompletion();
	}

	// Failed request due to timeout reported by ARES.
	TEST_F(DnsClientTest, TimeoutFromARES) {
	StartValidRequest();
	task_environment_.FastForwardBy(kAresWait);
	ares_result_ = ARES_ETIMEOUT;
	EXPECT_CALL(ares_, ProcessFd(kAresChannel, ARES_SOCKET_BAD, ARES_SOCKET_BAD))
	.WillOnce(InvokeWithoutArgs(this, &DnsClientTest::CallReplyCB));
	ExpectPostCompletionTask();
	CallTimeout();
	EXPECT_CALL(callback_target_, CallTarget(IsError(Error::kOperationTimeout,
	DnsClient::kErrorTimedOut)));
	CallCompletion();
	}

	// Failed request due to "host not found" reported by ARES.
	TEST_F(DnsClientTest, HostNotFound) {
	StartValidRequest();
	task_environment_.FastForwardBy(kAresWait);
	ares_result_ = ARES_ENOTFOUND;
	EXPECT_CALL(ares_,
	ProcessFd(kAresChannel, fake_ares_socket_.Get(), ARES_SOCKET_BAD))
	.WillOnce(InvokeWithoutArgs(this, &DnsClientTest::CallReplyCB));
	ExpectPostCompletionTask();
	CallDnsRead();
	EXPECT_CALL(callback_target_, CallTarget(IsError(Error::kOperationFailed,
	DnsClient::kErrorNotFound)));
	CallCompletion();
	}

	} // namespace shill