patchpanel/network_monitor_service_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2020 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 "patchpanel/network_monitor_service.h"

 #include <memory>
 #include <linux/rtnetlink.h>

 #include <base/test/task_environment.h>
 #include <chromeos/dbus/service_constants.h>
 #include <gtest/gtest.h>

 #include "patchpanel/fake_shill_client.h"
 #include "shill/net/mock_rtnl_handler.h"

 namespace patchpanel {

 namespace {
 constexpr int kTestInterfaceIndex = 1;
 constexpr char kTestInterfaceName[] = "wlan0";

 MATCHER_P(IsNeighborGetMessage, address, "") {
   if (!(arg->type() == shill::RTNLMessage::kTypeNeighbor &&
         arg->flags() == NLM_F_REQUEST &&
         arg->mode() == shill::RTNLMessage::kModeGet &&
         arg->interface_index() == kTestInterfaceIndex &&
         arg->HasAttribute(NDA_DST)))
     return false;

   shill::IPAddress msg_address(arg->family(), arg->GetAttribute(NDA_DST));
   return msg_address == shill::IPAddress(address);
 }

 MATCHER_P(IsNeighborProbeMessage, address, "") {
   if (!(arg->type() == shill::RTNLMessage::kTypeNeighbor &&
         arg->flags() == NLM_F_REQUEST | NLM_F_REPLACE &&
         arg->mode() == shill::RTNLMessage::kModeAdd &&
         arg->neighbor_status().state == NUD_PROBE &&
         arg->interface_index() == kTestInterfaceIndex &&
         arg->HasAttribute(NDA_DST)))
     return false;

   shill::IPAddress msg_address(arg->family(), arg->GetAttribute(NDA_DST));
   return msg_address == shill::IPAddress(address);
 }

 shill::RTNLMessage* CreateIncomingRTNLMessage(
     const shill::RTNLMessage::Mode mode,
     const std::string& address,
     uint16_t nud_state) {
   auto* rtnl_response = new shill::RTNLMessage(
       shill::RTNLMessage::kTypeNeighbor, mode, 0, 0, 0, kTestInterfaceIndex,
       shill::IPAddress::kFamilyIPv4);

   rtnl_response->SetAttribute(NDA_DST, shill::IPAddress(address).address());
   if (mode == shill::RTNLMessage::kModeAdd) {
     rtnl_response->set_neighbor_status(
         shill::RTNLMessage::NeighborStatus(nud_state, 0, 0));
     rtnl_response->SetAttribute(
         NDA_LLADDR, shill::ByteString(std::vector<uint8_t>{1, 2, 3, 4, 5, 6}));
   }

   return rtnl_response;
 }

 shill::RTNLMessage* CreateNUDStateChangedMessage(const std::string& address,
                                                  uint16_t nud_state) {
   return CreateIncomingRTNLMessage(shill::RTNLMessage::kModeAdd, address,
                                    nud_state);
 }

 shill::RTNLMessage* CreateNeighborDeletedMessage(const std::string& address) {
   return CreateIncomingRTNLMessage(shill::RTNLMessage::kModeDelete, address, 0);
 }

 }  // namespace

 class NeighborLinkMonitorTest : public testing::Test {
  protected:
   void SetUp() override {
     mock_rtnl_handler_ = std::make_unique<shill::MockRTNLHandler>();
     link_monitor_ = std::make_unique<NeighborLinkMonitor>(
         kTestInterfaceIndex, kTestInterfaceName, mock_rtnl_handler_.get());
   }

   void TearDown() override {
     // We should make sure |mock_rtnl_handler_| is valid during the life time of
     // |link_monitor_|.
     link_monitor_ = nullptr;
     mock_rtnl_handler_ = nullptr;
   }

   void FastForwardOneActiveProbeInterval() {
     task_environment_.FastForwardBy(NeighborLinkMonitor::kActiveProbeInterval);
   }

   base::test::TaskEnvironment task_environment_{
       base::test::TaskEnvironment::TimeSource::MOCK_TIME};
   std::unique_ptr<shill::MockRTNLHandler> mock_rtnl_handler_;
   std::unique_ptr<NeighborLinkMonitor> link_monitor_;
 };

 TEST_F(NeighborLinkMonitorTest, SendNeighborGetMessageOnIPConfigChanged) {
   ShillClient::IPConfig ipconfig;
   ipconfig.ipv4_address = "1.2.3.4";
   ipconfig.ipv4_gateway = "1.2.3.5";
   ipconfig.ipv4_prefix_length = 24;
   // The second dns address is not in this subnet, and should be ignored by the
   // link monitor.
   ipconfig.ipv4_dns_addresses = {"1.2.3.6", "4.3.2.1"};

   // On ipconfig changed, the link monitor should send a get request for each
   // watching address, to fetch their current NUD state.
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborGetMessage("1.2.3.5"), _))
       .WillOnce(Return(true));
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborGetMessage("1.2.3.6"), _))
       .WillOnce(Return(true));

   link_monitor_->OnIPConfigChanged(ipconfig);
 }

 TEST_F(NeighborLinkMonitorTest, WatchLinkLocalIPv6DNSServerAddress) {
   ShillClient::IPConfig ipconfig;
   ipconfig.ipv6_address = "2401::1";
   ipconfig.ipv6_prefix_length = 64;
   ipconfig.ipv6_gateway = "fe80::1";
   ipconfig.ipv6_dns_addresses = {"fe80::2"};

   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborGetMessage("fe80::1"), _))
       .WillOnce(Return(true));
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborGetMessage("fe80::2"), _))
       .WillOnce(Return(true));

   link_monitor_->OnIPConfigChanged(ipconfig);
 }

 TEST_F(NeighborLinkMonitorTest, SendNeighborProbeMessage) {
   // Only the gateway should be in the wathing list.
   ShillClient::IPConfig ipconfig;
   ipconfig.ipv4_address = "1.2.3.4";
   ipconfig.ipv4_gateway = "1.2.3.5";
   ipconfig.ipv4_prefix_length = 24;
   link_monitor_->OnIPConfigChanged(ipconfig);

   // Creates a RTNL message about the NUD state of the gateway is NUD_REACHABLE
   // now. A probe message should be sent immediately after we know this address.
   std::unique_ptr<shill::RTNLMessage> address_is_reachable(
       CreateNUDStateChangedMessage("1.2.3.5", NUD_REACHABLE));
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
       .WillOnce(Return(true));
   link_monitor_->OnNeighborMessage(*address_is_reachable);

   // Another probe message should be sent when the timer is triggered.
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
       .WillOnce(Return(true));
   FastForwardOneActiveProbeInterval();

   // If the state changed to NUD_PROBE, we should not probe this address again
   // when the timer is triggered.
   std::unique_ptr<shill::RTNLMessage> address_is_probing(
       CreateNUDStateChangedMessage("1.2.3.5", NUD_PROBE));
   link_monitor_->OnNeighborMessage(*address_is_probing);
   FastForwardOneActiveProbeInterval();

   // The gateway is removed in the kernel. A get request should be sent when the
   // timer is triggered.
   std::unique_ptr<shill::RTNLMessage> address_is_removed(
       CreateNeighborDeletedMessage("1.2.3.5"));
   link_monitor_->OnNeighborMessage(*address_is_removed);
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborGetMessage("1.2.3.5"), _))
       .WillOnce(Return(true));
   FastForwardOneActiveProbeInterval();
 }

 TEST_F(NeighborLinkMonitorTest, UpdateWatchingEntries) {
   ShillClient::IPConfig ipconfig;
   ipconfig.ipv4_address = "1.2.3.4";
   ipconfig.ipv4_gateway = "1.2.3.5";
   ipconfig.ipv4_dns_addresses = {"1.2.3.6"};
   ipconfig.ipv4_prefix_length = 24;
   link_monitor_->OnIPConfigChanged(ipconfig);

   ipconfig.ipv4_dns_addresses = {"1.2.3.7"};
   // The watching list should be updated to {"1.2.3.5", "1.2.3.7"}, and only
   // "1.2.3.7" is an new entry, so it should be probed immediately.
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborGetMessage("1.2.3.7"), _))
       .WillOnce(Return(true));
   link_monitor_->OnIPConfigChanged(ipconfig);

   // Updates both addresses to NUD_PROBE (to avoid the link monitor sending a
   // probe request), and then NUD_REACHABLE state.
   std::unique_ptr<shill::RTNLMessage> addr_5_is_probing(
       CreateNUDStateChangedMessage("1.2.3.5", NUD_PROBE));
   std::unique_ptr<shill::RTNLMessage> addr_5_is_reachable(
       CreateNUDStateChangedMessage("1.2.3.5", NUD_REACHABLE));
   std::unique_ptr<shill::RTNLMessage> addr_7_is_probing(
       CreateNUDStateChangedMessage("1.2.3.7", NUD_PROBE));
   std::unique_ptr<shill::RTNLMessage> addr_7_is_reachable(
       CreateNUDStateChangedMessage("1.2.3.7", NUD_REACHABLE));
   link_monitor_->OnNeighborMessage(*addr_5_is_probing);
   link_monitor_->OnNeighborMessage(*addr_5_is_reachable);
   link_monitor_->OnNeighborMessage(*addr_7_is_probing);
   link_monitor_->OnNeighborMessage(*addr_7_is_reachable);

   // Nothing should happen within one interval.
   task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(30));

   // Checks if probe requests sent for both addresses when the timer is
   // triggered.
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
       .WillOnce(Return(true));
   EXPECT_CALL(*mock_rtnl_handler_,
               DoSendMessage(IsNeighborProbeMessage("1.2.3.7"), _))
       .WillOnce(Return(true));
   FastForwardOneActiveProbeInterval();
 }

 class NetworkMonitorServiceTest : public testing::Test {
  protected:
   void SetUp() override {
     fake_shill_client_ = shill_helper_.FakeClient();
     monitor_svc_ =
         std::make_unique<NetworkMonitorService>(fake_shill_client_.get());
     mock_rtnl_handler_ = std::make_unique<shill::MockRTNLHandler>();
   }

   FakeShillClientHelper shill_helper_;
   std::unique_ptr<FakeShillClient> fake_shill_client_;
   std::unique_ptr<shill::MockRTNLHandler> mock_rtnl_handler_;
   std::unique_ptr<NetworkMonitorService> monitor_svc_;
 };

 TEST_F(NetworkMonitorServiceTest, StartRTNLHanlderOnServiceStart) {
   monitor_svc_->rtnl_handler_ = mock_rtnl_handler_.get();
   EXPECT_CALL(*mock_rtnl_handler_, Start(RTMGRP_NEIGH));
   monitor_svc_->Start();
 }

 TEST_F(NetworkMonitorServiceTest, CallGetDevicePropertiesOnNewDevice) {
   monitor_svc_->rtnl_handler_ = mock_rtnl_handler_.get();
   // Device added before service starts.
   std::vector<dbus::ObjectPath> devices = {dbus::ObjectPath("/device/eth0")};
   fake_shill_client_->NotifyManagerPropertyChange(shill::kDevicesProperty,
                                                   brillo::Any(devices));
   monitor_svc_->Start();

   // Device added after service starts.
   devices.emplace_back(dbus::ObjectPath("/device/wlan0"));
   fake_shill_client_->NotifyManagerPropertyChange(shill::kDevicesProperty,
                                                   brillo::Any(devices));
   const std::set<std::string>& calls =
       fake_shill_client_->get_device_properties_calls();
   EXPECT_EQ(calls.size(), 2);
   EXPECT_NE(calls.find("eth0"), calls.end());
   EXPECT_NE(calls.find("wlan0"), calls.end());
 }

 }  // namespace patchpanel
	// Copyright 2020 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 "patchpanel/network_monitor_service.h"

	#include <memory>
	#include <linux/rtnetlink.h>

	#include <base/test/task_environment.h>
	#include <chromeos/dbus/service_constants.h>
	#include <gtest/gtest.h>

	#include "patchpanel/fake_shill_client.h"
	#include "shill/net/mock_rtnl_handler.h"

	namespace patchpanel {

	namespace {
	constexpr int kTestInterfaceIndex = 1;
	constexpr char kTestInterfaceName[] = "wlan0";

	MATCHER_P(IsNeighborGetMessage, address, "") {
	if (!(arg->type() == shill::RTNLMessage::kTypeNeighbor &&
	arg->flags() == NLM_F_REQUEST &&
	arg->mode() == shill::RTNLMessage::kModeGet &&
	arg->interface_index() == kTestInterfaceIndex &&
	arg->HasAttribute(NDA_DST)))
	return false;

	shill::IPAddress msg_address(arg->family(), arg->GetAttribute(NDA_DST));
	return msg_address == shill::IPAddress(address);
	}

	MATCHER_P(IsNeighborProbeMessage, address, "") {
	if (!(arg->type() == shill::RTNLMessage::kTypeNeighbor &&
	arg->flags() == NLM_F_REQUEST \| NLM_F_REPLACE &&
	arg->mode() == shill::RTNLMessage::kModeAdd &&
	arg->neighbor_status().state == NUD_PROBE &&
	arg->interface_index() == kTestInterfaceIndex &&
	arg->HasAttribute(NDA_DST)))
	return false;

	shill::IPAddress msg_address(arg->family(), arg->GetAttribute(NDA_DST));
	return msg_address == shill::IPAddress(address);
	}

	shill::RTNLMessage* CreateIncomingRTNLMessage(
	const shill::RTNLMessage::Mode mode,
	const std::string& address,
	uint16_t nud_state) {
	auto* rtnl_response = new shill::RTNLMessage(
	shill::RTNLMessage::kTypeNeighbor, mode, 0, 0, 0, kTestInterfaceIndex,
	shill::IPAddress::kFamilyIPv4);

	rtnl_response->SetAttribute(NDA_DST, shill::IPAddress(address).address());
	if (mode == shill::RTNLMessage::kModeAdd) {
	rtnl_response->set_neighbor_status(
	shill::RTNLMessage::NeighborStatus(nud_state, 0, 0));
	rtnl_response->SetAttribute(
	NDA_LLADDR, shill::ByteString(std::vector<uint8_t>{1, 2, 3, 4, 5, 6}));
	}

	return rtnl_response;
	}

	shill::RTNLMessage* CreateNUDStateChangedMessage(const std::string& address,
	uint16_t nud_state) {
	return CreateIncomingRTNLMessage(shill::RTNLMessage::kModeAdd, address,
	nud_state);
	}

	shill::RTNLMessage* CreateNeighborDeletedMessage(const std::string& address) {
	return CreateIncomingRTNLMessage(shill::RTNLMessage::kModeDelete, address, 0);
	}

	} // namespace

	class NeighborLinkMonitorTest : public testing::Test {
	protected:
	void SetUp() override {
	mock_rtnl_handler_ = std::make_unique<shill::MockRTNLHandler>();
	link_monitor_ = std::make_unique<NeighborLinkMonitor>(
	kTestInterfaceIndex, kTestInterfaceName, mock_rtnl_handler_.get());
	}

	void TearDown() override {
	// We should make sure \|mock_rtnl_handler_\| is valid during the life time of
	// \|link_monitor_\|.
	link_monitor_ = nullptr;
	mock_rtnl_handler_ = nullptr;
	}

	void FastForwardOneActiveProbeInterval() {
	task_environment_.FastForwardBy(NeighborLinkMonitor::kActiveProbeInterval);
	}

	base::test::TaskEnvironment task_environment_{
	base::test::TaskEnvironment::TimeSource::MOCK_TIME};
	std::unique_ptr<shill::MockRTNLHandler> mock_rtnl_handler_;
	std::unique_ptr<NeighborLinkMonitor> link_monitor_;
	};

	TEST_F(NeighborLinkMonitorTest, SendNeighborGetMessageOnIPConfigChanged) {
	ShillClient::IPConfig ipconfig;
	ipconfig.ipv4_address = "1.2.3.4";
	ipconfig.ipv4_gateway = "1.2.3.5";
	ipconfig.ipv4_prefix_length = 24;
	// The second dns address is not in this subnet, and should be ignored by the
	// link monitor.
	ipconfig.ipv4_dns_addresses = {"1.2.3.6", "4.3.2.1"};

	// On ipconfig changed, the link monitor should send a get request for each
	// watching address, to fetch their current NUD state.
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborGetMessage("1.2.3.5"), _))
	.WillOnce(Return(true));
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborGetMessage("1.2.3.6"), _))
	.WillOnce(Return(true));

	link_monitor_->OnIPConfigChanged(ipconfig);
	}

	TEST_F(NeighborLinkMonitorTest, WatchLinkLocalIPv6DNSServerAddress) {
	ShillClient::IPConfig ipconfig;
	ipconfig.ipv6_address = "2401::1";
	ipconfig.ipv6_prefix_length = 64;
	ipconfig.ipv6_gateway = "fe80::1";
	ipconfig.ipv6_dns_addresses = {"fe80::2"};

	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborGetMessage("fe80::1"), _))
	.WillOnce(Return(true));
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborGetMessage("fe80::2"), _))
	.WillOnce(Return(true));

	link_monitor_->OnIPConfigChanged(ipconfig);
	}

	TEST_F(NeighborLinkMonitorTest, SendNeighborProbeMessage) {
	// Only the gateway should be in the wathing list.
	ShillClient::IPConfig ipconfig;
	ipconfig.ipv4_address = "1.2.3.4";
	ipconfig.ipv4_gateway = "1.2.3.5";
	ipconfig.ipv4_prefix_length = 24;
	link_monitor_->OnIPConfigChanged(ipconfig);

	// Creates a RTNL message about the NUD state of the gateway is NUD_REACHABLE
	// now. A probe message should be sent immediately after we know this address.
	std::unique_ptr<shill::RTNLMessage> address_is_reachable(
	CreateNUDStateChangedMessage("1.2.3.5", NUD_REACHABLE));
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
	.WillOnce(Return(true));
	link_monitor_->OnNeighborMessage(*address_is_reachable);

	// Another probe message should be sent when the timer is triggered.
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
	.WillOnce(Return(true));
	FastForwardOneActiveProbeInterval();

	// If the state changed to NUD_PROBE, we should not probe this address again
	// when the timer is triggered.
	std::unique_ptr<shill::RTNLMessage> address_is_probing(
	CreateNUDStateChangedMessage("1.2.3.5", NUD_PROBE));
	link_monitor_->OnNeighborMessage(*address_is_probing);
	FastForwardOneActiveProbeInterval();

	// The gateway is removed in the kernel. A get request should be sent when the
	// timer is triggered.
	std::unique_ptr<shill::RTNLMessage> address_is_removed(
	CreateNeighborDeletedMessage("1.2.3.5"));
	link_monitor_->OnNeighborMessage(*address_is_removed);
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborGetMessage("1.2.3.5"), _))
	.WillOnce(Return(true));
	FastForwardOneActiveProbeInterval();
	}

	TEST_F(NeighborLinkMonitorTest, UpdateWatchingEntries) {
	ShillClient::IPConfig ipconfig;
	ipconfig.ipv4_address = "1.2.3.4";
	ipconfig.ipv4_gateway = "1.2.3.5";
	ipconfig.ipv4_dns_addresses = {"1.2.3.6"};
	ipconfig.ipv4_prefix_length = 24;
	link_monitor_->OnIPConfigChanged(ipconfig);

	ipconfig.ipv4_dns_addresses = {"1.2.3.7"};
	// The watching list should be updated to {"1.2.3.5", "1.2.3.7"}, and only
	// "1.2.3.7" is an new entry, so it should be probed immediately.
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborGetMessage("1.2.3.7"), _))
	.WillOnce(Return(true));
	link_monitor_->OnIPConfigChanged(ipconfig);

	// Updates both addresses to NUD_PROBE (to avoid the link monitor sending a
	// probe request), and then NUD_REACHABLE state.
	std::unique_ptr<shill::RTNLMessage> addr_5_is_probing(
	CreateNUDStateChangedMessage("1.2.3.5", NUD_PROBE));
	std::unique_ptr<shill::RTNLMessage> addr_5_is_reachable(
	CreateNUDStateChangedMessage("1.2.3.5", NUD_REACHABLE));
	std::unique_ptr<shill::RTNLMessage> addr_7_is_probing(
	CreateNUDStateChangedMessage("1.2.3.7", NUD_PROBE));
	std::unique_ptr<shill::RTNLMessage> addr_7_is_reachable(
	CreateNUDStateChangedMessage("1.2.3.7", NUD_REACHABLE));
	link_monitor_->OnNeighborMessage(*addr_5_is_probing);
	link_monitor_->OnNeighborMessage(*addr_5_is_reachable);
	link_monitor_->OnNeighborMessage(*addr_7_is_probing);
	link_monitor_->OnNeighborMessage(*addr_7_is_reachable);

	// Nothing should happen within one interval.
	task_environment_.FastForwardBy(base::TimeDelta::FromSeconds(30));

	// Checks if probe requests sent for both addresses when the timer is
	// triggered.
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborProbeMessage("1.2.3.5"), _))
	.WillOnce(Return(true));
	EXPECT_CALL(*mock_rtnl_handler_,
	DoSendMessage(IsNeighborProbeMessage("1.2.3.7"), _))
	.WillOnce(Return(true));
	FastForwardOneActiveProbeInterval();
	}

	class NetworkMonitorServiceTest : public testing::Test {
	protected:
	void SetUp() override {
	fake_shill_client_ = shill_helper_.FakeClient();
	monitor_svc_ =
	std::make_unique<NetworkMonitorService>(fake_shill_client_.get());
	mock_rtnl_handler_ = std::make_unique<shill::MockRTNLHandler>();
	}

	FakeShillClientHelper shill_helper_;
	std::unique_ptr<FakeShillClient> fake_shill_client_;
	std::unique_ptr<shill::MockRTNLHandler> mock_rtnl_handler_;
	std::unique_ptr<NetworkMonitorService> monitor_svc_;
	};

	TEST_F(NetworkMonitorServiceTest, StartRTNLHanlderOnServiceStart) {
	monitor_svc_->rtnl_handler_ = mock_rtnl_handler_.get();
	EXPECT_CALL(*mock_rtnl_handler_, Start(RTMGRP_NEIGH));
	monitor_svc_->Start();
	}

	TEST_F(NetworkMonitorServiceTest, CallGetDevicePropertiesOnNewDevice) {
	monitor_svc_->rtnl_handler_ = mock_rtnl_handler_.get();
	// Device added before service starts.
	std::vector<dbus::ObjectPath> devices = {dbus::ObjectPath("/device/eth0")};
	fake_shill_client_->NotifyManagerPropertyChange(shill::kDevicesProperty,
	brillo::Any(devices));
	monitor_svc_->Start();

	// Device added after service starts.
	devices.emplace_back(dbus::ObjectPath("/device/wlan0"));
	fake_shill_client_->NotifyManagerPropertyChange(shill::kDevicesProperty,
	brillo::Any(devices));
	const std::set<std::string>& calls =
	fake_shill_client_->get_device_properties_calls();
	EXPECT_EQ(calls.size(), 2);
	EXPECT_NE(calls.find("eth0"), calls.end());
	EXPECT_NE(calls.find("wlan0"), calls.end());
	}

	} // namespace patchpanel