shill/dhcp/dhcpv6_config_unittest.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2015 The Chromium OS 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 "shill/dhcp/dhcpv6_config.h"

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

 #include <base/bind.h>
 #include <base/files/file_util.h>
 #include <base/files/scoped_temp_dir.h>
 #include <base/strings/stringprintf.h>
 #include <chromeos/dbus/service_constants.h>
 #include <chromeos/minijail/mock_minijail.h>

 #include "shill/dbus_adaptor.h"
 #include "shill/dhcp/dhcp_provider.h"
 #include "shill/dhcp/mock_dhcp_proxy.h"
 #include "shill/event_dispatcher.h"
 #include "shill/mock_control.h"
 #include "shill/mock_glib.h"
 #include "shill/mock_log.h"
 #include "shill/mock_metrics.h"
 #include "shill/mock_proxy_factory.h"
 #include "shill/property_store_unittest.h"
 #include "shill/testing.h"

 using base::Bind;
 using base::FilePath;
 using base::ScopedTempDir;
 using base::Unretained;
 using chromeos::MockMinijail;
 using std::string;
 using std::unique_ptr;
 using std::vector;
 using testing::_;
 using testing::AnyNumber;
 using testing::ContainsRegex;
 using testing::InvokeWithoutArgs;
 using testing::Mock;
 using testing::Return;
 using testing::SetArgumentPointee;
 using testing::Test;

 namespace shill {

 namespace {
 const char kDeviceName[] = "eth0";
 const char kLeaseFileSuffix[] = "leasefilesuffix";
 const bool kHasLeaseSuffix = true;
 const char kIPAddress[] = "2001:db8:0:1::1";
 const char kDelegatedPrefix[] = "2001:db8:0:100::";
 }  // namespace

 typedef scoped_refptr<DHCPv6Config> DHCPv6ConfigRefPtr;

 class DHCPv6ConfigTest : public PropertyStoreTest {
  public:
   DHCPv6ConfigTest()
       : proxy_(new MockDHCPProxy()),
         minijail_(new MockMinijail()),
         config_(new DHCPv6Config(&control_,
                                  dispatcher(),
                                  DHCPProvider::GetInstance(),
                                  kDeviceName,
                                  kLeaseFileSuffix,
                                  glib())) {}

   virtual void SetUp() {
     config_->proxy_factory_ = &proxy_factory_;
     config_->minijail_ = minijail_.get();
   }

   virtual void TearDown() {
     config_->proxy_factory_ = nullptr;
     config_->minijail_ = nullptr;
   }

   bool StartInstance(DHCPv6ConfigRefPtr config) {
     return config->Start();
   }

   void StopInstance() {
     config_->Stop("In test");
   }

   DHCPv6ConfigRefPtr CreateMockMinijailConfig(const string& lease_suffix);
   DHCPv6ConfigRefPtr CreateRunningConfig(const string& lease_suffix);
   void StopRunningConfigAndExpect(DHCPv6ConfigRefPtr config,
                                   bool lease_file_exists);

  protected:
   static const int kPID;
   static const unsigned int kTag;

   FilePath lease_file_;
   FilePath pid_file_;
   ScopedTempDir temp_dir_;
   unique_ptr<MockDHCPProxy> proxy_;
   MockProxyFactory proxy_factory_;
   MockControl control_;
   unique_ptr<MockMinijail> minijail_;
   DHCPv6ConfigRefPtr config_;
 };

 const int DHCPv6ConfigTest::kPID = 123456;
 const unsigned int DHCPv6ConfigTest::kTag = 77;

 DHCPv6ConfigRefPtr DHCPv6ConfigTest::CreateMockMinijailConfig(
     const string& lease_suffix) {
   DHCPv6ConfigRefPtr config(new DHCPv6Config(&control_,
                                              dispatcher(),
                                              DHCPProvider::GetInstance(),
                                              kDeviceName,
                                              lease_suffix,
                                              glib()));
   config->minijail_ = minijail_.get();

   return config;
 }

 DHCPv6ConfigRefPtr DHCPv6ConfigTest::CreateRunningConfig(
     const string& lease_suffix) {
   DHCPv6ConfigRefPtr config(new DHCPv6Config(&control_,
                                              dispatcher(),
                                              DHCPProvider::GetInstance(),
                                              kDeviceName,
                                              lease_suffix,
                                              glib()));
   config->minijail_ = minijail_.get();
   EXPECT_CALL(*minijail_, RunAndDestroy(_, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(kPID), Return(true)));
   EXPECT_CALL(*glib(), ChildWatchAdd(kPID, _, _)).WillOnce(Return(kTag));
   EXPECT_TRUE(config->Start());
   EXPECT_EQ(kPID, config->pid_);
   EXPECT_EQ(config.get(), DHCPProvider::GetInstance()->GetConfig(kPID).get());
   EXPECT_EQ(kTag, config->child_watch_tag_);

   EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
   config->root_ = temp_dir_.path();
   FilePath varrun = temp_dir_.path().Append("var/run/dhcpcd");
   EXPECT_TRUE(base::CreateDirectory(varrun));
   pid_file_ = varrun.Append(base::StringPrintf("dhcpcd-%s-6.pid", kDeviceName));
   FilePath varlib = temp_dir_.path().Append("var/lib/dhcpcd");
   EXPECT_TRUE(base::CreateDirectory(varlib));
   lease_file_ =
       varlib.Append(base::StringPrintf("dhcpcd-%s.lease6", kDeviceName));
   EXPECT_EQ(0, base::WriteFile(pid_file_, "", 0));
   EXPECT_EQ(0, base::WriteFile(lease_file_, "", 0));
   EXPECT_TRUE(base::PathExists(pid_file_));
   EXPECT_TRUE(base::PathExists(lease_file_));

   return config;
 }

 void DHCPv6ConfigTest::StopRunningConfigAndExpect(DHCPv6ConfigRefPtr config,
                                                   bool lease_file_exists) {
   ScopedMockLog log;
   // We use a non-zero exit status so that we get the log message.
   EXPECT_CALL(log, Log(_, _, ::testing::EndsWith("status 10")));
   DHCPConfig::ChildWatchCallback(kPID, 10, config.get());
   EXPECT_EQ(nullptr, DHCPProvider::GetInstance()->GetConfig(kPID).get());

   EXPECT_FALSE(base::PathExists(pid_file_));
   EXPECT_EQ(lease_file_exists, base::PathExists(lease_file_));
 }

 TEST_F(DHCPv6ConfigTest, ParseConfiguration) {
   const char kConfigIPAddress[] = "2001:db8:0:1::129";
   const char kConfigDelegatedPrefix[] = "2001:db8:1:100::";
   const char kConfigNameServer[] = "fec8:0::1";
   const char kConfigDomainSearch[] = "example.domain";
   const uint32_t kConfigDelegatedPrefixLength = 56;
   const uint32_t kConfigIPAddressLeaseTime = 5;
   const uint32_t kConfigDelegatedPrefixLeaseTime = 10;

   DHCPConfig::Configuration conf;
   conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
       kConfigIPAddress);
   conf[DHCPv6Config::kConfigurationKeyIPAddressLeaseTime].writer()
       .append_uint32(kConfigIPAddressLeaseTime);
   conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer().append_string(
       kConfigDelegatedPrefix);
   conf[DHCPv6Config::kConfigurationKeyDelegatedPrefixLength].writer()
       .append_uint32(kConfigDelegatedPrefixLength);
   conf[DHCPv6Config::kConfigurationKeyDelegatedPrefixLeaseTime].writer()
       .append_uint32(kConfigDelegatedPrefixLeaseTime);
   {
     vector<string> dns;
     dns.push_back(kConfigNameServer);
     DBus::MessageIter writer =
         conf[DHCPv6Config::kConfigurationKeyDNS].writer();
     writer << dns;
   }
   {
     vector<string> domain_search;
     domain_search.push_back(kConfigDomainSearch);
     DBus::MessageIter writer =
         conf[DHCPv6Config::kConfigurationKeyDomainSearch].writer();
     writer << domain_search;
   }
   conf["UnknownKey"] = DBus::Variant();

   ASSERT_TRUE(config_->ParseConfiguration(conf));
   EXPECT_EQ(kConfigIPAddress, config_->properties_.address);
   EXPECT_EQ(kConfigDelegatedPrefix, config_->properties_.delegated_prefix);
   EXPECT_EQ(kConfigDelegatedPrefixLength,
             config_->properties_.delegated_prefix_length);
   ASSERT_EQ(1, config_->properties_.dns_servers.size());
   EXPECT_EQ(kConfigNameServer, config_->properties_.dns_servers[0]);
   ASSERT_EQ(1, config_->properties_.domain_search.size());
   EXPECT_EQ(kConfigDomainSearch, config_->properties_.domain_search[0]);
   // Use IP address lease time since it is shorter.
   EXPECT_EQ(kConfigIPAddressLeaseTime,
             config_->properties_.lease_duration_seconds);
 }

 MATCHER_P(IsDHCPCDv6Args, has_lease_suffix, "") {
   if (string(arg[0]) != "/sbin/dhcpcd" ||
       string(arg[1]) != "-B" ||
       string(arg[2]) != "-q" ||
       string(arg[3]) != "-6" ||
       string(arg[4]) != "-a") {
     return false;
   }

   int end_offset = 5;

   string device_arg = has_lease_suffix ?
       string(kDeviceName) + "=" + string(kLeaseFileSuffix) : kDeviceName;
   return string(arg[end_offset]) == device_arg &&
          arg[end_offset + 1] == nullptr;
 }

 TEST_F(DHCPv6ConfigTest, StartDhcpcd) {
   EXPECT_CALL(*minijail_, RunAndDestroy(_, IsDHCPCDv6Args(kHasLeaseSuffix), _))
       .WillOnce(Return(false));
   EXPECT_FALSE(StartInstance(config_));
 }


 namespace {

 class DHCPv6ConfigCallbackTest : public DHCPv6ConfigTest {
  public:
   virtual void SetUp() {
     DHCPv6ConfigTest::SetUp();
     config_->RegisterUpdateCallback(
         Bind(&DHCPv6ConfigCallbackTest::SuccessCallback, Unretained(this)));
     config_->RegisterFailureCallback(
         Bind(&DHCPv6ConfigCallbackTest::FailureCallback, Unretained(this)));
     ip_config_ = config_;
   }

   MOCK_METHOD2(SuccessCallback,
                void(const IPConfigRefPtr& ipconfig, bool new_lease_acquired));
   MOCK_METHOD1(FailureCallback, void(const IPConfigRefPtr& ipconfig));

   // The mock methods above take IPConfigRefPtr because this is the type
   // that the registered callbacks take.  This conversion of the DHCP
   // config ref pointer eases our work in setting up expectations.
   const IPConfigRefPtr& ConfigRef() { return ip_config_; }

  private:
   IPConfigRefPtr ip_config_;
 };

 }  // namespace

 TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalFail) {
   DHCPConfig::Configuration conf;
   conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
       kIPAddress);
   conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer().append_string(
       kDelegatedPrefix);
   EXPECT_CALL(*this, SuccessCallback(_, _)).Times(0);
   EXPECT_CALL(*this, FailureCallback(ConfigRef()));
   config_->ProcessEventSignal(DHCPv6Config::kReasonFail, conf);
   Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(config_->properties().address.empty());
 }

 TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalSuccess) {
   for (const auto& reason : { DHCPv6Config::kReasonBound,
                               DHCPv6Config::kReasonRebind,
                               DHCPv6Config::kReasonReboot,
                               DHCPv6Config::kReasonRenew }) {
     for (const auto lease_time_given : { false, true }) {
       DHCPConfig::Configuration conf;
       conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
           kIPAddress);
       conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer()
           .append_string(kDelegatedPrefix);
       if (lease_time_given) {
         const uint32_t kLeaseTime = 1;
         conf[DHCPv6Config::kConfigurationKeyIPAddressLeaseTime].writer()
             .append_uint32(kLeaseTime);
       }
       EXPECT_CALL(*this, SuccessCallback(ConfigRef(), true));
       EXPECT_CALL(*this, FailureCallback(_)).Times(0);
       config_->ProcessEventSignal(reason, conf);
       string failure_message = string(reason) + " failed with lease time " +
           (lease_time_given ? "given" : "not given");
       EXPECT_TRUE(Mock::VerifyAndClearExpectations(this)) << failure_message;
       EXPECT_EQ("2001:db8:0:1::1", config_->properties().address)
           << failure_message;
     }
   }
 }

 TEST_F(DHCPv6ConfigCallbackTest, StoppedDuringFailureCallback) {
   DHCPConfig::Configuration conf;
   conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
       kIPAddress);
   conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer()
       .append_string(kDelegatedPrefix);
   // Stop the DHCP config while it is calling the failure callback.  We
   // need to ensure that no callbacks are left running inadvertently as
   // a result.
   EXPECT_CALL(*this, FailureCallback(ConfigRef()))
       .WillOnce(InvokeWithoutArgs(this, &DHCPv6ConfigTest::StopInstance));
   config_->ProcessEventSignal(DHCPv6Config::kReasonFail, conf);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
 }

 TEST_F(DHCPv6ConfigCallbackTest, StoppedDuringSuccessCallback) {
   DHCPConfig::Configuration conf;
   conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
       kIPAddress);
   conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer()
       .append_string(kDelegatedPrefix);
   const uint32_t kLeaseTime = 1;
   conf[DHCPv6Config::kConfigurationKeyIPAddressLeaseTime].writer()
       .append_uint32(kLeaseTime);
   // Stop the DHCP config while it is calling the success callback.  This
   // can happen if the device has a static IP configuration and releases
   // the lease after accepting other network parameters from the DHCP
   // IPConfig properties.  We need to ensure that no callbacks are left
   // running inadvertently as a result.
   EXPECT_CALL(*this, SuccessCallback(ConfigRef(), true))
       .WillOnce(InvokeWithoutArgs(this, &DHCPv6ConfigTest::StopInstance));
   config_->ProcessEventSignal(DHCPv6Config::kReasonBound, conf);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
 }

 TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalUnknown) {
   DHCPConfig::Configuration conf;
   conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
       kIPAddress);
   conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer()
       .append_string(kDelegatedPrefix);
   static const char kReasonUnknown[] = "UNKNOWN_REASON";
   EXPECT_CALL(*this, SuccessCallback(_, _)).Times(0);
   EXPECT_CALL(*this, FailureCallback(_)).Times(0);
   config_->ProcessEventSignal(kReasonUnknown, conf);
   Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(config_->properties().address.empty());
 }

 TEST_F(DHCPv6ConfigTest, StartSuccessEphemeral) {
   DHCPv6ConfigRefPtr config =
       CreateRunningConfig(kDeviceName);
   StopRunningConfigAndExpect(config, false);
 }

 TEST_F(DHCPv6ConfigTest, StartSuccessPersistent) {
   DHCPv6ConfigRefPtr config =
       CreateRunningConfig(kLeaseFileSuffix);
   StopRunningConfigAndExpect(config, true);
 }

 }  // namespace shill
	// Copyright 2015 The Chromium OS 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 "shill/dhcp/dhcpv6_config.h"

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

	#include <base/bind.h>
	#include <base/files/file_util.h>
	#include <base/files/scoped_temp_dir.h>
	#include <base/strings/stringprintf.h>
	#include <chromeos/dbus/service_constants.h>
	#include <chromeos/minijail/mock_minijail.h>

	#include "shill/dbus_adaptor.h"
	#include "shill/dhcp/dhcp_provider.h"
	#include "shill/dhcp/mock_dhcp_proxy.h"
	#include "shill/event_dispatcher.h"
	#include "shill/mock_control.h"
	#include "shill/mock_glib.h"
	#include "shill/mock_log.h"
	#include "shill/mock_metrics.h"
	#include "shill/mock_proxy_factory.h"
	#include "shill/property_store_unittest.h"
	#include "shill/testing.h"

	using base::Bind;
	using base::FilePath;
	using base::ScopedTempDir;
	using base::Unretained;
	using chromeos::MockMinijail;
	using std::string;
	using std::unique_ptr;
	using std::vector;
	using testing::_;
	using testing::AnyNumber;
	using testing::ContainsRegex;
	using testing::InvokeWithoutArgs;
	using testing::Mock;
	using testing::Return;
	using testing::SetArgumentPointee;
	using testing::Test;

	namespace shill {

	namespace {
	const char kDeviceName[] = "eth0";
	const char kLeaseFileSuffix[] = "leasefilesuffix";
	const bool kHasLeaseSuffix = true;
	const char kIPAddress[] = "2001:db8:0:1::1";
	const char kDelegatedPrefix[] = "2001:db8:0:100::";
	} // namespace

	typedef scoped_refptr<DHCPv6Config> DHCPv6ConfigRefPtr;

	class DHCPv6ConfigTest : public PropertyStoreTest {
	public:
	DHCPv6ConfigTest()
	: proxy_(new MockDHCPProxy()),
	minijail_(new MockMinijail()),
	config_(new DHCPv6Config(&control_,
	dispatcher(),
	DHCPProvider::GetInstance(),
	kDeviceName,
	kLeaseFileSuffix,
	glib())) {}

	virtual void SetUp() {
	config_->proxy_factory_ = &proxy_factory_;
	config_->minijail_ = minijail_.get();
	}

	virtual void TearDown() {
	config_->proxy_factory_ = nullptr;
	config_->minijail_ = nullptr;
	}

	bool StartInstance(DHCPv6ConfigRefPtr config) {
	return config->Start();
	}

	void StopInstance() {
	config_->Stop("In test");
	}

	DHCPv6ConfigRefPtr CreateMockMinijailConfig(const string& lease_suffix);
	DHCPv6ConfigRefPtr CreateRunningConfig(const string& lease_suffix);
	void StopRunningConfigAndExpect(DHCPv6ConfigRefPtr config,
	bool lease_file_exists);

	protected:
	static const int kPID;
	static const unsigned int kTag;

	FilePath lease_file_;
	FilePath pid_file_;
	ScopedTempDir temp_dir_;
	unique_ptr<MockDHCPProxy> proxy_;
	MockProxyFactory proxy_factory_;
	MockControl control_;
	unique_ptr<MockMinijail> minijail_;
	DHCPv6ConfigRefPtr config_;
	};

	const int DHCPv6ConfigTest::kPID = 123456;
	const unsigned int DHCPv6ConfigTest::kTag = 77;

	DHCPv6ConfigRefPtr DHCPv6ConfigTest::CreateMockMinijailConfig(
	const string& lease_suffix) {
	DHCPv6ConfigRefPtr config(new DHCPv6Config(&control_,
	dispatcher(),
	DHCPProvider::GetInstance(),
	kDeviceName,
	lease_suffix,
	glib()));
	config->minijail_ = minijail_.get();

	return config;
	}

	DHCPv6ConfigRefPtr DHCPv6ConfigTest::CreateRunningConfig(
	const string& lease_suffix) {
	DHCPv6ConfigRefPtr config(new DHCPv6Config(&control_,
	dispatcher(),
	DHCPProvider::GetInstance(),
	kDeviceName,
	lease_suffix,
	glib()));
	config->minijail_ = minijail_.get();
	EXPECT_CALL(*minijail_, RunAndDestroy(_, _, _))
	.WillOnce(DoAll(SetArgumentPointee<2>(kPID), Return(true)));
	EXPECT_CALL(*glib(), ChildWatchAdd(kPID, _, _)).WillOnce(Return(kTag));
	EXPECT_TRUE(config->Start());
	EXPECT_EQ(kPID, config->pid_);
	EXPECT_EQ(config.get(), DHCPProvider::GetInstance()->GetConfig(kPID).get());
	EXPECT_EQ(kTag, config->child_watch_tag_);

	EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
	config->root_ = temp_dir_.path();
	FilePath varrun = temp_dir_.path().Append("var/run/dhcpcd");
	EXPECT_TRUE(base::CreateDirectory(varrun));
	pid_file_ = varrun.Append(base::StringPrintf("dhcpcd-%s-6.pid", kDeviceName));
	FilePath varlib = temp_dir_.path().Append("var/lib/dhcpcd");
	EXPECT_TRUE(base::CreateDirectory(varlib));
	lease_file_ =
	varlib.Append(base::StringPrintf("dhcpcd-%s.lease6", kDeviceName));
	EXPECT_EQ(0, base::WriteFile(pid_file_, "", 0));
	EXPECT_EQ(0, base::WriteFile(lease_file_, "", 0));
	EXPECT_TRUE(base::PathExists(pid_file_));
	EXPECT_TRUE(base::PathExists(lease_file_));

	return config;
	}

	void DHCPv6ConfigTest::StopRunningConfigAndExpect(DHCPv6ConfigRefPtr config,
	bool lease_file_exists) {
	ScopedMockLog log;
	// We use a non-zero exit status so that we get the log message.
	EXPECT_CALL(log, Log(_, _, ::testing::EndsWith("status 10")));
	DHCPConfig::ChildWatchCallback(kPID, 10, config.get());
	EXPECT_EQ(nullptr, DHCPProvider::GetInstance()->GetConfig(kPID).get());

	EXPECT_FALSE(base::PathExists(pid_file_));
	EXPECT_EQ(lease_file_exists, base::PathExists(lease_file_));
	}

	TEST_F(DHCPv6ConfigTest, ParseConfiguration) {
	const char kConfigIPAddress[] = "2001:db8:0:1::129";
	const char kConfigDelegatedPrefix[] = "2001:db8:1:100::";
	const char kConfigNameServer[] = "fec8:0::1";
	const char kConfigDomainSearch[] = "example.domain";
	const uint32_t kConfigDelegatedPrefixLength = 56;
	const uint32_t kConfigIPAddressLeaseTime = 5;
	const uint32_t kConfigDelegatedPrefixLeaseTime = 10;

	DHCPConfig::Configuration conf;
	conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
	kConfigIPAddress);
	conf[DHCPv6Config::kConfigurationKeyIPAddressLeaseTime].writer()
	.append_uint32(kConfigIPAddressLeaseTime);
	conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer().append_string(
	kConfigDelegatedPrefix);
	conf[DHCPv6Config::kConfigurationKeyDelegatedPrefixLength].writer()
	.append_uint32(kConfigDelegatedPrefixLength);
	conf[DHCPv6Config::kConfigurationKeyDelegatedPrefixLeaseTime].writer()
	.append_uint32(kConfigDelegatedPrefixLeaseTime);
	{
	vector<string> dns;
	dns.push_back(kConfigNameServer);
	DBus::MessageIter writer =
	conf[DHCPv6Config::kConfigurationKeyDNS].writer();
	writer << dns;
	}
	{
	vector<string> domain_search;
	domain_search.push_back(kConfigDomainSearch);
	DBus::MessageIter writer =
	conf[DHCPv6Config::kConfigurationKeyDomainSearch].writer();
	writer << domain_search;
	}
	conf["UnknownKey"] = DBus::Variant();

	ASSERT_TRUE(config_->ParseConfiguration(conf));
	EXPECT_EQ(kConfigIPAddress, config_->properties_.address);
	EXPECT_EQ(kConfigDelegatedPrefix, config_->properties_.delegated_prefix);
	EXPECT_EQ(kConfigDelegatedPrefixLength,
	config_->properties_.delegated_prefix_length);
	ASSERT_EQ(1, config_->properties_.dns_servers.size());
	EXPECT_EQ(kConfigNameServer, config_->properties_.dns_servers[0]);
	ASSERT_EQ(1, config_->properties_.domain_search.size());
	EXPECT_EQ(kConfigDomainSearch, config_->properties_.domain_search[0]);
	// Use IP address lease time since it is shorter.
	EXPECT_EQ(kConfigIPAddressLeaseTime,
	config_->properties_.lease_duration_seconds);
	}

	MATCHER_P(IsDHCPCDv6Args, has_lease_suffix, "") {
	if (string(arg[0]) != "/sbin/dhcpcd" \|\|
	string(arg[1]) != "-B" \|\|
	string(arg[2]) != "-q" \|\|
	string(arg[3]) != "-6" \|\|
	string(arg[4]) != "-a") {
	return false;
	}

	int end_offset = 5;

	string device_arg = has_lease_suffix ?
	string(kDeviceName) + "=" + string(kLeaseFileSuffix) : kDeviceName;
	return string(arg[end_offset]) == device_arg &&
	arg[end_offset + 1] == nullptr;
	}

	TEST_F(DHCPv6ConfigTest, StartDhcpcd) {
	EXPECT_CALL(*minijail_, RunAndDestroy(_, IsDHCPCDv6Args(kHasLeaseSuffix), _))
	.WillOnce(Return(false));
	EXPECT_FALSE(StartInstance(config_));
	}


	namespace {

	class DHCPv6ConfigCallbackTest : public DHCPv6ConfigTest {
	public:
	virtual void SetUp() {
	DHCPv6ConfigTest::SetUp();
	config_->RegisterUpdateCallback(
	Bind(&DHCPv6ConfigCallbackTest::SuccessCallback, Unretained(this)));
	config_->RegisterFailureCallback(
	Bind(&DHCPv6ConfigCallbackTest::FailureCallback, Unretained(this)));
	ip_config_ = config_;
	}

	MOCK_METHOD2(SuccessCallback,
	void(const IPConfigRefPtr& ipconfig, bool new_lease_acquired));
	MOCK_METHOD1(FailureCallback, void(const IPConfigRefPtr& ipconfig));

	// The mock methods above take IPConfigRefPtr because this is the type
	// that the registered callbacks take. This conversion of the DHCP
	// config ref pointer eases our work in setting up expectations.
	const IPConfigRefPtr& ConfigRef() { return ip_config_; }

	private:
	IPConfigRefPtr ip_config_;
	};

	} // namespace

	TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalFail) {
	DHCPConfig::Configuration conf;
	conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
	kIPAddress);
	conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer().append_string(
	kDelegatedPrefix);
	EXPECT_CALL(*this, SuccessCallback(_, _)).Times(0);
	EXPECT_CALL(*this, FailureCallback(ConfigRef()));
	config_->ProcessEventSignal(DHCPv6Config::kReasonFail, conf);
	Mock::VerifyAndClearExpectations(this);
	EXPECT_TRUE(config_->properties().address.empty());
	}

	TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalSuccess) {
	for (const auto& reason : { DHCPv6Config::kReasonBound,
	DHCPv6Config::kReasonRebind,
	DHCPv6Config::kReasonReboot,
	DHCPv6Config::kReasonRenew }) {
	for (const auto lease_time_given : { false, true }) {
	DHCPConfig::Configuration conf;
	conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
	kIPAddress);
	conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer()
	.append_string(kDelegatedPrefix);
	if (lease_time_given) {
	const uint32_t kLeaseTime = 1;
	conf[DHCPv6Config::kConfigurationKeyIPAddressLeaseTime].writer()
	.append_uint32(kLeaseTime);
	}
	EXPECT_CALL(*this, SuccessCallback(ConfigRef(), true));
	EXPECT_CALL(*this, FailureCallback(_)).Times(0);
	config_->ProcessEventSignal(reason, conf);
	string failure_message = string(reason) + " failed with lease time " +
	(lease_time_given ? "given" : "not given");
	EXPECT_TRUE(Mock::VerifyAndClearExpectations(this)) << failure_message;
	EXPECT_EQ("2001:db8:0:1::1", config_->properties().address)
	<< failure_message;
	}
	}
	}

	TEST_F(DHCPv6ConfigCallbackTest, StoppedDuringFailureCallback) {
	DHCPConfig::Configuration conf;
	conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
	kIPAddress);
	conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer()
	.append_string(kDelegatedPrefix);
	// Stop the DHCP config while it is calling the failure callback. We
	// need to ensure that no callbacks are left running inadvertently as
	// a result.
	EXPECT_CALL(*this, FailureCallback(ConfigRef()))
	.WillOnce(InvokeWithoutArgs(this, &DHCPv6ConfigTest::StopInstance));
	config_->ProcessEventSignal(DHCPv6Config::kReasonFail, conf);
	EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
	}

	TEST_F(DHCPv6ConfigCallbackTest, StoppedDuringSuccessCallback) {
	DHCPConfig::Configuration conf;
	conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
	kIPAddress);
	conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer()
	.append_string(kDelegatedPrefix);
	const uint32_t kLeaseTime = 1;
	conf[DHCPv6Config::kConfigurationKeyIPAddressLeaseTime].writer()
	.append_uint32(kLeaseTime);
	// Stop the DHCP config while it is calling the success callback. This
	// can happen if the device has a static IP configuration and releases
	// the lease after accepting other network parameters from the DHCP
	// IPConfig properties. We need to ensure that no callbacks are left
	// running inadvertently as a result.
	EXPECT_CALL(*this, SuccessCallback(ConfigRef(), true))
	.WillOnce(InvokeWithoutArgs(this, &DHCPv6ConfigTest::StopInstance));
	config_->ProcessEventSignal(DHCPv6Config::kReasonBound, conf);
	EXPECT_TRUE(Mock::VerifyAndClearExpectations(this));
	}

	TEST_F(DHCPv6ConfigCallbackTest, ProcessEventSignalUnknown) {
	DHCPConfig::Configuration conf;
	conf[DHCPv6Config::kConfigurationKeyIPAddress].writer().append_string(
	kIPAddress);
	conf[DHCPv6Config::kConfigurationKeyDelegatedPrefix].writer()
	.append_string(kDelegatedPrefix);
	static const char kReasonUnknown[] = "UNKNOWN_REASON";
	EXPECT_CALL(*this, SuccessCallback(_, _)).Times(0);
	EXPECT_CALL(*this, FailureCallback(_)).Times(0);
	config_->ProcessEventSignal(kReasonUnknown, conf);
	Mock::VerifyAndClearExpectations(this);
	EXPECT_TRUE(config_->properties().address.empty());
	}

	TEST_F(DHCPv6ConfigTest, StartSuccessEphemeral) {
	DHCPv6ConfigRefPtr config =
	CreateRunningConfig(kDeviceName);
	StopRunningConfigAndExpect(config, false);
	}

	TEST_F(DHCPv6ConfigTest, StartSuccessPersistent) {
	DHCPv6ConfigRefPtr config =
	CreateRunningConfig(kLeaseFileSuffix);
	StopRunningConfigAndExpect(config, true);
	}

	} // namespace shill